582 lines
37 KiB
Python
582 lines
37 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', 'knowledge:reject',
|
|
'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_each_knowledge_button_has_its_own_permission(self):
|
|
actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
|
|
ArchiveStore(self.db).import_messages(fixtures.KnowledgeTest.payload(self), actor, '')
|
|
store = self.client.app.state.knowledge_store
|
|
store.create_run(['default'], {'engine': 'rules', 'staff_confirmed': True}, actor, '')
|
|
worker = KnowledgeWorker(store)
|
|
while worker.step():
|
|
pass
|
|
item = self.client.get('/api/v2/knowledge/items', headers=self.headers).json()['items'][0]
|
|
role = self.client.post('/api/v2/roles', headers=self.headers, json={
|
|
'code': 'k-approver', 'name': '只能审核通过', 'permissions': ['knowledge:read', 'knowledge:review', 'im:content:read']})
|
|
self.assertEqual(role.status_code, 200, role.text)
|
|
self.client.post('/api/v2/users', headers=self.headers, json={'username': 'ka', 'password': 'Scoped@2026x', 'role': 'k-approver'})
|
|
user = self.db.authenticate('ka', 'Scoped@2026x')
|
|
self.db.change_password(user['id'], 'Scoped@2026x', 'Scoped@2026y', '')
|
|
token = self.client.post('/api/v2/auth/login', json={'username': 'ka', 'password': 'Scoped@2026y'}).json()['access_token']
|
|
approver = {'Authorization': 'Bearer ' + token}
|
|
url = '/api/v2/knowledge/items/' + item['id']
|
|
for action, code in (('reject', 'knowledge:reject'), ('disable', 'knowledge:disable'),
|
|
('publish', 'knowledge:publish'), ('delete', 'knowledge:delete'), ('restore', 'knowledge:restore')):
|
|
refused = self.client.post(f'{url}/{action}', headers=approver, json={'revision': item['revision'], 'confirmed': True})
|
|
self.assertEqual(refused.status_code, 403, action)
|
|
self.assertIn(code, refused.json()['detail'])
|
|
self.assertEqual(self.client.post(f'{url}/explode', headers=approver, json={'revision': 1}).status_code, 400)
|
|
self.assertEqual(self.client.put(url, headers=approver, json=item).status_code, 403)
|
|
for method, path in (('post', 'runs/preview'), ('post', 'runs'), ('put', 'config'), ('post', 'review-tasks/preview'),
|
|
('post', 'search'), ('put', 'settings')):
|
|
response = getattr(self.client, method)('/api/v2/knowledge/' + path, headers=approver, json={'query': '退款问题'})
|
|
self.assertEqual(response.status_code, 403, path)
|
|
# 审核通过这个按钮本身可以用:缺的是适用条件,不是权限
|
|
approve = self.client.post(f'{url}/approve', headers=approver, json={'revision': item['revision'], 'confirmed': True})
|
|
self.assertEqual(approve.status_code, 400, approve.text)
|
|
|
|
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)
|