"""整理批次(一次整理全部账号、全部聊天)、模型清洗、并发和 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)