This commit is contained in:
gr
2026-11-16 09:39:42 +08:00
parent 0aeab6c6f5
commit 9178069f07
7440 changed files with 241428 additions and 2129 deletions
@@ -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)