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

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

561 lines
33 KiB
Python

import copy
import io
import json
import sys
import tempfile
import threading
import unittest
from pathlib import Path
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'scripts'))
sys.path.insert(0, str(Path(__file__).resolve().parent))
from nao_agent_task import TaskUnavailable, normalize_task
from nao_protocol_execution import execute
from nao_query_contract import bind_query
from nao_query_plan import normalize_query_plan
from nao_quality_tools import QualityToolError, QualityTools
from nao_evidence_finalizer import _resolve_completed_protocol_raw_gaps
from test_nao_agent_task import task_value
from test_nao_protocol_execution import BoundApi, RELEASE, TURN, identity
class RawPlanTests(unittest.TestCase):
def root(self, **overrides):
value = {'period':{'year':2026,'monthStart':1,'monthEnd':2},
'comparisonPeriod':None,'filters':{'department':'部门甲'},
'fields':[],'dimensions':[],'stages':[],
'trendRequired':False,'comparisonRequired':False,
'verifySource':True,'fullDetails':True,'periodCoverage':'available'}
value.update(overrides)
return value
def plan(self):
return [
{'nodeId':'source','purpose':'source','fields':[],'stages':['black'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
{'nodeId':'records','purpose':'records','fields':[],'stages':['black'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
]
def test_raw_node_union_sets_root_stage_and_flags_without_kpi_fields(self):
root = self.root()
result = normalize_query_plan(self.plan(), root_task=root, root_value=self.root())
self.assertEqual([node['purpose'] for node in result], ['source','records'])
self.assertEqual(root['fields'], [])
self.assertEqual(root['stages'], ['black'])
self.assertTrue(root['verifySource'])
self.assertTrue(root['fullDetails'])
self.assertEqual(root['dimensions'], [])
def test_raw_flags_cannot_be_omitted_or_downgraded(self):
cases = [
(self.root(verifySource=False), self.plan()),
(self.root(fullDetails=False), self.plan()),
(self.root(fullDetails=True), self.plan()[:1]),
]
for root, plan in cases:
with self.subTest(root=root, plan=plan), self.assertRaises(ValueError):
normalize_query_plan(plan, root_task=copy.deepcopy(root), root_value=root)
def test_raw_nodes_require_empty_fields_and_no_visuals(self):
for update in ({'fields':['rate']}, {'visualType':'bar'}, {'visualPreference':'auto'},
{'stages':[]}):
raw = self.plan()[:1]
raw[0].update(update)
with self.subTest(update=update), self.assertRaises(ValueError):
normalize_query_plan(raw, root_task=self.root(fullDetails=False),
root_value=self.root(fullDetails=False))
def test_source_fields_are_stage_specific_authorized_stable_keys(self):
catalog = {'sourceFields':[
{'key':'order_no','type':'source_value','stages':['black'],
'columns':{'black':'委托单号'}},
{'key':'batch_code','type':'source_value','stages':['bright'],
'columns':{'bright':'批次号'}},
]}
plan = self.plan()[:1]
plan[0]['sourceFields'] = {'black':['order_no']}
root = self.root(fullDetails=False)
result = normalize_query_plan(plan, root_task=root, root_value=root,
context={'_businessCatalog':catalog})
self.assertEqual(result[0]['sourceFields'], {'black':['order_no']})
for selected in ({'black':['missing']}, {'bright':['batch_code']},
{'black':['order_no','order_no']}):
bad = copy.deepcopy(plan)
bad[0]['sourceFields'] = selected
with self.subTest(selected=selected), self.assertRaises(ValueError):
normalize_query_plan(bad, root_task=self.root(fullDetails=False),
root_value=self.root(fullDetails=False),
context={'_businessCatalog':catalog})
def test_legacy_pure_raw_kinds_synthesize_query_plan_and_keep_full_goal(self):
source = task_value(kind='source_verify',dimensions=[],fields=[],stages=['black'],
verifySource=True,fullDetails=False,period={'year':2026})
records = task_value(kind='details',dimensions=[],fields=[],stages=['bright'],
verifySource=False,fullDetails=True,period={'year':2026})
for value, purpose in ((source,'source'),(records,'records')):
task = normalize_task(value,'完整核验当前原始数据',
{'_protocol':{'version':1}})
self.assertEqual(len(task['queryPlan']),1)
self.assertEqual(task['queryPlan'][0]['purpose'],purpose)
self.assertEqual(task['queryPlan'][0]['fields'],[])
self.assertEqual(task['queryPlan'][0]['stages'],[value['stages'][0]])
self.assertEqual(task['verifySource'],purpose=='source')
self.assertEqual(task['fullDetails'],purpose=='records')
def test_legacy_metrics_with_explicit_raw_requirements_keeps_metric_and_scope(self):
value=task_value(kind='metrics',dimensions=[],stages=[],fields=['rate'],
verifySource=True,fullDetails=True,period={'year':2026},
filterUpdates={'department':'部门甲'},trendRequired=False,
comparisonRequired=False)
task=normalize_task(value,'在部门甲范围分析综合合格率并核对原表、读取所有记录',
{'_protocol':{'version':1}})
by_purpose={node['purpose']:node for node in task['queryPlan']}
self.assertEqual(by_purpose['metrics']['fields'],['rate'])
self.assertEqual(by_purpose['metrics']['stages'],[])
self.assertEqual(by_purpose['source']['fields'],[])
self.assertEqual(by_purpose['records']['fields'],[])
self.assertEqual(task['fields'],['rate'])
self.assertEqual(task['filters']['department'],'部门甲')
self.assertTrue(task['verifySource'])
self.assertTrue(task['fullDetails'])
def test_scoped_investigate_binds_month_range_columns_exclusions_and_stage(self):
columns = [{'field':'customer_code','stages':['black'],'operator':'in','values':['C01']}]
task = {'filters':{'department':'部门甲','exclusions':{'product':['P-2']},
'columnFilters':columns},
'dimensions':[],'stages':['black'],'dimensionStages':{},
'period':{'year':2026,'monthStart':1,'monthEnd':2},
'comparisonPeriod':None}
args = {'mode':'investigate','action':'rows','releaseId':RELEASE,
'period':copy.deepcopy(task['period']),
'filters':{'department':'部门甲','exclusions':{'product':['P-2']}},
'columnFilters':copy.deepcopy(columns),'stage':'black',
'limit':100,'offset':0,'recordFilter':'all'}
bound = bind_query(args, {'task':task,'releaseId':RELEASE,'exactScope':True})
self.assertEqual(bound['period'],task['period'])
self.assertEqual(bound['filters']['exclusions'],task['filters']['exclusions'])
self.assertEqual(bound['columnFilters'],columns)
self.assertEqual(bound['stage'],'black')
class InvestigationApi:
def __init__(self, *, total_rows=205, missing_proof=False, wrong_context_key=None):
self.total_rows = total_rows
self.missing_proof = missing_proof
self.wrong_context_key = wrong_context_key
self.calls = []
self.query_count = 0
self.scopes = []
@staticmethod
def source_fields():
return [{'key':'customer_code','type':'source_value','stages':['black'],
'columns':{'black':'客户代码'},'operators':['in']}]
def add_scope(self, node_id, scope_id, purpose, root):
child = copy.deepcopy(root)
child.pop('queryPlan',None)
child['kind'] = 'source_verify' if purpose == 'source' else 'details'
child['fields'] = []
child['dimensions'] = []
child['dimensionStages'] = {}
child['stages'] = ['black']
child['trendRequired'] = False
child['comparisonRequired'] = False
child['visualType'] = None
child['visualPreference'] = 'none'
child['verifySource'] = purpose == 'source'
child['fullDetails'] = purpose == 'records'
child['investigationFields'] = {'black':['委托单号','客户代码']}
self.scopes.append({'nodeId':node_id,'scopeId':scope_id,'label':scope_id,
'purpose':purpose,'task':child})
def call(self, path, payload=None, method=None, *, node_id=None, scope_id=None):
self.calls.append({'path':path,'payload':copy.deepcopy(payload),
'method':method,'nodeId':node_id,'scopeId':scope_id})
if path == '/api/analysis/protocol/queries':
return {'version':1,'scopes':copy.deepcopy(self.scopes),'pending':[],'gaps':[]}
if path == '/api/releases':
return {'items':[{'id':RELEASE,'name':'Release','status':'PUBLISHED'}]}
if path == '/api/analysis/tools/catalog':
return {'kind':'analysis_catalog','sourceFields':self.source_fields()}
if path != '/api/analysis/investigate':
raise AssertionError(path)
self.query_count += 1
expected_period = {key:payload[key] for key in
('year','month','quarter','monthStart','monthEnd') if key in payload}
context = {**expected_period,'releaseId':RELEASE,'stage':payload['stage'],
'category':None,'sourceRevisionId':None,'includeUnassigned':False,
'department':payload.get('department'),'group':payload.get('group'),
'product':payload.get('product'),'projectGroup':payload.get('projectGroup'),
'extraFilters':payload.get('extraFilters',{}),
'columnFilters':payload.get('columnFilters',[]),
'exclusions':payload.get('exclusions',{})}
if self.wrong_context_key:
context[self.wrong_context_key] = 'OUT_OF_SCOPE_SENTINEL'
proof = {'queryId':f'raw-{self.query_count}','attemptId':identity()['attemptId'],
'sessionId':identity()['sessionId'],'turnId':identity()['turnId'],
'revision':identity()['revision'],'executionId':identity()['executionId'],
'responseHash':f'{self.query_count:064x}','nodeId':node_id,'scopeId':scope_id}
action = payload['action']
response = {'kind':'quality_investigation','action':action,'releaseId':RELEASE,
'context':context,'totalRows':self.total_rows,'aggregateComplete':True,
'categories':[],'lineage':[]}
if action == 'source':
response['sourceVerification'] = {'expectedRows':self.total_rows,
'complete':self.total_rows > 0,'verifiedRows':self.total_rows,
'missingRows':0,'mismatchRows':0,'allSelectedValuesMatchStored':self.total_rows > 0,
'files':[]}
else:
offset = payload.get('offset',0)
limit = payload['limit']
count = min(limit,max(0,self.total_rows-offset))
rows = [{'rowNumber':offset+index+1,'product':'规格A',
'values':{'委托单号':f'ORDER-{offset+index+1}',
'客户代码':'PRIVATE_RAW_VALUE'}}
for index in range(count)]
response.update(rows=rows,offset=offset,returnedRows=count,
matchingRows=self.total_rows,hasMore=offset+count<self.total_rows,
nextOffset=offset+count if offset+count<self.total_rows else None)
if not self.missing_proof:
response['protocolEvidence'] = proof
return response
class RawPlanExecutionTests(unittest.TestCase):
def root_task(self, *, purposes=('source','records'), with_column_filters=True):
nodes = []
for purpose in purposes:
nodes.append({'nodeId':purpose,'purpose':purpose,'fields':[],'stages':['black'],
'selector':{'kind':'base'},'visualType':None,
'visualPreference':'none','comparisonRequired':False})
columns=[{'field':'customer_code','stages':['black'],'operator':'in','values':['C01']}]
value = task_value(kind='analysis',dimensions=[],stages=['black'],fields=[],
verifySource='source' in purposes,fullDetails='records' in purposes,
period={'year':2026,'monthStart':1,'monthEnd':2},queryPlan=nodes,
**({'columnFilters':columns} if with_column_filters else {}),
filterUpdates={'exclusions':{'product':['P-2']}},
comparisonRequired=False,trendRequired=False)
return normalize_task(value,'核验原表并读取完整记录',
{'_protocol':{'version':1},
'_businessCatalog':{'sourceFields':InvestigationApi.source_fields()}})
def run_query(self, api, purposes=('source','records'), *, with_column_filters=True,
return_completion=False):
task = self.root_task(purposes=purposes,with_column_filters=with_column_filters)
if not with_column_filters:
task['filters'].pop('columnFilters',None)
for purpose in purposes:
api.add_scope(purpose,purpose+'-scope',purpose,task)
with tempfile.TemporaryDirectory() as folder:
root=Path(folder);(root/'evidence').mkdir();(root/'private').mkdir()
with patch('nao_evidence_finalizer.synthesize') as synth:
result=execute(request={'releaseId':RELEASE,'turnId':TURN,
'question':task['question']},task=task,
authority={**identity(),'task':task},actor_root=root,delegated=api,
connection=('http://offline','synthetic','model'),
cancel_event=threading.Event(),emit=lambda _:None)
documents=[json.loads(path.read_text()) for path in (root/'evidence').glob('nao-quality-*.json')]
completion=json.loads((root/'private'/'protocol-completion.json').read_text())
return (result,documents,synth,completion) if return_completion else (result,documents,synth)
def test_raw_nodes_use_server_columns_envelopes_and_read_all_stable_pages(self):
api=InvestigationApi(total_rows=205)
result,documents,synth=self.run_query(api)
self.assertEqual(result['status'],'COMPLETED',result['evidenceCompletion']['missingEvidence'])
self.assertEqual(result['stopReason'],'evidence_finalized')
self.assertEqual(result['completionMethod'],'bounded_scoped_query_plan')
self.assertEqual(result['finishReason'],'stop')
self.assertTrue(result['evidenceCompletion']['serverCoverageSufficient'])
self.assertEqual(len(result['protocolEvidence']),4)
self.assertFalse(synth.called)
reads=[call for call in api.calls if call['path']=='/api/analysis/investigate']
self.assertEqual(len(reads),4)
self.assertEqual({(call['nodeId'],call['scopeId']) for call in reads},
{('source','source-scope'),('records','records-scope')})
self.assertEqual([call['payload']['offset'] for call in reads if call['payload']['action']=='rows'],
[0,100,200])
self.assertTrue(all(call['payload']['includeUnassigned'] is False for call in reads))
self.assertTrue(all(call['payload']['limit']==100 for call in reads))
self.assertTrue(all(call['payload']['fields']==['委托单号','客户代码'] for call in reads))
self.assertTrue(all(call['payload']['columnFilters']==[
{'field':'customer_code','stages':['black'],'operator':'in','values':['C01']}
] for call in reads))
self.assertTrue(all(call['payload']['exclusions']=={'product':['P-2']} for call in reads))
self.assertFalse(any(call['payload'].get('recordFilter') for call in reads
if call['payload']['action']=='source'))
self.assertFalse(any('PRIVATE_RAW_VALUE' in json.dumps(value,ensure_ascii=False)
for value in (result['answer'],result['scopeDiagnostics'])))
self.assertNotIn('recordList',result)
self.assertEqual({doc['mode'] for doc in documents},{'investigate'})
def test_autonomous_source_and_records_only_plan_uses_finalizer_and_keeps_raw_coverage(self):
task=self.root_task(purposes=('source','records'))
api=InvestigationApi(total_rows=1)
for purpose in ('source','records'):
api.add_scope(purpose,purpose+'-scope',purpose,task)
captured={}
def synthesize_stub(**kwargs):
captured['evidence']=copy.deepcopy(kwargs['evidence'])
captured['question']=kwargs['question']
return {'answer':'仅确认了原表核验,原问题仍缺少正式分析依据。',
'evidenceSufficient':False,'missingEvidence':['原问题所需正式分析依据未取得。'],
'modelDeclaredEvidenceSufficient':None,'usage':{},'finishReason':'stop',
'selectedFactIds':[]}
with tempfile.TemporaryDirectory() as folder:
root=Path(folder);(root/'evidence').mkdir();(root/'private').mkdir()
with patch('nao_evidence_finalizer.synthesize',side_effect=synthesize_stub) as synth:
result=execute(request={'releaseId':RELEASE,'turnId':TURN,
'question':task['question'],'_autonomousAnswer':True},task=task,
authority={**identity(),'task':task},actor_root=root,delegated=api,
connection=('http://offline','synthetic','model'),
cancel_event=threading.Event(),emit=lambda _:None)
self.assertTrue(synth.called)
source_docs=[doc for doc in captured['evidence'] if doc.get('mode')=='investigate'
and (doc.get('result') or {}).get('action')=='source']
self.assertEqual(len(source_docs),1)
self.assertFalse(any((doc.get('result') or {}).get('action')=='rows'
for doc in captured['evidence']))
self.assertEqual(source_docs[0]['result']['current']['sourceVerification']['verifiedRows'],1)
self.assertIn('已按稳定分页读全1条',result['answer'])
self.assertEqual(result['status'],'PARTIAL')
self.assertIn('原问题所需正式分析依据未取得。',result['evidenceCompletion']['missingEvidence'])
def test_autonomous_records_only_plan_stays_deterministic(self):
task=self.root_task(purposes=('records',))
api=InvestigationApi(total_rows=1)
api.add_scope('records','records-scope','records',task)
with tempfile.TemporaryDirectory() as folder:
root=Path(folder);(root/'evidence').mkdir();(root/'private').mkdir()
with patch('nao_evidence_finalizer.synthesize') as synth:
result=execute(request={'releaseId':RELEASE,'turnId':TURN,
'question':task['question'],'_autonomousAnswer':True},task=task,
authority={**identity(),'task':task},actor_root=root,delegated=api,
connection=('http://offline','synthetic','model'),
cancel_event=threading.Event(),emit=lambda _:None)
self.assertFalse(synth.called)
self.assertEqual(result['status'],'COMPLETED')
self.assertIn('已按本轮服务器授权范围核对原始数据。',result['answer'])
def test_unselected_column_filters_accept_canonical_empty_context_echo(self):
api=InvestigationApi(total_rows=2)
result,_,_=self.run_query(api,with_column_filters=False)
self.assertEqual(result['status'],'COMPLETED',result['evidenceCompletion']['missingEvidence'])
reads=[call for call in api.calls if call['path']=='/api/analysis/investigate']
self.assertTrue(reads)
self.assertTrue(all('columnFilters' not in call['payload'] for call in reads))
def test_failed_raw_read_keeps_private_safe_error_diagnostic(self):
api=InvestigationApi(total_rows=2,wrong_context_key='product')
result,_,_,completion=self.run_query(api,return_completion=True)
self.assertEqual(result['status'],'PARTIAL')
self.assertEqual(result['stopReason'],'evidence_incomplete')
self.assertEqual(result['completionMethod'],'bounded_scoped_query_plan')
self.assertEqual(result['finishReason'],'stop')
diagnostic=next(item for item in completion['queryDiagnostics']
if item.get('nodeId')=='records')
self.assertEqual(diagnostic['errorType'],'QualityToolError')
self.assertIn('未确认product范围',diagnostic['errorSummary'])
self.assertNotIn('P-2',diagnostic['errorSummary'])
self.assertNotIn('C01',diagnostic['errorSummary'])
self.assertNotIn('OUT_OF_SCOPE_SENTINEL',diagnostic['errorSummary'])
self.assertNotIn('QualityToolError',result['answer'])
self.assertNotIn('OUT_OF_SCOPE_SENTINEL',result['answer'])
def test_records_stop_at_global_4000_row_bound_and_finish_partial(self):
api=InvestigationApi(total_rows=4500)
result,documents,_=self.run_query(api,purposes=('records',))
self.assertEqual(result['status'],'PARTIAL')
self.assertEqual(result['evidenceCompletion']['serverCoverageSufficient'],False)
reads=[call for call in api.calls if call['path']=='/api/analysis/investigate']
self.assertEqual(len(reads),40)
self.assertEqual(sum(call['payload'].get('limit',0) for call in reads
if call['payload']['action']=='rows'),4000)
self.assertTrue(any('4000条' in gap for gap in result['evidenceCompletion']['missingEvidence']))
def test_missing_raw_protocol_proof_is_partial_and_never_promoted_to_complete(self):
api=InvestigationApi(total_rows=2,missing_proof=True)
result,documents,_=self.run_query(api)
self.assertEqual(result['status'],'PARTIAL')
self.assertFalse(result['evidenceCompletion']['serverCoverageSufficient'])
self.assertFalse(result['protocolEvidence'])
self.assertTrue(result['evidenceCompletion']['missingEvidence'])
def test_only_completed_raw_requirement_gaps_are_resolved(self):
raw_gaps=[
'该范围内逐条原始记录(客户代码、委托订单号、加工单位,不去重)未返回可用事实',
'上述字段与归档原始Excel的一致性核验结果未返回可用事实',
'亮片报废率仍缺少正式来源月份',
]
complete={'records':{'requiredChecks':1,'verifiedChecks':1,'complete':True},
'source':{'requiredChecks':1,'verifiedChecks':1,'complete':True}}
retained,resolved=_resolve_completed_protocol_raw_gaps(raw_gaps,complete)
self.assertEqual(retained,[raw_gaps[2]])
self.assertEqual(resolved,raw_gaps[:2])
incomplete={'records':complete['records'],
'source':{'requiredChecks':1,'verifiedChecks':0,'complete':False}}
retained,resolved=_resolve_completed_protocol_raw_gaps(raw_gaps,incomplete)
self.assertEqual(retained,raw_gaps[1:])
self.assertEqual(resolved,[raw_gaps[0]])
class MixedRawMetricsApi(BoundApi):
def __init__(self, root, plan):
super().__init__()
self.plan=plan
self.raw_api=InvestigationApi(total_rows=165)
self.scopes=[]
for node in plan:
purpose=node['purpose']
child=copy.deepcopy(root)
child.pop('queryPlan',None)
child['kind']={'source':'source_verify','records':'details'}.get(purpose,'metrics')
child['fields']=copy.deepcopy(node['fields'])
child['dimensions']=[]
child['dimensionStages']={}
child['stages']=copy.deepcopy(node['stages'])
child['trendRequired']=purpose=='trend'
child['comparisonRequired']=node['comparisonRequired']
child['visualType']=None
child['visualPreference']='none'
child['verifySource']=purpose=='source'
child['fullDetails']=purpose=='records'
if purpose in ('source','records'):
child['investigationFields']={stage:['客户代码','委托订单号','加工单位']
for stage in node['stages']}
self.scopes.append({'nodeId':node['nodeId'],'scopeId':purpose+'-scope',
'label':purpose,'purpose':purpose,'task':child})
def call(self, path, payload=None, method=None, *, node_id=None, scope_id=None):
if path=='/api/analysis/protocol/queries':
return {'version':1,'scopes':copy.deepcopy(self.scopes),'pending':[],'gaps':[]}
if path=='/api/analysis/investigate':
return self.raw_api.call(path,payload,method,node_id=node_id,scope_id=scope_id)
result=super().call(path,payload,method)
if path.startswith('/api/metrics'):
result['summary']['bright']['scrapRate']=0.081
for month in result.get('coverage',{}).get('sourceMonths',[]):
month['blackRows']=10
month['brightRows']=12
proof=result.get('protocolEvidence')
if isinstance(proof,dict):
proof.update(nodeId=node_id,scopeId=scope_id,queryId='mixed-kpi',responseHash='b'*64)
return result
class MixedRawPlanExecutionTests(unittest.TestCase):
def test_mixed_plan_synthesizes_only_kpi_evidence_and_platform_reports_raw_completion(self):
plan=[
{'nodeId':'records','purpose':'records','fields':[],'stages':['bright'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
{'nodeId':'verify','purpose':'source','fields':[],'stages':['bright'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
{'nodeId':'metric','purpose':'metrics','fields':['scrapRate'],'stages':['bright'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
]
value=task_value(kind='details',dimensions=[],stages=['bright'],fields=['scrapRate'],
verifySource=True,fullDetails=True,period={'year':2026,'month':9},queryPlan=plan,
visualPreference='none',visualType=None,comparisonRequired=False,trendRequired=False)
task=normalize_task(value,'查询2026年9月亮片报废率,并读取该范围逐条原始记录及核验归档原件',
{'_protocol':{'version':1}})
api=MixedRawMetricsApi(task,task['queryPlan'])
for node in task['queryPlan']:
self.assertIn(node['purpose'],{'records','source','metrics'})
raw_model_gaps=[
'该范围内逐条原始记录(客户代码、委托订单号、加工单位,不去重)未返回可用事实',
'上述字段与归档原始Excel的一致性核验结果未返回可用事实',
]
model_requests=[]
def model_opener(request,timeout):
body=json.loads(request.data.decode())
model_requests.append(body)
selector=json.loads(body['messages'][1]['content'])
fact_id=selector['facts'][0]['id']
completion={'model':'model','usage':{},'choices':[{'finish_reason':'stop','message':{
'content':json.dumps({'reportTitle':'2026年9月亮片报废率',
'answerBlocks':[{'type':'paragraph','factIds':[fact_id]}],
'evidenceSufficient':False,'missingEvidence':raw_model_gaps},ensure_ascii=False)}}]}
return io.BytesIO(json.dumps(completion,ensure_ascii=False).encode())
with tempfile.TemporaryDirectory() as folder:
root=Path(folder);(root/'evidence').mkdir();(root/'private').mkdir()
with patch('nao_evidence_finalizer._open_model',side_effect=model_opener):
result=execute(request={'releaseId':RELEASE,'turnId':TURN,
'question':task['question']},task=task,
authority={**identity(),'task':task},actor_root=root,delegated=api,
connection=('http://offline','synthetic','model'),
cancel_event=threading.Event(),emit=lambda _:None)
docs=[json.loads(path.read_text()) for path in (root/'evidence').glob('nao-quality-*.json')]
self.assertEqual(result['status'],'COMPLETED',result['evidenceCompletion']['missingEvidence'])
self.assertTrue(task['verifySource'])
self.assertTrue(task['fullDetails'])
self.assertEqual(len(result['protocolEvidence']),4)
self.assertEqual(result['evidenceCompletion']['missingEvidence'],[])
self.assertFalse(result['evidenceCompletion']['modelDeclaredEvidenceSufficient'])
self.assertEqual(len(model_requests),1)
selector=json.loads(model_requests[0]['messages'][1]['content'])
self.assertEqual([item['kind'] for item in selector['coverage']],['quality_metrics'])
raw_summary=selector['protocolRawCoverage']
self.assertTrue(selector['agentTask']['verifySource'])
self.assertTrue(selector['agentTask']['fullDetails'])
self.assertEqual(raw_summary,{
'source':{'requiredChecks':1,'verifiedChecks':1,'complete':True},
'records':{'requiredChecks':1,'verifiedChecks':1,'complete':True}})
self.assertIn('source/records节点由平台独立执行',model_requests[0]['messages'][0]['content'])
self.assertNotIn('PRIVATE_RAW_VALUE',model_requests[0]['messages'][1]['content'])
self.assertEqual({document['mode'] for document in docs},{'query','investigate'})
self.assertIn('已按稳定分页读全165条',result['answer'])
self.assertIn('原表值与存储记录一致',result['answer'])
self.assertNotIn('PRIVATE_RAW_VALUE',result['answer'])
def test_autonomous_mixed_synthesis_receives_source_proof_without_record_rows(self):
plan=[
{'nodeId':'records','purpose':'records','fields':[],'stages':['bright'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
{'nodeId':'verify','purpose':'source','fields':[],'stages':['bright'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
{'nodeId':'metric','purpose':'metrics','fields':['scrapRate'],'stages':['bright'],
'selector':{'kind':'base'},'visualType':None,'visualPreference':'none',
'comparisonRequired':False},
]
value=task_value(kind='details',dimensions=[],stages=['bright'],fields=['scrapRate'],
verifySource=True,fullDetails=True,period={'year':2026,'month':9},queryPlan=plan,
visualPreference='none',visualType=None,comparisonRequired=False,trendRequired=False)
task=normalize_task(value,'查询亮片报废率,并核验原表及读取明细',{'_protocol':{'version':1}})
api=MixedRawMetricsApi(task,task['queryPlan'])
captured={}
def synthesize_stub(**kwargs):
captured['evidence']=copy.deepcopy(kwargs['evidence'])
return {'answer':'已基于正式指标和原表核验完成说明。','evidenceSufficient':True,
'missingEvidence':[],'modelDeclaredEvidenceSufficient':True,'usage':{},
'finishReason':'stop','selectedFactIds':[]}
with tempfile.TemporaryDirectory() as folder:
root=Path(folder);(root/'evidence').mkdir();(root/'private').mkdir()
with patch('nao_evidence_finalizer.synthesize',side_effect=synthesize_stub):
result=execute(request={'releaseId':RELEASE,'turnId':TURN,'question':task['question'],
'_autonomousAnswer':True},task=task,authority={**identity(),'task':task},
actor_root=root,delegated=api,connection=('http://offline','synthetic','model'),
cancel_event=threading.Event(),emit=lambda _:None)
docs=captured['evidence']
self.assertTrue(any(doc.get('mode')=='query' for doc in docs))
source_docs=[doc for doc in docs if doc.get('mode')=='investigate'
and (doc.get('result') or {}).get('action')=='source']
self.assertTrue(source_docs)
self.assertFalse(any((doc.get('result') or {}).get('action')=='rows' for doc in docs))
self.assertNotIn('PRIVATE_RAW_VALUE',json.dumps(docs,ensure_ascii=False))
self.assertEqual(result['status'],'COMPLETED',result['evidenceCompletion']['missingEvidence'])
if __name__ == '__main__':
unittest.main()