Files
kefu/deploy/knowledge-view-20261007/server-bundle/tests/test_knowledge_runs.py
T
2026-11-16 09:39:42 +08:00

548 lines
34 KiB
Python

"""整理批次(一次整理全部账号、全部聊天)、模型清洗、并发和 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_items_can_be_viewed_and_reviewed_from_all_accounts_within_scope(self):
actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
archive = ArchiveStore(self.db)
archive.import_messages(fixtures.KnowledgeTest.payload(self), actor, '')
archive.import_messages(fixtures.KnowledgeTest.payload(self, 'tenant_b'), actor, '')
store = self.client.app.state.knowledge_store
store.create_run(['default', 'tenant_b'], {'engine': 'rules', 'staff_confirmed': True}, actor, '')
worker = KnowledgeWorker(store)
while worker.step():
pass
with self.db.connect() as db:
now = '2026-10-07T00:00:00.000+00:00'
db.execute("INSERT INTO desktop_accounts (zyt_user_id,tenant_id,zyt_sn,nickname,created_at,updated_at) "
"VALUES ('b','tenant_b','ZYT-B','账号B',?,?)", (now, now))
account_b = db.execute("SELECT id FROM desktop_accounts WHERE tenant_id='tenant_b'").fetchone()[0]
listed = self.client.get('/api/v2/knowledge/items?account_id=-1', headers=self.headers).json()['items']
self.assertEqual({(item['tenant_id'], item['account_label']) for item in listed},
{('default', '旧版未归属数据'), ('tenant_b', '账号B')})
item_b = next(item for item in listed if item['tenant_id'] == 'tenant_b')
item_default = next(item for item in listed if item['tenant_id'] == 'default')
url = '/api/v2/knowledge/items/' + item_b['id']
detail = self.client.get(url + '?account_id=-1', headers=self.headers)
self.assertEqual(detail.status_code, 200, detail.text)
self.assertEqual((detail.json()['account_label'], len(detail.json()['sources'])), ('账号B', 2))
edited = {**detail.json(), 'conditions': '仅限测试门店'}
saved = self.client.put(url + '?account_id=-1', headers=self.headers, json=edited)
self.assertEqual(saved.status_code, 200, saved.text)
approved = self.client.post(url + '/approve?account_id=-1', headers=self.headers,
json={'revision': saved.json()['revision'], 'confirmed': True})
self.assertEqual((approved.status_code, approved.json()['status']), (200, 'approved'))
self.assertEqual(self.client.get('/api/v2/knowledge/items/nope?account_id=-1', headers=self.headers).status_code, 404)
# 只管账号 B 的管理员:「全部」= 他能看的全部;别的账号的知识当作不存在
role = self.client.post('/api/v2/roles', headers=self.headers, json={
'code': 'k-reviewer', 'name': '审核', 'permissions': ['knowledge:read', 'knowledge:review', 'im:content:read']})
self.assertEqual(role.status_code, 200, role.text)
self.assertEqual(self.client.post('/api/v2/users', headers=self.headers, json={
'username': 'kb', 'password': 'Scoped@2026x', 'role': 'k-reviewer'}).status_code, 200)
user = self.db.authenticate('kb', 'Scoped@2026x')
self.db.change_password(user['id'], 'Scoped@2026x', 'Scoped@2026y', '')
self.db.set_desktop_account_admins(account_b, [user['id']], actor, '')
token = self.client.post('/api/v2/auth/login', json={'username': 'kb', 'password': 'Scoped@2026y'}).json()['access_token']
scoped = {'Authorization': 'Bearer ' + token}
mine = self.client.get('/api/v2/knowledge/items?account_id=-1', headers=scoped).json()['items']
self.assertEqual({item['tenant_id'] for item in mine}, {'tenant_b'})
self.assertEqual(self.client.get(url + '?account_id=-1', headers=scoped).status_code, 200)
other = '/api/v2/knowledge/items/' + item_default['id']
self.assertEqual(self.client.get(other + '?account_id=-1', headers=scoped).status_code, 404)
self.assertEqual(self.client.post(other + '/reject?account_id=-1', headers=scoped,
json={'revision': 1}).status_code, 404)
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)