同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。 补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。 统一午夜黑及其他主题的控件细节、中文和业务数字字体。 排除本地业务数据、凭据、预览、发布与验收产物。 验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
329 lines
19 KiB
Python
329 lines
19 KiB
Python
import copy
|
|
import json
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
from pathlib import Path
|
|
from urllib.parse import parse_qs, urlsplit
|
|
from unittest.mock import patch
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
|
|
from nao_quality_tools import QualityTools, QualityToolError
|
|
from test_nao_quality_tools import FakeApi, snapshot_period
|
|
from nao_agent_task import normalize_task, bind_task
|
|
from test_nao_agent_task import task_value
|
|
from analysis_visuals import build_visuals
|
|
from nao_evidence_finalizer import coverage_sufficient
|
|
from nao_protocol_execution import execute
|
|
from nao_weight_ranking import rank_response, ranking_chart, ranking_report, missing_ranking_visuals
|
|
|
|
|
|
QUESTION = '做几张26年的亮片生产重量柏拉图,产品级、产业部级'
|
|
ACTOR='11111111-1111-4111-8111-111111111111'
|
|
SESSION='22222222-2222-4222-8222-222222222222'
|
|
TURN='55555555-5555-4555-8555-555555555555'
|
|
|
|
|
|
def signed_response(positive_rows=872, unavailable_rows=167, *, top_weight=None, metric='totalWeight', stage='black'):
|
|
period={'year':2026,'monthStart':1,'monthEnd':9}
|
|
total=sum([top_weight] if top_weight is not None else [])
|
|
rows=[]
|
|
for index in range(positive_rows):
|
|
weight=(top_weight if index==0 and top_weight is not None else 1)
|
|
total+=weight if not (index==0 and top_weight is not None) else 0
|
|
rows.append({'key':f'product-{index:04d}','label':f'规格{index:04d}',
|
|
stage:{metric:weight},'coverage':{stage+'Rows':1}})
|
|
rows.append({'key':'mimo-negative','label':'mimo-negative',stage:{metric:-10.05},'coverage':{stage+'Rows':1}})
|
|
for index in range(unavailable_rows):
|
|
rows.append({'key':f'no-stage-{index:04d}','label':f'未覆盖{index:04d}',stage:{metric:None},
|
|
'coverage':{stage+'Rows':0}})
|
|
total-=10.05
|
|
months=[{'year':2026,'month':month,'blackRows':1 if stage=='black' else 0,
|
|
'brightRows':1 if stage=='bright' else 0} for month in range(1,10)]
|
|
summary={stage:{metric:total}}
|
|
return {'rows':rows,'context':{'rowCount':len(rows)},'summary':summary,
|
|
'coverage':{'rawRows':len(rows),'includedRows':len(rows),'sourceMonths':months}},period
|
|
|
|
|
|
class WeightApi(FakeApi):
|
|
def __init__(self, *, partial_year=True, hole=False, mismatch=False):
|
|
super().__init__()
|
|
self.partial_year, self.hole, self.mismatch = partial_year, hole, mismatch
|
|
self.metric_query = 0
|
|
|
|
def call(self, path, payload=None, method=None):
|
|
result = super().call(path, payload, method)
|
|
if path == '/api/analysis/tools/catalog':
|
|
result['sourceFields'] = [{'key':'customer_code','label':'客户编码','type':'source_value',
|
|
'stages':['bright'],'columns':{'bright':'客户编码'},'operators':['in']}]
|
|
if path.startswith('/api/metrics?'):
|
|
self.metric_query += 1
|
|
params = parse_qs(urlsplit(path).query)
|
|
for month in result['coverage']['sourceMonths']:month['brightRows']=12
|
|
rows = []
|
|
for label, weight, scrap in [('scrap-leader', 10, 9), ('production-leader', 80, 1), ('third', 60, 2)]:
|
|
row = self._product_row(label, label, 1, scrap)
|
|
row['bright']['totalWeight'] = weight
|
|
rows.append(row)
|
|
result['rows'] = rows
|
|
result['context']['rowCount'] = 3
|
|
result['summary']['bright']['totalWeight'] = 151 if self.mismatch else 150
|
|
result['summary']['bright']['scrapWeight'] = 12
|
|
if self.partial_year:
|
|
result['coverage']['sourceMonths'] = result['coverage']['sourceMonths'][:9]
|
|
result['coverage']['missingStages'] = [{'year':2026,'month':m,'stage':'bright'} for m in (10,11,12)]
|
|
if self.hole:
|
|
result['coverage']['sourceMonths'] = [m for m in result['coverage']['sourceMonths'] if m['month'] != 5]
|
|
if 'monthStart' in params:
|
|
result['context']['monthStart'] = int(params['monthStart'][0])
|
|
result['context']['monthEnd'] = int(params['monthEnd'][0])
|
|
if 'columnFilters' in params:
|
|
result['filters'] = {'columnFilters':json.loads(params['columnFilters'][0])}
|
|
result['protocolEvidence'] = {'queryId':f'rank-query-{self.metric_query}',
|
|
'attemptId':'attempt','sessionId':'session','turnId':'turn','revision':1,
|
|
'executionId':'execution','responseHash':'a'*64}
|
|
return result
|
|
|
|
|
|
class NegativeWeightApi(WeightApi):
|
|
def call(self, path, payload=None, method=None):
|
|
result=super().call(path,payload,method)
|
|
if path.startswith('/api/metrics?'):
|
|
params=parse_qs(urlsplit(path).query)
|
|
if params.get('view',[''])[0]=='product':
|
|
rows=[]
|
|
for key,label,weight in (('large','大重量规格',100),('small','小重量规格',1),('mimo','mimo修正',-10.05)):
|
|
row=self._product_row(key,label,1,1)
|
|
row['black']['totalWeight']=weight
|
|
rows.append(row)
|
|
result['rows']=rows;result['context']['rowCount']=3
|
|
result['summary']['black']['totalWeight']=90.95
|
|
for month in result['coverage']['sourceMonths']:month['blackRows']=1
|
|
result['protocolEvidence']={'attemptId':SESSION,'sessionId':ACTOR,'turnId':TURN,
|
|
'revision':3,'executionId':TURN,'queryId':'signed-rank-query','responseHash':'b'*64}
|
|
return result
|
|
|
|
|
|
def planned(**updates):
|
|
value={'dimensions':['product','department'],'stages':['bright'],'fields':['totalWeight'],
|
|
'period':{'year':2026},'visualPreference':'required','visualType':'pareto','periodCoverage':'available'}
|
|
value.update(updates)
|
|
return normalize_task(task_value(**value), QUESTION)
|
|
|
|
|
|
class WeightRankingTests(unittest.TestCase):
|
|
def run_rank(self, metric='totalWeight', **options):
|
|
api = WeightApi(**options)
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
QualityTools(api_factory=lambda:api, evidence_dir=Path(folder)).quality_data({
|
|
'mode':'rank','releaseId':'release-a','period':{'year':2026},
|
|
'dimension':'product','stage':'bright','metric':metric,'limit':2})
|
|
doc = json.loads(next(Path(folder).glob('nao-quality-*.json')).read_text())
|
|
return doc, api
|
|
|
|
def test_ranks_all_products_by_requested_stage_weight_before_top_cut(self):
|
|
doc, api = self.run_rank()
|
|
result = doc['result']
|
|
self.assertEqual([row['label'] for row in result['rows']], ['production-leader','third'])
|
|
self.assertEqual(result['totalWeight'], 150)
|
|
self.assertEqual(result['rows'][0]['share'], 80/150)
|
|
self.assertAlmostEqual(result['rows'][-1]['cumulativeShare'], 140/150)
|
|
self.assertLess(result['rows'][-1]['cumulativeShare'], 1)
|
|
self.assertEqual(result['rankingCoverage']['groups'], 3)
|
|
self.assertFalse(any('rowLimit=' in path for _,path,_ in api.calls if path.startswith('/api/metrics')))
|
|
|
|
def test_black_total_weight_signed_reconciliation_keeps_all_absent_groups_auditable(self):
|
|
response,period=signed_response()
|
|
result=rank_response(response,{'id':'release-a','name':'A','status':'PUBLISHED'},period,{},
|
|
'product','black','totalWeight',10)
|
|
audit=result['rankingCoverage']
|
|
self.assertEqual(response['context']['rowCount'],1040)
|
|
self.assertEqual(audit['sourceGroups'],1040)
|
|
self.assertEqual(audit['groups'],873)
|
|
self.assertEqual(audit['unavailableGroups'],167)
|
|
self.assertEqual(audit['positiveGroups'],872)
|
|
self.assertEqual(audit['negativeGroups'],1)
|
|
self.assertEqual(audit['negativeWeight'],-10.05)
|
|
self.assertEqual(audit['negativeWeightMagnitude'],10.05)
|
|
self.assertEqual(result['totalWeight'],861.95)
|
|
self.assertEqual(result['rows'][0]['weight'],1)
|
|
self.assertTrue(all(row['weight']>0 for row in result['rows']))
|
|
self.assertAlmostEqual(result['rows'][0]['share'],1/861.95)
|
|
doc={'evidenceRef':'QSIGNED10','result':result}
|
|
task=planned(dimensions=['product'],stages=['black'],fields=['totalWeight'],period=period)
|
|
chart=ranking_chart(doc,'signed-black-total',task)
|
|
self.assertIsNotNone(chart)
|
|
self.assertIn('1项负向投入重量修正',chart['note'])
|
|
bad=copy.deepcopy(response);bad['summary']['black']['totalWeight']+=.1
|
|
with self.assertRaisesRegex(QualityToolError,'合计与同范围正式总量不一致'):
|
|
rank_response(bad,{'id':'release-a'},period,{},'product','black','totalWeight',10)
|
|
|
|
def test_negative_weights_remain_rejected_outside_black_total_weight(self):
|
|
for stage,metric in (('black','scrapWeight'),('bright','totalWeight'),('bright','scrapWeight')):
|
|
with self.subTest(stage=stage,metric=metric):
|
|
response={'rows':[{'key':'negative','label':'负值',stage:{metric:-1},'coverage':{stage+'Rows':1}}],
|
|
'context':{'rowCount':1},'summary':{stage:{metric:10}},
|
|
'coverage':{'sourceMonths':[{'year':2026,'month':month,'blackRows':1,'brightRows':1}
|
|
for month in range(1,10)]}}
|
|
with self.assertRaisesRegex(QualityToolError,'重量不能为负'):
|
|
rank_response(response,{'id':'release-a'},{'year':2026,'monthStart':1,'monthEnd':9},
|
|
{},'product',stage,metric,10)
|
|
|
|
def test_signed_black_total_reports_correction_and_blocks_over_100_chart_as_partial(self):
|
|
response,period=signed_response(positive_rows=2,unavailable_rows=0,top_weight=100)
|
|
result=rank_response(response,{'id':'release-a','name':'A','status':'PUBLISHED'},period,{},
|
|
'product','black','totalWeight',10)
|
|
self.assertEqual(result['totalWeight'],90.95)
|
|
self.assertEqual([row['label'] for row in result['rows']],['规格0000','规格0001'])
|
|
self.assertGreater(result['rows'][-1]['cumulativeShare'],1)
|
|
document={'evidenceRef':'QNEGATIVE1','result':result}
|
|
task=planned(dimensions=['product'],stages=['black'],fields=['totalWeight'],period=period,
|
|
visualPreference='required')
|
|
context=bind_task({'releaseId':'release-a'},task)
|
|
self.assertIsNone(ranking_chart(document,'negative-correction',task))
|
|
gap=missing_ranking_visuals(task,[],[document])
|
|
self.assertEqual(len(gap),1)
|
|
self.assertIn('负向修正使正重量Top合计超过黑片净总重',gap[0])
|
|
report=ranking_report([document],task,context)
|
|
self.assertIn('1项负向投入重量修正,净额-10.05 kg仍计入正式净总重分母',report['facts'][0]['text'])
|
|
section=report['sections'][0]
|
|
self.assertGreater(section.index('排名表只展示正重量Top'),section.index('| 1 |'))
|
|
|
|
def test_protocol_execution_keeps_signed_denominator_but_returns_partial_without_over_100_chart(self):
|
|
t=normalize_task(task_value(kind='analysis',dimensions=['product'],stages=['black'],
|
|
dimensionStages={'product':['black']},fields=['totalWeight'],period={'year':2026},
|
|
trendRequired=False,visualPreference='auto',visualType='pareto'),
|
|
'按产品查看黑片投入重量排名',{'_protocol':{'version':1}})
|
|
if t['filters'].get('columnFilters')==[]:t['filters'].pop('columnFilters')
|
|
api=NegativeWeightApi()
|
|
with tempfile.TemporaryDirectory() as folder,patch('nao_evidence_finalizer.synthesize',return_value={
|
|
'answer':'已核验黑片修正重量排名','evidenceSufficient':True,'missingEvidence':[],'usage':{}}):
|
|
root=Path(folder);(root/'evidence').mkdir();(root/'private').mkdir()
|
|
result=execute(request={'releaseId':'release-a','turnId':TURN,'question':t['question']},task=t,
|
|
authority={'attemptId':SESSION,'sessionId':ACTOR,'turnId':TURN,'revision':3,'executionId':TURN},
|
|
actor_root=root,delegated=api,connection=('offline','synthetic','model'),
|
|
cancel_event=threading.Event(),emit=lambda _:None)
|
|
doc=json.loads(next((root/'evidence').glob('nao-quality-*.json')).read_text())
|
|
self.assertEqual(doc['result']['totalWeight'],90.95)
|
|
self.assertEqual(doc['result']['rankingCoverage']['negativeGroups'],1)
|
|
self.assertEqual(doc['result']['rankingCoverage']['negativeWeight'],-10.05)
|
|
self.assertEqual(result['status'],'PARTIAL')
|
|
self.assertTrue(any('负向修正使正重量Top合计超过黑片净总重' in item
|
|
for item in result['evidenceCompletion']['missingEvidence']))
|
|
self.assertFalse(result['visuals'])
|
|
|
|
def test_rank_retains_column_filter_month_range_and_execution_proof(self):
|
|
api=WeightApi()
|
|
rule={'field':'customer_code','stages':['bright'],'operator':'in','values':['0012']}
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
QualityTools(api_factory=lambda:api,evidence_dir=Path(folder)).quality_data({
|
|
'mode':'rank','releaseId':'release-a','period':{'year':2026,'monthStart':1,'monthEnd':9},
|
|
'filters':{},'columnFilters':[rule],'dimension':'product','stage':'bright',
|
|
'metric':'totalWeight','limit':2})
|
|
doc=json.loads(next(Path(folder).glob('nao-quality-*.json')).read_text())
|
|
result=doc['result']
|
|
self.assertEqual(result['filters']['columnFilters'],[rule])
|
|
self.assertEqual(result['period'],{'year':2026,'monthStart':1,'monthEnd':9})
|
|
self.assertEqual(result['periodCoverage']['availableMonths'],list(range(1,10)))
|
|
self.assertTrue(result['periodCoverage']['complete'])
|
|
self.assertEqual(result['protocolEvidence']['queryId'],'rank-query-1')
|
|
metrics_paths=[path for _,path,_ in api.calls if path.startswith('/api/metrics')]
|
|
self.assertEqual(len(metrics_paths),1)
|
|
self.assertIn('columnFilters=',metrics_paths[0])
|
|
self.assertNotIn('rowLimit=',metrics_paths[0])
|
|
self.assertNotIn('rowOffset=',metrics_paths[0])
|
|
|
|
def test_rank_only_allows_column_filter_parameter_and_other_modes_reject_it(self):
|
|
api=WeightApi()
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
tools=QualityTools(api_factory=lambda:api,evidence_dir=Path(folder))
|
|
with self.assertRaisesRegex(QualityToolError,'query/compare/rank'):
|
|
tools.quality_data({'mode':'changes','releaseId':'release-a','period':{'year':2026},
|
|
'comparisonPeriod':{'year':2025},'dimension':'group','columnFilters':[]})
|
|
self.assertEqual(api.calls,[])
|
|
|
|
def test_ranking_chart_scope_preserves_exact_continuous_month_range(self):
|
|
from nao_weight_ranking import ranking_chart
|
|
doc,_=self.run_rank()
|
|
doc['result']['period']={'year':2026,'monthStart':3,'monthEnd':5}
|
|
t=planned();t['period']=doc['result']['period']
|
|
chart=ranking_chart(doc,'range-ranking-turn',t)
|
|
self.assertIsNotNone(chart)
|
|
self.assertEqual({key:chart['scope'][key] for key in ('year','monthStart','monthEnd')},t['period'])
|
|
|
|
def test_pareto_keeps_top_rows_but_binds_ratio_to_full_population(self):
|
|
doc, _ = self.run_rank()
|
|
task = planned()
|
|
context = bind_task({'releaseId':'release-a'},task)
|
|
output = build_visuals([doc],QUESTION,'turn-ranking',context=context)
|
|
self.assertEqual(output['visualState'],'ready')
|
|
chart = output['visuals'][0]
|
|
self.assertEqual(chart['type'],'pareto')
|
|
self.assertEqual(chart['coverage']['denominator'],150)
|
|
self.assertEqual(chart['coverage']['shareBasis'],'all_scope_weight')
|
|
self.assertIn('1—9月',chart['subtitle'])
|
|
self.assertEqual(len(chart['categories']),2)
|
|
department=copy.deepcopy(doc);department['result']['dimension']='department';department['evidenceRef']='Q00000002'
|
|
output=build_visuals([doc,department],QUESTION,'turn-ranking',context=context)
|
|
self.assertEqual({v['dimension'] for v in output['visuals']},{'product','department'})
|
|
from nao_weight_ranking import missing_ranking_visuals
|
|
self.assertEqual(missing_ranking_visuals(task,output['visuals']),[])
|
|
self.assertTrue(missing_ranking_visuals(task,output['visuals'][:1]))
|
|
|
|
def test_pareto_emits_each_requested_weight_field_for_the_same_stage(self):
|
|
total_doc,_=self.run_rank()
|
|
scrap_doc,_=self.run_rank(metric='scrapWeight')
|
|
task=planned(fields=['totalWeight','scrapWeight'],dimensions=['product'],visualPreference='auto')
|
|
context=bind_task({'releaseId':'release-a'},task)
|
|
output=build_visuals([total_doc,scrap_doc],QUESTION,'two-field-ranking',context=context)
|
|
self.assertEqual(output['visualState'],'ready')
|
|
self.assertEqual({visual['metric'] for visual in output['visuals']},
|
|
{'bright_total_weight','bright_scrap_weight'})
|
|
from nao_weight_ranking import missing_ranking_visuals
|
|
self.assertEqual(missing_ranking_visuals(task,output['visuals']),[])
|
|
|
|
def test_missing_dimension_is_not_completion_and_year_data_is_not_called_absent(self):
|
|
doc, _ = self.run_rank()
|
|
task = planned()
|
|
context = bind_task({'releaseId':'release-a'},task)
|
|
self.assertFalse(coverage_sufficient([doc],QUESTION,context))
|
|
department = copy.deepcopy(doc)
|
|
department['result']['dimension'] = 'department'
|
|
department['evidenceRef'] = 'Q00000002'
|
|
self.assertTrue(coverage_sufficient([doc,department],QUESTION,context))
|
|
complete = planned(periodCoverage='complete')
|
|
self.assertFalse(coverage_sufficient([doc,department],QUESTION,bind_task({'releaseId':'release-a'},complete)))
|
|
|
|
def test_internal_month_holes_and_total_mismatch_do_not_pass_as_complete(self):
|
|
doc, _ = self.run_rank(hole=True)
|
|
context = bind_task({'releaseId':'release-a'},planned())
|
|
self.assertFalse(coverage_sufficient([doc],QUESTION,context))
|
|
with self.assertRaises(QualityToolError):self.run_rank(mismatch=True)
|
|
|
|
def test_enum_strings_are_normalized_without_guessing_business_intent(self):
|
|
task = normalize_task(task_value(dimensions='product,department',stages='bright',fields='totalWeight'),QUESTION)
|
|
self.assertEqual(task['dimensions'],['product','department'])
|
|
self.assertEqual(task['stages'],['bright'])
|
|
|
|
def test_each_ranking_dimension_uses_only_its_declared_stage(self):
|
|
doc, _ = self.run_rank()
|
|
department = copy.deepcopy(doc)
|
|
department['result'].update(dimension='department', stage='black')
|
|
department['evidenceRef'] = 'Q00000002'
|
|
task = planned()
|
|
task['stages'] = ['black', 'bright']
|
|
task['dimensionStages'] = {'product': ['bright'], 'department': ['black']}
|
|
context = bind_task({'releaseId': 'release-a'}, task)
|
|
self.assertTrue(coverage_sufficient([doc, department], QUESTION, context))
|
|
charts = build_visuals([doc, department], QUESTION, 'mixed-stage-ranking', context=context)['visuals']
|
|
self.assertEqual({(v['dimension'], v['stage']) for v in charts}, {('product', 'bright'), ('department', 'black')})
|
|
self.assertTrue(all(v['coverage']['denominator'] == 150 for v in charts))
|
|
from nao_weight_ranking import missing_ranking_visuals
|
|
self.assertEqual(missing_ranking_visuals(task, charts), [])
|
|
wrong = copy.deepcopy(department); wrong['result']['stage'] = 'bright'
|
|
self.assertFalse(coverage_sufficient([doc, wrong], QUESTION, context))
|
|
|
|
|
|
if __name__ == '__main__':unittest.main()
|