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'], [])