920 lines
58 KiB
Python
920 lines
58 KiB
Python
import json
|
||
import unittest
|
||
|
||
from scripts.analysis_visuals import MAX_BODY_BYTES, build_visuals
|
||
|
||
|
||
def evidence(result, *, ref="Q1234ABCD", release_id="r-1"):
|
||
return {
|
||
"tool": "quality_data",
|
||
"mode": "compare",
|
||
"releaseId": release_id,
|
||
"evidenceRef": ref,
|
||
"result": {
|
||
"release": {"id": release_id},
|
||
"releaseId": release_id,
|
||
**result,
|
||
},
|
||
}
|
||
|
||
|
||
def comparison_result(**overrides):
|
||
result = {
|
||
"kind": "quality_comparison",
|
||
"releaseId": "r-1",
|
||
"filterBinding": {"department": "电机部", "includeUnassigned": False, "extraFilters": {}},
|
||
"current": {
|
||
"period": {"year": 2026, "month": 9},
|
||
"compositeRate": 0.98,
|
||
"black": {"rate": 0.97, "scrapWeight": 12.0},
|
||
"bright": {"rate": 0.99, "scrapWeight": 5.0},
|
||
},
|
||
"comparison": {
|
||
"period": {"year": 2026, "month": 8},
|
||
"compositeRate": 0.96,
|
||
"black": {"rate": 0.95, "scrapWeight": 10.0},
|
||
"bright": {"rate": 0.98, "scrapWeight": 7.0},
|
||
},
|
||
"delta": {"available": True, "percentagePoints": 2.0},
|
||
"stageRateChangesPP": {"black": 2.0, "bright": 1.0},
|
||
}
|
||
result.update(overrides)
|
||
return result
|
||
|
||
|
||
def decomposed_comparison_result(**overrides):
|
||
result = comparison_result(
|
||
current={
|
||
"period": {"year": 2026, "month": 9}, "compositeRate": 0.9556,
|
||
"black": {"rate": 0.947, "scrapWeight": 12.0,
|
||
"defects": [{"name": "责废", "weight": 12.0}, {"name": "料废", "weight": 8.0}, {"name": "外废", "weight": 2.0}]},
|
||
"bright": {"rate": 0.978, "scrapWeight": 5.0,
|
||
"defects": [{"name": "镀废", "weight": 5.0}, {"name": "材料废", "weight": 3.0},
|
||
{"name": "加工废", "weight": 2.0}, {"name": "扩散废", "weight": 1.0}]},
|
||
},
|
||
comparison={
|
||
"period": {"year": 2026, "month": 8}, "compositeRate": 0.96,
|
||
"black": {"rate": 0.95, "scrapWeight": 10.0,
|
||
"defects": [{"name": "责废", "weight": 10.0}, {"name": "料废", "weight": 7.0}, {"name": "外废", "weight": 1.0}]},
|
||
"bright": {"rate": 0.98, "scrapWeight": 7.0,
|
||
"defects": [{"name": "镀废", "weight": 6.0}, {"name": "材料废", "weight": 3.5},
|
||
{"name": "加工废", "weight": 2.0}, {"name": "扩散废", "weight": 1.5}]},
|
||
},
|
||
delta={"available": True, "rate": -0.0044, "percentagePoints": -0.44},
|
||
stageRateChangesPP={"black": -0.3, "bright": -0.2},
|
||
stageDecomposition={"status": "available", "blackContributionToCompositePP": -0.3,
|
||
"brightContributionToCompositePP": -0.14, "sumPP": -0.44},
|
||
)
|
||
result.update(overrides)
|
||
return result
|
||
|
||
|
||
def changes_result(**overrides):
|
||
result = {
|
||
"kind": "quality_changes",
|
||
"releaseId": "r-1",
|
||
"filters": {"department": "电机部", "includeUnassigned": False, "extraFilters": {}},
|
||
"dimension": "product",
|
||
"stage": "black",
|
||
"category": None,
|
||
"currentPeriod": {"year": 2026, "month": 9},
|
||
"comparisonPeriod": {"year": 2026, "month": 8},
|
||
"sort": "scrap_delta",
|
||
"rows": [
|
||
{"rank": 1, "key": "p-1", "label": "规格一", "scrapDelta": 4.0, "current": {"scrapWeight": 8.0}},
|
||
{"rank": 2, "key": "p-2", "label": "规格二", "scrapDelta": -2.0, "current": {"scrapWeight": 3.0}},
|
||
],
|
||
"totalRows": 8,
|
||
"returnedRows": 2,
|
||
"truncated": True,
|
||
}
|
||
result.update(overrides)
|
||
return result
|
||
|
||
|
||
def metric_result(period, composite_rate, *, release_id="r-1", filters=None):
|
||
return {
|
||
"kind": "quality_metrics",
|
||
"releaseId": release_id,
|
||
"period": period,
|
||
"filters": filters or {"department": "电机部", "includeUnassigned": False, "extraFilters": {}},
|
||
"view": "overall",
|
||
"summary": {"compositeRate": composite_rate, "black": {"rate": composite_rate - 0.01},
|
||
"bright": {"rate": composite_rate + 0.01}},
|
||
}
|
||
|
||
|
||
def fine_field(key, category):
|
||
return {"key": key, "label": key, "category": category, "sourceField": key}
|
||
|
||
|
||
class AnalysisVisualsTest(unittest.TestCase):
|
||
def test_frozen_followup_scope_selects_same_comparison_as_text(self):
|
||
import inspect
|
||
global_result=comparison_result(filterBinding={})
|
||
local=comparison_result(filterBinding={'group':'组A'})
|
||
local['current']['compositeRate']=.80
|
||
docs=[evidence(global_result,ref='Q00000001'),evidence(local,ref='Q00000002')]
|
||
kwargs={'context':{'year':2026,'month':9,'group':'组A'}} if 'context' in inspect.signature(build_visuals).parameters else {}
|
||
charts=build_visuals(docs,'比较本期综合率变化','turn-bound-followup',**kwargs)['visuals']
|
||
overview=[c for c in charts if c.get('metric')=='composite_rate']
|
||
self.assertEqual(len(overview),1)
|
||
self.assertEqual(overview[0]['scope'].get('group'),'组A')
|
||
self.assertEqual(overview[0]['series'][0]['values'],[.96,.80])
|
||
|
||
def test_frozen_period_excludes_other_period_comparison_and_defects(self):
|
||
import inspect
|
||
selected=comparison_result(filterBinding={})
|
||
older=comparison_result(filterBinding={})
|
||
older['current']['period']={'year':2026,'month':7};older['comparison']['period']={'year':2026,'month':6}
|
||
kwargs={'context':{'year':2026,'month':9}} if 'context' in inspect.signature(build_visuals).parameters else {}
|
||
charts=build_visuals([evidence(selected,ref='Q00000001'),evidence(older,ref='Q00000002')],
|
||
'比较综合率变化','turn-bound-period',**kwargs)['visuals']
|
||
self.assertTrue(charts)
|
||
self.assertTrue(all(c.get('period',{}).get('month')==9 for c in charts))
|
||
|
||
def test_available_requested_stage_is_drawn_when_other_stage_blocks_composite(self):
|
||
result=comparison_result(delta={'available':False,'reason':'缺少黑片来源'},stageRateChangesPP={'black':None,'bright':1})
|
||
result['current']['black']['rate']=1
|
||
charts=build_visuals([evidence(result)],'比较亮片合格率变化','turn-stage-only')['visuals']
|
||
self.assertEqual([c['metric'] for c in charts],['bright_rate'])
|
||
scoped=build_visuals([evidence(result)],'比较本期变化','turn-stage-context',context={'year':2026,'month':9,'stage':'bright'})['visuals']
|
||
self.assertEqual([c['metric'] for c in scoped],['bright_rate'])
|
||
|
||
def test_formal_comparison_emits_safe_single_metric_chart_with_zero_and_null(self):
|
||
result = comparison_result(
|
||
current={"period": {"year": 2026, "month": 9}, "compositeRate": 0.0,
|
||
"black": {"rate": None}, "bright": {"rate": 0.99}},
|
||
comparison={"period": {"year": 2026, "month": 8}, "compositeRate": None,
|
||
"black": {"rate": 0.95}, "bright": {"rate": 0.98}},
|
||
stageRateChangesPP={"black": None, "bright": 1.0},
|
||
)
|
||
output = build_visuals([evidence(result)], "请比较8月和9月综合合格率", "turn-01")
|
||
self.assertEqual(output["visualState"], "ready")
|
||
chart = output["visuals"][0]
|
||
self.assertEqual(chart["metric"], "composite_rate")
|
||
self.assertEqual(chart["unit"], "ratio")
|
||
self.assertEqual(chart["series"][0]["values"], [None, 0.0])
|
||
self.assertNotIn("stage", chart)
|
||
self.assertEqual(chart["scope"]["releaseId"], "r-1")
|
||
self.assertEqual(chart["originTurnId"], "turn-01")
|
||
self.assertEqual(chart["type"], "column")
|
||
|
||
def test_comparison_skips_mismatched_period_or_release(self):
|
||
bad_period = comparison_result()
|
||
bad_period["current"]["period"] = {"year": 2026, "month": 8}
|
||
self.assertEqual(build_visuals([evidence(bad_period)], "比较两个期间变化", "turn-01")["visualState"], "not_requested")
|
||
self.assertEqual(build_visuals([evidence(comparison_result(), release_id="other")], "比较两个期间变化", "turn-01")["visualState"], "not_requested")
|
||
|
||
def test_negative_or_nonfinite_rate_is_never_clamped_or_drawn(self):
|
||
for invalid in (-.01, float('nan'), float('inf')):
|
||
with self.subTest(invalid=invalid):
|
||
result = comparison_result()
|
||
result["current"]["compositeRate"] = invalid
|
||
output = build_visuals([evidence(result)], "比较综合合格率变化", "turn-01")
|
||
self.assertEqual(output["visualState"], "not_requested")
|
||
self.assertEqual(output["visuals"], [])
|
||
|
||
def test_broad_cause_analysis_adds_three_rates_math_waterfall_and_both_category_deltas(self):
|
||
output = build_visuals([evidence(decomposed_comparison_result())], "分析整体合格率下降原因", "turn-broad-chapters")
|
||
charts = output["visuals"]
|
||
self.assertEqual(output["visualState"], "ready")
|
||
by_section = {}
|
||
for chart in charts:
|
||
by_section.setdefault(chart["sectionKey"], []).append(chart)
|
||
self.assertEqual(len(by_section["overview"]), 2)
|
||
self.assertEqual({chart["metric"] for chart in by_section["stage"]}, {"black_rate", "bright_rate"})
|
||
waterfall = next(chart for chart in charts if chart["type"] == "waterfall")
|
||
self.assertEqual(waterfall["metric"], "composite_impact_pp")
|
||
self.assertEqual(waterfall["series"][0]["values"], [-0.3, -0.14, -0.44])
|
||
self.assertEqual(waterfall["requiredFields"], [
|
||
"black_good_weight", "black_total_weight", "bright_good_weight", "bright_total_weight"
|
||
])
|
||
self.assertIn("拆解", waterfall["note"])
|
||
self.assertNotIn("数学", waterfall["note"])
|
||
self.assertNotIn("生产根因", waterfall["title"])
|
||
self.assertEqual({chart["sectionKey"] for chart in charts if chart["sectionKey"].startswith("category_")},
|
||
{"category_black", "category_bright"})
|
||
black_categories = next(chart for chart in charts if chart["sectionKey"] == "category_black")
|
||
self.assertEqual(black_categories["series"][0]["values"], [2.0, 1.0, 1.0])
|
||
self.assertEqual(black_categories["dimension"], "category")
|
||
|
||
def test_followup_product_comparisons_do_not_crowd_out_main_chapters(self):
|
||
docs = [evidence(decomposed_comparison_result(filterBinding={}), ref="Q00000001")]
|
||
for index in range(6):
|
||
docs.append(evidence(decomposed_comparison_result(filterBinding={"product": f"规格-{index}"}), ref=f"Q{index+2:08X}"))
|
||
for index, dimension in enumerate(("department", "group", "product")):
|
||
docs.append(evidence(changes_result(filters={}, dimension=dimension), ref=f"Q{index+20:08X}"))
|
||
for index, stage in enumerate(("black", "bright")):
|
||
docs.append(evidence(changes_result(filters={}, dimension="department", stage=stage), ref=f"Q{index+30:08X}"))
|
||
field, category = ("责废其他重量", "责废") if stage == "black" else ("加工磕边重量", "加工废")
|
||
docs.append(evidence({"kind":"quality_fine_defects","dimension":"defect","grain":"source_defect_weight","stage":stage,"filters":{},
|
||
"period":{"year":2026,"month":9},"comparisonPeriod":{"year":2026,"month":8},
|
||
"coverage":{"available":True},"comparisonCoverage":{"available":True},
|
||
"sourceFields":[fine_field(field,category)],"comparisonSourceFields":[fine_field(field,category)],
|
||
"pairedRows":[{"key":field,"current":{"label":field,"category":category,"weight":3},"comparison":{"label":field,"category":category,"weight":2},"deltaWeight":1,"deltaAvailable":True}],
|
||
"pairedTotalRows":1,"pairedTruncated":False,"pairedRankingComplete":True,"sort":"scrap_delta"},ref=f"Q{index+40:08X}"))
|
||
charts = build_visuals(docs, "分析整体变化,覆盖产业部、业务分组、重点产品与报废类别", "turn-balanced")["visuals"]
|
||
self.assertEqual(len(charts), 12)
|
||
self.assertTrue({"department", "group", "product", "category_black", "category_bright", "defect_black", "defect_bright"}.issubset({c["sectionKey"] for c in charts}))
|
||
self.assertFalse(charts[0]["scope"].get("product"))
|
||
self.assertEqual({c["metric"] for c in charts if c["sectionKey"] == "stage" and not c["scope"].get("product")}, {"black_rate", "bright_rate"})
|
||
|
||
def test_waterfall_requires_exact_finite_decomposition_that_matches_service_delta(self):
|
||
valid = decomposed_comparison_result()
|
||
bad_cases = []
|
||
mismatch_delta = json.loads(json.dumps(valid))
|
||
mismatch_delta["delta"]["percentagePoints"] = -0.5
|
||
bad_cases.append(mismatch_delta)
|
||
mismatch_sum = json.loads(json.dumps(valid))
|
||
mismatch_sum["stageDecomposition"]["sumPP"] = -0.5
|
||
bad_cases.append(mismatch_sum)
|
||
missing_stage = json.loads(json.dumps(valid))
|
||
missing_stage["stageDecomposition"]["brightContributionToCompositePP"] = None
|
||
bad_cases.append(missing_stage)
|
||
non_finite = json.loads(json.dumps(valid))
|
||
non_finite["stageDecomposition"]["blackContributionToCompositePP"] = float("inf")
|
||
bad_cases.append(non_finite)
|
||
for index, result in enumerate(bad_cases):
|
||
output = build_visuals([evidence(result)], "画瀑布图解释整体合格率下降原因", f"turn-waterfall-invalid-{index}")
|
||
self.assertEqual(output["visualState"], "unavailable")
|
||
self.assertEqual(output["visuals"], [])
|
||
|
||
def test_formal_category_delta_requires_matching_complete_category_sets(self):
|
||
result = decomposed_comparison_result()
|
||
chart = next(chart for chart in build_visuals(
|
||
[evidence(result)], "分析两阶段正式报废类别增减", "turn-category-delta"
|
||
)["visuals"] if chart["sectionKey"] == "category_bright")
|
||
self.assertEqual(chart["metric"], "source_defect_delta_weight")
|
||
self.assertEqual(chart["stage"], "bright")
|
||
self.assertEqual(chart["series"][0]["values"], [-1.0, -0.5, 0.0, -0.5])
|
||
self.assertEqual(chart["coverage"], {"totalRows": 4, "returnedRows": 4, "truncated": False})
|
||
|
||
partial = json.loads(json.dumps(result))
|
||
partial["current"]["bright"]["defects"].pop()
|
||
output = build_visuals([evidence(partial)], "分析两阶段正式报废类别增减", "turn-category-delta-partial")
|
||
self.assertFalse(any(chart.get("sectionKey") == "category_bright" for chart in output["visuals"]))
|
||
|
||
zero_only = json.loads(json.dumps(result))
|
||
for side in ("current", "comparison"):
|
||
for item in zero_only[side]["black"]["defects"]:
|
||
item["weight"] = 0
|
||
output = build_visuals([evidence(zero_only)], "分析黑片正式报废类别增减", "turn-category-delta-zero")
|
||
self.assertFalse(any(chart.get("sectionKey") == "category_black" for chart in output["visuals"]))
|
||
|
||
def test_scoped_defect_charts_keep_separate_chapter_scope_from_global_chart(self):
|
||
def fine_result(filters):
|
||
return {
|
||
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
|
||
"grain": "source_defect_weight", "stage": "black", "filters": filters,
|
||
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
|
||
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
|
||
"sourceFields": [fine_field("责废其他重量", "责废")],
|
||
"comparisonSourceFields": [fine_field("责废其他重量", "责废")],
|
||
"pairedRows": [{
|
||
"key": "责废其他重量",
|
||
"current": {"label": "责废其他重量", "category": "责废", "weight": 3.0},
|
||
"comparison": {"label": "责废其他重量", "category": "责废", "weight": 2.0},
|
||
"deltaWeight": 1.0, "deltaAvailable": True,
|
||
}],
|
||
"sort": "scrap_delta", "pairedTotalRows": 1, "pairedTruncated": False,
|
||
"pairedRankingComplete": True,
|
||
}
|
||
|
||
docs = [
|
||
evidence(fine_result({"extraFilters": {}}), ref="Q00000031"),
|
||
evidence(fine_result({"group": "汽车交通-国内", "extraFilters": {}}), ref="Q00000032"),
|
||
]
|
||
charts = build_visuals(docs, "画图看黑片来源具体缺陷增减", "turn-scoped-defects")["visuals"]
|
||
self.assertEqual(len(charts), 2)
|
||
self.assertEqual({chart["sectionKey"] for chart in charts}, {"defect_black"})
|
||
self.assertEqual({chart["dimension"] for chart in charts}, {"defect"})
|
||
self.assertEqual({chart["scope"].get("group") for chart in charts}, {None, "汽车交通-国内"})
|
||
self.assertEqual(len({chart["id"] for chart in charts}), 2)
|
||
scoped_chart = next(chart for chart in charts if chart["scope"].get("group"))
|
||
self.assertIn("范围 业务分组:汽车交通-国内", scoped_chart["subtitle"])
|
||
|
||
many_scopes = [evidence(fine_result({"group": f"业务组-{index}", "extraFilters": {}}),
|
||
ref=f"Q{index:08X}") for index in range(13)]
|
||
bounded = build_visuals(many_scopes, "画图看黑片来源具体缺陷增减", "turn-12-limit")
|
||
self.assertEqual(len(bounded["visuals"]), 12)
|
||
self.assertEqual(len({chart["id"] for chart in bounded["visuals"]}), 12)
|
||
self.assertLess(len(json.dumps(bounded, ensure_ascii=False).encode("utf-8")), MAX_BODY_BYTES)
|
||
|
||
def test_change_chart_preserves_signed_values_and_returned_order(self):
|
||
rows = changes_result()["rows"]
|
||
rows[0]["scrapDelta"] = -1.0
|
||
rows[1]["scrapDelta"] = 5.0
|
||
output = build_visuals([evidence(changes_result(rows=rows))], "画图比较产品报废增量", "turn-02")
|
||
chart = output["visuals"][0]
|
||
self.assertEqual(chart["metric"], "scrap_delta")
|
||
self.assertEqual(chart["stage"], "black")
|
||
self.assertEqual(chart["series"][0]["values"], [-1.0, 5.0])
|
||
self.assertEqual([row["key"] for row in chart["categories"]], ["p-1", "p-2"])
|
||
self.assertTrue(chart["coverage"]["truncated"])
|
||
self.assertEqual(chart["coverage"]["totalRows"], 8)
|
||
|
||
def test_rate_drop_is_signed_and_converted_to_percentage_points(self):
|
||
result = changes_result(sort="rate_drop", rows=[
|
||
{"rank": 1, "key": "p-1", "label": "规格一", "rateDrop": 0.025},
|
||
{"rank": 2, "key": "p-2", "label": "规格二", "rateDrop": -0.04},
|
||
])
|
||
chart = build_visuals([evidence(result)], "画图比较产品合格率降幅", "turn-03")["visuals"][0]
|
||
self.assertEqual(chart["metric"], "rate_drop_pp")
|
||
self.assertEqual(chart["unit"], "pp")
|
||
self.assertEqual(chart["series"][0]["values"], [-2.5, 4.0])
|
||
self.assertEqual([row["key"] for row in result["rows"]], ["p-1", "p-2"])
|
||
self.assertEqual([item["key"] for item in chart["categories"]], ["p-1", "p-2"])
|
||
self.assertIn("率降幅线索", chart["title"])
|
||
self.assertIn("本期减比较期", chart["note"])
|
||
self.assertIn("仍按率降幅排序", chart["note"])
|
||
self.assertIn("未纳入投入规模", chart["note"])
|
||
|
||
def test_broad_product_focus_omits_rate_only_ranking_chart(self):
|
||
rate = changes_result(stage=None, sort="rate_drop", returnedRows=1, rows=[
|
||
{"rank": 1, "key": "tiny", "label": "小量规格", "rateDrop": 0.9943,
|
||
"scrapDelta": 6.74, "current": {"blackInputWeight": 7.1, "brightInputWeight": 39.66}},
|
||
])
|
||
scrap = changes_result(stage=None, sort="scrap_delta", returnedRows=1, rows=[
|
||
{"rank": 1, "key": "large", "label": "报废增量规格", "scrapDelta": 758.76},
|
||
])
|
||
charts = build_visuals(
|
||
[evidence(rate, ref="Q00000001"), evidence(scrap, ref="Q00000002")],
|
||
"分析下近期要关注的重点产品", "turn-product-focus",
|
||
)["visuals"]
|
||
self.assertEqual([chart["metric"] for chart in charts], ["scrap_delta"])
|
||
raw_only = build_visuals(
|
||
[evidence(rate)], "分析下近期要关注的重点产品", "turn-product-focus-raw-only",
|
||
)
|
||
self.assertEqual(raw_only["visualState"], "not_requested")
|
||
self.assertEqual(raw_only["visuals"], [])
|
||
mixed = build_visuals(
|
||
[evidence(rate)], "分析重点产品的合格率下降和报废占比", "turn-product-focus-mixed",
|
||
)
|
||
self.assertEqual(mixed["visuals"], [])
|
||
|
||
def test_rank_metadata_must_match_order_and_zero_is_preserved(self):
|
||
result = changes_result(rows=[
|
||
{"rank": 2, "key": "p-1", "label": "规格一", "scrapDelta": 0.0},
|
||
{"rank": 1, "key": "p-2", "label": "规格二", "scrapDelta": 3.0},
|
||
])
|
||
self.assertEqual(build_visuals([evidence(result)], "画图比较产品报废增量", "turn-04")["visualState"], "unavailable")
|
||
|
||
def test_change_chart_requires_stage_and_matching_filter_shape(self):
|
||
no_stage = changes_result(stage=None)
|
||
output = build_visuals([evidence(no_stage)], "画图比较产品报废增量", "turn-05")
|
||
chart = output["visuals"][0]
|
||
self.assertEqual(chart["metric"], "scrap_delta")
|
||
self.assertNotIn("stage", chart)
|
||
self.assertNotIn("stage", chart["scope"])
|
||
self.assertEqual(chart["requiredFields"], ["black_scrap_weight", "bright_scrap_weight"])
|
||
secret_filter = changes_result(filters={"department": "电机部", "apiKey": "secret-value"})
|
||
self.assertEqual(build_visuals([evidence(secret_filter)], "画图比较产品报废增量", "turn-05")["visualState"], "unavailable")
|
||
|
||
def test_overall_rate_drop_uses_canonical_two_stage_fields(self):
|
||
result = changes_result(stage=None, sort="rate_drop", rows=[
|
||
{"rank": 1, "key": "p-1", "label": "规格一", "rateDrop": 0.02},
|
||
{"rank": 2, "key": "p-2", "label": "规格二", "rateDrop": -0.01},
|
||
])
|
||
chart = build_visuals([evidence(result)], "画产品综合合格率变化", "turn-05b")["visuals"][0]
|
||
self.assertEqual(chart["metric"], "rate_drop_pp")
|
||
self.assertEqual(chart["requiredFields"], [
|
||
"black_good_weight", "black_total_weight", "bright_good_weight", "bright_total_weight"
|
||
])
|
||
self.assertEqual(chart["series"][0]["values"], [-2.0, 1.0])
|
||
self.assertIn("负值为下降,正值为上升", chart["note"])
|
||
self.assertIn("本期减比较期", chart["note"])
|
||
|
||
def test_quality_top_uses_ranked_weights_and_never_share(self):
|
||
result = {
|
||
"kind": "quality_top", "releaseId": "r-1", "stage": "black", "dimension": "product",
|
||
"period": {"year": 2026, "month": 9},
|
||
"filters": {"department": "电机部", "extraFilters": {}},
|
||
"rankingCoverage": {"groups": 12, "complete": False},
|
||
"rows": [
|
||
{"rank": index + 1, "key": f"p-{index}", "label": f"产品{index}",
|
||
"weight": index + 0.5, "share": 0.99 - index * 0.01}
|
||
for index in range(12)
|
||
],
|
||
}
|
||
chart = build_visuals([evidence(result)], "哪些产品报废最多", "turn-top") ["visuals"][0]
|
||
self.assertEqual(chart["metric"], "current_scrap_weight")
|
||
self.assertEqual(chart["requiredFields"], ["black_scrap_weight"])
|
||
self.assertEqual(chart["series"][0]["values"], [index + 0.5 for index in range(10)])
|
||
self.assertEqual(chart["coverage"], {"totalRows": 12, "returnedRows": 10, "truncated": True})
|
||
self.assertNotIn("share", json.dumps(chart, ensure_ascii=False))
|
||
|
||
def test_quality_top_categories_require_stage_canonical_source_fields(self):
|
||
result = {
|
||
"kind": "quality_top", "releaseId": "r-1", "stage": "bright", "dimension": "category",
|
||
"period": {"year": 2026, "month": 9}, "filters": {"extraFilters": {}},
|
||
"rankingCoverage": {"groups": 3, "complete": True},
|
||
"cumulativeThresholdApplied": False,
|
||
"rows": [
|
||
{"rank": 1, "key": "加工废", "label": "加工废", "weight": 3.0},
|
||
{"rank": 2, "key": "材料废", "label": "材料废", "weight": 2.0},
|
||
{"rank": 3, "key": "扩散废", "label": "扩散废", "weight": 1.0},
|
||
],
|
||
}
|
||
chart = build_visuals([evidence(result)], "分析亮片报废类别排名", "turn-cat")["visuals"][0]
|
||
self.assertEqual(chart["metric"], "source_defect_weight")
|
||
self.assertEqual([item["key"] for item in chart["categories"]], [
|
||
"bright_processing_scrap", "bright_material_scrap", "bright_diffusion_scrap"
|
||
])
|
||
self.assertEqual(chart["requiredFields"], [
|
||
"bright_diffusion_scrap", "bright_material_scrap", "bright_processing_scrap"
|
||
])
|
||
result["rows"][0]["label"] = "VCM总计"
|
||
self.assertEqual(build_visuals([evidence(result)], "分析亮片报废类别排名", "turn-cat")["visualState"], "not_requested")
|
||
|
||
def test_real_category_top_shape_without_ranking_coverage_requires_endpoint_denominator_proof(self):
|
||
denominator = 7118.885021
|
||
weights = [3421.516018, 2812.668772, 868.241231, 16.459]
|
||
labels = ["加工废", "镀废", "材料废", "扩散废"]
|
||
result = {
|
||
"kind": "quality_top", "releaseId": "r-1", "stage": "bright", "dimension": "category",
|
||
"period": {"year": 2026, "month": 9},
|
||
"filters": {"department": "工业电机产业部", "includeUnassigned": False},
|
||
"rankingCoverage": None,
|
||
"denominator": denominator,
|
||
"shareBasis": "所选筛选条件下选中原报废分类的重量总和",
|
||
"cumulativeThresholdApplied": False,
|
||
"rows": [
|
||
{"rank": index + 1, "key": label, "label": label, "weight": weight,
|
||
"denominator": denominator, "share": weight / denominator}
|
||
for index, (label, weight) in enumerate(zip(labels, weights))
|
||
],
|
||
}
|
||
doc = evidence(result)
|
||
doc["apiSource"] = {"calls": [
|
||
{"method": "GET", "path": "/api/releases", "params": {}},
|
||
{"method": "GET", "path": "/api/analytics/top", "params": {
|
||
"releaseId": "r-1", "stage": "bright", "dimension": "category", "limit": 10,
|
||
"year": 2026, "month": 9, "department": "工业电机产业部", "includeUnassigned": False,
|
||
}},
|
||
]}
|
||
|
||
donut = build_visuals([doc], "亮片已列报废类别用环状图展示构成", "turn-real-category-donut")["visuals"][0]
|
||
self.assertEqual(donut["type"], "donut")
|
||
self.assertEqual(donut["series"][0]["values"], weights)
|
||
self.assertEqual(donut["coverage"], {
|
||
"totalRows": 4, "returnedRows": 4, "truncated": False, "shareBasis": "displayed_categories"
|
||
})
|
||
|
||
pareto = build_visuals([doc], "亮片报废类别画柏拉图", "turn-real-category-pareto")["visuals"][0]
|
||
self.assertEqual(pareto["type"], "pareto")
|
||
self.assertEqual(pareto["series"][0]["values"], weights)
|
||
|
||
subset = json.loads(json.dumps(result))
|
||
subset["rows"] = result["rows"][:3]
|
||
subset["denominator"] = sum(weights[:3])
|
||
for row in subset["rows"]:
|
||
row["denominator"] = subset["denominator"]
|
||
row["share"] = row["weight"] / subset["denominator"]
|
||
subset_doc = evidence(subset)
|
||
subset_doc["apiSource"] = doc["apiSource"]
|
||
self.assertEqual(build_visuals([subset_doc], "亮片类别环状构成", "turn-authorized-subset")["visualState"], "ready")
|
||
|
||
invalid_cases = []
|
||
low_limit = json.loads(json.dumps(doc))
|
||
low_limit["apiSource"]["calls"][1]["params"]["limit"] = 3
|
||
invalid_cases.append(low_limit)
|
||
wrong_denominator = json.loads(json.dumps(doc))
|
||
wrong_denominator["result"]["denominator"] += 1
|
||
invalid_cases.append(wrong_denominator)
|
||
threshold = json.loads(json.dumps(doc))
|
||
threshold["result"]["cumulativeThresholdApplied"] = True
|
||
invalid_cases.append(threshold)
|
||
narrowed = json.loads(json.dumps(doc))
|
||
narrowed["apiSource"]["calls"][1]["params"]["category"] = "加工废"
|
||
invalid_cases.append(narrowed)
|
||
mismatched_filter = json.loads(json.dumps(doc))
|
||
mismatched_filter["apiSource"]["calls"][1]["params"]["department"] = "其他部门"
|
||
invalid_cases.append(mismatched_filter)
|
||
for index, invalid_doc in enumerate(invalid_cases):
|
||
self.assertEqual(build_visuals([invalid_doc], "亮片类别环状构成", f"turn-category-invalid-{index}")["visualState"], "unavailable")
|
||
|
||
def test_candidate_priority_keeps_comparison_product_and_fine_defect_charts_separate(self):
|
||
comparison = evidence(comparison_result(), ref="Q00000011")
|
||
changes = evidence(changes_result(stage=None), ref="Q00000012")
|
||
fine_result = {
|
||
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
|
||
"grain": "source_defect_weight", "stage": "bright", "filters": {"department": "其他部门"},
|
||
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
|
||
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
|
||
"sourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废"), fine_field("材料隐裂重量", "材料废")],
|
||
"comparisonSourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废"), fine_field("材料隐裂重量", "材料废")],
|
||
"pairedRows": [
|
||
{"key": "晶界扩散其他缺陷重量", "current": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 3},
|
||
"comparison": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 2}, "deltaWeight": 1, "deltaAvailable": True},
|
||
{"key": "材料隐裂重量", "current": {"label": "材料隐裂重量", "category": "材料废", "weight": 2},
|
||
"comparison": {"label": "材料隐裂重量", "category": "材料废", "weight": 1}, "deltaWeight": 1, "deltaAvailable": True},
|
||
],
|
||
"sort": "scrap_delta", "pairedTotalRows": 2, "pairedTruncated": False,
|
||
"pairedRankingComplete": True,
|
||
}
|
||
fine = evidence(fine_result, ref="Q00000013")
|
||
output = build_visuals([fine, changes, comparison], "分析本期变化并绘制综合对比、产品报废增量和来源缺陷图", "turn-priority")
|
||
self.assertEqual([chart["metric"] for chart in output["visuals"]], [
|
||
"composite_rate", "scrap_delta", "source_defect_delta_weight"
|
||
])
|
||
self.assertEqual(output["visuals"][2]["scope"]["department"], "其他部门")
|
||
self.assertEqual(output["visuals"][2]["requiredFields"], ["晶界扩散其他缺陷重量", "材料隐裂重量"])
|
||
scoped = build_visuals([fine, changes, comparison],
|
||
"展示正式综合合格率、重点产品报废增量和亮片具体缺陷增量", "turn-priority-stage")
|
||
self.assertEqual([chart["metric"] for chart in scoped["visuals"]], [
|
||
"composite_rate", "scrap_delta", "source_defect_delta_weight"
|
||
])
|
||
|
||
def test_fine_defects_use_paired_rows_and_do_not_turn_totals_only_into_zero(self):
|
||
result = {
|
||
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
|
||
"grain": "source_defect_weight", "stage": "bright",
|
||
"filters": {"department": "电机部", "extraFilters": {}},
|
||
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
|
||
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
|
||
"sourceRows": 4,
|
||
"sourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废")],
|
||
"comparisonSourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废")],
|
||
"pairedRows": [
|
||
{"key": "晶界扩散其他缺陷重量", "current": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 0.0},
|
||
"comparison": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 1.0}, "deltaWeight": -1.0, "deltaAvailable": True},
|
||
],
|
||
"sort": "scrap_delta", "pairedTotalRows": 2, "pairedTruncated": False,
|
||
"pairedRankingComplete": True,
|
||
"categoryReconciliation": [{"category": "扩散废", "sourceRows": 4,
|
||
"expectedTotalsOnly": {"rows": 1}}],
|
||
"comparisonCategoryReconciliation": [{"category": "扩散废", "sourceRows": 4,
|
||
"expectedTotalsOnly": {"rows": 0}}],
|
||
}
|
||
output = build_visuals([evidence(result)], "画图比较亮片来源具体缺陷增量", "turn-06")
|
||
chart = output["visuals"][0]
|
||
self.assertEqual(chart["metric"], "source_defect_delta_weight")
|
||
self.assertEqual(chart["stage"], "bright")
|
||
self.assertEqual(chart["categories"], [{"key": "晶界扩散其他缺陷重量", "label": "晶界扩散其他缺陷重量"}])
|
||
self.assertEqual(chart["series"][0]["values"], [-1.0])
|
||
self.assertNotIn("VCM", chart["note"])
|
||
self.assertEqual(chart["requiredFields"], ["晶界扩散其他缺陷重量"])
|
||
|
||
def test_fine_defect_missing_delta_stays_null_and_unavailable_coverage_skips(self):
|
||
result = {
|
||
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
|
||
"grain": "source_defect_weight", "stage": "black", "filters": {},
|
||
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
|
||
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
|
||
"sourceFields": [fine_field("责废尺寸重量", "责废"), fine_field("责废其他重量", "责废")],
|
||
"comparisonSourceFields": [fine_field("责废尺寸重量", "责废"), fine_field("责废其他重量", "责废")],
|
||
"pairedRows": [
|
||
{"key": "责废尺寸重量", "current": {"label": "责废尺寸重量", "category": "责废", "weight": 2},
|
||
"comparison": None, "deltaWeight": None, "deltaAvailable": False},
|
||
{"key": "责废其他重量", "current": {"label": "责废其他重量", "category": "责废", "weight": 3},
|
||
"comparison": {"label": "责废其他重量", "category": "责废", "weight": 1}, "deltaWeight": 2, "deltaAvailable": True},
|
||
],
|
||
"sort": "scrap_delta", "pairedTotalRows": 2, "pairedTruncated": False,
|
||
"pairedRankingComplete": False,
|
||
}
|
||
output = build_visuals([evidence(result)], "画图比较黑片来源缺陷增量", "turn-07")
|
||
self.assertEqual(output["visuals"][0]["series"][0]["values"], [None, 2.0])
|
||
result["coverage"] = {"available": False}
|
||
self.assertEqual(build_visuals([evidence(result)], "画图比较黑片来源缺陷增量", "turn-07")["visualState"], "unavailable")
|
||
|
||
def test_fine_defects_authorize_only_real_source_fields_and_bind_category_scope(self):
|
||
result = {
|
||
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
|
||
"grain": "source_defect_weight", "stage": "bright",
|
||
"filters": {"department": "电机部", "extraFilters": {"项目类型": ["VCM"]}},
|
||
"category": "加工废",
|
||
"period": {"year": 2026, "month": 9}, "coverage": {"available": True, "sourceRows": 3},
|
||
"sourceRows": 3, "sourceFields": [fine_field("加工尺寸超差重量", "加工废")],
|
||
"rows": [{"key": "加工尺寸超差重量", "label": "加工尺寸超差重量", "category": "加工废", "weight": 0}],
|
||
"totalRows": 1, "truncated": False, "rankingComplete": True,
|
||
}
|
||
chart = build_visuals([evidence(result)], "画图看亮片来源具体缺陷重量", "turn-real-shape")["visuals"][0]
|
||
self.assertEqual(chart["categories"], [{"key": "加工尺寸超差重量", "label": "加工尺寸超差重量"}])
|
||
self.assertEqual(chart["requiredFields"], ["加工尺寸超差重量"])
|
||
self.assertEqual(chart["series"][0]["values"], [0.0])
|
||
self.assertEqual(chart["scope"]["category"], "加工废")
|
||
self.assertEqual(chart["scope"]["extraFilters"], {"项目类型": ["VCM"]})
|
||
|
||
result["rows"][0]["key"] = "未授权缺陷重量"
|
||
result["rows"][0]["label"] = "未授权缺陷重量"
|
||
self.assertEqual(build_visuals([evidence(result)], "画图看亮片来源具体缺陷重量", "turn-real-shape")["visualState"], "unavailable")
|
||
|
||
def test_fine_defect_partial_totals_only_keeps_valid_mixed_rows_and_full_totals_only_is_not_zero(self):
|
||
mixed = {
|
||
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
|
||
"grain": "source_defect_weight", "stage": "bright", "filters": {},
|
||
"period": {"year": 2026, "month": 9}, "coverage": {"available": True, "sourceRows": 4},
|
||
"sourceRows": 4, "sourceFields": [fine_field("晶界扩散外观异常重量", "扩散废")],
|
||
"rows": [{"key": "晶界扩散外观异常重量", "label": "晶界扩散外观异常重量",
|
||
"category": "扩散废", "weight": 2.5}],
|
||
"categoryReconciliation": [{"category": "扩散废", "sourceRows": 4,
|
||
"expectedTotalsOnly": {"rows": 1},
|
||
"reconciliationStatus": "DIFF"}],
|
||
"totalRows": 1, "truncated": False, "rankingComplete": True,
|
||
}
|
||
chart = build_visuals([evidence(mixed)], "画图看亮片来源具体缺陷排名", "turn-mixed")["visuals"][0]
|
||
self.assertEqual(chart["series"][0]["values"], [2.5])
|
||
self.assertNotIn("VCM", chart.get("note", ""))
|
||
|
||
all_totals = dict(mixed)
|
||
all_totals["rows"] = [{"key": "晶界扩散外观异常重量", "label": "晶界扩散外观异常重量",
|
||
"category": "扩散废", "weight": None}]
|
||
all_totals["categoryReconciliation"] = [{"category": "扩散废", "sourceRows": 4,
|
||
"expectedTotalsOnly": {"rows": 4},
|
||
"reconciliationStatus": "EXPECTED_TOTALS_ONLY"}]
|
||
self.assertEqual(build_visuals([evidence(all_totals)], "画图看亮片来源具体缺陷排名", "turn-mixed")["visualState"], "unavailable")
|
||
|
||
paired_totals = dict(all_totals)
|
||
paired_totals["comparisonPeriod"] = {"year": 2026, "month": 8}
|
||
paired_totals["comparisonCoverage"] = {"available": True, "sourceRows": 4}
|
||
paired_totals["comparisonSourceFields"] = [fine_field("晶界扩散外观异常重量", "扩散废")]
|
||
paired_totals["comparisonCategoryReconciliation"] = list(all_totals["categoryReconciliation"])
|
||
paired_totals["sort"] = "scrap_delta"
|
||
paired_totals["pairedRows"] = [{
|
||
"key": "晶界扩散外观异常重量",
|
||
"current": {"label": "晶界扩散外观异常重量", "category": "扩散废", "weight": None},
|
||
"comparison": {"label": "晶界扩散外观异常重量", "category": "扩散废", "weight": None},
|
||
"deltaWeight": None, "deltaAvailable": False,
|
||
}]
|
||
paired_totals["pairedTotalRows"] = 1
|
||
paired_totals["pairedTruncated"] = False
|
||
paired_totals["pairedRankingComplete"] = True
|
||
self.assertEqual(build_visuals([evidence(paired_totals)], "画图比较亮片来源具体缺陷增量", "turn-mixed")["visualState"], "unavailable")
|
||
|
||
def test_fine_defect_chart_limits_to_ten_and_authorizes_only_displayed_fields(self):
|
||
keys = ["责废尺寸重量", "责废缺角重量", "责废垂直度重量", "责废刀丝重量", "责废烂毛重量",
|
||
"责废开裂重量", "责废其他重量", "料废尺寸重量", "料废缺角重量", "料废开裂重量",
|
||
"料废烂毛重量", "料废其他重量"]
|
||
result = {
|
||
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
|
||
"grain": "source_defect_weight", "stage": "black", "filters": {},
|
||
"period": {"year": 2026, "month": 9}, "coverage": {"available": True, "sourceRows": 2},
|
||
"sourceRows": 2, "sourceFields": [fine_field(key, "责废" if key.startswith("责废") else "料废") for key in keys],
|
||
"rows": [{"key": key, "label": key, "category": "责废" if key.startswith("责废") else "料废",
|
||
"weight": float(index + 1)} for index, key in enumerate(keys)],
|
||
"totalRows": len(keys), "truncated": False, "rankingComplete": True,
|
||
}
|
||
chart = build_visuals([evidence(result)], "画图看黑片来源具体缺陷排名", "turn-ten")["visuals"][0]
|
||
self.assertEqual(len(chart["categories"]), 10)
|
||
self.assertEqual(chart["coverage"], {"totalRows": 12, "returnedRows": 10, "truncated": True})
|
||
self.assertEqual(chart["requiredFields"], [item["key"] for item in chart["categories"]])
|
||
|
||
def test_multi_query_trend_requires_same_release_and_filters_and_keeps_gaps_null(self):
|
||
docs = [
|
||
evidence(metric_result({"year": 2026, "month": 1}, 0.91), ref="Q00000001"),
|
||
evidence(metric_result({"year": 2026, "month": 3}, 0.93), ref="Q00000002"),
|
||
evidence(metric_result({"year": 2026, "month": 4}, 0.94), ref="Q00000003"),
|
||
]
|
||
charts = build_visuals(docs, "画综合合格率趋势图", "turn-08")["visuals"]
|
||
chart = next(item for item in charts if item["metric"] == "composite_rate")
|
||
self.assertEqual([item["key"] for item in chart["categories"]], ["2026-01", "2026-02", "2026-03", "2026-04"])
|
||
self.assertEqual(chart["series"][0]["values"], [0.91, None, 0.93, 0.94])
|
||
annual = {'year': 2026, 'department': '电机部', 'trendGranularity': 'month'}
|
||
bounded = build_visuals(docs, '画综合合格率趋势图', 'turn-annual', context=annual)['visuals']
|
||
self.assertEqual(bounded[0]['series'][0]['values'], [0.91, None, 0.93, 0.94])
|
||
unrelated = [evidence(metric_result({'year':2025,'month':12},0.50),ref='Q00000009'),
|
||
evidence(metric_result({'year':2026,'month':2},0.10,filters={'department':'其他'}),ref='Q00000010')]
|
||
filtered = build_visuals(docs+unrelated, '画综合合格率趋势图', 'turn-filtered-year', context=annual)['visuals']
|
||
self.assertEqual(filtered[0]['series'][0]['values'], [0.91, None, 0.93, 0.94])
|
||
quarter_docs = docs + [evidence(metric_result({'year':2026,'month':2},0.92),ref='Q00000011')]
|
||
quarter = build_visuals(quarter_docs, '画综合合格率趋势图', 'turn-quarter', context={**annual,'quarter':1})['visuals']
|
||
self.assertEqual(quarter[0]['series'][0]['values'], [0.91, 0.92, 0.93])
|
||
single_month = build_visuals(docs, '画综合合格率趋势图', 'turn-month', context={**annual,'month':3})
|
||
self.assertEqual(single_month['visualState'], 'unavailable')
|
||
mismatch = [docs[0], docs[1], evidence(metric_result({"year": 2026, "month": 4}, 0.94, filters={"department": "其他"}), ref="Q00000004")]
|
||
self.assertEqual(build_visuals(mismatch, "画综合合格率趋势图", "turn-08")["visualState"], "unavailable")
|
||
mixed_release = [docs[0], docs[1], evidence(metric_result({"year": 2026, "month": 4}, 0.94, release_id="r-2"), ref="Q00000005", release_id="r-2")]
|
||
self.assertEqual(build_visuals(mixed_release, "画综合合格率趋势图", "turn-08")["visualState"], "unavailable")
|
||
|
||
def test_trend_uses_the_same_unique_comparison_scope_as_the_text(self):
|
||
scoped = comparison_result(filterBinding={'group':'A'},
|
||
current={'period':{'year':2026},'compositeRate':.98,'black':{'rate':.99},'bright':{'rate':.99}},
|
||
comparison={'period':{'year':2025},'compositeRate':.97,'black':{'rate':.98},'bright':{'rate':.99}})
|
||
global_docs = [evidence(metric_result({'year':2026,'month':m},.90+m/100,filters={}),ref=f'Q0000000{m}') for m in (1,3,4)]
|
||
charts = build_visuals([evidence(scoped)]+global_docs,'比较今年变化并画趋势图','turn-root-trend',context={'year':2026})['visuals']
|
||
self.assertFalse(any(chart.get('sectionKey')=='trend' for chart in charts))
|
||
local_docs = [evidence(metric_result({'year':2026,'month':m},.95+m/100,filters={'group':'A'}),ref=f'Q0000001{m}') for m in (1,3,4)]
|
||
charts = build_visuals([evidence(scoped)]+global_docs+local_docs,'比较今年变化并画趋势图','turn-root-trend-ok',context={'year':2026})['visuals']
|
||
trend = next(chart for chart in charts if chart.get('sectionKey')=='trend')
|
||
self.assertEqual(trend['scope']['group'], 'A')
|
||
self.assertEqual(trend['series'][0]['values'], [.96, None, .98, .99])
|
||
|
||
def test_native_trend_is_sorted_and_bounded(self):
|
||
result = metric_result({"year": 2026, "month": 9}, 0.93)
|
||
result.update({
|
||
"trend": [
|
||
{"period": "2026-03", "compositeRate": 0.93, "black": {"rate": 0.92}, "bright": {"rate": 0.94}},
|
||
{"period": "2026-01", "compositeRate": 0.91, "black": {"rate": 0.90}, "bright": {"rate": 0.92}},
|
||
{"period": "2026-04", "compositeRate": 0.94, "black": {"rate": 0.93}, "bright": {"rate": 0.95}},
|
||
],
|
||
"trendCount": 3,
|
||
"trendTruncated": False,
|
||
})
|
||
chart = build_visuals([evidence(result)], "画合格率趋势图", "turn-09")["visuals"][0]
|
||
self.assertEqual(chart["metric"], "composite_rate")
|
||
self.assertEqual([item["key"] for item in chart["categories"]], ["2026-01", "2026-02", "2026-03", "2026-04"])
|
||
self.assertEqual(chart["series"][0]["values"], [0.91, None, 0.93, 0.94])
|
||
result["trendTruncated"] = True
|
||
self.assertEqual(build_visuals([evidence(result)], "画合格率趋势图", "turn-09")["visualState"], "unavailable")
|
||
|
||
def test_explicit_heatmap_and_area_are_real_period_trends_only(self):
|
||
result = metric_result({"year": 2026, "month": 12}, 0.93)
|
||
result.update({
|
||
"trend": [
|
||
{"period": f"2026-{month:02d}", "compositeRate": 0.8 + month / 100,
|
||
"black": {"rate": 0.79 + month / 100, "scrapWeight": month},
|
||
"bright": {"rate": 0.81 + month / 100, "scrapWeight": month / 2}}
|
||
for month in range(1, 13)
|
||
],
|
||
"trendCount": 12,
|
||
"trendTruncated": False,
|
||
})
|
||
ordinary = build_visuals([evidence(result)], "查看综合合格率月度趋势", "turn-usual-trend")["visuals"][0]
|
||
self.assertEqual(ordinary["type"], "line")
|
||
heatmap = build_visuals([evidence(result)], "用热力图展示综合合格率趋势", "turn-heatmap")["visuals"][0]
|
||
self.assertEqual(heatmap["type"], "heatmap")
|
||
self.assertEqual(len(heatmap["categories"]), 12)
|
||
self.assertEqual(len(heatmap["series"]), 1)
|
||
|
||
result["trend"] = result["trend"][:4]
|
||
result["trendCount"] = 4
|
||
area = build_visuals([evidence(result)], "画亮片报废重量面积趋势图", "turn-area")["visuals"][0]
|
||
self.assertEqual(area["type"], "area")
|
||
self.assertEqual(area["stage"], "bright")
|
||
self.assertEqual(area["metric"], "current_scrap_weight")
|
||
self.assertTrue(all(value is None or value >= 0 for value in area["series"][0]["values"]))
|
||
|
||
result["trend"] = result["trend"][:2]
|
||
result["trendCount"] = 2
|
||
self.assertEqual(build_visuals([evidence(result)], "画面积图", "turn-area-invalid")["visualState"], "unavailable")
|
||
|
||
def test_formal_summary_produces_guarded_donut_and_pareto(self):
|
||
defects = [
|
||
{"name": "镀废", "weight": 3.0},
|
||
{"name": "材料废", "weight": 5.0},
|
||
{"name": "加工废", "weight": 0.0},
|
||
{"name": "扩散废", "weight": 2.0},
|
||
]
|
||
result = metric_result({"year": 2026, "month": 9}, 0.93)
|
||
result["summary"]["bright"] = {"defects": defects}
|
||
doc = evidence(result)
|
||
donut = build_visuals([doc], "用环状图展示亮片已列正式报废类别构成", "turn-donut")["visuals"][0]
|
||
self.assertEqual(donut["type"], "donut")
|
||
self.assertEqual(donut["metric"], "source_defect_weight")
|
||
self.assertEqual(donut["series"][0]["values"], [3.0, 5.0, 0.0, 2.0])
|
||
self.assertEqual(donut["coverage"], {
|
||
"totalRows": 4, "returnedRows": 4, "truncated": False, "shareBasis": "displayed_categories"
|
||
})
|
||
self.assertEqual(donut["requiredFields"], [
|
||
"bright_plating_scrap", "bright_material_scrap", "bright_processing_scrap", "bright_diffusion_scrap"
|
||
])
|
||
self.assertIn("占比按本图已列类别重量合计", donut["note"])
|
||
|
||
pareto = build_visuals([doc], "绘制亮片柏拉图并标注报废类别", "turn-pareto")["visuals"][0]
|
||
self.assertEqual(pareto["type"], "pareto")
|
||
self.assertEqual(pareto["series"][0]["values"], [5.0, 3.0, 2.0, 0.0])
|
||
self.assertEqual([category["key"] for category in pareto["categories"]], [
|
||
"bright_material_scrap", "bright_plating_scrap", "bright_diffusion_scrap", "bright_processing_scrap"
|
||
])
|
||
self.assertNotEqual(donut["id"], pareto["id"])
|
||
|
||
comparison = comparison_result()
|
||
comparison["current"]["bright"] = {"defects": defects, "rate": 0.99, "scrapWeight": 5.0}
|
||
current_donut = build_visuals([evidence(comparison)], "亮片当前已列类别构成环状图", "turn-comparison-donut")["visuals"][0]
|
||
self.assertEqual(current_donut["type"], "donut")
|
||
self.assertEqual(current_donut["period"], {"year": 2026, "month": 9})
|
||
self.assertNotIn("comparisonPeriod", current_donut)
|
||
|
||
def test_summary_and_complete_category_top_only_make_share_charts_when_complete(self):
|
||
result = metric_result({"year": 2026, "month": 9}, 0.93)
|
||
result["summary"]["black"] = {"defects": [
|
||
{"name": "责废", "weight": 1.0}, {"name": "料废", "weight": 2.0}, {"name": "外废", "weight": 3.0}
|
||
]}
|
||
result["summary"]["black"]["defects"][1]["weight"] = -2.0
|
||
self.assertEqual(build_visuals([evidence(result)], "黑片环状图展示构成", "turn-negative")["visualState"], "unavailable")
|
||
result["summary"]["black"]["defects"][1]["weight"] = 0.0
|
||
result["summary"]["black"]["defects"][2]["weight"] = 0.0
|
||
result["summary"]["black"]["defects"][0]["weight"] = 0.0
|
||
self.assertEqual(build_visuals([evidence(result)], "黑片环状图展示构成", "turn-zero")["visualState"], "unavailable")
|
||
result["summary"]["black"]["defects"][0]["weight"] = 1.0
|
||
filtered = dict(result)
|
||
filtered["filters"] = {"category": "责废", "extraFilters": {}}
|
||
self.assertEqual(build_visuals([evidence(filtered)], "黑片环状图展示构成", "turn-filtered-category")["visualState"], "unavailable")
|
||
|
||
top = {
|
||
"kind": "quality_top", "releaseId": "r-1", "stage": "black", "dimension": "category",
|
||
"period": {"year": 2026, "month": 9}, "filters": {"extraFilters": {}},
|
||
"rankingCoverage": {"groups": 3, "complete": True},
|
||
"cumulativeThresholdApplied": False,
|
||
"rows": [
|
||
{"rank": 1, "key": "责废", "label": "责废", "weight": 8.0},
|
||
{"rank": 2, "key": "料废", "label": "料废", "weight": 4.0},
|
||
{"rank": 3, "key": "外废", "label": "外废", "weight": 1.0},
|
||
],
|
||
}
|
||
chart = build_visuals([evidence(top)], "黑片柏拉图按正式类别", "turn-pareto-top")["visuals"][0]
|
||
self.assertEqual(chart["type"], "pareto")
|
||
self.assertEqual(chart["series"][0]["values"], [8.0, 4.0, 1.0])
|
||
top["rankingCoverage"]["complete"] = False
|
||
self.assertEqual(build_visuals([evidence(top)], "黑片柏拉图按正式类别", "turn-pareto-incomplete")["visualState"], "unavailable")
|
||
|
||
def test_colloquial_quality_analysis_requests_generate_bound_charts(self):
|
||
questions = [
|
||
'查一下消费电子美洲近期质量下滑严重的产品',
|
||
'看看电机部合格率下跌的规格', '电机部质量走低的产品',
|
||
'电机部合格率回落的产品', '电机部合格率降低的产品',
|
||
'查查电机部质量变差的产品', '查查电机部质量变坏的产品',
|
||
'查查电机部质量变糟的产品', '找出电机部降幅大的规格',
|
||
'查电机部跌幅大的产品', '电机部质量最差的产品',
|
||
'电机部质量较差的产品', '电机部合格率偏低的规格',
|
||
'查查电机部质量不理想的产品', '电机部表现不佳的产品',
|
||
'电机部质量不稳定的产品', '电机部质量波动大的产品',
|
||
'电机部报废突然变多的产品', '电机部报废突增的规格',
|
||
'电机部报废激增的产品', '近期值得关注的规格',
|
||
'近期重点产品', '电机部质量好转的规格',
|
||
'电机部合格率提升的产品', '电机部合格率回升的产品',
|
||
'电机部报废减少的产品', '电机部质量环比怎么样',
|
||
'电机部与上月差异', '电机部质量异常的产品',
|
||
'电机部质量不好的产品', '电机部质量不佳的产品',
|
||
'电机部质量差的产品', '电机部质量糟糕的产品',
|
||
'电机部合格率变低的规格', '电机部质量退步的产品',
|
||
'电机部质量不达标的产品', '电机部合格率低于目标的规格',
|
||
'电机部质量降得厉害的产品', '电机部合格率掉得多的规格',
|
||
]
|
||
doc = evidence(comparison_result())
|
||
context = {'releaseId': 'r-1', 'filters': {'department': '电机部'}}
|
||
for question in questions:
|
||
with self.subTest(question=question):
|
||
output = build_visuals([doc], question, 'turn-colloquial', context=context)
|
||
self.assertEqual(output['visualState'], 'ready')
|
||
self.assertTrue(output['visuals'])
|
||
self.assertTrue(all(v['scope'].get('department') == '电机部' for v in output['visuals']))
|
||
self.assertTrue(all(v['evidenceRefs'] == ['Q1234ABCD'] for v in output['visuals']))
|
||
|
||
def test_colloquial_requests_keep_text_only_and_no_evidence_guards(self):
|
||
question = '查一下近期质量下滑严重的产品'
|
||
doc = evidence(comparison_result())
|
||
for suffix in ['只要文字', '仅需文本', '仅用文字', '只返回数值', '不用画图', '不需要配图', '不要图表', '只需要文字', '仅输出数字', '仅文字', '无需图', '不必画图']:
|
||
with self.subTest(suffix=suffix):
|
||
self.assertEqual(build_visuals([doc], question + ',' + suffix, 'turn-text-only')['visuals'], [])
|
||
for simple in ['综合合格率是多少', '黑片合格率多少', '产品名称是什么', '查一下数据源文件名']:
|
||
with self.subTest(simple=simple):
|
||
self.assertEqual(build_visuals([doc], simple, 'turn-simple')['visuals'], [])
|
||
self.assertEqual(build_visuals([], question, 'turn-no-evidence')['visuals'], [])
|
||
wrong_scope = {'releaseId': 'r-1', 'filters': {'department': '无关部门'}}
|
||
labelled = build_visuals([doc], question, 'turn-wrong-scope', context=wrong_scope)['visuals']
|
||
self.assertTrue(all(v['scope'].get('department') == '电机部' for v in labelled))
|
||
|
||
def test_simple_text_and_negative_visual_request_override(self):
|
||
doc = evidence(comparison_result())
|
||
self.assertEqual(build_visuals([doc], "综合合格率是多少", "turn-10")["visualState"], "not_requested")
|
||
self.assertEqual(build_visuals([doc], "不要图,只要文字,比较两个期间", "turn-10")["visualState"], "not_requested")
|
||
self.assertEqual(build_visuals([doc], "不要绘图,只要文本,比较两个期间", "turn-10")["visualState"], "not_requested")
|
||
self.assertEqual(build_visuals([], "重新分析重点产品并写出降幅", "turn-followup", context={})["visualState"], "not_requested")
|
||
self.assertEqual(build_visuals([], "画图比较重点产品降幅", "turn-followup", context={})["visualState"], "unavailable")
|
||
column = build_visuals([doc], "不要环状图,用柱状图比较两期综合合格率", "turn-negative-style-column")["visuals"][0]
|
||
self.assertEqual(column["type"], "column")
|
||
self.assertEqual(build_visuals([doc], "不用柏拉图,显示条形图比较两期综合合格率", "turn-negative-style-bar")["visuals"][0]["type"], "bar")
|
||
|
||
def test_explicit_composite_trend_does_not_add_unrequested_stages_or_plot_missing_as_perfect(self):
|
||
result = metric_result({"year": 2026}, 0.93)
|
||
result.update({"trend": [
|
||
{"period": "2026-01", "compositeRate": 0.91},
|
||
{"period": "2026-02", "compositeRate": 1.0, "coverage": {"blackRows": 0, "brightRows": 0}},
|
||
{"period": "2026-03", "compositeRate": 0.93},
|
||
{"period": "2026-04", "compositeRate": 0.94},
|
||
{"period": "2026-05", "compositeRate": 1.0, "monthStatus": "future"},
|
||
], "trendCount": 5, "trendTruncated": False})
|
||
charts = build_visuals([evidence(result)], "只展示综合合格率趋势图", "turn-nodata")["visuals"]
|
||
self.assertEqual([chart["metric"] for chart in charts], ["composite_rate"])
|
||
self.assertEqual(charts[0]["series"][0]["values"], [0.91, None, 0.93, 0.94, None])
|
||
|
||
def test_ids_are_stable_per_semantics_and_output_is_isolated(self):
|
||
doc = evidence(comparison_result())
|
||
doc["absoluteEvidencePath"] = "/Users/alice/private/source.json"
|
||
first = build_visuals([doc], "比较两个期间变化", "turn-11")
|
||
second = build_visuals([doc], "比较两个期间变化", "turn-11")
|
||
self.assertEqual(first["visuals"][0]["id"], second["visuals"][0]["id"])
|
||
self.assertNotIn("absoluteEvidencePath", json.dumps(first, ensure_ascii=False))
|
||
self.assertNotIn("/Users/alice", json.dumps(first, ensure_ascii=False))
|
||
self.assertLess(len(json.dumps(first, ensure_ascii=False).encode("utf-8")), MAX_BODY_BYTES)
|
||
changed_turn = build_visuals([doc], "比较两个期间变化", "turn-12")
|
||
self.assertNotEqual(first["visuals"][0]["id"], changed_turn["visuals"][0]["id"])
|
||
|
||
def test_malformed_evidence_and_large_rankings_fail_softly(self):
|
||
malformed = evidence(changes_result(rows=[{"rank": True, "key": "p-1", "label": "x", "scrapDelta": 1}]))
|
||
self.assertEqual(build_visuals([malformed], "画产品报废增量排名", "turn-13")["visualState"], "unavailable")
|
||
result = changes_result(rows=[
|
||
{"rank": index + 1, "key": f"p-{index}", "label": f"规格{index}", "scrapDelta": index}
|
||
for index in range(15)
|
||
], totalRows=15, returnedRows=15, truncated=False)
|
||
chart = build_visuals([evidence(result)], "画产品报废增量排名", "turn-13")["visuals"][0]
|
||
self.assertEqual(len(chart["categories"]), 10)
|
||
self.assertTrue(chart["coverage"]["truncated"])
|
||
self.assertEqual(chart["series"][0]["values"], list(map(float, range(10))))
|
||
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|