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

367 lines
23 KiB
Python

"""Full-scope review snapshot, permissions, transactions and pagination."""
import json
from unittest import TestCase, mock
import test_knowledge as fixtures
from archive_store import ArchiveStore, new_id
from knowledge_access import KnowledgeAccessDenied
from knowledge_assignments import KnowledgeAssignments
from knowledge_review import KnowledgeReviewStore, KnowledgeReviewWorker
class FullReviewTest(TestCase):
setUp = fixtures.KnowledgeTest.setUp
tearDown = fixtures.KnowledgeTest.tearDown
payload = fixtures.KnowledgeTest.payload
start_job = fixtures.KnowledgeTest.start_job
process = fixtures.KnowledgeTest.process
first = fixtures.KnowledgeTest.first
def seed(self, count=75, tenant='default', *, assign=True):
self.process(tenant)
original = self.first(tenant)
original['conditions'] = '仅用于虚构门店测试'
with self.db.connect() as db:
self.store._save_item(db, self.store._item(db, tenant, original['id']), original['revision'],
self.store._edit_fields(original), self.actor, '')
original = self.store.detail(tenant, original['id'])
ids = [original['id']]
with self.db.connect() as db:
for index in range(count - 1):
item_id = new_id(); ids.append(item_id)
db.execute("""INSERT INTO knowledge_item(id,tenant_id,job_id,dedup_hash,title,question,answer,conditions,
category,kind,flags_json,status,revision,valid_until,created_at,updated_at)
SELECT ?,tenant_id,job_id,?,title||?,question,answer,conditions,category,kind,flags_json,
status,revision,valid_until,created_at,updated_at FROM knowledge_item WHERE id=?""",
(item_id, item_id, str(index), original['id']))
db.execute('INSERT INTO knowledge_source SELECT ?,message_id,version_no,role,content,sent_at '
'FROM knowledge_source WHERE item_id=?', (item_id, original['id']))
if assign:
KnowledgeAssignments(self.store).assign(tenant, [{'id': item_id, 'revision': original['revision']}
for item_id in ids], self.actor, self.actor, '')
return ids
def test_all_pages_approve_without_publishing_or_model_calls(self):
self.seed(237)
reviews = KnowledgeReviewStore(self.store)
preview = reviews.preview('*', -1, self.actor, '')
self.assertEqual((preview['total'], preview['preview']['eligible']), (237, 237))
self.assertEqual(len(self.store.list_items('default')['items']), 30)
self.assertEqual(self.store.stats('default').get('approved', 0), 0)
with self.assertRaises(ValueError):
reviews.action(preview['id'], 'start', self.actor, '', False)
reviews.action(preview['id'], 'start', self.actor, '', True)
reviews.action(preview['id'], 'start', self.actor, '', True)
worker = KnowledgeReviewWorker(self.store)
with mock.patch('model_gateway.call_outlet', side_effect=AssertionError('No model call allowed')):
worker.step()
self.assertEqual(reviews.get(preview['id'], self.actor)['processed'], 100)
worker.step(); worker.step()
result = reviews.get(preview['id'], self.actor)
self.assertEqual((result['status'], result['approved'], result['skipped'], result['progress_percent']), ('completed', 237, 0, 100))
self.assertEqual(self.store.stats('default'), {'approved': 237})
with self.db.connect() as db:
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_fts').fetchone()[0], 0)
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action='approve'").fetchone()[0], 237)
results = reviews.results(preview['id'], self.actor, '*', 'approved', 8, 30)
self.assertEqual((results['total'], len(results['items'])), (237, 27))
def test_preview_reports_missing_conditions_fields_expiry_and_sources(self):
ids = self.seed(6)
with self.db.connect() as db:
db.execute("UPDATE knowledge_item SET conditions='' WHERE id=?", (ids[0],))
db.execute("UPDATE knowledge_item SET question='' WHERE id=?", (ids[1],))
db.execute("UPDATE knowledge_item SET valid_until='2000-01-01' WHERE id=?", (ids[2],))
db.execute('DELETE FROM knowledge_source WHERE item_id=?', (ids[3],))
db.execute('UPDATE knowledge_source SET version_no=99 WHERE item_id=?', (ids[4],))
reviews = KnowledgeReviewStore(self.store)
job = reviews.preview('*', -1, self.actor, '')
self.assertEqual((job['total'], job['preview']['eligible'], job['preview']['blocked']), (5, 1, 4))
self.assertEqual({reason['code'] for reason in job['preview']['reasons']},
{'missing_conditions', 'invalid_fields', 'expired', 'missing_source'})
reviews.action(job['id'], 'start', self.actor, '', True)
KnowledgeReviewWorker(self.store).step()
final = reviews.get(job['id'], self.actor)
self.assertEqual((final['approved'], final['skipped']), (1, 4))
self.assertEqual(self.store.stats('default'), {'approved': 1, 'draft': 5})
def test_changed_deleted_and_new_items_are_not_approved_from_old_snapshot(self):
ids = self.seed(4)
reviews = KnowledgeReviewStore(self.store)
job = reviews.preview('*', -1, self.actor, '')
edit = self.store.detail('default', ids[0]); edit['answer'] = '已经编辑的新答案,需要重新审核。'
with self.db.connect() as db:
self.store._save_item(db, self.store._item(db, 'default', ids[0]), edit['revision'],
self.store._edit_fields(edit), self.actor, '')
db.execute('DELETE FROM knowledge_source WHERE item_id=?', (ids[1],))
db.execute('DELETE FROM knowledge_revision WHERE item_id=?', (ids[1],))
db.execute('DELETE FROM knowledge_item WHERE id=?', (ids[1],))
db.execute("UPDATE knowledge_item SET status='rejected' WHERE id=?", (ids[2],))
self.seed(1, 'new-tenant')
reviews.action(job['id'], 'start', self.actor, '', True)
KnowledgeReviewWorker(self.store).step()
final = reviews.get(job['id'], self.actor)
self.assertEqual((final['total'], final['approved'], final['skipped']), (1, 1, 0))
self.assertEqual(self.store.stats('new-tenant'), {'draft': 1})
self.assertEqual(reviews.results(job['id'], self.actor, '*')['items'], [])
def test_snapshot_excludes_unassigned_and_later_assigned_drafts(self):
self.seed(33); self.seed(4, 'other', assign=False)
reviews = KnowledgeReviewStore(self.store)
job = reviews.preview('*', -1, self.actor, '')
self.seed(2, 'later')
reviews.action(job['id'], 'start', self.actor, '', True)
KnowledgeReviewWorker(self.store).step()
self.assertEqual(self.store.stats('default'), {'approved': 33})
self.assertEqual(self.store.stats('other'), {'draft': 4})
self.assertEqual(self.store.stats('later'), {'draft': 2})
def test_assignor_with_no_assignment_has_empty_preview_in_both_modes(self):
self.seed(2, assign=False)
reviews = KnowledgeReviewStore(self.store)
for mode in ('approve', 'approve_publish'):
with self.subTest(mode=mode):
job = reviews.preview('*', -1, self.actor, '', mode)
self.assertEqual((job['total'], job['preview']['eligible'], job['preview']['accounts']), (0, 0, []))
self.assertEqual(reviews.results(job['id'], self.actor, '*', ''), {'items': [], 'total': 0})
with self.assertRaises(ValueError):
reviews.action(job['id'], 'start', self.actor, '', True)
self.assertEqual(self.store.stats('default'), {'draft': 2})
def test_legacy_unscoped_jobs_hidden_untouched_and_do_not_block_new_work(self):
ids = self.seed(2, assign=False)
with self.db.connect() as db:
for status in ('preview', 'queued', 'running', 'completed', 'expired'):
db.execute("""INSERT INTO knowledge_review_job(id,created_by,account_id,scope_label,status,total,
preview_json,expires_at,created_at,updated_at) VALUES (?,?,-1,'legacy-account',?,1,'{}',0,'2000','2000')""",
(status, self.actor, status))
db.execute("""INSERT INTO knowledge_review_target(job_id,item_id,tenant_id,revision,item_updated_at)
SELECT ?,id,tenant_id,revision,updated_at FROM knowledge_item WHERE id=?""", (status, ids[0]))
self.store.initialize()
reviews = KnowledgeReviewStore(self.store)
self.assertEqual(reviews.jobs(self.actor), [])
for job_id in ('preview', 'queued', 'running', 'completed', 'expired'):
with self.assertRaises(KeyError):
reviews.get(job_id, self.actor)
with self.assertRaises(KeyError):
reviews.results(job_id, self.actor, '*', '')
for action in ('start', 'resume', 'pause', 'cancel'):
with self.assertRaises(KeyError):
reviews.action(job_id, action, self.actor, '', True)
KnowledgeAssignments(self.store).assign('*', [{'id': ids[1], 'revision': 2}], self.actor, self.actor, '')
current = reviews.preview('*', -1, self.actor, '')
reviews.action(current['id'], 'start', self.actor, '', True)
worker = KnowledgeReviewWorker(self.store)
self.assertTrue(worker.step())
self.assertFalse(worker.step())
self.assertEqual(self.store.detail('default', ids[0])['status'], 'draft')
self.assertEqual(self.store.detail('default', ids[1])['status'], 'approved')
with self.db.connect() as db:
old = db.execute("SELECT id,status FROM knowledge_review_job WHERE created_at='2000'").fetchall()
self.assertEqual(len(old), 5)
self.assertTrue(all(row['id'] == row['status'] for row in old))
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_review_target WHERE item_id=? AND result='pending'",
(ids[0],)).fetchone()[0], 5)
def test_pause_resume_cancel_and_new_worker_are_durable(self):
self.seed(7)
reviews = KnowledgeReviewStore(self.store)
job = reviews.preview('*', -1, self.actor, '')
reviews.action(job['id'], 'start', self.actor, '', True)
KnowledgeReviewWorker(self.store).step(2)
reviews.action(job['id'], 'pause', self.actor, '')
self.assertFalse(KnowledgeReviewWorker(self.store).step())
reviews.action(job['id'], 'resume', self.actor, '')
KnowledgeReviewWorker(self.store).step(2)
reviews.action(job['id'], 'cancel', self.actor, '')
self.assertFalse(KnowledgeReviewWorker(self.store).step())
result = reviews.get(job['id'], self.actor)
self.assertEqual((result['status'], result['approved'], result['processed']), ('cancelled', 4, 4))
self.assertEqual(self.store.stats('default'), {'approved': 4, 'draft': 3})
with self.assertRaises(ValueError):
reviews.action(job['id'], 'resume', self.actor, '')
def test_batch_failure_rolls_back_status_results_and_audit_together(self):
self.seed(4)
reviews = KnowledgeReviewStore(self.store); job = reviews.preview('*', -1, self.actor, '')
reviews.action(job['id'], 'start', self.actor, '', True)
original = self.store._record; calls = []
def broken(*args, **kwargs):
calls.append(1)
if len(calls) == 2:
raise RuntimeError('Simulated crash')
return original(*args, **kwargs)
with mock.patch.object(self.store, '_record', side_effect=broken), self.assertRaises(RuntimeError):
KnowledgeReviewWorker(self.store).step()
self.assertEqual(self.store.stats('default'), {'draft': 4})
self.assertEqual(reviews.get(job['id'], self.actor)['processed'], 0)
KnowledgeReviewWorker(self.store).step()
self.assertEqual(reviews.get(job['id'], self.actor)['approved'], 4)
def test_reviewer_permission_revoked_mid_job_stops_further_approvals(self):
self.seed(5)
reviews = KnowledgeReviewStore(self.store); job = reviews.preview('*', -1, self.actor, '')
reviews.action(job['id'], 'start', self.actor, '', True)
KnowledgeReviewWorker(self.store).step(2)
with self.db.connect() as db:
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review'")
KnowledgeReviewWorker(self.store).step()
with self.assertRaises(KnowledgeAccessDenied):
reviews.get(job['id'], self.actor)
with self.db.connect() as db:
db.execute("INSERT INTO role_permissions VALUES ('admin','knowledge:review')")
result = reviews.get(job['id'], self.actor)
self.assertEqual((result['status'], result['approved']), ('failed', 2))
reviews.action(job['id'], 'resume', self.actor, '')
KnowledgeReviewWorker(self.store).step()
self.assertEqual(reviews.get(job['id'], self.actor)['approved'], 5)
def test_expiry_and_replaced_previews(self):
self.seed(2)
reviews = KnowledgeReviewStore(self.store); old = reviews.preview('*', -1, self.actor, '')
job = reviews.preview('*', -1, self.actor, '')
with self.assertRaises(ValueError):
reviews.action(old['id'], 'start', self.actor, '', True)
with self.db.connect() as db:
db.execute('UPDATE knowledge_review_job SET expires_at=0 WHERE id=?', (job['id'],))
with self.assertRaises(ValueError):
reviews.action(job['id'], 'start', self.actor, '', True)
while KnowledgeReviewWorker(self.store).step():
pass
with self.assertRaises(KeyError):
reviews.get(job['id'], self.actor)
self.assertEqual(self.store.stats('default'), {'draft': 2})
def test_disabled_reviewer_cannot_start_or_continue(self):
self.seed(3)
reviews = KnowledgeReviewStore(self.store); job = reviews.preview('*', -1, self.actor, '')
with self.db.connect() as db:
db.execute('UPDATE users SET active=0 WHERE id=?', (self.actor,))
with self.assertRaises(ValueError):
reviews.action(job['id'], 'start', self.actor, '', True)
with self.db.connect() as db:
db.execute('UPDATE users SET active=1 WHERE id=?', (self.actor,))
reviews.action(job['id'], 'start', self.actor, '', True)
KnowledgeReviewWorker(self.store).step(1)
with self.db.connect() as db:
db.execute('UPDATE users SET active=0 WHERE id=?', (self.actor,))
KnowledgeReviewWorker(self.store).step()
with self.assertRaises(KnowledgeAccessDenied):
reviews.get(job['id'], self.actor)
with self.db.connect() as db:
db.execute('UPDATE users SET active=1 WHERE id=?', (self.actor,))
final = reviews.get(job['id'], self.actor)
self.assertEqual((final['status'], final['approved']), ('failed', 1))
self.assertEqual(self.store.stats('default'), {'approved': 1, 'draft': 2})
class FullReviewApiTest(TestCase):
payload = FullReviewTest.payload
start_job = FullReviewTest.start_job
process = FullReviewTest.process
first = FullReviewTest.first
seed = FullReviewTest.seed
setUp = fixtures.KnowledgeApiTest.setUp
tearDown = fixtures.KnowledgeApiTest.tearDown
def test_existing_session_rechecks_review_and_assignment_permissions_independently(self):
knowledge = '/api/v2/knowledge'
with self.db.connect() as db:
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review'")
for endpoint in ('my-reviews', 'review-tasks'):
response = self.client.get(f'{knowledge}/{endpoint}', headers=self.headers)
self.assertEqual(response.status_code, 403, endpoint)
for endpoint in ('items', 'retrievals', 'export'):
response = self.client.get(f'{knowledge}/{endpoint}', headers=self.headers)
self.assertEqual(response.status_code, 200, endpoint)
with self.db.connect() as db:
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review:assign'")
overview = self.client.get(knowledge + '/overview', headers=self.headers)
self.assertEqual(overview.status_code, 200)
self.assertEqual(overview.json()['counts'], {})
for endpoint in ('items', 'items/unknown', 'my-reviews', 'review-tasks', 'retrievals', 'export'):
response = self.client.get(f'{knowledge}/{endpoint}', headers=self.headers)
self.assertEqual(response.status_code, 403, endpoint)
for method, endpoint, body in (
('post', 'review-tasks/preview', {}),
('post', 'items/unknown/restore', {'revision': 1, 'restore_revision': 1}),
('post', 'review-assignees', {'items': [{'id': 'unknown', 'revision': 1}]}),
('put', 'items/unknown', {'revision': 1, 'title': '合成', 'question': '合成',
'answer': '合成', 'conditions': '合成'}),
):
response = getattr(self.client, method)(f'{knowledge}/{endpoint}', headers=self.headers, json=body)
self.assertEqual(response.status_code, 403, endpoint)
def test_auth_confirmation_owner_and_read_only_pagination(self):
url = '/api/v2/knowledge/review-tasks'
self.assertEqual(self.client.post(url + '/preview').status_code, 401)
response = self.client.post(url + '/preview?account_id=-1', headers=self.headers)
self.assertEqual(response.status_code, 200, response.text)
job = response.json()
self.assertEqual(job['total'], 0)
self.assertEqual(self.client.post(url + '/' + job['id'] + '/start', headers=self.headers,
json={'confirmed': False}).status_code, 400)
self.assertEqual(self.client.get(url + '/' + job['id'] + '/results?page_size=1000', headers=self.headers).status_code, 422)
actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
self.db.create_user('reviewer', 'InitialReader123', 'viewer', actor, '')
user_id = self.db.authenticate('reviewer', 'InitialReader123')['id']
self.db.change_password(user_id, 'InitialReader123', 'ChangedReader@2026', '')
login = self.client.post('/api/v2/auth/login', json={'username': 'reviewer', 'password': 'ChangedReader@2026'})
headers = {'Authorization': 'Bearer ' + login.json()['access_token']}
self.assertEqual(self.client.post(url + '/preview', headers=headers).status_code, 403)
with self.db.connect() as db:
db.executemany("INSERT OR IGNORE INTO role_permissions VALUES ('viewer',?)", [(p,) for p in ('knowledge:read','knowledge:review','knowledge:review:auto','im:content:read')])
self.assertEqual(self.client.get(url + '/' + job['id'], headers=headers).status_code, 404)
self.assertEqual(self.client.post(url + '/' + job['id'] + '/cancel', headers=headers, json={}).status_code, 404)
def test_explicit_cross_account_assignments_only_and_withdrawal_after_queueing(self):
self.actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
self.store = self.client.app.state.knowledge_store
self.archive = ArchiveStore(self.db)
accounts, ids = [], []
for index in range(3):
_, account = self.db.create_desktop_session(
{'user_id': f'full-review-{index}', 'sn': f'REV{index}', 'nickname': f'测试账号{index}'},
f'review-device-{index}', 'Review QA', '1.0', '')
accounts.append(account)
ids.append(self.seed(2, account['tenant_id'], assign=False))
self.db.create_user('limited-reviewer', 'InitialReader123', 'viewer', self.actor, '')
reviewer = self.db.authenticate('limited-reviewer', 'InitialReader123')['id']
self.db.change_password(reviewer, 'InitialReader123', 'ChangedReader@2026', '')
with self.db.connect() as db:
db.executemany("INSERT OR IGNORE INTO role_permissions VALUES ('viewer',?)",
[(p,) for p in ('knowledge:read','knowledge:review','knowledge:review:auto','im:content:read')])
self.db.set_desktop_account_admins(accounts[0]['id'], [reviewer], self.actor, '')
login = self.client.post('/api/v2/auth/login', json={'username': 'limited-reviewer', 'password': 'ChangedReader@2026'})
headers = {'Authorization': 'Bearer ' + login.json()['access_token']}
url = '/api/v2/knowledge/review-tasks'
self.assertEqual(self.client.post(url + '/preview?account_id=' + str(accounts[2]['id']), headers=headers).status_code, 400)
empty = self.client.post(url + '/preview?account_id=-1', headers=headers)
self.assertEqual(empty.json()['total'], 0)
assignments = KnowledgeAssignments(self.store)
own = {'id': ids[0][0], 'revision': 2}
delegated = {'id': ids[2][0], 'revision': 2}
assignments.assign('*', [own, delegated], reviewer, self.actor, '')
snapshot = self.client.post(url + '/preview?account_id=-1', headers=headers)
self.assertEqual(snapshot.status_code, 200, snapshot.text)
job = snapshot.json()
self.assertEqual(job['total'], 2)
self.assertEqual(job['preview']['accounts'], [])
pending = self.client.get(url + '/' + job['id'] + '/results?result=pending', headers=headers).json()
self.assertEqual({row['item_id'] for row in pending['items']}, {own['id'], delegated['id']})
self.assertTrue(all({'tenant_id', 'account_id', 'account_name'}.isdisjoint(row) for row in pending['items']))
response = self.client.post(url + '/' + job['id'] + '/start', headers=headers, json={'confirmed': True})
self.assertEqual(response.status_code, 200, response.text)
assignments.assign('*', [own], None, self.actor, '')
self.assertEqual(self.client.get(url + '/' + job['id'], headers=headers).json()['total'], 1)
KnowledgeReviewWorker(self.store).step()
final = self.client.get(url + '/' + job['id'], headers=headers).json()
self.assertEqual((final['status'], final['total'], final['approved'], final['skipped']), ('completed', 1, 1, 0))
self.assertEqual(self.store.stats(accounts[0]['tenant_id']), {'draft': 2})
self.assertEqual(self.store.stats(accounts[1]['tenant_id']), {'draft': 2})
self.assertEqual(self.store.stats(accounts[2]['tenant_id']), {'approved': 1, 'draft': 1})
results = self.client.get(url + '/' + job['id'] + '/results?result=', headers=headers).json()
self.assertEqual([row['item_id'] for row in results['items']], [delegated['id']])