Files
lyun f1a2fbd494 统一:DSH 智能分析、Top100 与图表静默恢复
接入 DSH 专用运行时和对话界面,保留模型原始回答,支持会话分页、连续追问与显式报告。
补齐组合筛选、各维度 Top100、分组查询到排名图的转换,图表故障静默省略并基于保存数据自动恢复。
优化报告风格、图表顺序和表格换行,更新接入说明及构建输入。

验证:独立目录前后端构建通过;118 项 Java、102 项前端、102 项图表、14 项 DSH 应用和 13 项组合筛选检查通过。
仅提交相关源码、锁定依赖与测试;不包含凭据、会话、业务数据或本地产物。
2026-11-12 11:57:41 +08:00

393 lines
23 KiB
Python

"""Loopback fake-provider tests: no configured model, credential file or real network service."""
import json
import sys
import threading
import unittest
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.error import HTTPError
from urllib.request import Request, urlopen
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
from nao_model_gate import ModelGate
class HeldOpenProviderResponse:
"""A provider that sends a terminal SSE event but keeps its transport alive."""
status = 200
headers = {'Content-Type': 'text/event-stream'}
def __init__(self, chunks):
self.chunks = list(chunks)
self.read_count = 0
self.terminal_delivered = threading.Event()
self.read_after_terminal = threading.Event()
self.release = threading.Event()
self.closed = threading.Event()
def __enter__(self): return self
def __exit__(self, *_): self.closed.set()
def read1(self, _size):
self.read_count += 1
if self.chunks:
chunk = self.chunks.pop(0)
if not self.chunks:
self.terminal_delivered.set()
return chunk
self.read_after_terminal.set()
# Heartbeats keep the connection readable without adding completion data.
return b'' if self.release.wait(.02) else b': heartbeat\n\n'
class ModelGateTests(unittest.TestCase):
def setUp(self):
self.allowed = True
self.calls = []
self.provider_status = 200
owner = self
class Provider(BaseHTTPRequestHandler):
def log_message(self, *_): pass
def do_POST(self):
owner.calls.append(json.loads(self.rfile.read(int(self.headers['Content-Length']))))
data = json.dumps({'choices': [{'message': {'content': 'fake model'}}]} if owner.provider_status == 200
else {'error': 'fake-sensitive-provider-details'}).encode()
self.send_response(owner.provider_status)
self.send_header('Content-Type', 'application/json')
self.send_header('Content-Length', str(len(data)))
self.end_headers(); self.wfile.write(data)
self.provider = ThreadingHTTPServer(('127.0.0.1', 0), Provider)
self.provider.daemon_threads = True
self.thread = threading.Thread(target=self.provider.serve_forever, daemon=True); self.thread.start()
self.gate = ModelGate(upstream_base=f'http://127.0.0.1:{self.provider.server_port}/v1', upstream_key='dummy-provider-key',
model='fake-model', port=0, client_key='dummy-native-key', authorize=self.authorize)
# Port zero is only used by this isolated test server.
self.base = f'http://127.0.0.1:{self.gate._server.server_port}/v1'
def tearDown(self):
self.gate.close(); self.provider.shutdown(); self.provider.server_close(); self.thread.join(timeout=1)
def authorize(self):
if not self.allowed: raise PermissionError('revoked or expired delegation')
def request(self, *, key='dummy-native-key', model='fake-model', extra=None, phase=None):
headers={'Content-Type':'application/json','Authorization':'Bearer '+key}
if phase:headers['X-Quality-Analysis-Phase']=phase
request = Request(self.base+'/chat/completions', data=json.dumps({'model': model, 'messages': [{'role': 'user', 'content': 'offline fixture'}],**(extra or {})}).encode(),
headers=headers)
try:
with urlopen(request, timeout=3) as response: return response.status, response.read().decode()
except HTTPError as error: return error.code, error.read().decode()
def test_revocation_blocks_native_and_final_synthesis_requests_before_fake_provider(self):
self.assertEqual(self.request()[0], 200)
self.assertEqual(len(self.calls), 1)
self.allowed = False
self.assertEqual(self.request()[0], 403) # next native provider request
self.assertEqual(self.request()[0], 403) # final synthesis uses this same connection
self.assertEqual(len(self.calls), 1)
def test_initial_denial_or_wrong_native_credential_never_reaches_provider(self):
self.allowed = False
self.assertEqual(self.request()[0], 403)
self.allowed = True
self.assertEqual(self.request(key='wrong-key')[0], 403)
self.assertEqual(self.request(model='different-model')[0], 400)
self.assertEqual(len(self.calls), 0)
def test_dsh_keeps_only_its_bound_quality_tool_at_the_provider_boundary(self):
self.gate.runtime_engine='DSH'
names=['mcp__quality__quality_data','bash','mcp_call','story','mcp__other__quality_data']
tools=[{'type':'function','function':{'name':name,'parameters':{'type':'object'}}} for name in names]
self.assertEqual(self.request(extra={'tools':tools})[0],200)
self.assertEqual([x['function']['name'] for x in self.calls[-1]['tools']],['mcp__quality__quality_data'])
def test_dsh_stream_separates_complete_calls_when_the_provider_reuses_an_index(self):
from unittest.mock import Mock
from nao_thinking_stream import ProviderStream
self.gate.runtime_engine='DSH'
name='mcp__quality__quality_data'
tool={'type':'function','function':{'name':name,'parameters':{'type':'object'}}}
frames=[{'choices':[{'index':0,'delta':{'tool_calls':[{'index':index,'id':identity,'type':'function',
'function':{'name':name,'arguments':json.dumps({'probe':identity})}}]},'finish_reason':None}]}
for index,identity in [(0,'a'),(1,'b'),(1,'c'),(2,'d')]]
frames.append({'choices':[{'index':0,'delta':{},'finish_reason':'tool_calls'}]})
chunks=[('data: '+json.dumps(frame)+'\n\n').encode() for frame in frames]+[b'data: [DONE]\n\n']
upstream=HeldOpenProviderResponse(chunks);upstream.release.set()
self.gate._opener=Mock();self.gate._opener.open.return_value=upstream
code,body=self.request(extra={'stream':True,'tools':[tool]})
self.assertEqual(code,200)
observer=ProviderStream(lambda _:None);observer.feed(body.encode());observer.finish()
calls=observer.completion()['choices'][0]['message']['tool_calls']
self.assertEqual([call['id'] for call in calls],['a','b','c','d'])
self.assertEqual([call['function']['name'] for call in calls],[name]*4)
self.assertEqual([json.loads(call['function']['arguments']) for call in calls],[{'probe':x} for x in 'abcd'])
def test_revocation_interrupts_an_inflight_provider_read(self):
from unittest.mock import Mock
class StalledResponse:
status=200
headers={'Content-Type':'text/event-stream'}
def __init__(self):
self.reading=threading.Event();self.released=threading.Event()
def __enter__(self):return self
def __exit__(self,*_):self.close()
def read1(self,_):
self.reading.set();self.released.wait(5);return b''
def close(self):self.released.set()
stalled=StalledResponse();self.gate._opener=Mock()
self.gate._opener.open.return_value=stalled
done=threading.Event();result=[]
def query():
try:result.append(self.request())
finally:done.set()
worker=threading.Thread(target=query,daemon=True);worker.start()
self.assertTrue(stalled.reading.wait(1))
self.gate.revoke()
self.assertTrue(done.wait(1),'revoked provider read was left waiting for its timeout')
worker.join(1)
# SSE headers may have been sent before revocation; HTTP 200 alone is
# not a completion receipt. The interrupted body has no terminal event.
self.assertIn(result[0][0],(200,502))
self.assertNotIn('[DONE]',result[0][1])
self.assertNotIn('"finish_reason": "stop"',result[0][1])
self.assertEqual(self.request()[0],403)
def test_quality_api_charts_do_not_advertise_incompatible_sql_renderer(self):
data_tool={'type':'function','function':{'name':'mcp_call','parameters':{'type':'object'}}}
chart_tool={'type':'function','function':{'name':'display_chart','parameters':{'type':'object'}}}
self.assertEqual(self.request(extra={'tools':[data_tool,chart_tool],
'tool_choice':{'type':'function','function':{'name':'display_chart'}}})[0],200)
self.assertEqual(self.calls[-1]['tools'],[data_tool])
self.assertNotIn('tool_choice',self.calls[-1])
self.assertEqual(self.request(extra={'tools':[chart_tool],'tool_choice':'required'})[0],200)
self.assertNotIn('tools',self.calls[-1])
self.assertNotIn('tool_choice',self.calls[-1])
def test_provider_errors_are_bounded_public_failures(self):
self.provider_status = 503
code, body = self.request()
self.assertEqual(code, 503)
self.assertNotIn('fake-sensitive-provider-details', body)
self.assertEqual(len(self.calls), 1)
def test_unadvertised_tool_calls_are_blocked_before_json_or_stream_execution(self):
from unittest.mock import Mock
data_tool={'type':'function','function':{'name':'mcp_call','parameters':{'type':'object'}}}
tool={'id':'call-blocked','type':'function','function':{'name':'clarification','arguments':'{}'}}
reply={'choices':[{'index':0,'message':{'role':'assistant','content':None,'tool_calls':[tool]},'finish_reason':'tool_calls'}]}
upstream=HeldOpenProviderResponse([json.dumps(reply).encode()]);upstream.headers={'Content-Type':'application/json'};upstream.release.set()
self.gate._opener=Mock();self.gate._opener.open.return_value=upstream
code,body=self.request(extra={'tools':[data_tool]})
self.assertEqual(code,502);self.assertNotIn('clarification',body)
self.assertEqual(self.gate.rejected_tool_names,['clarification'])
from types import SimpleNamespace
from nao_model_gate import ToolPolicyError
observer=SimpleNamespace(tools={0:{0:{'function':{'name':'secret=never-log','arguments':'private argument'}}}},
choices={0:{'finish_reason':'tool_calls'}},done=True)
with self.assertRaises(ToolPolicyError):
self.gate.check_returned_tools(observer,{'mcp_call'},final=True)
self.assertEqual(self.gate.rejected_tool_names,['clarification','<invalid_name>'])
for newline in (True,False):
prefix=b'data: {"choices":[{"index":0,"delta":{"content":"Preserved text"}}]}\n\n'
bad=('data: '+json.dumps({'choices':[{'index':0,'delta':{'tool_calls':[tool]},'finish_reason':'tool_calls'}]})+ ('\n\n' if newline else '')).encode()
upstream=HeldOpenProviderResponse([prefix,bad[:19],bad[19:]]);upstream.release.set()
self.gate._opener.open.return_value=upstream
code,body=self.request(extra={'stream':True,'tools':[data_tool]})
self.assertEqual(code,200);self.assertIn('Preserved text',body)
self.assertNotIn('clarification',body);self.assertIn('error',body)
def test_allowed_fragmented_tool_calls_keep_their_exact_wire_data(self):
from unittest.mock import Mock
rows=[{'choices':[{'index':0,'delta':{'tool_calls':[{'index':0,'id':'q','type':'function','function':{'name':'mcp_','arguments':''}}]}}]},
{'choices':[{'index':0,'delta':{'tool_calls':[{'index':0,'function':{'name':'call','arguments':'{}'}}]},'finish_reason':'tool_calls'}]}]
wire=b''.join(('data: '+json.dumps(row)+'\n\n').encode() for row in rows)+b'data: [DONE]\n\n'
upstream=HeldOpenProviderResponse([wire[:23],wire[23:71],wire[71:]]);upstream.release.set()
self.gate._opener=Mock();self.gate._opener.open.return_value=upstream
code,body=self.request(extra={'stream':True,'tools':[{'type':'function','function':{'name':'mcp_call'}}]})
self.assertEqual(code,200);self.assertEqual(body.encode(),wire)
def test_follow_up_tool_cannot_end_analysis_before_the_model_writes_an_answer(self):
data_tool = {'type': 'function', 'function': {'name': 'mcp_call', 'parameters': {'type': 'object'}}}
follow_up = {'type': 'function', 'function': {'name': 'suggest_follow_ups', 'parameters': {'type': 'object'}}}
for choice in ('auto', {'type': 'function', 'function': {'name': 'suggest_follow_ups'}}):
with self.subTest(choice=choice):
self.assertEqual(self.request(extra={'tools': [data_tool, follow_up], 'tool_choice': choice})[0], 200)
self.assertEqual(self.calls[-1]['tools'], [data_tool])
if isinstance(choice, dict):
self.assertNotIn('tool_choice', self.calls[-1])
self.assertEqual(self.request(extra={'tools': [follow_up], 'tool_choice': 'required'})[0], 200)
self.assertNotIn('tools', self.calls[-1])
self.assertNotIn('tool_choice', self.calls[-1])
def test_only_supported_tools_reach_the_native_model_in_each_execution_mode(self):
helpers = ['read', 'list', 'grep', 'search', 'mcp_call', 'mcp_connect']
incompatible = ['clarification', 'request_warehouse_selection', 'request_warehouse_credentials',
'execute_sql', 'execute_semantic_query', 'read_query_result', 'display_chart', 'display_map',
'write', 'str_replace', 'execute_python', 'execute_sandboxed_code', 'task',
'onboarding_command', 'onboarding_progress', 'generate_onboarding_rules',
'suggest_follow_ups', 'future_unknown_tool']
tools = [{'type': 'function', 'function': {'name': n, 'parameters': {'type': 'object'}}}
for n in helpers + ['story'] + incompatible]
for native in (False, True):
self.gate.native_agent = native
self.assertEqual(self.request(extra={'tools': tools})[0], 200)
self.assertEqual([t['function']['name'] for t in self.calls[-1]['tools']],
helpers + ([] if native else ['story']))
def test_forced_unavailable_tool_cannot_survive_even_without_a_tool_definition(self):
for extra in ({'tool_choice': {'type': 'function', 'function': {'name': 'clarification'}}},
{'tool_choice': {'type': 'function', 'function': 'malformed'}},
{'tools': [], 'tool_choice': 'required'},
{'tools': [{'type': 'function', 'function': {'name': 'read'}}],
'tool_choice': {'type': 'function', 'function': {'name': 'execute_sql'}}}):
self.assertEqual(self.request(extra=extra)[0], 200)
self.assertNotIn('tool_choice', self.calls[-1])
def test_previous_turn_background_call_cannot_enter_current_thinking_or_provider(self):
marker='quality-turn:current-request'
self.gate._native_turn_marker=marker
self.gate._thinking={'enabled':True,'effort':'medium','protocol':'thinking'}
self.assertEqual(self.request(extra={'messages':[{'role':'user','content':'quality-turn:old-request'}]})[0],403)
self.assertEqual(self.request(extra={'messages':[{'role':'system','content':marker},{'role':'user','content':'old request'}]})[0],403)
self.assertEqual(self.calls,[])
self.assertEqual(self.gate._request_number,0)
self.assertEqual(self.gate.request_audit,[])
self.assertEqual(self.gate.rejected_stale_requests,2)
self.assertEqual(self.request(extra={'messages':[{'role':'user','content':[{'type':'text','text':marker+' current task'}]}]})[0],200)
self.assertEqual(self.request(phase='planning')[0],200)
self.assertEqual(len(self.calls),2)
self.assertEqual(len(self.gate.request_audit),2)
def test_saved_enabled_effort_applies_to_every_request_despite_helper_defaults(self):
self.gate._thinking={'enabled':True,'effort':'high','protocol':'thinking'}
self.assertEqual(self.request(extra={'thinking':{'type':'disabled'},'reasoning_effort':'low','temperature':.2,'max_completion_tokens':4096})[0],200)
body=self.calls[-1]
self.assertEqual(body['thinking'],{'type':'enabled'})
self.assertEqual(body['reasoning_effort'],'high')
self.assertNotIn('temperature',body)
from nao_runtime_policy import MAX_OUTPUT_TOKENS
self.assertEqual(body['max_completion_tokens'],MAX_OUTPUT_TOKENS)
self.assertNotIn('offline fixture',json.dumps(self.gate.request_audit))
def test_qwen38_native_effort_uses_template_low_medium_and_xhigh(self):
self.gate._model='qwen3.8-27b-local'
for selected,native in [('low','low'),('medium','medium'),('high','xhigh')]:
self.gate._thinking={'enabled':True,'effort':selected,'protocol':'chat_template'}
self.assertEqual(self.request(model='qwen3.8-27b-local',extra={'reasoning_effort':'high','chat_template_kwargs':{'reasoning_effort':'low','preserve_thinking':True}})[0],200)
body=self.calls[-1]
self.assertEqual(body['chat_template_kwargs'],{'reasoning_effort':native,'enable_thinking':True,'preserve_thinking':True})
self.assertNotIn('reasoning_effort',body)
self.assertEqual(self.gate.request_audit[-1]['reasoningEffort'],native)
def test_mimo_disables_thinking_only_for_native_tool_requests(self):
self.gate._model='mimo-v2.6-flash'
self.gate.runtime_engine='DSH'
self.gate._thinking={'enabled':True,'effort':'auto','protocol':'thinking'}
tool={'type':'function','function':{'name':'mcp__quality__quality_data','parameters':{'type':'object'}}}
for native,tools in ((False,[]),(True,[tool]),(True,[])):
with self.subTest(native=native,tools=bool(tools)):
self.gate.native_agent=native
self.assertEqual(self.request(model=self.gate._model,extra={'tools':tools})[0],200)
expected=not(native and tools)
self.assertEqual(self.calls[-1]['thinking'],{'type':'enabled' if expected else 'disabled'})
self.assertTrue(self.gate._thinking['enabled'])
self.assertTrue(self.gate.request_audit[-1]['requestedEnabled'])
def test_qwen_switch_uses_chat_template_control_and_removes_conflicting_flags(self):
self.gate._thinking={'enabled':False,'effort':'medium','protocol':'chat_template'}
self.assertEqual(self.request(extra={'thinking':{'type':'enabled'},'reasoning_effort':'high','chat_template_kwargs':{'enable_thinking':True}})[0],200)
body=self.calls[-1]
self.assertEqual(body['chat_template_kwargs']['enable_thinking'],False)
self.assertNotIn('thinking',body)
self.assertNotIn('reasoning_effort',body)
def test_explicit_sse_done_finishes_without_eof_for_bridge_and_passthrough(self):
from unittest.mock import Mock
rows = [
{'id': 'fake-completion', 'model': 'fake-model', 'choices': [
{'index': 0, 'delta': {'reasoning_content': '先核对。', 'content': '{"ok":'}}]},
{'choices': [{'index': 0, 'delta': {'content': 'true}'}, 'finish_reason': 'stop'}]},
# The usage-only tail must survive even though the choice already finished.
{'choices': [], 'usage': {'prompt_tokens': 7, 'completion_tokens': 12}},
]
wire = [('data: ' + json.dumps(row, ensure_ascii=False) + '\n\n').encode() for row in rows]
chunks = [*wire, b'data: [DO', b'NE]\n\n']
for stream, observe in ((False, True), (True, True), (True, False)):
with self.subTest(stream=stream, observe=observe):
events = []
self.gate._on_thinking = events.append if observe else None
upstream = HeldOpenProviderResponse(chunks)
self.gate._opener = Mock()
self.gate._opener.open.return_value = upstream
response = []
returned = threading.Event()
def request():
try:
response.append(self.request(extra={'stream': stream}))
except Exception as error:
response.append(error)
finally:
returned.set()
worker = threading.Thread(target=request, daemon=True)
worker.start()
try:
self.assertTrue(upstream.terminal_delivered.wait(1), 'fake provider did not deliver DONE')
completed_before_eof = returned.wait(1)
finally:
upstream.release.set()
worker.join(timeout=2)
self.assertTrue(completed_before_eof, 'ModelGate still waits for provider EOF after explicit DONE')
self.assertFalse(upstream.read_after_terminal.is_set(), 'ModelGate read beyond explicit DONE')
self.assertTrue(upstream.closed.is_set())
self.assertEqual(response[0][0], 200)
if stream:
self.assertEqual(response[0][1].encode(), b''.join(chunks))
else:
completion = json.loads(response[0][1])
self.assertEqual(completion['choices'][0]['message']['content'], '{"ok":true}')
self.assertEqual(completion['choices'][0]['finish_reason'], 'stop')
self.assertEqual(completion['usage'], {'prompt_tokens': 7, 'completion_tokens': 12})
self.assertNotIn('reasoning_content', completion['choices'][0]['message'])
if observe:
self.assertEqual(events[-1]['event'], 'end')
self.assertEqual(events[-1]['finishReason'], 'stop')
self.assertFalse(events[-1]['interrupted'])
def test_explicit_done_without_finish_reason_is_not_a_successful_completion(self):
from unittest.mock import Mock
upstream = HeldOpenProviderResponse([
b'data: {"choices":[{"index":0,"delta":{"content":"incomplete"}}]}\n\n',
b'data: [DONE]\n\n',
])
self.gate._opener = Mock()
self.gate._opener.open.return_value = upstream
events = []
self.gate._on_thinking = events.append
response = []
returned = threading.Event()
def request():
try:
response.append(self.request())
finally:
returned.set()
worker = threading.Thread(target=request, daemon=True)
worker.start()
try:
self.assertTrue(upstream.terminal_delivered.wait(1))
completed_before_eof = returned.wait(1)
finally:
upstream.release.set()
worker.join(timeout=2)
self.assertTrue(completed_before_eof, 'invalid DONE must fail without waiting for EOF')
self.assertEqual(response[0][0], 502)
self.assertTrue(events[-1]['interrupted'])
if __name__ == '__main__': unittest.main()