174 lines
9.1 KiB
Python
174 lines
9.1 KiB
Python
"""Exercise current review policy and account bindings across worker transactions."""
|
|
import json
|
|
from unittest import TestCase, mock
|
|
|
|
from archive_store import utc_now
|
|
from knowledge_access import OWN_CODE, current_access
|
|
from knowledge_assignments import KnowledgeAssignments
|
|
from knowledge_review import KnowledgeReviewStore, KnowledgeReviewWorker
|
|
from knowledge_review_policy import POLICY_SCHEMA, SELF_REVIEW_MESSAGE
|
|
import test_knowledge as fixtures
|
|
from test_knowledge_own_scope import BRIDGE, DESKTOP, GROUP
|
|
|
|
|
|
class ReviewWorkerPolicyTest(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)
|
|
bridge = mock.patch.dict('os.environ', {'ZYT_GROUP_API_URL': GROUP, 'ZYT_KNOWLEDGE_ACCOUNT_BRIDGE': BRIDGE})
|
|
bridge.start()
|
|
self.addCleanup(bridge.stop)
|
|
self.accounts = [self.db.create_desktop_session({'user_id': f'admin:{165 + index}', 'sn': f'POLICY{index}'},
|
|
f'policy-device-{index}', 'Synthetic QA', '1.0', '')[1] for index in range(2)]
|
|
self.own, self.other = [account['tenant_id'] for account in self.accounts]
|
|
self.items = {}
|
|
for tenant in (self.own, self.other):
|
|
self.process(tenant)
|
|
draft = self.first(tenant)
|
|
draft['conditions'] = '仅用于合成测试'
|
|
with self.db.connect() as db:
|
|
self.store._save_item(db, self.store._item(db, tenant, draft['id']), draft['revision'],
|
|
self.store._edit_fields(draft), self.actor, '')
|
|
self.items[tenant] = self.store.detail(tenant, draft['id'])
|
|
now = utc_now()
|
|
with self.db.connect() as db:
|
|
db.executescript(POLICY_SCHEMA)
|
|
db.execute('UPDATE model_config SET config_json=? WHERE id=1', (json.dumps({'ZYT_LOGIN_API_URL': DESKTOP}),))
|
|
db.execute('INSERT INTO group_sso_bindings VALUES (?,?,?,?,?,?,?,?,?)',
|
|
('zyt_group', 'gid_' + 'a' * 32, self.actor, 165, 'synthetic-reviewer', 'Synthetic', 1, now, now))
|
|
db.execute('UPDATE knowledge_job SET created_by=0 WHERE id=?', (self.items[self.own]['job_id'],))
|
|
self.assertNotIn(OWN_CODE, current_access(db, self.actor).permissions)
|
|
self.reviews = KnowledgeReviewStore(self.store)
|
|
self.worker = KnowledgeReviewWorker(self.store)
|
|
self.assignments = KnowledgeAssignments(self.store)
|
|
self.assignments.assign('*', [{'id': item['id'], 'revision': item['revision']}
|
|
for item in self.items.values()], self.actor, self.actor, '')
|
|
|
|
def disable_self_review(self):
|
|
with self.db.connect() as db:
|
|
db.execute('BEGIN IMMEDIATE')
|
|
db.execute('INSERT INTO knowledge_review_policy VALUES (1,0)')
|
|
|
|
def start(self, mode, *, single=False):
|
|
if single:
|
|
other = self.items[self.other]
|
|
self.assignments.assign('*', [{'id': other['id'], 'revision': other['revision']}], None, self.actor, '')
|
|
job = self.reviews.preview('*', -1, self.actor, '', mode)
|
|
self.assertEqual(job['preview']['eligible'], 1 if single else 2)
|
|
self.reviews.action(job['id'], 'start', self.actor, '', True)
|
|
return job['id']
|
|
|
|
def assert_own_draft_skipped(self, job_id, approved):
|
|
job = self.reviews.get(job_id, self.actor)
|
|
self.assertEqual((job['status'], job['processed'], job['approved'], job['skipped']),
|
|
('completed', 1 + approved, approved, 1))
|
|
skipped = self.reviews.results(job_id, self.actor, '*')['items']
|
|
self.assertEqual([(row['item_id'], row['reason'], row['reason_text']) for row in skipped],
|
|
[(self.items[self.own]['id'], 'self_review', SELF_REVIEW_MESSAGE)])
|
|
self.assertEqual(self.store.stats(self.own), {'draft': 1})
|
|
own_id = self.items[self.own]['id']
|
|
with self.db.connect() as db:
|
|
self.assertIsNone(db.execute('SELECT 1 FROM knowledge_fts WHERE item_id=?', (own_id,)).fetchone())
|
|
self.assertIsNone(db.execute("SELECT 1 FROM knowledge_revision WHERE item_id=? "
|
|
"AND action IN ('approve','publish')", (own_id,)).fetchone())
|
|
|
|
def test_preview_counts_self_review_separately_in_both_modes(self):
|
|
self.disable_self_review()
|
|
with self.db.connect() as db:
|
|
db.execute("UPDATE knowledge_item SET conditions='' WHERE id=?", (self.items[self.own]['id'],))
|
|
for mode in ('approve', 'approve_publish'):
|
|
with self.subTest(mode=mode):
|
|
job = self.reviews.preview('*', -1, self.actor, '', mode)
|
|
preview = job['preview']
|
|
self.assertEqual((preview['total'], preview['eligible'], preview['blocked']), (2, 1, 1))
|
|
self.assertEqual(preview['reasons'], [{'code': 'self_review', 'count': 1, 'reason': SELF_REVIEW_MESSAGE}])
|
|
self.assertEqual(preview['accounts'], [])
|
|
|
|
def test_approval_only_rechecks_policy_for_already_queued_drafts(self):
|
|
job_id = self.start('approve')
|
|
with self.db.connect() as db:
|
|
db.execute("UPDATE knowledge_review_job SET preview_json=json_remove(preview_json,'$.mode') WHERE id=?",
|
|
(job_id,))
|
|
self.disable_self_review()
|
|
self.worker.step()
|
|
self.assert_own_draft_skipped(job_id, 1)
|
|
self.assertEqual(self.store.stats(self.other), {'approved': 1})
|
|
|
|
def test_reenabled_policy_does_not_expand_confirmed_snapshot(self):
|
|
self.disable_self_review()
|
|
job = self.reviews.preview('*', -1, self.actor, '', 'approve_publish')
|
|
self.assertEqual(job['preview']['eligible'], 1)
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE knowledge_review_policy SET allow_self_review=1 WHERE id=1')
|
|
self.reviews.action(job['id'], 'start', self.actor, '', True)
|
|
self.worker.step()
|
|
self.assert_own_draft_skipped(job['id'], 1)
|
|
self.assertEqual(self.store.stats(self.other), {'published': 1})
|
|
|
|
def test_inactive_owned_account_remains_self_owned(self):
|
|
self.disable_self_review()
|
|
with self.db.connect() as db:
|
|
db.execute("UPDATE desktop_accounts SET status='disabled' WHERE id=?", (self.accounts[0]['id'],))
|
|
job = self.reviews.preview('*', -1, self.actor, '', 'approve')
|
|
self.assertEqual(job['preview']['eligible'], 1)
|
|
self.reviews.action(job['id'], 'start', self.actor, '', True)
|
|
self.worker.step()
|
|
self.assert_own_draft_skipped(job['id'], 1)
|
|
|
|
def test_unverifiable_linked_owner_is_blocked_while_policy_is_off(self):
|
|
self.disable_self_review()
|
|
with mock.patch('knowledge_access.account_bridge_ready', return_value=False):
|
|
job = self.reviews.preview('*', -1, self.actor, '', 'approve')
|
|
self.assertEqual(job['preview']['eligible'], 0)
|
|
self.assertEqual(job['preview']['reasons'][0]['count'], 2)
|
|
|
|
def test_combined_rechecks_policy_before_indexing(self):
|
|
job_id = self.start('approve_publish')
|
|
self.disable_self_review()
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.return_value = 'synthetic-profile'
|
|
self.worker.step()
|
|
index.return_value.publish.assert_called_once()
|
|
self.assertEqual(index.return_value.publish.call_args.args[0]['tenant_id'], self.other)
|
|
self.assert_own_draft_skipped(job_id, 1)
|
|
self.assertEqual(self.store.stats(self.other), {'published': 1})
|
|
|
|
def test_combined_rechecks_policy_after_indexing(self):
|
|
job_id = self.start('approve_publish', single=True)
|
|
|
|
def disable_while_indexing(_draft):
|
|
self.assertEqual(self.store.stats(self.own), {'draft': 1})
|
|
self.disable_self_review()
|
|
return 'synthetic-profile'
|
|
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = disable_while_indexing
|
|
self.worker.step()
|
|
index.return_value.publish.assert_called_once()
|
|
self.assert_own_draft_skipped(job_id, 0)
|
|
|
|
def test_combined_rechecks_trusted_account_binding_after_indexing(self):
|
|
self.disable_self_review()
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE group_sso_bindings SET source_admin_id=166 WHERE user_id=?', (self.actor,))
|
|
job_id = self.start('approve_publish', single=True)
|
|
|
|
def rebind_while_indexing(_draft):
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE group_sso_bindings SET source_admin_id=165 WHERE user_id=?', (self.actor,))
|
|
return 'synthetic-profile'
|
|
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = rebind_while_indexing
|
|
self.worker.step()
|
|
index.return_value.publish.assert_called_once()
|
|
self.assert_own_draft_skipped(job_id, 0)
|