231 lines
13 KiB
Python
231 lines
13 KiB
Python
"""Synthetic API coverage for item-specific delegated review."""
|
|
from unittest import TestCase
|
|
|
|
import rbac
|
|
import test_knowledge_own_scope as fixtures
|
|
from archive_store import utc_now
|
|
|
|
|
|
class ReviewAssignmentTest(TestCase):
|
|
tearDown = fixtures.OwnKnowledgeTest.tearDown
|
|
payload = fixtures.OwnKnowledgeTest.payload
|
|
start_job = fixtures.OwnKnowledgeTest.start_job
|
|
process = fixtures.OwnKnowledgeTest.process
|
|
first = fixtures.OwnKnowledgeTest.first
|
|
scope_flag = fixtures.OwnKnowledgeTest.scope_flag
|
|
|
|
def setUp(self):
|
|
fixtures.OwnKnowledgeTest.setUp(self)
|
|
self.scope_flag(True)
|
|
self.item_id = self.ids['alice']
|
|
self.bob = self.tokens['bob']
|
|
self.inbox = self.url + '/my-reviews'
|
|
self.assignees = self.url + '/review-assignees?account_id=-1'
|
|
self.assignments = self.url + '/review-assignments?account_id=-1'
|
|
self.set_permission('knowledge:review:assign', False)
|
|
|
|
def set_permission(self, permission, enabled):
|
|
with self.db.connect() as db:
|
|
if enabled:
|
|
db.execute("INSERT INTO role_permissions VALUES ('cleaner',?)", (permission,))
|
|
else:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='cleaner' AND permission_code=?", (permission,))
|
|
|
|
def selection(self, item_id=None, revision=None):
|
|
item_id = item_id or self.item_id
|
|
if revision is None:
|
|
with self.db.connect() as db:
|
|
revision = db.execute('SELECT revision FROM knowledge_item WHERE id=?', (item_id,)).fetchone()[0]
|
|
return {'id': item_id, 'revision': revision}
|
|
|
|
def assign(self, name, items=None, *, headers=None, status=200):
|
|
response = self.client.put(self.assignments, headers=headers or self.headers,
|
|
json={'assignee_id': self.users[name] if name else None, 'items': items or [self.selection()]})
|
|
self.assertEqual(response.status_code, status, response.text)
|
|
return response.json()
|
|
|
|
def tasks(self, headers, total):
|
|
response = self.client.get(self.inbox, headers=headers)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
self.assertEqual(response.json()['total'], total)
|
|
return response.json()['items']
|
|
|
|
def detail(self, headers):
|
|
response = self.client.get(f'{self.inbox}/{self.item_id}', headers=headers)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
return response.json()
|
|
|
|
def edit(self, item, status):
|
|
values = {k: item[k] for k in ('revision', 'title', 'question', 'answer', 'conditions',
|
|
'category', 'kind', 'valid_until')}
|
|
response = self.client.put(f'{self.inbox}/{self.item_id}', headers=self.bob,
|
|
json={**values, 'title': '更新后的合成标题', 'assignment_id': item['review_assignment']['id']})
|
|
self.assertEqual(response.status_code, status, response.text)
|
|
return response.json()
|
|
|
|
def act(self, action, item, status, *, headers=None, confirmed=True):
|
|
response = self.client.post(f'{self.inbox}/{self.item_id}/{action}', headers=headers or self.bob,
|
|
json={'revision': item['revision'], 'assignment_id': item['review_assignment']['id'], 'confirmed': confirmed})
|
|
self.assertEqual(response.status_code, status, response.text)
|
|
return response.json()
|
|
|
|
def test_cross_account_grant_exposes_only_exact_draft_and_redacted_snapshot(self):
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE knowledge_source SET content=? WHERE item_id=?', ('测试手机号 13800138000', self.item_id))
|
|
payload = {'items': [self.selection()]}
|
|
self.assertEqual(self.client.post(self.assignees, headers=self.bob, json=payload).status_code, 403)
|
|
result = self.client.post(self.assignees, headers=self.headers, json=payload).json()['items']
|
|
bob = next(user for user in result if user['id'] == self.users['bob'])
|
|
self.assertEqual(set(bob), {'id', 'username', 'name'})
|
|
self.assertEqual(self.assign('bob'), {'updated': 1})
|
|
item = self.detail(self.bob)
|
|
self.assertEqual(self.tasks(self.bob, 1)[0]['id'], self.item_id)
|
|
self.assertEqual(set(item['sources'][0]), {'role', 'content', 'sent_at'})
|
|
self.assertNotIn('13800138000', item['sources'][0]['content'])
|
|
self.assertTrue({'tenant_id', 'source_key', 'job_id', 'account_id', 'history'}.isdisjoint(item))
|
|
self.assertEqual(self.client.get(f'{self.inbox}/{self.ids["bob"]}', headers=self.bob).status_code, 404)
|
|
normal = self.url + f'/items/{self.item_id}?account_id=-1'
|
|
self.assertEqual(self.client.get(normal, headers=self.bob).status_code, 403)
|
|
self.assertEqual(self.client.get(self.url + '/items?account_id=-1', headers=self.bob).status_code, 403)
|
|
manager_item = next(row for row in self.client.get(self.url + '/items?account_id=-1', headers=self.headers)
|
|
.json()['items'] if row['id'] == self.item_id)
|
|
self.assertEqual(manager_item['review_assignment'], item['review_assignment'])
|
|
saved = self.edit(item, 200)
|
|
self.assertEqual(saved['revision'], item['revision'] + 1)
|
|
self.assertEqual(saved['review_assignment']['id'], item['review_assignment']['id'])
|
|
self.act('approve', item, 400)
|
|
self.act('approve', saved, 400, confirmed=False)
|
|
self.act('approve', saved, 422, confirmed='true')
|
|
self.act('publish', saved, 422)
|
|
self.assertEqual(self.act('approve', saved, 200), {'status': 'approved'})
|
|
self.tasks(self.bob, 0)
|
|
self.assertEqual(self.store.detail(self.tenant, self.item_id)['status'], 'approved')
|
|
|
|
def test_stale_batch_or_out_of_scope_selection_makes_no_changes(self):
|
|
item = self.selection()
|
|
self.assign('bob', [item, self.selection(self.ids['bob'], revision=2)], status=400)
|
|
self.assign('bob', [item, item], status=422)
|
|
self.assign('bob', [item, self.selection('does-not-exist', 1)], status=404)
|
|
self.set_permission('knowledge:review:assign', True)
|
|
self.assign('bob', [item, self.selection(self.ids['cross'])], headers=self.alice, status=404)
|
|
self.tasks(self.bob, 0)
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_review_assignment').fetchone()[0], 0)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM audit_log WHERE action='knowledge.review.assign'").fetchone()[0], 0)
|
|
|
|
def test_reassignment_return_and_withdraw_reject_stale_modal(self):
|
|
self.assign('bob')
|
|
old = self.detail(self.bob)
|
|
self.assertEqual(self.assign('bob'), {'updated': 0})
|
|
self.assign('alice')
|
|
self.tasks(self.bob, 0)
|
|
self.tasks(self.alice, 1)
|
|
self.act('reject', old, 404)
|
|
self.assign('bob')
|
|
self.tasks(self.alice, 0)
|
|
new = self.detail(self.bob)
|
|
self.assertNotEqual(old['review_assignment']['id'], new['review_assignment']['id'])
|
|
self.edit(old, 404)
|
|
self.act('reject', old, 404)
|
|
self.assertEqual(self.assign(None), {'updated': 1})
|
|
self.tasks(self.bob, 0)
|
|
self.act('reject', new, 404)
|
|
with self.db.connect() as db:
|
|
records = list(db.execute("SELECT action FROM audit_log WHERE action LIKE 'knowledge.review.%' ORDER BY id"))
|
|
self.assertEqual([row['action'] for row in records], ['knowledge.review.assign'] * 3 + ['knowledge.review.withdraw'])
|
|
|
|
def test_assignor_scope_and_recipient_permissions_rechecked_with_old_tokens(self):
|
|
self.set_permission('knowledge:review:assign', True)
|
|
self.assign('bob', headers=self.alice)
|
|
item = self.detail(self.bob)
|
|
self.set_permission('knowledge:review:assign', False)
|
|
self.tasks(self.bob, 0)
|
|
self.act('approve', item, 404)
|
|
self.set_permission('knowledge:review:assign', True)
|
|
with self.db.connect() as db:
|
|
db.execute('INSERT INTO admin_account_scope VALUES (?,?,?)',
|
|
(self.users['alice'], self.accounts[1]['id'], utc_now()))
|
|
self.tasks(self.bob, 0)
|
|
self.edit(item, 404)
|
|
self.assign('bob', headers=self.alice, status=404)
|
|
with self.db.connect() as db:
|
|
db.execute('DELETE FROM admin_account_scope WHERE admin_user_id=?', (self.users['alice'],))
|
|
for permission, action in [('knowledge:write', 'edit'), ('knowledge:reject', 'reject')]:
|
|
self.set_permission(permission, False)
|
|
self.tasks(self.bob, 1)
|
|
if action == 'edit':
|
|
self.edit(item, 403)
|
|
else:
|
|
self.act(action, item, 403)
|
|
self.set_permission(permission, True)
|
|
self.set_permission('im:content:read', False)
|
|
self.assertEqual(self.client.get(self.inbox, headers=self.bob).status_code, 403)
|
|
self.act('approve', item, 403)
|
|
self.set_permission('im:content:read', True)
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE users SET active=0 WHERE id=?', (self.users['bob'],))
|
|
self.assign('bob', status=400)
|
|
candidates = self.client.post(self.assignees, headers=self.headers,
|
|
json={'items': [self.selection()]}).json()['items']
|
|
self.assertNotIn(self.users['bob'], {candidate['id'] for candidate in candidates})
|
|
self.assertIn(self.client.get(self.inbox, headers=self.bob).status_code, {401, 403})
|
|
|
|
def test_external_revision_change_invalidates_existing_assignment(self):
|
|
self.assign('bob')
|
|
old = self.detail(self.bob)
|
|
item = self.store.detail(self.tenant, self.item_id)
|
|
with self.db.connect() as db:
|
|
self.store._save_item(db, self.store._item(db, self.tenant, self.item_id), item['revision'],
|
|
self.store._edit_fields(item), self.actor, '')
|
|
self.tasks(self.bob, 0)
|
|
self.act('approve', old, 404)
|
|
self.assign('bob')
|
|
new = self.detail(self.bob)
|
|
self.act('reject', new, 200)
|
|
self.tasks(self.bob, 0)
|
|
self.store.delete_rejected(self.tenant, self.item_id, new['revision'], self.actor, '')
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_review_assignment').fetchone()[0], 0)
|
|
|
|
def test_review_permission_without_assignment_discloses_no_draft_even_to_manager(self):
|
|
for headers in (self.headers, self.bob):
|
|
self.assertEqual(self.tasks(headers, 0), [])
|
|
self.assertEqual(self.client.get(f'{self.inbox}/{self.item_id}', headers=headers).status_code, 404)
|
|
self.assertEqual(self.client.get(self.url + '/overview?account_id=-1', headers=self.bob).json()['counts'], {})
|
|
path = self.url + '/items/' + self.item_id
|
|
self.assertIn(self.client.get(path + '?account_id=-1', headers=self.headers).status_code, (403, 404))
|
|
for action in ('approve', 'reject', 'approve_publish'):
|
|
response = self.client.post(path + '/' + action + '?account_id=-1', headers=self.headers,
|
|
json={'revision': self.selection()['revision'], 'confirmed': True})
|
|
self.assertEqual(response.status_code, 403)
|
|
manager_rows = self.client.get(self.url + '/items?account_id=-1', headers=self.headers).json()['items']
|
|
summary = next(row for row in manager_rows if row['id'] == self.item_id)
|
|
for field in ('question', 'answer', 'conditions', 'sources', 'history'):
|
|
self.assertFalse(summary.get(field), field)
|
|
self.assertEqual(self.store.detail(self.tenant, self.item_id)['status'], 'draft')
|
|
|
|
def test_self_review_switch_applies_to_candidates_pending_approval_and_rejection(self):
|
|
self.assign('alice')
|
|
item = self.detail(self.alice)
|
|
with self.db.connect() as db:
|
|
db.execute('INSERT INTO knowledge_review_policy(id,allow_self_review) VALUES(1,0) '
|
|
'ON CONFLICT(id) DO UPDATE SET allow_self_review=0')
|
|
candidates = self.client.post(self.assignees, headers=self.headers,
|
|
json={'items': [self.selection()]}).json()['items']
|
|
self.assertNotIn(self.users['alice'], {candidate['id'] for candidate in candidates})
|
|
self.assertIn(self.users['bob'], {candidate['id'] for candidate in candidates})
|
|
self.assign('alice', status=400)
|
|
self.assertTrue(self.detail(self.alice)['self_review_blocked'])
|
|
for action in ('approve', 'reject'):
|
|
self.act(action, item, 403, headers=self.alice)
|
|
self.assign('bob')
|
|
self.assertFalse(self.detail(self.bob)['self_review_blocked'])
|
|
self.assertEqual(self.act('reject', self.detail(self.bob), 200), {'status': 'rejected'})
|
|
|
|
def test_permission_seeding_adds_only_admin_grant(self):
|
|
with self.db.connect() as db:
|
|
self.assertIn('knowledge:review:assign', rbac.permissions_of(db, 'admin'))
|
|
for role_code, _, _ in rbac.BUILTIN_ROLES:
|
|
if role_code != 'admin':
|
|
self.assertNotIn('knowledge:review:assign', rbac.permissions_of(db, role_code))
|