gengx
This commit is contained in:
@@ -0,0 +1,521 @@
|
||||
"""Knowledge lifecycle, tenant isolation, resumability and source invalidation."""
|
||||
import json
|
||||
import tempfile
|
||||
import time
|
||||
from pathlib import Path
|
||||
from unittest import TestCase, mock
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import admin_api
|
||||
import admin_backend
|
||||
from archive_store import ArchiveStore
|
||||
from knowledge_processing import redact
|
||||
from knowledge_retriever import KnowledgeRetriever, inject_references
|
||||
from knowledge_store import KnowledgeStore, day_boundary
|
||||
from knowledge_worker import KnowledgeWorker
|
||||
|
||||
|
||||
class KnowledgeTest(TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.db = admin_backend.Database(Path(self.temp.name) / 'test.db')
|
||||
self.db.initialize('InitialAdmin123')
|
||||
self.actor = self.db.authenticate('admin', 'InitialAdmin123')['id']
|
||||
self.store = KnowledgeStore(self.db)
|
||||
self.store.initialize()
|
||||
self.archive = ArchiveStore(self.db)
|
||||
self.env = mock.patch.dict('os.environ', {'KNOWLEDGE_QDRANT_URL': '', 'KNOWLEDGE_EMBEDDING_URL': '', 'KNOWLEDGE_EMBEDDING_MODEL': ''})
|
||||
self.env.start()
|
||||
|
||||
def tearDown(self):
|
||||
self.env.stop()
|
||||
self.temp.cleanup()
|
||||
|
||||
def payload(self, tenant='default', messages=None, conversation='S:customer'):
|
||||
contents = messages or [('inbound', '请问预约挂号需要准备什么材料?'),
|
||||
('outbound', '预约挂号请先提供就诊日期和科室,再确认可预约时段。')]
|
||||
return {'tenant_id': tenant, 'source_account': {'external_account_id': 'staff-01', 'display_name': '客服'},
|
||||
'messages': [{'source_message_id': str(i), 'conversation': {'external_id': conversation},
|
||||
'sender': {'external_id': 'staff-01' if direction == 'outbound' else 'customer-01',
|
||||
'display_name': '客服' if direction == 'outbound' else '张三',
|
||||
'identity_type': 'wecom_local_uid', 'scope_id': 'staff-01'},
|
||||
'direction': direction, 'message_type': 'text', 'sent_at': 1724472000 + i,
|
||||
'content': content} for i, (direction, content) in enumerate(contents)]}
|
||||
|
||||
def start_job(self, tenant='default', **options):
|
||||
with self.db.connect() as db:
|
||||
account = db.execute('SELECT id FROM archive_source_account WHERE tenant_id=?', (tenant,)).fetchone()[0]
|
||||
return self.store.create_job(tenant, {'source_account_id': account, 'engine': 'rules',
|
||||
'max_messages': 10000, 'max_model_calls': 100, 'staff_confirmed': True, **options}, self.actor, '')
|
||||
|
||||
def process(self, tenant='default', payload=None):
|
||||
self.archive.import_messages(payload or self.payload(tenant), self.actor, '')
|
||||
job = self.start_job(tenant)
|
||||
worker = KnowledgeWorker(self.store)
|
||||
while worker.step():
|
||||
pass
|
||||
return self.store.job(tenant, job['id'])
|
||||
|
||||
def first(self, tenant='default'):
|
||||
return self.store.list_items(tenant)['items'][0]
|
||||
|
||||
def publish(self, item=None, tenant='default'):
|
||||
item = item or self.first(tenant)
|
||||
item['conditions'] = '适用于普通门诊预约咨询;具体号源以实时查询为准。'
|
||||
item = self.store.save(tenant, item['id'], item, self.actor, '')
|
||||
self.store.transition(tenant, item['id'], item['revision'], 'approve', self.actor, '', True)
|
||||
return self.store.publish(tenant, item['id'], item['revision'], self.actor, '')
|
||||
|
||||
def test_lifecycle_only_published_knowledge_is_retrievable(self):
|
||||
job = self.process()
|
||||
self.assertEqual((job['status'], job['created_items']), ('completed', 1))
|
||||
retriever = KnowledgeRetriever(self.store)
|
||||
self.assertFalse(retriever.search('default', '预约挂号材料')['hits'])
|
||||
item = self.publish()
|
||||
hits = retriever.search('default', '预约挂号材料')['hits']
|
||||
self.assertEqual(hits[0]['id'], item['id'])
|
||||
self.assertEqual(len(self.store.detail('default', item['id'])['sources']), 2)
|
||||
self.store.transition('default', item['id'], item['revision'], 'disable', self.actor, '')
|
||||
self.assertFalse(retriever.search('default', '预约挂号材料')['hits'])
|
||||
|
||||
def test_edits_remove_publication_and_stale_edit_is_rejected(self):
|
||||
self.process()
|
||||
item = self.publish()
|
||||
saved = self.store.save('default', item['id'], item, self.actor, '')
|
||||
self.assertEqual(saved['status'], 'draft')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.save('default', item['id'], item, self.actor, '')
|
||||
self.assertFalse(KnowledgeRetriever(self.store).search('default', '预约挂号')['hits'])
|
||||
|
||||
def test_source_revision_invalidates_knowledge_and_cached_references(self):
|
||||
self.process()
|
||||
item = self.publish()
|
||||
self.store.set_enabled('default', True, self.actor, '')
|
||||
retriever = KnowledgeRetriever(self.store)
|
||||
hits = retriever.search('default', '预约挂号')['hits']
|
||||
self.assertTrue(retriever.references_current('default', hits))
|
||||
payload = self.payload()
|
||||
payload['messages'][1]['status'] = 'revoked'
|
||||
self.archive.import_messages(payload, self.actor, '')
|
||||
self.assertEqual(self.first()['status'], 'stale')
|
||||
self.assertFalse(retriever.search('default', '预约挂号')['hits'])
|
||||
self.assertFalse(retriever.references_current('default', hits))
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.save('default', item['id'], item, self.actor, '')
|
||||
|
||||
def test_reprocessing_is_idempotent(self):
|
||||
self.process()
|
||||
job = self.start_job()
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
self.assertEqual(self.store.job('default', job['id'])['duplicates'], 1)
|
||||
self.assertEqual(self.store.list_items('default')['total'], 1)
|
||||
|
||||
def test_tenants_cannot_read_or_publish_each_others_knowledge(self):
|
||||
self.process('tenant_a')
|
||||
item = self.publish(tenant='tenant_a')
|
||||
self.assertEqual(self.store.list_items('tenant_b')['total'], 0)
|
||||
self.assertFalse(KnowledgeRetriever(self.store).search('tenant_b', '预约挂号')['hits'])
|
||||
with self.assertRaises(KeyError):
|
||||
self.store.publish('tenant_b', item['id'], item['revision'], self.actor, '')
|
||||
|
||||
def test_cross_page_answers_are_preserved_and_pause_resumes(self):
|
||||
content = [('unknown', '系统消息')] * 198 + [('inbound', '预约挂号需要什么材料?'),
|
||||
('outbound', '请先确认就诊日期。'), ('outbound', '还需要确认就诊科室。')]
|
||||
self.archive.import_messages(self.payload(messages=content), self.actor, '')
|
||||
job = self.start_job()
|
||||
worker = KnowledgeWorker(self.store)
|
||||
worker.step()
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
self.store.job_action('default', job['id'], 'pause', self.actor, '')
|
||||
self.assertFalse(worker.step())
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
self.assertIn('确认就诊日期', self.first()['answer'])
|
||||
self.assertIn('确认就诊科室', self.first()['answer'])
|
||||
|
||||
def test_sample_limit_does_not_publish_half_answer(self):
|
||||
payload = self.payload(messages=[('inbound', '预约挂号需要什么材料?'),
|
||||
('outbound', '请先确认就诊日期。'), ('outbound', '还需要确认就诊科室。')])
|
||||
self.archive.import_messages(payload, self.actor, '')
|
||||
self.start_job(max_messages=2)
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
|
||||
def test_snapshot_uses_old_version_and_marks_changed_source_stale(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
self.start_job()
|
||||
payload = self.payload()
|
||||
payload['messages'][1]['content'] = '新的业务口径请咨询前台工作人员。'
|
||||
self.archive.import_messages(payload, self.actor, '')
|
||||
with self.db.connect() as db:
|
||||
db.execute("UPDATE archive_message_version SET created_at='2099-01-01T00:00:00.000+00:00' WHERE version_no=2")
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
item = self.first()
|
||||
self.assertIn('就诊日期', item['answer'])
|
||||
self.assertEqual(item['status'], 'stale')
|
||||
|
||||
def test_group_and_unverified_outbound_are_excluded(self):
|
||||
self.process(payload=self.payload(conversation='R:group'))
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
payload = self.payload()
|
||||
payload['messages'][1]['sender']['external_id'] = 'unknown-employee'
|
||||
self.process(payload=payload)
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
|
||||
def test_names_and_contact_details_are_redacted_before_model(self):
|
||||
self.process(payload=self.payload(messages=[('inbound', '我是张三,手机号13800138000,怎么预约挂号?'),
|
||||
('outbound', '张三,预约挂号请先确认就诊日期。联系13800138000。')]))
|
||||
detail = self.store.detail('default', self.first()['id'])
|
||||
text = json.dumps(detail, ensure_ascii=False)
|
||||
self.assertNotIn('张三', text)
|
||||
self.assertNotIn('13800138000', text)
|
||||
self.assertIn('[姓名]', text)
|
||||
|
||||
def test_expired_knowledge_not_returned(self):
|
||||
self.process()
|
||||
item = self.first()
|
||||
item['valid_until'] = '2099-01-01'
|
||||
self.publish(item)
|
||||
with mock.patch.object(KnowledgeRetriever, '_today', return_value='2099-01-02'):
|
||||
self.assertFalse(KnowledgeRetriever(self.store).search('default', '预约挂号')['hits'])
|
||||
|
||||
def test_abandoned_lease_is_recovered(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job()
|
||||
worker = KnowledgeWorker(self.store)
|
||||
worker.claim()
|
||||
self.assertFalse(KnowledgeWorker(self.store).step())
|
||||
with self.db.connect() as db:
|
||||
db.execute('UPDATE knowledge_job SET lease_until=0 WHERE id=?', (job['id'],))
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
self.assertEqual(self.store.list_items('default')['total'], 1)
|
||||
|
||||
def test_vector_stale_revision_or_wrong_tenant_is_not_returned(self):
|
||||
self.process()
|
||||
item = self.publish()
|
||||
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
||||
index.return_value.configured = True
|
||||
index.return_value.profile = 'test'
|
||||
index.return_value.search.return_value = [{'score': 0.99, 'payload': {
|
||||
'tenant_id': 'default', 'item_id': item['id'], 'revision': 999}}]
|
||||
self.assertFalse(KnowledgeRetriever(self.store).search('default', '完全不同的问题')['hits'])
|
||||
index.return_value.search.return_value[0]['payload']['tenant_id'] = 'tenant_b'
|
||||
self.assertFalse(KnowledgeRetriever(self.store).search('default', '完全不同的问题')['hits'])
|
||||
|
||||
def test_incremental_watch_enqueues_only_changed_conversation(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
self.start_job(auto_watch=True)
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
payload = self.payload()
|
||||
payload['messages'][1]['content'] = '预约挂号请携带既往就诊记录并确认就诊日期。'
|
||||
self.archive.import_messages(payload, self.actor, '')
|
||||
with self.db.connect() as db:
|
||||
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_dirty').fetchone()[0], 1)
|
||||
self.assertFalse(KnowledgeWorker(self.store).step(), 'Active conversations should wait for a quiet interval')
|
||||
with self.db.connect() as db:
|
||||
db.execute("UPDATE knowledge_dirty SET changed_at='2000-01-01T00:00:00.000+00:00'")
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
items = self.store.list_items('default')['items']
|
||||
self.assertEqual(len(items), 2)
|
||||
self.assertEqual({item['status'] for item in items}, {'draft', 'stale'})
|
||||
# 持续整理的小任务不进默认列表(以前上千条把手动任务挤出了列表),只在概况里汇总
|
||||
self.assertEqual(len(self.store.jobs('default')), 1)
|
||||
self.assertEqual(len(self.store.jobs('default', include_auto=True)), 2)
|
||||
self.assertEqual(self.store.auto_summary('default')['jobs_24h'], 1)
|
||||
|
||||
def test_publish_checks_source_again_after_vector_upload(self):
|
||||
self.process()
|
||||
item = self.first()
|
||||
item['conditions'] = '通用预约流程'
|
||||
item = self.store.save('default', item['id'], item, self.actor, '')
|
||||
self.store.transition('default', item['id'], item['revision'], 'approve', self.actor, '', True)
|
||||
def changed(_item):
|
||||
payload = self.payload()
|
||||
payload['messages'][1]['status'] = 'revoked'
|
||||
self.archive.import_messages(payload, self.actor, '')
|
||||
return 'profile'
|
||||
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
||||
index.return_value.configured = True
|
||||
index.return_value.publish.side_effect = changed
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.publish('default', item['id'], item['revision'], self.actor, '')
|
||||
self.assertFalse(KnowledgeRetriever(self.store).search('default', '预约挂号')['hits'])
|
||||
|
||||
def test_model_call_budget_is_durable_on_failure(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
with mock.patch('knowledge_models.resolve_model', side_effect=lambda db, options: options.update(model_provider_id='test-model')):
|
||||
job = self.start_job(engine='model', max_model_calls=1)
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=ValueError('模型整理失败')) as enhance:
|
||||
KnowledgeWorker(self.store).step()
|
||||
failed = self.store.job('default', job['id'])
|
||||
self.assertEqual((failed['status'], failed['model_calls']), ('failed', 1))
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(enhance.call_count, 1)
|
||||
|
||||
def test_reindex_changes_only_current_publications(self):
|
||||
from knowledge_worker import reindex
|
||||
self.process()
|
||||
item = self.publish()
|
||||
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
||||
index.return_value.configured = True
|
||||
index.return_value.publish.return_value = 'profile-new'
|
||||
self.assertEqual(reindex(self.store, 'default'), 1)
|
||||
self.assertEqual(self.first()['vector_profile'], 'profile-new')
|
||||
def disable(_item):
|
||||
self.store.transition('default', item['id'], item['revision'], 'disable', self.actor, '')
|
||||
return 'profile-after-disable'
|
||||
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
||||
index.return_value.configured = True
|
||||
index.return_value.publish.side_effect = disable
|
||||
self.assertEqual(reindex(self.store, 'default'), 0)
|
||||
self.assertEqual(self.first()['vector_profile'], 'profile-new')
|
||||
|
||||
def test_query_uses_tail_customer_bubbles_not_old_history(self):
|
||||
from knowledge_processing import latest_query
|
||||
chat = '客服 10:00\n旧话题\n客户 10:01\n我要预约\n客户 10:02\n需要什么材料?'
|
||||
self.assertEqual(latest_query(chat), '我要预约\n需要什么材料?')
|
||||
self.assertEqual(latest_query('[语音] 00:05'), '[语音] 00:05')
|
||||
|
||||
def test_dates_use_business_timezone_and_prompt_does_not_mutate_input(self):
|
||||
self.assertEqual(day_boundary('2026-09-16'), '2026-09-15T16:00:00.000+00:00')
|
||||
messages = [{'role': 'user', 'content': '怎么预约'}]
|
||||
changed = inject_references(messages, [])
|
||||
self.assertEqual(messages[0]['content'], '怎么预约')
|
||||
self.assertIn('不要编造', changed[0]['content'])
|
||||
|
||||
def test_preview_is_read_only_scoped_and_counts_only_direct_conversations(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
self.archive.import_messages(self.payload('tenant_b'), self.actor, '')
|
||||
group = self.payload(conversation='R:group')
|
||||
for row in group['messages']:
|
||||
row['source_message_id'] = 'group-' + row['source_message_id']
|
||||
row['conversation']['conversation_type'] = 'group'
|
||||
self.archive.import_messages(group, self.actor, '')
|
||||
with self.db.connect() as db:
|
||||
source = db.execute("SELECT id FROM archive_source_account WHERE tenant_id='default'").fetchone()[0]
|
||||
options = {'source_account_id': source, 'max_messages': 1}
|
||||
preview = self.store.preview_job('default', options)
|
||||
self.assertEqual((preview['available_messages'], preview['total_messages'], preview['conversations']), (2, 1, 1))
|
||||
self.assertEqual(preview['eligible_text_messages'], 2)
|
||||
self.assertTrue(preview['limited'])
|
||||
self.assertEqual(self.store.jobs('default'), [])
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.preview_job('tenant_b', options)
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.preview_job('default', {**options, 'date_from': '2026-09-16', 'date_to': '2026-09-15'})
|
||||
empty = self.store.preview_job('default', {**options, 'date_from': '2099-01-01'})
|
||||
self.assertEqual(empty['total_messages'], 0)
|
||||
|
||||
def test_exact_limit_preserves_complete_final_answer_and_progress(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job(max_messages=2)
|
||||
self.assertEqual((job['total_messages'], job['progress_percent']), (2, 0))
|
||||
KnowledgeWorker(self.store).step()
|
||||
finished = self.store.job('default', job['id'])
|
||||
self.assertEqual((finished['processed'], finished['progress_percent'], finished['completion_reason']),
|
||||
(2, 100, 'source_exhausted'))
|
||||
self.assertEqual(finished['created_items'], 1)
|
||||
|
||||
def test_real_progress_and_limit_reason(self):
|
||||
rows = [('unknown', '系统消息')] * 401
|
||||
self.archive.import_messages(self.payload(messages=rows), self.actor, '')
|
||||
job = self.start_job(max_messages=201)
|
||||
worker = KnowledgeWorker(self.store)
|
||||
worker.step()
|
||||
partial = self.store.job('default', job['id'])
|
||||
self.assertEqual((partial['processed'], partial['total_messages'], partial['progress_percent']), (200, 201, 99))
|
||||
worker.step()
|
||||
final = self.store.job('default', job['id'])
|
||||
self.assertEqual((final['processed'], final['completion_reason']), (201, 'message_limit'))
|
||||
|
||||
def test_cancel_fences_an_inflight_batch_and_allows_replacement(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job()
|
||||
with self.assertRaisesRegex(ValueError, '已有未完成任务'):
|
||||
self.start_job()
|
||||
worker = KnowledgeWorker(self.store)
|
||||
original = worker.rows
|
||||
def cancel_after_read(row, size):
|
||||
rows = original(row, size)
|
||||
self.store.job_action('default', job['id'], 'cancel', self.actor, '')
|
||||
return rows
|
||||
with mock.patch.object(worker, 'rows', side_effect=cancel_after_read):
|
||||
worker.step()
|
||||
self.assertEqual(self.store.job('default', job['id'])['status'], 'cancelled')
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
replacement = self.start_job()
|
||||
worker.step()
|
||||
self.assertEqual(self.store.job('default', replacement['id'])['created_items'], 1)
|
||||
|
||||
def test_enabling_requires_current_unexpired_publication(self):
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.set_enabled('default', True, self.actor, '')
|
||||
self.process()
|
||||
item = self.publish()
|
||||
self.store.set_enabled('default', True, self.actor, '')
|
||||
self.store.transition('default', item['id'], item['revision'], 'disable', self.actor, '')
|
||||
self.store.set_enabled('default', False, self.actor, '')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.set_enabled('default', True, self.actor, '')
|
||||
|
||||
def test_review_and_publication_validate_expiry_and_state(self):
|
||||
self.process()
|
||||
item = self.first()
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.transition('default', item['id'], item['revision'], 'disable', self.actor, '')
|
||||
item['conditions'], item['valid_until'] = '通用预约流程', '2000-01-01'
|
||||
item = self.store.save('default', item['id'], item, self.actor, '')
|
||||
with self.assertRaisesRegex(ValueError, '有效期'):
|
||||
self.store.transition('default', item['id'], item['revision'], 'approve', self.actor, '', True)
|
||||
item['valid_until'] = '2099-01-01'
|
||||
item = self.store.save('default', item['id'], item, self.actor, '')
|
||||
self.store.transition('default', item['id'], item['revision'], 'approve', self.actor, '', True)
|
||||
with mock.patch.object(KnowledgeRetriever, '_today', return_value='2099-01-02'):
|
||||
with self.assertRaisesRegex(ValueError, '有效期'):
|
||||
self.store.publish('default', item['id'], item['revision'], self.actor, '')
|
||||
|
||||
def test_preview_eligible_text_follows_archive_direction(self):
|
||||
"""单聊里收发方向以归档为准。以前还要求发送者身份对上来源账号,身份没关联的账号
|
||||
几乎所有客服回复都被当成方向不明丢掉;方向本身不明的仍然不算。"""
|
||||
payload = self.payload(messages=[('inbound', '预约挂号需要什么材料?'), ('outbound', '请先确认日期。'), ('unknown', '无法确认角色')])
|
||||
payload['messages'][1]['sender']['external_id'] = 'other-person'
|
||||
self.archive.import_messages(payload, self.actor, '')
|
||||
with self.db.connect() as db:
|
||||
source = db.execute('SELECT id FROM archive_source_account').fetchone()[0]
|
||||
preview = self.store.preview_job('default', {'source_account_id': source})
|
||||
self.assertEqual((preview['available_messages'], preview['eligible_text_messages']), (3, 2))
|
||||
job = self.start_job()
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
finished = self.store.job('default', job['id'])
|
||||
self.assertEqual((finished['created_items'], finished['skip_reasons']), (1, {'unknown_direction': 1}))
|
||||
|
||||
|
||||
|
||||
class KnowledgeApiTest(TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.db = admin_backend.Database(Path(self.temp.name) / 'test.db')
|
||||
self.db.initialize('InitialAdmin123')
|
||||
actor = self.db.authenticate('admin', 'InitialAdmin123')['id']
|
||||
self.db.change_password(actor, 'InitialAdmin123', 'ChangedAdmin@2026', '')
|
||||
self.client = TestClient(admin_api.create_app(self.db.path))
|
||||
response = self.client.post('/api/v2/auth/login', json={'username': 'admin', 'password': 'ChangedAdmin@2026'})
|
||||
self.headers = {'Authorization': 'Bearer ' + response.json()['access_token']}
|
||||
|
||||
def tearDown(self):
|
||||
self.client.close()
|
||||
self.temp.cleanup()
|
||||
|
||||
def test_api_authentication_and_all_scope_write_rejection(self):
|
||||
self.assertEqual(self.client.get('/api/v2/knowledge/overview').status_code, 401)
|
||||
self.assertEqual(self.client.get('/api/v2/knowledge/overview', headers=self.headers).status_code, 200)
|
||||
result = self.client.put('/api/v2/knowledge/settings?account_id=-1', headers=self.headers, json={'enabled': True})
|
||||
self.assertEqual(result.status_code, 400)
|
||||
result = self.client.post('/api/v2/knowledge/search', headers=self.headers, json={'query': '预约挂号'})
|
||||
self.assertEqual(result.status_code, 200)
|
||||
self.assertEqual(result.json()['hits'], [])
|
||||
|
||||
def test_empty_export_is_valid_and_audited(self):
|
||||
response = self.client.get('/api/v2/knowledge/export', headers=self.headers)
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.text, '')
|
||||
with self.db.connect() as db:
|
||||
self.assertIsNotNone(db.execute("SELECT 1 FROM audit_log WHERE action='knowledge.export'").fetchone())
|
||||
|
||||
def test_preview_auth_scope_and_enable_empty_library(self):
|
||||
actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
|
||||
ArchiveStore(self.db).import_messages(KnowledgeTest.payload(self), actor, '')
|
||||
with self.db.connect() as db:
|
||||
source = db.execute('SELECT id FROM archive_source_account').fetchone()[0]
|
||||
body = {'source_account_id': source}
|
||||
url = '/api/v2/knowledge/jobs/preview'
|
||||
self.assertEqual(self.client.post(url, json=body).status_code, 401)
|
||||
self.assertEqual(self.client.post(url + '?account_id=-1', json=body, headers=self.headers).status_code, 400)
|
||||
response = self.client.post(url, json=body, headers=self.headers)
|
||||
self.assertEqual(response.status_code, 200, response.text)
|
||||
self.assertEqual(response.json()['total_messages'], 2)
|
||||
enabled = self.client.put('/api/v2/knowledge/settings', json={'enabled': True}, headers=self.headers)
|
||||
self.assertEqual(enabled.status_code, 400)
|
||||
self.db.create_user('reviewer', 'InitialReader123', 'viewer', actor, '')
|
||||
reader = self.db.authenticate('reviewer', 'InitialReader123')['id']
|
||||
self.db.change_password(reader, 'InitialReader123', 'ChangedReader@2026', '')
|
||||
with self.db.connect() as db:
|
||||
db.execute("INSERT OR IGNORE INTO role_permissions VALUES ('viewer','knowledge:write')")
|
||||
db.execute("DELETE FROM role_permissions WHERE role_code='viewer' AND permission_code='im:content:read'")
|
||||
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, json=body, headers=headers).status_code, 403)
|
||||
|
||||
|
||||
|
||||
class KnowledgeGatewayTest(TestCase):
|
||||
from test_model_gateway import GatewayEndpointTest as _fixture
|
||||
setUp = _fixture.setUp
|
||||
_post_then_drain = _fixture._post_then_drain
|
||||
_post = _fixture._post
|
||||
_upstream = _fixture._upstream
|
||||
|
||||
def tearDown(self):
|
||||
import shutil
|
||||
assert self.root.parent.resolve() == Path(tempfile.gettempdir()).resolve()
|
||||
shutil.rmtree(self.root)
|
||||
|
||||
def seed(self):
|
||||
self.db = admin_backend.Database(self.db_path)
|
||||
with self.db.connect() as db:
|
||||
self.actor = db.execute("SELECT id FROM users WHERE username='admin'").fetchone()[0]
|
||||
self.store = KnowledgeStore(self.db)
|
||||
self.archive = ArchiveStore(self.db)
|
||||
tenant = self.desktop_account['tenant_id']
|
||||
self.archive.import_messages(KnowledgeTest.payload(self, tenant), self.actor, '')
|
||||
KnowledgeTest.start_job(self, tenant)
|
||||
while KnowledgeWorker(self.store).step():
|
||||
pass
|
||||
item = KnowledgeTest.first(self, tenant)
|
||||
item['conditions'] = '通用门诊预约'
|
||||
item = self.store.save(tenant, item['id'], item, self.actor, '')
|
||||
self.store.transition(tenant, item['id'], item['revision'], 'approve', self.actor, '', True)
|
||||
self.store.publish(tenant, item['id'], item['revision'], self.actor, '')
|
||||
self.store.set_enabled(tenant, True, self.actor, '')
|
||||
return item
|
||||
|
||||
def test_reply_receives_evidence_and_records_version(self):
|
||||
import httpx
|
||||
item = self.seed()
|
||||
sent = []
|
||||
def handler(request):
|
||||
sent.append(json.loads(request.content.decode()))
|
||||
return httpx.Response(200, json={'choices': [{'message': {'content': '请先确认就诊日期和科室。'}}]})
|
||||
response, _ = self._post_then_drain(handler, body={'customer_text': '预约挂号需要什么材料?', 'task_id': 'rag-1'})
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.json()['knowledge']['hits'][0]['id'], item['id'])
|
||||
self.assertTrue(any('已审核知识参考' in json.dumps(body, ensure_ascii=False) for body in sent))
|
||||
with self.db.connect() as db:
|
||||
log = db.execute("SELECT hits_json FROM knowledge_retrieval_log WHERE task_id='rag-1'").fetchone()
|
||||
self.assertEqual(json.loads(log[0])[0]['revision'], item['revision'])
|
||||
|
||||
def test_internal_purpose_skips_retrieval(self):
|
||||
self.seed()
|
||||
response, _ = self._post_then_drain(self._upstream(), body={'customer_text': '预约挂号', 'task_id': 'guard-rag', 'purpose': 'guard'})
|
||||
self.assertFalse(response.json()['knowledge']['enabled'])
|
||||
|
||||
def test_disabled_reference_is_not_served_from_idempotency_cache(self):
|
||||
item = self.seed()
|
||||
body = {'customer_text': '预约挂号', 'task_id': 'cache-rag'}
|
||||
headers = {'X-Idempotency-Key': 'cache-rag-key'}
|
||||
response = self._post(self._upstream(), headers=headers, body=body)
|
||||
self.assertTrue(response.json()['knowledge']['hits'])
|
||||
self.store.transition(self.desktop_account['tenant_id'], item['id'], item['revision'], 'disable', self.actor, '')
|
||||
response = self._post(self._upstream(), headers=headers, body=body)
|
||||
self.assertEqual(response.json()['knowledge']['hits'], [])
|
||||
@@ -0,0 +1,163 @@
|
||||
"""Model output tolerance must preserve evidence and the human review gate."""
|
||||
import copy
|
||||
import json
|
||||
from unittest import TestCase, mock
|
||||
|
||||
import test_knowledge_tasks as fixtures
|
||||
from knowledge_model_output import ModelOutputError, normalize_output, original_draft
|
||||
from knowledge_worker import KnowledgeWorker
|
||||
|
||||
|
||||
def candidate():
|
||||
return {'title': '原始测试问题', 'question': '虚构门店预约需要提前多久?',
|
||||
'answer': '测试门店请提前一天预约,具体以当天安排为准。',
|
||||
'conditions': '', 'category': '待分类', 'kind': 'qa', 'flags': ['来源需核对'],
|
||||
'sources': [{'message_id': 'synthetic-1', 'content': '完整原始测试证据'}]}
|
||||
|
||||
|
||||
def fields(**overrides):
|
||||
return {'title': '测试预约', 'question': '测试门店何时预约?',
|
||||
'answer': '测试门店应提前一天预约,以当天安排为准。',
|
||||
'conditions': '仅限虚构测试门店', 'category': '预约咨询', 'kind': 'qa', **overrides}
|
||||
|
||||
|
||||
class ModelOutputTest(TestCase):
|
||||
def test_missing_auxiliary_fields_are_safe_and_conditions_remain_empty(self):
|
||||
source = candidate(); before = copy.deepcopy(source)
|
||||
for values in ({'question': '测试问题?', 'answer': '仅供虚构门店验收的测试答案。'},
|
||||
fields(title=None, conditions=None, category=None, kind=None),
|
||||
fields(title=[], conditions={}, category=2, kind=[])):
|
||||
with self.subTest(values=values):
|
||||
result, _, _ = normalize_output(source, json.dumps(values), 100)
|
||||
self.assertTrue(result['title'])
|
||||
self.assertEqual(result['conditions'], '')
|
||||
self.assertEqual(result['category'], '待分类')
|
||||
self.assertEqual(result['kind'], 'qa')
|
||||
self.assertEqual(result['sources'], source['sources'])
|
||||
self.assertEqual(source, before, 'Model processing must not corrupt pending evidence')
|
||||
|
||||
def test_auxiliary_lengths_and_aliases_do_not_truncate_core_facts(self):
|
||||
data = fields(title='题' * 200, conditions='条件' * 1100, category='类' * 120, kind='标准问答')
|
||||
result, _, _ = normalize_output(candidate(), json.dumps(data), 10)
|
||||
self.assertEqual(len(result['title']), 160)
|
||||
self.assertEqual(result['question'], '测试门店何时预约?')
|
||||
self.assertEqual(result['answer'], '测试门店应提前一天预约,以当天安排为准。')
|
||||
self.assertEqual(result['conditions'], '')
|
||||
self.assertEqual(result['category'], '待分类')
|
||||
self.assertEqual(result['kind'], 'qa')
|
||||
self.assertTrue(any('适用条件' in flag for flag in result['flags']))
|
||||
|
||||
def test_bad_core_fields_raise_specific_safe_errors_and_leave_source_untouched(self):
|
||||
source = candidate(); before = copy.deepcopy(source)
|
||||
for key, value, word in [('question', '', '问题'), ('question', None, '问题'),
|
||||
('answer', ['不应拼接'], '答案'), ('answer', {}, '答案'),
|
||||
('answer', '字' * 8001, '8000'), ('question', '字' * 4001, '4000'),
|
||||
('answer', '\u337f' * 3000, '8000')]:
|
||||
raw = json.dumps(fields(**{key: value}), ensure_ascii=False)
|
||||
with self.subTest(key=key, value_type=type(value).__name__):
|
||||
with self.assertRaisesRegex(ModelOutputError, word) as raised:
|
||||
normalize_output(source, raw, 123)
|
||||
self.assertEqual((raised.exception.input_chars, raised.exception.output_chars), (123, len(raw)))
|
||||
self.assertEqual(source, before)
|
||||
|
||||
def test_invalid_json_and_empty_results_do_not_retain_raw_response(self):
|
||||
for raw in ('{"private-response":', '["private-response"]', '', None):
|
||||
with self.assertRaises(ModelOutputError) as raised:
|
||||
normalize_output(candidate(), raw, 75)
|
||||
self.assertNotIn('private-response', str(raised.exception))
|
||||
self.assertEqual(raised.exception.input_chars, 75)
|
||||
raw = '\ufeff```JSON\n' + json.dumps(fields()) + '\n```'
|
||||
result, _, count = normalize_output(candidate(), raw, 60)
|
||||
self.assertEqual(result['answer'], '测试门店应提前一天预约,以当天安排为准。')
|
||||
self.assertEqual(count, len(raw))
|
||||
|
||||
def test_fallback_retains_complete_original_even_when_long(self):
|
||||
source = candidate(); source['answer'] = '原始业务限制。' * 1500
|
||||
result = original_draft(source, ModelOutputError('模型答案字段为空'))
|
||||
self.assertEqual(result['answer'], source['answer'])
|
||||
self.assertEqual(result['sources'], source['sources'])
|
||||
self.assertEqual(result['conditions'], '')
|
||||
self.assertIn('不能直接发布', result['flags'][-1])
|
||||
self.assertEqual(len(source['flags']), 1)
|
||||
|
||||
|
||||
class ModelOutputWorkerTest(TestCase):
|
||||
setUp = fixtures.KnowledgeTaskTest.setUp
|
||||
tearDown = fixtures.KnowledgeTaskTest.tearDown
|
||||
payload = fixtures.KnowledgeTaskTest.payload
|
||||
start_job = fixtures.KnowledgeTaskTest.start_job
|
||||
|
||||
def seed(self):
|
||||
self.archive.import_messages(self.payload(messages=[
|
||||
('inbound', '虚构门店需要提前多久预约?'), ('outbound', '测试门店请提前一天预约,以当天确认结果为准。'),
|
||||
('inbound', '测试门店周末的营业时间是几点?'), ('outbound', '测试门店周末上午九点至下午五点营业。')]), self.actor, '')
|
||||
return self.start_job(engine='model', model_provider_id='alpha')
|
||||
|
||||
def test_invalid_response_is_quarantined_as_draft_and_next_pair_continues(self):
|
||||
job = self.seed()
|
||||
first_reply = json.dumps(fields(answer=None))
|
||||
second_reply = json.dumps(fields(title='正常第二条', question='测试门店周末几点营业?'))
|
||||
async def reply(client, outlet, messages, **kwargs):
|
||||
# 两段问答并发整理,调用顺序不固定:按问题内容决定回什么
|
||||
return {'text': first_reply if '提前多久预约' in messages[0]['content'] else second_reply, 'error': ''}
|
||||
with mock.patch('model_gateway.call_outlet', side_effect=reply):
|
||||
KnowledgeWorker(self.store).step()
|
||||
result = self.store.job('default', job['id'])
|
||||
self.assertEqual((result['status'], result['created_items'], result['pending_items'], result['model_calls']), ('completed', 2, 0, 2))
|
||||
self.assertEqual(result['options']['model_format_fallbacks'], 1)
|
||||
self.assertIn('答案', result['options']['model_last_warning'])
|
||||
self.assertEqual(result['output_chars'], len(first_reply) + len(second_reply))
|
||||
items = self.store.list_items('default')['items']
|
||||
original = next(item for item in items if any('模型格式异常' in flag for flag in item['flags']))
|
||||
self.assertEqual(original['question'], '虚构门店需要提前多久预约?')
|
||||
self.assertEqual(original['answer'], '测试门店请提前一天预约,以当天确认结果为准。')
|
||||
self.assertEqual(original['conditions'], '')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.transition('default', original['id'], original['revision'], 'approve', self.actor, '', True)
|
||||
self.assertEqual(len(self.store.detail('default', original['id'])['sources']), 2)
|
||||
|
||||
def test_fallback_commit_survives_later_transport_failure_and_resume(self):
|
||||
job = self.seed()
|
||||
async def reply(client, outlet, messages, **kwargs):
|
||||
if '提前多久预约' in messages[0]['content']:
|
||||
return {'text': 'incomplete JSON', 'error': ''}
|
||||
return {'text': '', 'error': '上游返回 429: private-provider-body'}
|
||||
with mock.patch('model_gateway.call_outlet', side_effect=reply):
|
||||
KnowledgeWorker(self.store).step()
|
||||
# 限流是临时错误:保存好的结果留着,任务放回队列、退避后自动重试,而不是停下来等人
|
||||
waiting = self.store.job('default', job['id'])
|
||||
self.assertEqual((waiting['status'], waiting['created_items'], waiting['pending_items']), ('queued', 1, 1))
|
||||
self.assertEqual(waiting['options']['model_format_fallbacks'], 1)
|
||||
self.assertIn('429', waiting['error']); self.assertIn('自动重试', waiting['error'])
|
||||
self.assertNotIn('private-provider-body', waiting['error'])
|
||||
self.assertFalse(KnowledgeWorker(self.store).step(), 'A backing-off job must not be claimed early')
|
||||
self.store.job_action('default', job['id'], 'pause', self.actor, '')
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': json.dumps(fields()), 'error': ''}
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(call.call_count, 1)
|
||||
result = self.store.job('default', job['id'])
|
||||
self.assertEqual((result['status'], result['created_items'], result['model_calls']), ('completed', 2, 3))
|
||||
self.assertEqual(result['options']['model_format_fallbacks'], 1)
|
||||
|
||||
def test_cancel_during_invalid_response_does_not_save_fallback(self):
|
||||
job = self.seed()
|
||||
async def cancel(*args, **kwargs):
|
||||
self.store.job_action('default', job['id'], 'cancel', self.actor, '')
|
||||
return {'text': '{}', 'error': ''}
|
||||
with mock.patch('model_gateway.call_outlet', side_effect=cancel):
|
||||
KnowledgeWorker(self.store).step()
|
||||
result = self.store.job('default', job['id'])
|
||||
self.assertEqual((result['status'], result['created_items'], result['pending_items']), ('cancelled', 0, 0))
|
||||
self.assertEqual(result['options'].get('model_format_fallbacks', 0), 0)
|
||||
|
||||
def test_normalized_empty_conditions_cannot_be_approved_without_editing(self):
|
||||
job = self.seed()
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': json.dumps(fields(conditions=None)), 'error': ''}
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(self.store.job('default', job['id'])['status'], 'completed')
|
||||
for item in self.store.list_items('default')['items']:
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.transition('default', item['id'], item['revision'], 'approve', self.actor, '', True)
|
||||
@@ -0,0 +1,267 @@
|
||||
"""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_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'):
|
||||
self.process(tenant)
|
||||
original = self.first(tenant)
|
||||
original['conditions'] = '仅用于虚构门店测试'
|
||||
original = self.store.save(tenant, original['id'], original, self.actor, '')
|
||||
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']))
|
||||
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('default', 0, self.actor, '')
|
||||
self.assertEqual((job['total'], job['preview']['eligible'], job['preview']['blocked']), (6, 1, 5))
|
||||
self.assertEqual({reason['code'] for reason in job['preview']['reasons']},
|
||||
{'missing_conditions', 'invalid_fields', 'expired', 'missing_source', 'changed_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, 5))
|
||||
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('default', 0, self.actor, '')
|
||||
edit = self.store.detail('default', ids[0]); edit['answer'] = '已经编辑的新答案,需要重新审核。'
|
||||
self.store.save('default', ids[0], edit, self.actor, '')
|
||||
self.store.transition('default', ids[1], 2, 'reject', self.actor, '')
|
||||
self.store.delete_rejected('default', ids[1], 2, self.actor, '')
|
||||
with self.db.connect() as db:
|
||||
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']), (4, 1, 3))
|
||||
self.assertEqual(self.store.stats('new-tenant'), {'draft': 1})
|
||||
reasons = {row['reason'] for row in reviews.results(job['id'], self.actor, '*')['items']}
|
||||
self.assertEqual(reasons, {'changed_item', 'deleted'})
|
||||
|
||||
def test_single_account_scope_and_snapshot_excludes_later_drafts(self):
|
||||
self.seed(33); self.seed(4, 'other')
|
||||
reviews = KnowledgeReviewStore(self.store)
|
||||
job = reviews.preview('default', 0, 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_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()
|
||||
result = reviews.get(job['id'], self.actor)
|
||||
self.assertEqual((result['status'], result['approved']), ('failed', 2))
|
||||
with self.db.connect() as db:
|
||||
db.execute("INSERT INTO role_permissions VALUES ('admin','knowledge:review')")
|
||||
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()
|
||||
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_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','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_restricted_all_accounts_and_revocation_during_background_execution(self):
|
||||
self.actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
|
||||
self.store = self.client.app.state.knowledge_store
|
||||
self.archive = ArchiveStore(self.db)
|
||||
accounts = []
|
||||
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)
|
||||
self.seed(10 + index, account['tenant_id'])
|
||||
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','im:content:read')])
|
||||
for account in accounts[:2]:
|
||||
self.db.set_desktop_account_admins(account['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, 403)
|
||||
single = self.client.post(url + '/preview?account_id=' + str(accounts[0]['id']), headers=headers)
|
||||
self.assertEqual(single.json()['total'], 10)
|
||||
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'], 21)
|
||||
self.assertEqual(len(job['preview']['accounts']), 2)
|
||||
self.db.set_desktop_account_admins(accounts[1]['id'], [], self.actor, '')
|
||||
response = self.client.post(url + '/' + job['id'] + '/start', headers=headers, json={'confirmed': True})
|
||||
self.assertEqual(response.status_code, 200, response.text)
|
||||
KnowledgeReviewWorker(self.store).step()
|
||||
final = self.client.get(url + '/' + job['id'], headers=headers).json()
|
||||
self.assertEqual((final['approved'], final['skipped']), (10, 11))
|
||||
self.assertEqual(self.store.stats(accounts[2]['tenant_id']), {'draft': 12})
|
||||
self.assertEqual(self.store.stats(accounts[1]['tenant_id']), {'draft': 11})
|
||||
results = self.client.get(url + '/' + job['id'] + '/results', headers=headers).json()
|
||||
self.assertEqual(results['total'], 0, 'Do not expose titles from revoked accounts')
|
||||
@@ -0,0 +1,497 @@
|
||||
"""整理批次(一次整理全部账号、全部聊天)、模型清洗、并发和 v2 提取规则。"""
|
||||
import asyncio
|
||||
import json
|
||||
import threading
|
||||
import time
|
||||
from types import SimpleNamespace
|
||||
from unittest import TestCase, mock
|
||||
|
||||
from archive_store import ArchiveStore
|
||||
from knowledge_model_output import ModelDiscard
|
||||
from knowledge_models import model_choices, resolve_model, safe_model_error
|
||||
from knowledge_processing import classify, feed, finish
|
||||
from knowledge_worker import KnowledgeWorker, enhance
|
||||
import test_knowledge as fixtures
|
||||
import test_knowledge_tasks as tasks
|
||||
|
||||
|
||||
def fields(**overrides):
|
||||
return {'keep': True, 'title': '测试标题', 'question': '测试门店几点营业?', 'answer': '测试门店上午九点营业。',
|
||||
'conditions': '仅限虚构测试门店', 'category': '营业时间', 'kind': 'qa', **overrides}
|
||||
|
||||
|
||||
def row(index, direction, content, kind='文本', status='normal', conversation='c1'):
|
||||
return {'id': f'm{index}', 'version_no': 1, 'conversation_id': conversation, 'source_account_id': 's1',
|
||||
'sender_person_id': 'customer' if direction == 'inbound' else 'staff', 'sender_name': '',
|
||||
'message_type': kind, 'direction': direction, 'status': status, 'content': content,
|
||||
'sent_at': f'2026-10-07T00:00:{index:02d}.000+00:00', 'sent_at_epoch': 1791331200 + index}
|
||||
|
||||
|
||||
def run_rules(rows):
|
||||
state, out = {}, []
|
||||
for item in rows:
|
||||
state, emitted = feed(state, item)
|
||||
out.extend(emitted)
|
||||
last = finish(state)
|
||||
return out + ([last] if last else [])
|
||||
|
||||
|
||||
class ExtractionRulesTest(TestCase):
|
||||
def test_media_inside_a_pair_becomes_a_placeholder_instead_of_dropping_it(self):
|
||||
out = run_rules([row(1, 'inbound', '请问代煎多久能发货?'), row(2, 'inbound', '', '图片'),
|
||||
row(3, 'outbound', '代煎一般两到三个工作日发货。')])
|
||||
self.assertEqual(len(out), 1)
|
||||
self.assertIn('[图片]', out[0]['question'])
|
||||
self.assertTrue(any('非文字' in flag for flag in out[0]['flags']))
|
||||
|
||||
def test_system_and_revoked_messages_do_not_break_a_pair(self):
|
||||
out = run_rules([row(1, 'inbound', '请问代煎多久能发货?'), row(2, 'inbound', '对方撤回了一条消息', '系统消息'),
|
||||
row(3, 'outbound', '旧的说法', status='revoked'), row(4, 'outbound', '代煎一般两到三个工作日发货。')])
|
||||
self.assertEqual(len(out), 1)
|
||||
self.assertEqual(out[0]['answer'], '代煎一般两到三个工作日发货。')
|
||||
self.assertEqual([s['message_id'] for s in out[0]['sources']], ['m1', 'm4'])
|
||||
|
||||
def test_quote_reply_counts_as_text(self):
|
||||
out = run_rules([row(1, 'inbound', '请问代煎多久能发货?'), row(2, 'outbound', '代煎一般两到三个工作日发货。', '引用')])
|
||||
self.assertEqual(len(out), 1)
|
||||
|
||||
def test_media_only_question_is_not_knowledge(self):
|
||||
self.assertEqual(run_rules([row(1, 'inbound', '', '截图'), row(2, 'outbound', '好的,我看一下这个问题马上回复您。')]), [])
|
||||
|
||||
def test_every_skip_has_a_reason(self):
|
||||
self.assertEqual(classify(row(1, 'inbound', 'x', status='revoked')), ('skip', 'revoked'))
|
||||
self.assertEqual(classify(row(1, 'inbound', 'x', '系统通知')), ('skip', 'system'))
|
||||
self.assertEqual(classify(row(1, 'unknown', 'x')), ('skip', 'unknown_direction'))
|
||||
self.assertEqual(classify(row(1, 'inbound', ' ')), ('skip', 'empty'))
|
||||
self.assertEqual(classify(row(1, 'inbound', '', '语音')), ('media', ''))
|
||||
self.assertEqual(classify(row(1, 'inbound', '你好')), ('text', ''))
|
||||
|
||||
|
||||
class RunTest(TestCase):
|
||||
setUp = tasks.KnowledgeTaskTest.setUp
|
||||
tearDown = tasks.KnowledgeTaskTest.tearDown
|
||||
payload = fixtures.KnowledgeTest.payload
|
||||
start_job = fixtures.KnowledgeTest.start_job
|
||||
|
||||
def seed(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
self.archive.import_messages(self.payload('tenant_b'), self.actor, '')
|
||||
second = self.payload(conversation='S:other', messages=[
|
||||
('inbound', '测试门店周末几点开门?'), ('outbound', '测试门店周末上午九点开门,下午五点关门。')])
|
||||
second['source_account'] = {'external_account_id': 'staff-02', 'display_name': '客服二号'}
|
||||
for message in second['messages']:
|
||||
message['source_message_id'] = 'second-' + message['source_message_id']
|
||||
if message['direction'] == 'outbound':
|
||||
message['sender']['external_id'] = 'staff-02'
|
||||
self.archive.import_messages(second, self.actor, '')
|
||||
|
||||
def drain(self):
|
||||
worker = KnowledgeWorker(self.store)
|
||||
while worker.step():
|
||||
pass
|
||||
|
||||
def rules_run(self, tenants=None, **values):
|
||||
return self.store.create_run(tenants or self.store.scope_tenants('*'),
|
||||
{'engine': 'rules', 'staff_confirmed': True, **values}, self.actor, '',
|
||||
scope_label='全部账号')
|
||||
|
||||
def test_one_click_washes_every_account_and_every_source(self):
|
||||
self.seed()
|
||||
tenants = self.store.scope_tenants('*')
|
||||
self.assertEqual(tenants, ['default', 'tenant_b'])
|
||||
preview = self.store.preview_run(tenants, {})
|
||||
self.assertEqual((len(preview['accounts']), preview['totals']['messages'], preview['totals']['text_messages']), (2, 6, 6))
|
||||
with self.assertRaisesRegex(ValueError, '确认'):
|
||||
self.store.create_run(tenants, {'engine': 'rules'}, self.actor, '')
|
||||
run = self.rules_run(auto_watch=True)
|
||||
self.assertEqual((run['status'], len(run['accounts'])), ('running', 2))
|
||||
self.assertEqual(self.store.auto_summary('*')['watching_sources'], 3)
|
||||
self.assertTrue(run['label'].startswith('全部账号'))
|
||||
self.drain()
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual((run['status'], run['progress_percent'], run['processed'], run['created_items']), ('completed', 100, 6, 3))
|
||||
self.assertEqual({account['status'] for account in run['accounts']}, {'completed'})
|
||||
# 新消息自动整理产生的任务、旧的单账号任务都不会挤进批次
|
||||
self.assertEqual(self.store.jobs('default')[0]['options']['max_messages'], 0)
|
||||
|
||||
def test_runs_refuse_overlap_and_support_pause_resume_cancel(self):
|
||||
self.seed()
|
||||
run = self.rules_run()
|
||||
with self.assertRaisesRegex(ValueError, '未完成'):
|
||||
self.rules_run()
|
||||
self.assertEqual(self.store.run_action('*', run['id'], 'pause', self.actor, '')['status'], 'paused')
|
||||
self.assertFalse(KnowledgeWorker(self.store).step(), 'Paused runs must not be processed')
|
||||
self.assertEqual(self.store.run_action('*', run['id'], 'resume', self.actor, '')['status'], 'running')
|
||||
self.assertEqual(self.store.run_action('*', run['id'], 'cancel', self.actor, '')['status'], 'cancelled')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.run_action('*', run['id'], 'resume', self.actor, '')
|
||||
self.assertEqual(self.rules_run()['status'], 'running')
|
||||
|
||||
def test_scoped_admins_only_see_and_control_their_accounts(self):
|
||||
self.seed()
|
||||
run = self.rules_run()
|
||||
with self.assertRaisesRegex(ValueError, '无权'):
|
||||
self.store.run_action(['default'], run['id'], 'pause', self.actor, '')
|
||||
visible = self.store.runs(['default'])['items']
|
||||
self.assertEqual([account['tenant_id'] for account in visible[0]['accounts']], ['default'])
|
||||
self.assertEqual(self.store.runs(['nobody'])['items'], [])
|
||||
|
||||
def model_seed(self):
|
||||
self.archive.import_messages(self.payload(messages=[
|
||||
('inbound', '第一个测试问题是什么?'), ('outbound', '第一个测试问题的答案在这里。'),
|
||||
('inbound', '第二个测试问题是什么?'), ('outbound', '第二个测试问题的答案在这里。'),
|
||||
('inbound', '第三个测试问题是什么?'), ('outbound', '第三个测试问题的答案在这里。'),
|
||||
('inbound', '第四个测试问题是什么?'), ('outbound', '第四个测试问题的答案在这里。')]), self.actor, '')
|
||||
|
||||
def test_model_run_filters_rewashes_untouched_drafts_and_runs_concurrently(self):
|
||||
self.model_seed()
|
||||
self.rules_run()
|
||||
self.drain()
|
||||
drafts = {item['question']: item for item in self.store.list_items('default')['items']}
|
||||
self.assertEqual(len(drafts), 4)
|
||||
edited = dict(drafts['第四个测试问题是什么?'])
|
||||
edited['conditions'] = '人工补充的条件'
|
||||
self.store.save('default', edited['id'], edited, self.actor, '')
|
||||
active, peak, lock = [0], [0], threading.Lock()
|
||||
|
||||
def wash(candidate, database, options, **context):
|
||||
with lock:
|
||||
active[0] += 1
|
||||
peak[0] = max(peak[0], active[0])
|
||||
time.sleep(0.05)
|
||||
with lock:
|
||||
active[0] -= 1
|
||||
if candidate['question'].startswith('第一个'):
|
||||
raise ModelDiscard('寒暄', 30, 20)
|
||||
return {**candidate, 'question': '清洗后:' + candidate['question'], 'answer': '清洗后:' + candidate['answer'],
|
||||
'conditions': '虚构门店'}, 40, 60
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=wash):
|
||||
run = self.store.create_run(['default'], {'engine': 'model', 'model_provider_id': 'alpha', 'model_batch': 1,
|
||||
'model_concurrency': 4, 'staff_confirmed': True}, self.actor, '')
|
||||
self.drain()
|
||||
self.assertGreaterEqual(peak[0], 2, 'Model calls should run concurrently')
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual((run['status'], run['model_calls'], run['model_filtered'], run['updated_items'], run['created_items']),
|
||||
('completed', 4, 1, 2, 0))
|
||||
items = {item['question']: item for item in self.store.list_items('default')['items']}
|
||||
self.assertEqual(len(items), 4, 'Re-washing the same conversations must not duplicate drafts')
|
||||
self.assertIn('清洗后:第二个测试问题是什么?', items)
|
||||
self.assertIn('第一个测试问题是什么?', items, 'A discarded candidate leaves the earlier draft alone')
|
||||
self.assertIn('第四个测试问题是什么?', items, 'Human-edited drafts are never overwritten')
|
||||
washed = self.store.detail('default', items['清洗后:第二个测试问题是什么?']['id'])
|
||||
self.assertEqual([entry['action'] for entry in washed['history']][:1], ['rewash'])
|
||||
# 之后再跑规则整理(或新消息触发的自动整理)不能把洗好的草稿打回原话
|
||||
later = self.rules_run(['default'])
|
||||
self.drain()
|
||||
later = self.store.run('*', later['id'])
|
||||
self.assertEqual((later['created_items'], later['updated_items'], later['duplicates']), (0, 0, 4))
|
||||
self.assertIn('清洗后:第二个测试问题是什么?', {item['question'] for item in self.store.list_items('default')['items']})
|
||||
|
||||
def test_run_budget_cap_can_be_raised_and_resumed(self):
|
||||
self.model_seed()
|
||||
reply = lambda candidate, database, options, **context: ({**candidate, 'conditions': '虚构'}, 10, 10)
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=reply) as call:
|
||||
run = self.store.create_run(['default'], {'engine': 'model', 'model_provider_id': 'alpha', 'model_concurrency': 4,
|
||||
'model_batch': 1, 'max_model_calls': 2, 'staff_confirmed': True},
|
||||
self.actor, '')
|
||||
self.drain()
|
||||
self.assertEqual(call.call_count, 2)
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual((run['status'], run['model_calls'], run['created_items']), ('failed', 2, 2))
|
||||
self.assertIn('预算', run['errors'][0])
|
||||
with self.assertRaisesRegex(ValueError, '大于'):
|
||||
self.store.configure_run('*', run['id'], {'engine': 'model', 'max_model_calls': 2}, self.actor, '')
|
||||
self.store.configure_run('*', run['id'], {'engine': 'model', 'model_provider_id': 'beta', 'max_model_calls': 0},
|
||||
self.actor, '')
|
||||
self.store.run_action('*', run['id'], 'resume', self.actor, '')
|
||||
with self.assertRaisesRegex(ValueError, '暂停'):
|
||||
self.store.configure_run('*', run['id'], {'engine': 'rules'}, self.actor, '')
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=reply) as call:
|
||||
self.drain()
|
||||
self.assertEqual(call.call_args.args[2]['model_provider_id'], 'beta')
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual((run['status'], run['model_calls'], run['created_items'], run['options']['model_name']),
|
||||
('completed', 4, 4, 'beta'))
|
||||
|
||||
def test_legacy_single_account_jobs_still_listed_and_controllable(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job()
|
||||
items = self.store.runs('default')['items']
|
||||
self.assertEqual([item['id'] for item in items], ['job:' + job['id']])
|
||||
self.assertTrue(items[0]['legacy'])
|
||||
self.assertEqual(self.store.run_action('default', 'job:' + job['id'], 'pause', self.actor, '')['status'], 'paused')
|
||||
with self.assertRaises(KeyError):
|
||||
self.store.run_action('tenant_b', 'job:' + job['id'], 'resume', self.actor, '')
|
||||
|
||||
|
||||
|
||||
class BatchAndRetryTest(TestCase):
|
||||
"""线上:80 万条消息、思考模型一次几十秒——合并请求、临时错误自动重试、一步多读几页。"""
|
||||
setUp = tasks.KnowledgeTaskTest.setUp
|
||||
tearDown = tasks.KnowledgeTaskTest.tearDown
|
||||
payload = fixtures.KnowledgeTest.payload
|
||||
|
||||
def seed(self, pairs=5, filler=0):
|
||||
rows = []
|
||||
for index in range(pairs):
|
||||
rows += [('inbound', f'第{index + 1}个测试问题是什么?'), ('outbound', f'第{index + 1}个测试问题的答案在这里。')]
|
||||
rows += [('unknown', '系统提示')] * filler
|
||||
self.archive.import_messages(self.payload(messages=rows), self.actor, '')
|
||||
|
||||
def run_model(self, **values):
|
||||
return self.store.create_run(['default'], {'engine': 'model', 'model_provider_id': 'alpha', 'staff_confirmed': True,
|
||||
**values}, self.actor, '')
|
||||
|
||||
def drain(self, limit=50):
|
||||
worker = KnowledgeWorker(self.store)
|
||||
for _ in range(limit):
|
||||
if not worker.step():
|
||||
return
|
||||
|
||||
@staticmethod
|
||||
def batch_reply(messages, keep=lambda index: True, skip=()):
|
||||
prompt = messages[0]['content']
|
||||
items = json.loads(prompt[prompt.rfind('\n[') + 1:])
|
||||
out = []
|
||||
for item in items:
|
||||
if item['id'] in skip:
|
||||
continue
|
||||
out.append({'id': item['id'], 'keep': False, 'reason': '寒暄'} if not keep(int(item['id'])) else
|
||||
{'id': item['id'], 'keep': True, **fields(question='清洗后:' + item['question'], answer=item['answer'])})
|
||||
return {'text': json.dumps({'items': out}, ensure_ascii=False), 'error': ''}
|
||||
|
||||
def test_several_pairs_share_one_request_and_missing_ones_retry_alone(self):
|
||||
self.seed(5)
|
||||
calls = []
|
||||
|
||||
async def reply(client, outlet, messages, **kwargs):
|
||||
calls.append(messages[0]['content'])
|
||||
if '"items"' in messages[0]['content']:
|
||||
return self.batch_reply(messages, keep=lambda i: i != 3, skip={'5'})
|
||||
return {'text': json.dumps(fields(question='单独整理的第五个问题')), 'error': ''}
|
||||
with mock.patch('model_gateway.call_outlet', side_effect=reply):
|
||||
run = self.run_model(model_concurrency=1, model_batch=8)
|
||||
self.drain()
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual(len(calls), 2, 'Five pairs: one batch request plus a single retry for the missing one')
|
||||
self.assertEqual((run['status'], run['model_calls'], run['created_items'], run['model_filtered']), ('completed', 2, 4, 1))
|
||||
questions = {item['question'] for item in self.store.list_items('default')['items']}
|
||||
self.assertIn('清洗后:第1个测试问题是什么?', questions) # 存草稿前统一脱敏(全角标点转半角)
|
||||
self.assertIn('单独整理的第五个问题', questions)
|
||||
|
||||
def test_unparseable_batch_falls_back_to_single_requests(self):
|
||||
self.seed(3)
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.side_effect = [{'text': '{"items":[{"id":"1","keep":tr', 'error': ''}] + \
|
||||
[{'text': json.dumps(fields()), 'error': ''}] * 3
|
||||
run = self.run_model(model_concurrency=1)
|
||||
self.drain()
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual((run['status'], run['model_calls'], call.call_count), ('completed', 4, 4))
|
||||
|
||||
def test_temporary_failures_back_off_and_retry_automatically(self):
|
||||
self.seed(2)
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': '', 'error': '上游返回 503: busy'}
|
||||
run = self.run_model(model_concurrency=1)
|
||||
KnowledgeWorker(self.store).step()
|
||||
job = self.store.jobs('default')[0]
|
||||
self.assertEqual(job['status'], 'queued')
|
||||
self.assertIn('自动重试', job['error'])
|
||||
self.assertGreater(job['options']['retry_after'], time.time())
|
||||
self.assertFalse(KnowledgeWorker(self.store).step(), 'Backing-off jobs wait for their turn')
|
||||
with self.db.connect() as db: # 时间到了
|
||||
db.execute("UPDATE knowledge_job SET options_json=json_set(options_json,'$.retry_after',0)")
|
||||
async def reply(client, outlet, messages, **kwargs):
|
||||
return self.batch_reply(messages)
|
||||
with mock.patch('model_gateway.call_outlet', side_effect=reply):
|
||||
self.drain()
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual((run['status'], run['created_items']), ('completed', 2))
|
||||
self.assertNotIn('retry_after', self.store.jobs('default')[0]['options'])
|
||||
|
||||
def test_retries_give_up_after_the_limit_and_resume_resets_them(self):
|
||||
import knowledge_worker
|
||||
self.seed(1)
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': '', 'error': '超过单路时限 90s'}
|
||||
run = self.run_model(model_concurrency=1)
|
||||
for _ in range(knowledge_worker.MAX_TRANSIENT + 1):
|
||||
with self.db.connect() as db:
|
||||
db.execute("UPDATE knowledge_job SET options_json=json_set(options_json,'$.retry_after',0)")
|
||||
KnowledgeWorker(self.store).step()
|
||||
run = self.store.run('*', run['id'])
|
||||
self.assertEqual(run['status'], 'failed')
|
||||
self.assertIn('已自动重试', run['errors'][0])
|
||||
self.store.run_action('*', run['id'], 'resume', self.actor, '')
|
||||
options = self.store.jobs('default')[0]['options']
|
||||
self.assertNotIn('retry_after', options)
|
||||
self.assertNotIn('transient_failures', options)
|
||||
|
||||
def test_a_timed_out_batch_is_retried_one_by_one(self):
|
||||
self.seed(3)
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': '', 'error': '超过单路时限 90s'}
|
||||
self.run_model(model_concurrency=1)
|
||||
KnowledgeWorker(self.store).step()
|
||||
with self.db.connect() as db:
|
||||
state = json.loads(db.execute('SELECT state_json FROM knowledge_job').fetchone()[0])
|
||||
self.assertEqual([item.get('_single') for item in state['_pending']], [True, True, True])
|
||||
|
||||
def test_one_step_reads_enough_pages_to_fill_the_concurrent_batches(self):
|
||||
import knowledge_worker
|
||||
self.seed(6, filler=150) # 每段问答之间夹 150 条系统提示:一页只有一两段问答
|
||||
seen = []
|
||||
|
||||
async def reply(client, outlet, messages, **kwargs):
|
||||
prompt = messages[0]['content']
|
||||
seen.append(len(json.loads(prompt[prompt.rfind('\n[') + 1:])))
|
||||
return self.batch_reply(messages)
|
||||
with mock.patch('model_gateway.call_outlet', side_effect=reply):
|
||||
self.run_model(model_concurrency=1, model_batch=6)
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(seen, [6], 'All six pairs, spread over several pages, go out in one request')
|
||||
job = self.store.jobs('default')[0]
|
||||
self.assertGreater(job['processed'], knowledge_worker.SCAN_BATCH)
|
||||
|
||||
def test_thinking_is_switched_off_where_supported_and_dropped_when_rejected(self):
|
||||
import knowledge_models
|
||||
ark = SimpleNamespace(id='ark', name='ark', kind='openai',
|
||||
config={'model': 'doubao-seed-2-1-pro', 'base_url': 'https://ark.cn-beijing.volces.com/api/v3',
|
||||
'api_key': 'k'})
|
||||
self.assertEqual(knowledge_models.thinking_switch(ark), {'thinking': {'type': 'disabled'}})
|
||||
self.assertEqual(knowledge_models.thinking_switch(self.catalog.outlets['alpha']), {})
|
||||
knowledge_models._THINKING_UNSUPPORTED.discard('ark')
|
||||
rejected = {'text': '', 'error': '上游返回 400: {"error":{"message":"unknown parameter: thinking"}}'}
|
||||
with mock.patch('knowledge_models._post_direct', new_callable=mock.AsyncMock) as direct, \
|
||||
mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as gateway:
|
||||
direct.return_value = {'text': json.dumps(fields()), 'error': ''}
|
||||
result = asyncio.run(knowledge_models.call_model(None, ark, 'p', deadline=30, max_tokens=100))
|
||||
self.assertEqual((result['error'], direct.call_args.kwargs['extra']), ('', {'thinking': {'type': 'disabled'}}))
|
||||
self.assertEqual(gateway.call_count, 0)
|
||||
direct.return_value = rejected
|
||||
gateway.return_value = {'text': 'ok', 'error': ''}
|
||||
self.assertEqual(asyncio.run(knowledge_models.call_model(None, ark, 'p', deadline=30, max_tokens=100))['text'], 'ok')
|
||||
self.assertIn('ark', knowledge_models._THINKING_UNSUPPORTED)
|
||||
asyncio.run(knowledge_models.call_model(None, ark, 'p', deadline=30, max_tokens=100))
|
||||
self.assertEqual(direct.call_count, 2, 'Once rejected, the switch is not sent again')
|
||||
knowledge_models._THINKING_UNSUPPORTED.discard('ark')
|
||||
|
||||
def test_transient_classification(self):
|
||||
from knowledge_models import is_transient
|
||||
for error in ('超过单路时限 90s', '上游返回 429', '上游返回 503: x', 'ConnectError: connect failed', '熔断中'):
|
||||
self.assertTrue(is_transient(error), error)
|
||||
for error in ('上游返回 400: bad', '上游返回 401', '所选整理模型不可用'):
|
||||
self.assertFalse(is_transient(error), error)
|
||||
|
||||
|
||||
class ModelCallTest(TestCase):
|
||||
setUp = tasks.KnowledgeTaskTest.setUp
|
||||
tearDown = tasks.KnowledgeTaskTest.tearDown
|
||||
|
||||
def candidate(self):
|
||||
return {'title': '测试', 'question': '测试门店几点营业?', 'answer': '测试门店上午九点营业。', 'conditions': '',
|
||||
'category': '待分类', 'kind': 'qa', 'flags': [], 'sources': []}
|
||||
|
||||
def test_rejected_output_limit_retries_once_with_a_smaller_one(self):
|
||||
rejected = '上游返回 400: {"error":{"message":"max_tokens must be less than or equal to 2048","param":"max_tokens"}}'
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.side_effect = [{'text': '', 'error': rejected}, {'text': json.dumps(fields()), 'error': ''}]
|
||||
draft, _, _ = enhance(self.candidate(), self.db, {'model_provider_id': 'alpha', 'model_timeout_seconds': 60})
|
||||
self.assertEqual(draft['conditions'], '仅限虚构测试门店')
|
||||
self.assertEqual([c.kwargs['max_tokens'] for c in call.call_args_list], [4096, 2048])
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': '', 'error': rejected}
|
||||
with self.assertRaisesRegex(ValueError, '输出 Token 上限'):
|
||||
enhance(self.candidate(), self.db, {'model_provider_id': 'alpha', 'model_timeout_seconds': 60})
|
||||
|
||||
def test_discard_and_prose_wrapped_json(self):
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': '{"keep": false, "reason": "只是寒暄 13800138000"}', 'error': ''}
|
||||
with self.assertRaises(ModelDiscard) as discarded:
|
||||
enhance(self.candidate(), self.db, {'model_provider_id': 'alpha', 'model_timeout_seconds': 60})
|
||||
self.assertNotIn('13800138000', discarded.exception.reason)
|
||||
call.return_value = {'text': '好的,整理结果如下:\n' + json.dumps(fields(), ensure_ascii=False) + '\n以上。', 'error': ''}
|
||||
draft, _, _ = enhance(self.candidate(), self.db, {'model_provider_id': 'alpha', 'model_timeout_seconds': 60})
|
||||
self.assertEqual(draft['category'], '营业时间')
|
||||
# 关掉筛选时,keep=false 不生效(照常要正文)
|
||||
call.return_value = {'text': json.dumps(fields(keep=False)), 'error': ''}
|
||||
draft, _, _ = enhance(self.candidate(), self.db, {'model_provider_id': 'alpha', 'model_timeout_seconds': 60,
|
||||
'model_filter': False})
|
||||
self.assertEqual(draft['category'], '营业时间')
|
||||
|
||||
def test_provider_reason_is_readable_and_redacted(self):
|
||||
error = safe_model_error('上游返回 400: {"error":{"message":"model does not support temperature, call 13800138000"}}')
|
||||
self.assertIn('HTTP 400', error)
|
||||
self.assertIn('does not support temperature', error)
|
||||
self.assertNotIn('13800138000', error)
|
||||
self.assertIn('参数不合法', safe_model_error('上游返回 400:模型请求参数不合法,请检查模型及参数配置'))
|
||||
self.assertNotIn('private', safe_model_error('上游返回 500: private body'))
|
||||
|
||||
def test_image_generation_models_are_not_offered_and_default_follows_config(self):
|
||||
self.catalog.outlets['painter'] = SimpleNamespace(id='painter', name='painter', kind='openai',
|
||||
config={'model': 'p', 'capabilities': 'image_gen'})
|
||||
self.assertEqual([item['id'] for item in model_choices(self.db)], ['alpha', 'beta'])
|
||||
with self.assertRaises(ValueError):
|
||||
resolve_model(self.db, {'model_provider_id': 'painter'})
|
||||
self.store.save_config({'default_model_provider_id': 'beta'}, self.actor, '')
|
||||
self.assertEqual(model_choices(self.db)[0], {'id': 'beta', 'name': 'beta', 'model': 'beta', 'kind': 'dify', 'default': True})
|
||||
self.assertEqual(resolve_model(self.db, {}).id, 'beta')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.save_config({'default_model_provider_id': 'painter'}, self.actor, '')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.save_config({'model_concurrency': 40}, self.actor, '')
|
||||
|
||||
|
||||
class RunApiTest(TestCase):
|
||||
setUp = fixtures.KnowledgeApiTest.setUp
|
||||
tearDown = fixtures.KnowledgeApiTest.tearDown
|
||||
|
||||
def test_runs_api_in_all_accounts_mode(self):
|
||||
actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
|
||||
ArchiveStore(self.db).import_messages(fixtures.KnowledgeTest.payload(self), actor, '')
|
||||
get = lambda path: self.client.get('/api/v2/knowledge/' + path, headers=self.headers)
|
||||
post = lambda path, body=None: self.client.post('/api/v2/knowledge/' + path, headers=self.headers, json=body or {})
|
||||
with mock.patch('knowledge_models.catalog_for', return_value=tasks.fake_catalog()):
|
||||
self.assertEqual([m['id'] for m in get('models?account_id=-1').json()['items']], ['alpha', 'beta'])
|
||||
preview = post('runs/preview')
|
||||
self.assertEqual(preview.status_code, 200, preview.text)
|
||||
self.assertEqual((preview.json()['scope_label'], preview.json()['totals']['messages']), ('全部账号', 2))
|
||||
self.assertEqual(post('runs', {'engine': 'rules'}).status_code, 400)
|
||||
created = post('runs', {'engine': 'model', 'model_provider_id': 'alpha', 'staff_confirmed': True})
|
||||
self.assertEqual(created.status_code, 200, created.text)
|
||||
run = created.json()
|
||||
self.assertEqual((run['options']['model_name'], run['options']['model_concurrency']), ('alpha', 4))
|
||||
listed = get('runs').json()
|
||||
self.assertEqual(listed['items'][0]['id'], run['id'])
|
||||
self.assertIn('jobs_24h', listed['auto'])
|
||||
self.assertEqual(post(f"runs/{run['id']}/pause").json()['status'], 'paused')
|
||||
changed = self.client.put(f"/api/v2/knowledge/runs/{run['id']}/config", headers=self.headers,
|
||||
json={'engine': 'rules'})
|
||||
self.assertEqual(changed.status_code, 200, changed.text)
|
||||
self.assertEqual(changed.json()['options']['engine'], 'rules')
|
||||
self.assertEqual(post(f"runs/{run['id']}/explode").status_code, 400)
|
||||
config = self.client.put('/api/v2/knowledge/config', headers=self.headers,
|
||||
json={'default_engine': 'rules', 'model_concurrency': 2})
|
||||
self.assertEqual(config.status_code, 200, config.text)
|
||||
self.assertEqual(get('config').json()['model_concurrency'], 2)
|
||||
self.assertEqual(self.client.get('/api/v2/knowledge/runs').status_code, 401)
|
||||
|
||||
def test_model_test_endpoint(self):
|
||||
with mock.patch('knowledge_models.catalog_for', return_value=tasks.fake_catalog()), \
|
||||
mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': json.dumps(fields()), 'error': ''}
|
||||
ok = self.client.post('/api/v2/knowledge/models/test', headers=self.headers, json={'model_provider_id': 'beta'})
|
||||
self.assertEqual(ok.status_code, 200, ok.text)
|
||||
self.assertTrue(ok.json()['ok'])
|
||||
self.assertEqual((ok.json()['model_name'], ok.json()['draft']['category']), ('beta', '营业时间'))
|
||||
call.return_value = {'text': '', 'error': '上游返回 401: secret-body'}
|
||||
failed = self.client.post('/api/v2/knowledge/models/test', headers=self.headers, json={'model_provider_id': 'beta'})
|
||||
self.assertFalse(failed.json()['ok'])
|
||||
self.assertIn('HTTP 401', failed.json()['error'])
|
||||
self.assertNotIn('secret-body', failed.json()['error'])
|
||||
call.return_value = {'text': 'not json', 'error': ''}
|
||||
self.assertIn('格式', self.client.post('/api/v2/knowledge/models/test', headers=self.headers,
|
||||
json={'model_provider_id': 'beta'}).json()['error'])
|
||||
missing = self.client.post('/api/v2/knowledge/models/test', headers=self.headers, json={'model_provider_id': 'nope'})
|
||||
self.assertEqual(missing.status_code, 400)
|
||||
@@ -0,0 +1,40 @@
|
||||
"""Search request validation and published-only retrieval regressions."""
|
||||
from unittest import TestCase, mock
|
||||
import test_knowledge as fixtures
|
||||
from knowledge_retriever import KnowledgeRetriever
|
||||
|
||||
class KnowledgeSearchApiTest(TestCase):
|
||||
setUp = fixtures.KnowledgeApiTest.setUp
|
||||
tearDown = fixtures.KnowledgeApiTest.tearDown
|
||||
|
||||
def search(self, body):
|
||||
return self.client.post('/api/v2/knowledge/search?account_id=0', headers=self.headers, json=body)
|
||||
|
||||
def test_invalid_query_never_reaches_retriever(self):
|
||||
with mock.patch.object(KnowledgeRetriever, 'search') as retrieve:
|
||||
for value in ['', ' ', '\t\n', '约', ' 约 ', 'a' * 2001, None, {}, 123]:
|
||||
with self.subTest(value_type=type(value).__name__, length=len(value) if isinstance(value,str) else None):
|
||||
response = self.search({'query': value})
|
||||
self.assertEqual(response.status_code, 422)
|
||||
self.assertIsInstance(response.json()['detail'], list)
|
||||
self.assertEqual(self.search({}).status_code, 422)
|
||||
retrieve.assert_not_called()
|
||||
|
||||
def test_valid_query_trims_before_validation_and_search(self):
|
||||
with mock.patch.object(KnowledgeRetriever, 'search', return_value={'hits':[], 'mode':'lexical','elapsed_ms':0}) as retrieve:
|
||||
for text in ['预约', '🙂🙂', 'a' * 2000]:
|
||||
response = self.search({'query': ' \t'+text+'\n '})
|
||||
self.assertEqual(response.status_code, 200, response.text)
|
||||
self.assertEqual(retrieve.call_args.args[-1], text)
|
||||
|
||||
def test_no_published_knowledge_is_empty_success(self):
|
||||
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
||||
index.return_value.configured = False
|
||||
response = self.search({'query': '预约挂号'})
|
||||
self.assertEqual(response.status_code, 200, response.text)
|
||||
self.assertEqual(response.json()['hits'], [])
|
||||
|
||||
def test_authentication_and_specific_account_still_required(self):
|
||||
url = '/api/v2/knowledge/search'
|
||||
self.assertEqual(self.client.post(url, json={'query':'预约'}).status_code, 401)
|
||||
self.assertEqual(self.client.post(url+'?account_id=-1', headers=self.headers, json={'query':'预约'}).status_code, 400)
|
||||
@@ -0,0 +1,215 @@
|
||||
"""Failure recovery, pinned models, deletion and permission regressions."""
|
||||
import copy
|
||||
import json
|
||||
from types import SimpleNamespace
|
||||
from unittest import TestCase, mock
|
||||
|
||||
from archive_store import ArchiveStore
|
||||
from knowledge_models import model_choices, safe_model_error
|
||||
from knowledge_store import KnowledgeStore
|
||||
from knowledge_worker import KnowledgeWorker, enhance
|
||||
import test_knowledge as fixtures
|
||||
|
||||
|
||||
def fake_catalog():
|
||||
outlets = {name: SimpleNamespace(id=name, name=name, kind=kind,
|
||||
config={'model': name, 'api_key': 'private-value', 'timeout_ms': 30000})
|
||||
for name, kind in [('alpha', 'openai'), ('beta', 'dify'), ('image', 'comfyui')]}
|
||||
return SimpleNamespace(outlets=outlets, plan=lambda: ([outlets['alpha']], None, '', 1))
|
||||
|
||||
|
||||
class KnowledgeTaskTest(TestCase):
|
||||
payload = fixtures.KnowledgeTest.payload
|
||||
start_job = fixtures.KnowledgeTest.start_job
|
||||
process = fixtures.KnowledgeTest.process
|
||||
first = fixtures.KnowledgeTest.first
|
||||
publish = fixtures.KnowledgeTest.publish
|
||||
|
||||
def setUp(self):
|
||||
fixtures.KnowledgeTest.setUp(self)
|
||||
self.catalog = fake_catalog()
|
||||
self.patch = mock.patch('knowledge_models.catalog_for', return_value=self.catalog)
|
||||
self.patch.start()
|
||||
|
||||
def tearDown(self):
|
||||
self.patch.stop()
|
||||
fixtures.KnowledgeTest.tearDown(self)
|
||||
|
||||
def test_delete_requires_rejection_revision_and_tenant_and_keeps_archive(self):
|
||||
self.process()
|
||||
item = self.first()
|
||||
args = ('default', item['id'], item['revision'])
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.delete_rejected(*args, self.actor, '')
|
||||
self.store.transition(*args, 'reject', self.actor, '')
|
||||
with self.assertRaises(KeyError):
|
||||
self.store.delete_rejected('other', item['id'], item['revision'], self.actor, '')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.delete_rejected('default', item['id'], 99, self.actor, '')
|
||||
self.store.delete_rejected(*args, self.actor, '')
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
with self.assertRaises(KeyError):
|
||||
self.store.detail('default', item['id'])
|
||||
with self.db.connect() as db:
|
||||
self.assertEqual(db.execute('SELECT COUNT(*) FROM archive_message').fetchone()[0], 2)
|
||||
for table in ('knowledge_source', 'knowledge_revision', 'knowledge_fts'):
|
||||
self.assertEqual(db.execute(f'SELECT COUNT(*) FROM {table}').fetchone()[0], 0)
|
||||
self.assertIsNotNone(db.execute("SELECT 1 FROM audit_log WHERE action='knowledge.delete'").fetchone())
|
||||
self.start_job()
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0, 'Identical discarded drafts must stay discarded')
|
||||
|
||||
def test_model_choice_is_pinned_and_image_disabled_unknown_rejected(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job(engine='model', model_provider_id='beta', model_timeout_seconds=120)
|
||||
self.assertEqual(job['options']['model_provider_id'], 'beta')
|
||||
self.assertEqual(job['options']['model_name'], 'beta')
|
||||
default = self.start_job(engine='model')
|
||||
self.assertEqual(default['options']['model_provider_id'], 'alpha')
|
||||
for provider in ('missing', 'image'):
|
||||
with self.assertRaises(ValueError):
|
||||
self.start_job(engine='model', model_provider_id=provider)
|
||||
self.assertNotIn('private-value', json.dumps(model_choices(self.db)))
|
||||
self.assertEqual(len(model_choices(self.db)), 2)
|
||||
|
||||
def test_resume_preserves_successful_candidates_in_failed_batch(self):
|
||||
self.archive.import_messages(self.payload(messages=[
|
||||
('inbound', '预约挂号需要什么材料?'), ('outbound', '请先提供就诊日期和科室。'),
|
||||
('inbound', '测试门店周日营业时间是几点?'), ('outbound', '测试门店周日上午九点营业。')]), self.actor, '')
|
||||
job = self.start_job(engine='model', model_provider_id='alpha')
|
||||
seen = []
|
||||
def succeed_then_fail(candidate, database, options, **usage_context):
|
||||
seen.append(candidate['question'])
|
||||
if len(seen) == 2:
|
||||
raise ValueError('模拟超时')
|
||||
return candidate, 50, 80
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=succeed_then_fail):
|
||||
KnowledgeWorker(self.store).step()
|
||||
failed = self.store.job('default', job['id'])
|
||||
self.assertEqual((failed['status'], failed['processed'], failed['created_items'], failed['pending_items']), ('failed', 4, 1, 1))
|
||||
self.assertEqual(failed['input_chars'], 50)
|
||||
self.assertNotIn('state', failed)
|
||||
self.store.configure_job('default', job['id'], {'engine': 'model', 'model_provider_id': 'beta',
|
||||
'model_timeout_seconds': 120, 'max_model_calls': 200}, self.actor, '')
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
def remaining(candidate, database, options, **usage_context):
|
||||
self.assertEqual(candidate['question'], seen[1])
|
||||
self.assertEqual(options['model_provider_id'], 'beta')
|
||||
return candidate, 40, 60
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=remaining) as call:
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(call.call_count, 1)
|
||||
final = self.store.job('default', job['id'])
|
||||
self.assertEqual((final['status'], final['created_items'], final['processed'], final['model_calls']), ('completed', 2, 4, 3))
|
||||
|
||||
def test_budget_can_be_increased_without_losing_pending_candidate(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job(engine='model', max_model_calls=1)
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=ValueError('失败')):
|
||||
KnowledgeWorker(self.store).step()
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.configure_job('default', job['id'], {'engine': 'model', 'max_model_calls': 1}, self.actor, '')
|
||||
self.store.configure_job('default', job['id'], {'engine': 'rules'}, self.actor, '')
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
with mock.patch('knowledge_worker.enhance') as call:
|
||||
KnowledgeWorker(self.store).step()
|
||||
call.assert_not_called()
|
||||
self.assertEqual(self.store.job('default', job['id'])['created_items'], 1)
|
||||
|
||||
def test_cancel_during_call_fences_result_and_pause_can_continue(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job(engine='model')
|
||||
def pause(candidate, database, options, **usage_context):
|
||||
self.store.job_action('default', job['id'], 'pause', self.actor, '')
|
||||
return candidate, 10, 20
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=pause):
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
self.assertEqual(self.store.job('default', job['id'])['pending_items'], 1)
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
def cancel(candidate, database, options, **usage_context):
|
||||
self.store.job_action('default', job['id'], 'cancel', self.actor, '')
|
||||
return candidate, 10, 20
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=cancel):
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(self.store.job('default', job['id'])['status'], 'cancelled')
|
||||
self.assertEqual(self.store.job('default', job['id'])['pending_items'], 0)
|
||||
self.assertEqual(self.store.list_items('default')['total'], 0)
|
||||
|
||||
def test_config_rejects_active_foreign_invalid_timeout_and_pins_legacy_job(self):
|
||||
self.archive.import_messages(self.payload(), self.actor, '')
|
||||
job = self.start_job(engine='model')
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.configure_job('default', job['id'], {'engine': 'rules'}, self.actor, '')
|
||||
with self.assertRaises(KeyError):
|
||||
self.store.configure_job('other', job['id'], {'engine': 'rules'}, self.actor, '')
|
||||
self.store.job_action('default', job['id'], 'pause', self.actor, '')
|
||||
for timeout in (12, 181):
|
||||
with self.assertRaises(ValueError):
|
||||
self.store.configure_job('default', job['id'], {'model_timeout_seconds': timeout}, self.actor, '')
|
||||
with self.db.connect() as db:
|
||||
options = json.loads(db.execute('SELECT options_json FROM knowledge_job WHERE id=?', (job['id'],)).fetchone()[0])
|
||||
options.pop('model_provider_id')
|
||||
db.execute('UPDATE knowledge_job SET options_json=? WHERE id=?', (json.dumps(options), job['id']))
|
||||
self.store.job_action('default', job['id'], 'resume', self.actor, '')
|
||||
with mock.patch('knowledge_worker.enhance', side_effect=lambda c, d, o: (c, 10, 20)):
|
||||
KnowledgeWorker(self.store).step()
|
||||
self.assertEqual(self.store.job('default', job['id'])['options']['model_provider_id'], 'alpha')
|
||||
|
||||
def test_selected_model_timeout_output_budget_and_safe_errors(self):
|
||||
self.process()
|
||||
candidate = self.first()
|
||||
fields = {k: candidate[k] for k in ('title', 'question', 'answer', 'category', 'kind')}
|
||||
fields['conditions'] = '仅限虚构测试门店'
|
||||
options = {'model_provider_id': 'beta', 'model_timeout_seconds': 120}
|
||||
with mock.patch('model_gateway.call_outlet', new_callable=mock.AsyncMock) as call:
|
||||
call.return_value = {'text': '```json\n' + json.dumps(fields) + '\n```', 'error': ''}
|
||||
result, input_chars, output_chars = enhance(copy.deepcopy(candidate), self.db, options)
|
||||
self.assertEqual(result['conditions'], fields['conditions'])
|
||||
self.assertGreater(input_chars, 0)
|
||||
self.assertGreater(output_chars, 0)
|
||||
self.assertEqual(call.call_args.args[1].id, 'beta')
|
||||
self.assertEqual(call.call_args.args[1].config['timeout_ms'], 120000)
|
||||
self.assertEqual(call.call_args.kwargs['deadline'], 120)
|
||||
self.assertEqual(call.call_args.kwargs['max_tokens'], 4096)
|
||||
call.return_value = {'text': '', 'error': '上游返回 401: private-value https://secret/path'}
|
||||
with self.assertRaisesRegex(ValueError, 'HTTP 401') as error:
|
||||
enhance(candidate, self.db, options)
|
||||
self.assertNotIn('private-value', str(error.exception))
|
||||
for text in ('{"title":', '[]', '{"kind":"qa"}'):
|
||||
call.return_value = {'text': text, 'error': ''}
|
||||
with self.assertRaises(ValueError):
|
||||
enhance(copy.deepcopy(candidate), self.db, options)
|
||||
self.assertIn('超时', safe_model_error('ReadTimeout private-value'))
|
||||
self.assertIn('限流', safe_model_error('上游返回 429 secret'))
|
||||
|
||||
|
||||
class KnowledgeTaskApiTest(TestCase):
|
||||
setUp = fixtures.KnowledgeApiTest.setUp
|
||||
tearDown = fixtures.KnowledgeApiTest.tearDown
|
||||
|
||||
def test_delete_confirmation_and_model_metadata_auth(self):
|
||||
store = self.client.app.state.knowledge_store
|
||||
actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
|
||||
ArchiveStore(self.db).import_messages(fixtures.KnowledgeTest.payload(self), actor, '')
|
||||
with self.db.connect() as db:
|
||||
source = db.execute('SELECT id FROM archive_source_account').fetchone()[0]
|
||||
job = store.create_job('default', {'source_account_id': source, 'staff_confirmed': True}, actor, '')
|
||||
KnowledgeWorker(store).step()
|
||||
item = store.list_items('default')['items'][0]
|
||||
store.transition('default', item['id'], 1, 'reject', actor, '')
|
||||
url = '/api/v2/knowledge/items/' + item['id'] + '/delete'
|
||||
self.assertEqual(self.client.post(url, json={'revision': 1, 'confirmed': True}).status_code, 401)
|
||||
self.assertEqual(self.client.post(url, headers=self.headers, json={'revision': 1}).status_code, 400)
|
||||
self.assertEqual(self.client.post(url + '?account_id=-1', headers=self.headers, json={'revision': 1, 'confirmed': True}).status_code, 400)
|
||||
self.assertEqual(self.client.post(url, headers=self.headers, json={'revision': 1, 'confirmed': True}).status_code, 200)
|
||||
self.assertEqual(self.client.get(url.rsplit('/', 1)[0], headers=self.headers).status_code, 404)
|
||||
self.assertEqual(self.client.get('/api/v2/knowledge/models').status_code, 401)
|
||||
with mock.patch('knowledge_models.catalog_for', return_value=fake_catalog()):
|
||||
response = self.client.get('/api/v2/knowledge/models', headers=self.headers)
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertNotIn('private-value', response.text)
|
||||
self.assertEqual(len(response.json()['items']), 2)
|
||||
response = self.client.put('/api/v2/knowledge/jobs/' + job['id'] + '/config', headers=self.headers,
|
||||
json={'engine': 'model', 'model_timeout_seconds': 12})
|
||||
self.assertEqual(response.status_code, 422)
|
||||
Reference in New Issue
Block a user