Files
kefu/wechat_rpa/test_knowledge_assignment_only_store.py
2026-11-16 09:28:25 +08:00

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()