接入 DSH 专用运行时和对话界面,保留模型原始回答,支持会话分页、连续追问与显式报告。 补齐组合筛选、各维度 Top100、分组查询到排名图的转换,图表故障静默省略并基于保存数据自动恢复。 优化报告风格、图表顺序和表格换行,更新接入说明及构建输入。 验证:独立目录前后端构建通过;118 项 Java、102 项前端、102 项图表、14 项 DSH 应用和 13 项组合筛选检查通过。 仅提交相关源码、锁定依赖与测试;不包含凭据、会话、业务数据或本地产物。
393 lines
23 KiB
Python
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()
|