158 lines
8.7 KiB
Python
158 lines
8.7 KiB
Python
"""Storage-level review authorization using synthetic drafts and an isolated database."""
|
|
from unittest import TestCase, mock
|
|
|
|
import rbac
|
|
import test_knowledge as fixtures
|
|
from archive_store import utc_now
|
|
from knowledge_access import KnowledgeAccessDenied
|
|
from knowledge_assignments import REVIEWER, KnowledgeAssignments
|
|
|
|
|
|
class AssignmentOnlyStoreTest(TestCase):
|
|
tearDown = fixtures.KnowledgeTest.tearDown
|
|
payload = fixtures.KnowledgeTest.payload
|
|
start_job = fixtures.KnowledgeTest.start_job
|
|
process = fixtures.KnowledgeTest.process
|
|
first = fixtures.KnowledgeTest.first
|
|
|
|
def setUp(self):
|
|
fixtures.KnowledgeTest.setUp(self)
|
|
self.process()
|
|
self.item = self.first()
|
|
self.selection = {'id': self.item['id'], 'revision': self.item['revision']}
|
|
self.assignments = KnowledgeAssignments(self.store)
|
|
now = utc_now()
|
|
with self.db.connect() as db:
|
|
db.execute('INSERT INTO roles VALUES (?,?,?,?,?)', ('reviewer', '合成审核员', 0, now, now))
|
|
rbac.grant(db, 'reviewer', [*REVIEWER, 'knowledge:publish', 'knowledge:reject', 'knowledge:write'], now)
|
|
db.execute('UPDATE knowledge_item SET title=?,question=?,conditions=? WHERE id=?',
|
|
('合成标题', '合成草稿正文', '仅适用于合成测试', self.item['id']))
|
|
self.db.create_user('reviewer', 'InitialReader123', 'reviewer', self.actor, '')
|
|
self.reviewer = self.db.authenticate('reviewer', 'InitialReader123')['id']
|
|
|
|
def assign(self):
|
|
self.assignments.assign('default', [self.selection], self.reviewer, self.actor, '')
|
|
return self.assignments.detail(self.reviewer, self.item['id'])['review_assignment']['id']
|
|
|
|
def publish(self, assignment_id, *, actor=None, confirmed=True):
|
|
return self.assignments.transition(actor or self.reviewer, self.item['id'], self.item['revision'],
|
|
assignment_id, 'approve_publish', '', confirmed)
|
|
|
|
def assert_no_publication(self, status='draft'):
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute('SELECT status FROM knowledge_item WHERE id=?',
|
|
(self.item['id'],)).fetchone()[0], status)
|
|
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_fts').fetchone()[0], 0)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action IN ('approve','publish')")
|
|
.fetchone()[0], 0)
|
|
|
|
def test_management_draft_is_metadata_only_and_reviewers_only_see_own_assignments(self):
|
|
item_id = self.item['id']
|
|
for actor in (self.actor, self.reviewer):
|
|
self.assertEqual(self.assignments.inbox(actor, 1, 30), {'items': [], 'total': 0})
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
self.store.list_items('default', actor=self.reviewer)
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
self.store.stats('default', actor=self.reviewer)
|
|
summary = self.store.list_items('default', query='合成标题', actor=self.actor)['items'][0]
|
|
self.assertEqual(summary['id'], item_id)
|
|
self.assertTrue({'question', 'answer', 'conditions', 'sources', 'history'}.isdisjoint(summary))
|
|
self.assertEqual(self.store.list_items('default', query='合成草稿正文', actor=self.actor)['total'], 0)
|
|
with self.assertRaises(KeyError):
|
|
self.store.detail('default', item_id, actor=self.actor)
|
|
with self.assertRaises(KeyError):
|
|
self.store.save('default', item_id, self.item, self.actor, '')
|
|
for action in ('approve', 'reject'):
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
self.store.transition('default', item_id, self.item['revision'], action, self.actor, '', True)
|
|
|
|
token = self.assign()
|
|
self.assertEqual(self.assignments.detail(self.reviewer, item_id)['question'], '合成草稿正文')
|
|
self.assertEqual(self.store.list_items('default', actor=self.actor)['items'][0]['review_assignment']['id'], token)
|
|
self.assertEqual(self.assignments.inbox(self.actor, 1, 30)['total'], 0)
|
|
with self.assertRaises(KeyError):
|
|
self.assignments.detail(self.actor, item_id)
|
|
with self.assertRaises(KeyError):
|
|
self.assignments.save(self.reviewer, item_id, self.item, None, '')
|
|
with self.assertRaises(KeyError):
|
|
self.assignments.transition(self.reviewer, item_id, self.item['revision'], None, 'reject', '', True)
|
|
|
|
def test_source_revocation_does_not_expose_stale_draft(self):
|
|
self.assign()
|
|
changed = self.payload()
|
|
changed['messages'][1]['status'] = 'revoked'
|
|
self.archive.import_messages(changed, self.actor, '')
|
|
self.assertEqual(self.assignments.inbox(self.reviewer, 1, 30)['total'], 0)
|
|
summary = self.store.list_items('default', actor=self.actor)['items'][0]
|
|
self.assertEqual(summary['status'], 'stale')
|
|
self.assertNotIn('answer', summary)
|
|
self.assertEqual(self.store.list_items('default', query='合成草稿正文', actor=self.actor)['total'], 0)
|
|
with self.assertRaises(KeyError):
|
|
self.store.detail('default', self.item['id'], actor=self.actor)
|
|
|
|
def test_post_review_edit_returns_summary_and_reopens_without_assignment(self):
|
|
token = self.assign()
|
|
self.assertEqual(self.assignments.transition(self.reviewer, self.item['id'], self.item['revision'],
|
|
token, 'approve', '', True), {'status': 'approved'})
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
self.store.transition('default', self.item['id'], self.item['revision'], 'reject', self.actor, '', True)
|
|
reviewed = self.store.detail('default', self.item['id'], actor=self.actor)
|
|
self.assertEqual(reviewed['question'], '合成草稿正文')
|
|
draft = self.store.save('default', self.item['id'], reviewed, self.actor, '')
|
|
self.assertEqual(draft['status'], 'draft')
|
|
self.assertEqual(draft['revision'], self.item['revision'] + 1)
|
|
self.assertNotIn('answer', draft)
|
|
self.assertEqual(self.assignments.inbox(self.reviewer, 1, 30)['total'], 0)
|
|
with self.assertRaises(KeyError):
|
|
self.store.detail('default', self.item['id'], actor=self.actor)
|
|
|
|
def test_combined_publication_requires_exact_assignment_and_returns_status(self):
|
|
token = self.assign()
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = False
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
self.store.approve_publish('default', self.item['id'], self.item['revision'], self.actor, '', True)
|
|
with self.assertRaises(KeyError):
|
|
self.publish(token, actor=self.actor)
|
|
with self.assertRaises(KeyError):
|
|
self.publish('old-assignment')
|
|
with self.assertRaises(ValueError):
|
|
self.publish(token, confirmed='true')
|
|
index.assert_not_called()
|
|
self.assertEqual(self.publish(token), {'status': 'published'})
|
|
self.assertEqual(self.assignments.inbox(self.reviewer, 1, 30)['total'], 0)
|
|
with self.db.connect() as db:
|
|
actions = db.execute("SELECT action,actor_id FROM knowledge_revision WHERE action IN ('approve','publish') "
|
|
"ORDER BY rowid").fetchall()
|
|
self.assertEqual([tuple(row) for row in actions], [('approve', self.reviewer), ('publish', self.reviewer)])
|
|
|
|
def test_withdrawal_during_indexing_prevents_publication(self):
|
|
token = self.assign()
|
|
|
|
def withdraw_and_reassign(_):
|
|
self.assignments.assign('default', [self.selection], None, self.actor, '')
|
|
self.assertNotEqual(self.assign(), token)
|
|
return 'synthetic-index'
|
|
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = withdraw_and_reassign
|
|
with self.assertRaises(KeyError):
|
|
self.publish(token)
|
|
self.assert_no_publication()
|
|
|
|
def test_permission_revocation_during_indexing_prevents_publication(self):
|
|
token = self.assign()
|
|
|
|
def revoke(_):
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='reviewer' AND permission_code='knowledge:publish'")
|
|
return 'synthetic-index'
|
|
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = revoke
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
self.publish(token)
|
|
self.assert_no_publication()
|