380 lines
21 KiB
Python
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']))
|