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

380 lines
21 KiB
Python

"""Synthetic atomic review/publication checks; no business data or network."""
import json
from concurrent.futures import ThreadPoolExecutor
from threading import Barrier
from unittest import TestCase, mock
import httpx
import test_knowledge as fixtures
import test_knowledge_own_scope as own_fixtures
from archive_store import ArchiveStore
from knowledge_access import KnowledgeAccessDenied
from knowledge_assignments import KnowledgeAssignments
from knowledge_retriever import KnowledgeRetriever
class ApprovePublishStoreTest(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()
item = self.first()
item['conditions'] = '仅适用于合成测试的预约咨询。'
self.assignments, self.assignment_id = fixtures.assigned_draft(self.store, 'default', item, self.actor)
self.item = self.assignments.save(self.actor, item['id'], item, self.assignment_id, '')
def perform(self, **overrides):
values = dict(tenant='default', item_id=self.item['id'], revision=self.item['revision'],
actor=self.actor, ip='synthetic', confirmed=True, assignment_id=self.assignment_id)
values.update(overrides)
return self.store.approve_publish(**values)
def assert_no_publication(self, status='draft'):
self.assertEqual(self.store.detail('default', self.item['id'])['status'], status)
with self.db.connect() as db:
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_fts WHERE item_id=?',
(self.item['id'],)).fetchone()[0], 0)
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE item_id=? "
"AND action IN ('approve','publish')", (self.item['id'],)).fetchone()[0], 0)
self.assertEqual(db.execute("SELECT COUNT(*) FROM audit_log WHERE action IN "
"('knowledge.approve','knowledge.publish')").fetchone()[0], 0)
def test_success_returns_published_item_and_commits_both_audits(self):
self.assertEqual(self.perform(), {'status': 'published'})
result = self.store.detail('default', self.item['id'])
self.assertEqual((result['id'], result['revision'], result['status'], result['vector_status']),
(self.item['id'], self.item['revision'], 'published', 'not_configured'))
self.assertEqual(len(result['sources']), 2)
self.assertEqual(KnowledgeRetriever(self.store).search('default', '预约挂号材料')['hits'][0]['id'], result['id'])
with self.db.connect() as db:
records = db.execute("SELECT action,snapshot_json,actor_id FROM knowledge_revision WHERE item_id=? "
"AND action IN ('approve','publish') ORDER BY rowid", (self.item['id'],)).fetchall()
self.assertEqual([(r['action'], json.loads(r['snapshot_json'])['status'], r['actor_id']) for r in records],
[('approve', 'approved', self.actor), ('publish', 'published', self.actor)])
self.assertEqual([r[0] for r in db.execute("SELECT action FROM audit_log WHERE action IN "
"('knowledge.approve','knowledge.publish') ORDER BY id")],
['knowledge.approve', 'knowledge.publish'])
def test_configured_index_success_returns_ready_profile(self):
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.return_value = 'synthetic-profile'
self.assertEqual(self.perform(), {'status': 'published'})
index.return_value.publish.assert_called_once()
self.assertEqual(index.return_value.publish.call_args.args[0]['revision'], self.item['revision'])
result = self.store.detail('default', self.item['id'])
self.assertEqual((result['status'], result['vector_status'], result['vector_profile']),
('published', 'ready', 'synthetic-profile'))
def test_index_failure_leaves_no_approved_state_or_audit(self):
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = httpx.ConnectError('Synthetic index unavailable')
with self.assertRaises(httpx.ConnectError):
self.perform()
self.assert_no_publication()
def test_database_failure_rolls_back_status_fts_revisions_and_audit(self):
record = self.store._record
def fail_after_publish_record(db, item_id, actor, action, ip=''):
record(db, item_id, actor, action, ip)
with self.db.connect() as observer:
self.assertEqual(observer.execute('SELECT status FROM knowledge_item WHERE id=?',
(item_id,)).fetchone()[0], 'draft')
self.assertEqual(observer.execute("SELECT COUNT(*) FROM audit_log WHERE action IN "
"('knowledge.approve','knowledge.publish')").fetchone()[0], 0)
if action == 'publish':
raise RuntimeError('Synthetic commit failure')
with mock.patch.object(self.store, '_record', side_effect=fail_after_publish_record):
with self.assertRaisesRegex(RuntimeError, 'Synthetic commit failure'):
self.perform()
self.assert_no_publication()
def test_stale_revision_is_rejected_before_index_upload(self):
with mock.patch('knowledge_retriever.VectorIndex') as index:
with self.assertRaisesRegex(ValueError, '版本'):
self.perform(revision=self.item['revision'] - 1)
index.assert_not_called()
self.assert_no_publication()
def test_confirmation_requires_explicit_true(self):
for confirmed in (False, None, 1, 'true'):
with self.subTest(confirmed=confirmed), self.assertRaisesRegex(ValueError, '确认'):
self.perform(confirmed=confirmed)
self.assert_no_publication()
def test_invalid_conditions_fields_and_expiry_are_rejected(self):
invalid_values = [('conditions', ' '), ('conditions', '适' * 2001),
('title', ''), ('question', '问' * 4001), ('answer', ''),
('category', '类' * 101), ('kind', 'unknown'),
('valid_until', '2000-01-01'), ('valid_until', '20990101'),
('valid_until', 'not-a-date')]
for field, value in invalid_values:
with self.subTest(field=field, length=len(value)):
with self.db.connect() as db:
db.execute('UPDATE knowledge_item SET ' + field + '=? WHERE id=?', (value, self.item['id']))
with mock.patch('knowledge_retriever.VectorIndex') as index:
with self.assertRaises(ValueError):
self.perform()
index.assert_not_called()
self.assert_no_publication()
with self.db.connect() as db:
db.execute('UPDATE knowledge_item SET ' + field + '=? WHERE id=?',
(self.item[field], self.item['id']))
def test_missing_sources_are_rejected(self):
with self.db.connect() as db:
db.execute('DELETE FROM knowledge_source WHERE item_id=?', (self.item['id'],))
with self.assertRaisesRegex(ValueError, '来源'):
self.perform()
self.assert_no_publication()
def test_changed_source_version_is_rejected(self):
with self.db.connect() as db:
db.execute('UPDATE knowledge_source SET version_no=999 WHERE item_id=?', (self.item['id'],))
with self.assertRaises(KeyError):
self.perform()
self.assert_no_publication()
def test_source_without_archive_versions_is_rejected(self):
with self.db.connect() as db:
db.execute('DELETE FROM archive_message_version')
with self.assertRaisesRegex(ValueError, '来源'):
self.perform()
self.assert_no_publication()
def test_source_in_wrong_tenant_is_rejected(self):
with self.db.connect() as db:
db.execute("UPDATE archive_message SET tenant_id='other-tenant'")
with self.assertRaises(KeyError):
self.perform()
self.assert_no_publication()
def test_sources_changed_during_index_upload_are_rechecked(self):
def revoke_source(_item):
payload = self.payload()
payload['messages'][1]['status'] = 'revoked'
self.archive.import_messages(payload, self.actor, '')
return 'synthetic-profile'
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = revoke_source
with self.assertRaises((KeyError, ValueError)):
self.perform()
self.assert_no_publication('stale')
def test_edit_during_index_upload_is_not_published(self):
def edit_draft(_item):
values = dict(self.item, answer='编辑后的合成答案,需要重新审核。')
self.assignments.save(self.actor, self.item['id'], values, self.assignment_id, '')
return 'synthetic-profile'
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = edit_draft
with self.assertRaisesRegex(ValueError, '版本'):
self.perform()
self.assert_no_publication()
def test_each_permission_revoked_during_upload_prevents_commit(self):
for permission in ('knowledge:review', 'knowledge:publish', 'im:content:read'):
with self.subTest(permission=permission):
def revoke_permission(_item):
with self.db.connect() as db:
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code=?",
(permission,))
return 'synthetic-profile'
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = revoke_permission
with self.assertRaises(KnowledgeAccessDenied):
self.perform()
self.assert_no_publication()
with self.db.connect() as db:
db.execute("INSERT INTO role_permissions VALUES ('admin',?)", (permission,))
def test_approved_items_still_use_existing_publish_action(self):
self.assignments.transition(self.actor, self.item['id'], self.item['revision'], self.assignment_id, 'approve', '', True)
with self.assertRaises(KeyError):
self.perform()
result = self.store.publish('default', self.item['id'], self.item['revision'], self.actor, '')
self.assertEqual(result['status'], 'published')
def test_concurrent_requests_publish_once_and_record_one_audit_pair(self):
ready = Barrier(2)
def upload(_item):
ready.wait(timeout=10)
return 'synthetic-profile'
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = upload
with ThreadPoolExecutor(max_workers=2) as pool:
futures = [pool.submit(self.perform) for _ in range(2)]
results = []
for future in futures:
try:
results.append(future.result())
except (KeyError, ValueError) as error:
results.append(error)
self.assertEqual(sum(isinstance(result, dict) and result['status'] == 'published' for result in results), 1)
self.assertEqual(sum(isinstance(result, (KeyError, ValueError)) for result in results), 1)
with self.db.connect() as db:
self.assertEqual(db.execute("SELECT COUNT(*) FROM audit_log WHERE action IN "
"('knowledge.approve','knowledge.publish')").fetchone()[0], 2)
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action IN "
"('approve','publish')").fetchone()[0], 2)
def test_expiry_crossed_during_upload_prevents_commit(self):
with self.db.connect() as db:
db.execute("UPDATE knowledge_item SET valid_until='2099-01-01' WHERE id=?", (self.item['id'],))
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.return_value = 'synthetic-profile'
with mock.patch.object(KnowledgeRetriever, '_today', side_effect=['2099-01-01', '2099-01-02']):
with self.assertRaisesRegex(ValueError, '有效期'):
self.perform()
self.assert_no_publication()
class ApprovePublishApiTest(TestCase):
tearDown = fixtures.KnowledgeApiTest.tearDown
payload = fixtures.KnowledgeTest.payload
start_job = fixtures.KnowledgeTest.start_job
process = fixtures.KnowledgeTest.process
first = fixtures.KnowledgeTest.first
def setUp(self):
fixtures.KnowledgeApiTest.setUp(self)
self.actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
self.store = self.client.app.state.knowledge_store
self.archive = ArchiveStore(self.db)
env = mock.patch.dict('os.environ', {'KNOWLEDGE_QDRANT_URL': '', 'KNOWLEDGE_EMBEDDING_URL': '',
'KNOWLEDGE_EMBEDDING_MODEL': ''})
env.start()
self.addCleanup(env.stop)
self.process()
item = self.first()
item['conditions'] = '仅适用于合成测试。'
assignments, self.assignment_id = fixtures.assigned_draft(self.store, 'default', item, self.actor)
self.item = assignments.save(self.actor, item['id'], item, self.assignment_id, '')
self.url = '/api/v2/knowledge/my-reviews/' + item['id'] + '/approve_publish'
def post(self, **overrides):
body = dict(revision=self.item['revision'], confirmed=True, assignment_id=self.assignment_id)
body.update(overrides)
return self.client.post(self.url, headers=self.headers, json=body)
def test_api_returns_final_published_item(self):
response = self.post()
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(response.json(), {'status': 'published'})
actions = [r['action'] for r in self.store.detail('default', self.item['id'])['history']]
self.assertEqual((actions.count('approve'), actions.count('publish')), (1, 1))
def test_api_and_store_deny_each_missing_permission_with_existing_token(self):
for permission in ('knowledge:read', 'knowledge:review', 'knowledge:publish', 'im:content:read'):
with self.subTest(permission=permission):
with self.db.connect() as db:
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code=?", (permission,))
response = self.post()
self.assertEqual(response.status_code, 403, response.text)
self.assertIn(permission, response.json()['detail'])
with mock.patch('knowledge_retriever.VectorIndex') as index:
with self.assertRaises(KnowledgeAccessDenied):
self.store.approve_publish('default', self.item['id'], self.item['revision'], self.actor, '', True,
assignment_id=self.assignment_id)
index.assert_not_called()
with self.db.connect() as db:
db.execute("INSERT INTO role_permissions VALUES ('admin',?)", (permission,))
self.assertEqual(self.store.detail('default', self.item['id'])['status'], 'draft')
def test_api_requires_confirmation_and_current_revision(self):
for body in ({'revision': self.item['revision']}, {'revision': self.item['revision'], 'confirmed': False},
{'revision': self.item['revision'] - 1, 'confirmed': True}):
response = self.client.post(self.url, headers=self.headers, json={**body, 'assignment_id': self.assignment_id})
self.assertEqual(response.status_code, 400, response.text)
self.assertEqual(self.store.detail('default', self.item['id'])['status'], 'draft')
def test_index_http_error_is_502_and_draft_is_preserved(self):
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = httpx.ConnectError('Synthetic index unavailable')
response = self.post()
self.assertEqual(response.status_code, 502, response.text)
self.assertEqual(self.store.detail('default', self.item['id'])['status'], 'draft')
def test_api_rejects_non_boolean_confirmation(self):
for confirmed in (1, 'true', 'yes', 0, 'false', None):
with self.subTest(confirmed=confirmed):
response = self.post(confirmed=confirmed)
self.assertEqual(response.status_code, 422, response.text)
self.assertEqual(self.store.detail('default', self.item['id'])['status'], 'draft')
class ApprovePublishOwnScopeTest(TestCase):
setUp = own_fixtures.OwnKnowledgeTest.setUp
tearDown = own_fixtures.OwnKnowledgeTest.tearDown
payload = own_fixtures.OwnKnowledgeTest.payload
start_job = own_fixtures.OwnKnowledgeTest.start_job
process = own_fixtures.OwnKnowledgeTest.process
first = own_fixtures.OwnKnowledgeTest.first
def assign_item(self, key):
item = self.store.detail(self.other_tenant if key == 'cross' else self.tenant, self.ids[key])
assignments, token = fixtures.assigned_draft(self.store, self.tenant, item, self.users['alice'])
return token
def post_item(self, key, token='no-assignment', account_id=-1):
item = self.store.detail(self.other_tenant if key == 'cross' else self.tenant, self.ids[key])
return self.client.post(self.url + '/my-reviews/' + item['id'] + '/approve_publish',
params={'account_id': account_id}, headers=self.alice,
json={'assignment_id': token, 'revision': item['revision'], 'confirmed': True})
def test_mapped_account_allows_own_and_other_creator_items_in_same_tenant(self):
for key in ('alice', 'bob'):
response = self.post_item(key, self.assign_item(key))
self.assertEqual(response.status_code, 200, response.text)
self.assertEqual(response.json()['status'], 'published')
self.assertEqual(self.store.detail(self.other_tenant, self.ids['cross'])['status'], 'draft')
def test_cross_tenant_item_is_denied_for_all_account_selectors(self):
for account_id in (-1, self.accounts[0]['id'], self.accounts[1]['id']):
response = self.post_item('cross', account_id=account_id)
self.assertIn(response.status_code, (403, 404), response.text)
self.assertEqual(self.store.detail(self.other_tenant, self.ids['cross'])['status'], 'draft')
def test_missing_account_bridge_denies_publication(self):
token = self.assign_item('alice')
with mock.patch.dict('os.environ', {'ZYT_KNOWLEDGE_ACCOUNT_BRIDGE': ''}):
response = self.post_item('alice', token)
self.assertIn(response.status_code, (403, 404), response.text)
self.assertEqual(self.store.detail(self.tenant, self.ids['alice'])['status'], 'draft')
def test_account_binding_revoked_during_index_upload_prevents_commit(self):
token = self.assign_item('alice')
def revoke_binding(_item):
with self.db.connect() as db:
db.execute('DELETE FROM group_sso_bindings WHERE user_id=?', (self.users['alice'],))
return 'synthetic-profile'
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = revoke_binding
response = self.post_item('alice', token)
self.assertEqual(response.status_code, 404, response.text)
item = self.store.detail(self.tenant, self.ids['alice'])
self.assertEqual(item['status'], 'draft')
self.assertFalse(any(r['action'] in ('approve', 'publish') for r in item['history']))