181 lines
9.4 KiB
Python
181 lines
9.4 KiB
Python
import copy
|
|
import sys
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
|
|
from analysis_visual_evidence import protocol_visual_result
|
|
from nao_native_exploration import _proofs
|
|
from nao_query_plan import scope_documents
|
|
|
|
|
|
def metric_scope(*, preference='auto', comparison=False, trend=False, fields=None):
|
|
task = {
|
|
'kind': 'metrics', 'fields': fields or ['rate'], 'stages': ['black'],
|
|
'period': {'year': 2026, 'month': 9},
|
|
'comparisonPeriod': {'year': 2026, 'month': 8} if comparison else None,
|
|
'comparisonRequired': comparison, 'trendRequired': trend,
|
|
'filters': {}, 'visualPreference': preference, 'visualType': 'bar',
|
|
}
|
|
return {'nodeId': 'support-rate', 'scopeId': 'scope-support-rate',
|
|
'purpose': 'metrics', 'task': task}
|
|
|
|
|
|
def ranking_scope():
|
|
task = {
|
|
'kind': 'analysis', 'fields': ['scrapWeight'], 'stages': ['black'],
|
|
'dimensions': ['product'], 'dimensionStages': {'product': ['black']},
|
|
'period': {'year': 2026, 'month': 9}, 'filters': {},
|
|
'comparisonRequired': False, 'trendRequired': False,
|
|
'visualPreference': 'auto', 'visualType': 'bar',
|
|
}
|
|
return {'nodeId': 'main-ranking', 'scopeId': 'scope-main-ranking',
|
|
'purpose': 'ranking', 'task': task}
|
|
|
|
|
|
def ranking_chart():
|
|
return {'metric': 'black_scrap_weight', 'type': 'bar', 'dimension': 'product',
|
|
'stage': 'black', 'scope': {}, 'categories': [], 'series': []}
|
|
|
|
|
|
class ProtocolVisualRequirementTests(unittest.TestCase):
|
|
def test_native_proof_filter_keeps_comparison_root_chart_scope_selectable(self):
|
|
scope = metric_scope(comparison=True)
|
|
scope.update({'nodeId': 'root-rate', 'scopeId': 'scope-root-rate', 'purpose': 'metrics'})
|
|
scope['task']['stages'] = []
|
|
scope['task']['visualType'] = None
|
|
current_proof = {'queryId': 'query-current', 'executionId': 'execution',
|
|
'nodeId': 'root-rate', 'scopeId': 'scope-root-rate'}
|
|
comparison_proof = {'queryId': 'query-comparison', 'executionId': 'execution',
|
|
'nodeId': 'root-rate', 'scopeId': 'scope-root-rate'}
|
|
doc = {
|
|
'mode': 'compare', 'evidenceRef': 'Q1234ABCD',
|
|
'result': {
|
|
'kind': 'quality_comparison', 'releaseId': 'release',
|
|
'filterBinding': {},
|
|
'current': {'period': {'year': 2026, 'month': 9},
|
|
'compositeRate': 0.9512973521079284,
|
|
'protocolEvidence': current_proof},
|
|
'comparison': {'period': {'year': 2026, 'month': 8},
|
|
'compositeRate': 0.9557382889437664,
|
|
'protocolEvidence': comparison_proof},
|
|
'delta': {'available': True, 'rate': -0.004440936835838},
|
|
'protocolEvidence': [current_proof, comparison_proof],
|
|
},
|
|
}
|
|
original_doc = copy.deepcopy(doc)
|
|
|
|
# Native run filters accepted receipts with _proofs before visual scoping.
|
|
proofs = _proofs(doc['result'])
|
|
self.assertEqual(len(doc['result']['protocolEvidence']), 2)
|
|
accepted = {proof['queryId'] for proof in proofs}
|
|
self.assertEqual(accepted, {'query-current', 'query-comparison'})
|
|
complete_scopes = {('root-rate', 'scope-root-rate')}
|
|
selected_documents = [document for document in [doc]
|
|
if _proofs(document.get('result', {}))
|
|
and all(proof.get('executionId') == 'execution'
|
|
and proof.get('queryId') in accepted
|
|
and (proof.get('nodeId'), proof.get('scopeId')) in complete_scopes
|
|
for proof in _proofs(document.get('result', {})))]
|
|
self.assertEqual(selected_documents, [doc])
|
|
self.assertEqual(scope_documents(selected_documents, scope, release_id='release'), [doc])
|
|
self.assertEqual(doc, original_doc)
|
|
self.assertEqual({proof['queryId'] for proof in _proofs(doc['result'])}, accepted)
|
|
self.assertEqual(doc, original_doc)
|
|
|
|
result = protocol_visual_result(selected_documents, [scope], '9月份合格率下降原因', 'turn',
|
|
release_id='release')
|
|
self.assertEqual(result['missingEvidence'], [])
|
|
self.assertEqual([chart['metric'] for chart in result['visuals']], ['composite_rate'])
|
|
self.assertEqual(result['visuals'][0]['series'][0]['values'],
|
|
[0.9557382889437664, 0.9512973521079284])
|
|
self.assertEqual(doc, original_doc)
|
|
|
|
def test_nested_proof_collection_is_idempotent_for_multiple_side_proofs(self):
|
|
proofs = [
|
|
{'queryId': f'query-{index}', 'nodeId': 'root', 'scopeId': 'scope'}
|
|
for index in range(4)
|
|
]
|
|
response = {
|
|
'protocolEvidence': proofs,
|
|
'current': {'protocolEvidence': proofs[:2]},
|
|
'comparison': {'protocolEvidence': proofs[2:]},
|
|
}
|
|
original = copy.deepcopy(response)
|
|
|
|
self.assertEqual({item['queryId'] for item in _proofs(response)},
|
|
{item['queryId'] for item in proofs})
|
|
self.assertEqual(response, original)
|
|
self.assertEqual({item['queryId'] for item in _proofs(response)},
|
|
{item['queryId'] for item in proofs})
|
|
self.assertEqual(response, original)
|
|
|
|
def test_automatic_single_metric_support_can_remain_table_only(self):
|
|
scope = metric_scope()
|
|
with patch('analysis_visuals.build_visuals', return_value={
|
|
'visualState': 'unavailable', 'visuals': []}):
|
|
result = protocol_visual_result([], [scope], 'Top产品及其黑片率', 'turn',
|
|
release_id='release')
|
|
self.assertEqual(result['missingEvidence'], [])
|
|
self.assertEqual(result['visualState'], 'not_requested')
|
|
|
|
def test_explicit_required_and_comparison_metric_charts_remain_blocking(self):
|
|
for scope in (metric_scope(preference='required'), metric_scope(comparison=True)):
|
|
with self.subTest(scope=scope):
|
|
with patch('analysis_visuals.build_visuals', return_value={
|
|
'visualState': 'unavailable', 'visuals': []}):
|
|
result = protocol_visual_result([], [scope], '查看指标', 'turn',
|
|
release_id='release')
|
|
self.assertTrue(result['missingEvidence'])
|
|
self.assertEqual(result['visualState'], 'unavailable')
|
|
exact_chart = {'metric': 'black_rate', 'stage': 'black', 'type': 'bar'}
|
|
for scope in (metric_scope(preference='required'), metric_scope(comparison=True)):
|
|
with self.subTest(fulfilled=scope):
|
|
with patch('analysis_visuals.build_visuals', return_value={
|
|
'visualState': 'ready', 'visuals': [exact_chart]}):
|
|
result = protocol_visual_result([], [scope], '查看指标', 'turn',
|
|
release_id='release')
|
|
self.assertEqual(result['missingEvidence'], [])
|
|
|
|
def test_scalar_support_does_not_poison_a_complete_main_ranking_chart(self):
|
|
ranking = ranking_scope()
|
|
support = metric_scope()
|
|
with patch('analysis_visuals.build_visuals', side_effect=[
|
|
{'visualState': 'ready', 'visuals': [ranking_chart()]},
|
|
{'visualState': 'unavailable', 'visuals': []},
|
|
]):
|
|
result = protocol_visual_result([], [ranking, support], '黑片报废Top产品及其黑片率',
|
|
'turn', release_id='release')
|
|
self.assertEqual(result['visualState'], 'ready')
|
|
self.assertEqual(result['missingEvidence'], [])
|
|
self.assertEqual([chart['metric'] for chart in result['visuals']], ['black_scrap_weight'])
|
|
|
|
def test_a_chartable_ranking_without_its_chart_still_reports_a_gap(self):
|
|
with patch('analysis_visuals.build_visuals', return_value={
|
|
'visualState': 'unavailable', 'visuals': []}):
|
|
result = protocol_visual_result([], [ranking_scope()], '黑片报废Top产品',
|
|
'turn', release_id='release')
|
|
self.assertTrue(result['missingEvidence'])
|
|
self.assertEqual(result['visualState'], 'unavailable')
|
|
|
|
def test_required_trend_without_its_chart_still_reports_a_gap(self):
|
|
with patch('analysis_visuals.build_visuals', return_value={
|
|
'visualState': 'unavailable', 'visuals': []}):
|
|
result = protocol_visual_result([], [metric_scope(trend=True)], '黑片率趋势',
|
|
'turn', release_id='release')
|
|
self.assertTrue(result['missingEvidence'])
|
|
self.assertEqual(result['visualState'], 'unavailable')
|
|
|
|
def test_automatic_multimetric_visual_scope_keeps_its_chart_gap(self):
|
|
with patch('analysis_visuals.build_visuals', return_value={
|
|
'visualState': 'unavailable', 'visuals': []}):
|
|
result = protocol_visual_result([], [metric_scope(fields=['rate', 'scrapWeight'])],
|
|
'查看率和报废重量', 'turn', release_id='release')
|
|
self.assertTrue(result['missingEvidence'])
|
|
self.assertEqual(result['visualState'], 'unavailable')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|