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

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)