"""期 2、期 3 契约文件(recipe_types、recipe_parsers)的测试:只用合成字符串和合成夹具(参考配方、期 2 基线、 flow 夹具),不读任何真实文件。""" from __future__ import annotations import dataclasses import datetime as dt import hashlib import json import tempfile import typing from dataclasses import MISSING, asdict from pathlib import Path import pytest from tests.sqlite_baseline import baseline_file_hash from pydantic import ValidationError from app.data import recipe_parsers as P from app.data import recipe_types as T from app.data.recipe import canonical_recipe, recipe_sha256 FLOW = json.loads((Path(__file__).parent / "fixtures" / "recipes" / "flow_recipe.json").read_text(encoding="utf-8")) @pytest.mark.parametrize("text,canonical", [ ("7-8", "7-8"), ("7–8", "7-8"), ("7—8", "7-8"), ("07:00-08:00", "7-8"), ("7时-8时", "7-8"), ("7点-8点", "7-8"), ("7-8时", "7-8"), ("8-9", "8-9"), ("7-8 ", "7-8"), ("23-24", "23-24"), ]) def test_hour_range_accepts_tolerant_forms(text, canonical): assert P.hour_range(text).canonical == canonical @pytest.mark.parametrize("text", ["25-26", "8-7", "7:30-8:00", "18-22 时合计", "x" * 41, 7, None, ""]) def test_hour_range_rejects(text): assert P.hour_range(text) is None @pytest.mark.parametrize("text,canonical", [ ("18-22 时合计", "18-22时合计"), ("18:00-22:00合计", "18-22时合计"), ("18-22时小计", "18-22时小计"), ("18-24 时合计", "18-24时合计"), ("18–22时总计", "18-22时总计"), ]) def test_hour_range_total(text, canonical): assert P.hour_range_total(text).canonical == canonical def test_hour_range_total_rejects_plain_range(): assert P.hour_range_total("18-22") is None @pytest.mark.parametrize("text,start,end", [ ("统计时间范围:2026年9月1日至2026年9月30日", "2026-09-01", "2026-09-30"), ("统计时间范围:2026年9月1日至9月30日", "2026-09-01", "2026-09-30"), ("2026年12月15日至1月14日", "2026-12-15", "2027-01-14"), ("客流汇总表(2026年9月1日至2026年9月30日)", "2026-09-01", "2026-09-30"), ("2026-09-01至2026-09-30", "2026-09-01", "2026-09-30"), ]) def test_cn_date_range(text, start, end): assert P.cn_date_range(text).iso() == (start, end) @pytest.mark.parametrize("text", [ "客流汇总表(2026年9月)", "2026年9月1日至2026年9月30日;2026年10月1日至10月31日", "2026年2月30日至3月1日", "注:9月15日闸机故障,当日客流为估算值", "x" * 81, ]) def test_cn_date_range_rejects(text): assert P.cn_date_range(text) is None def test_year_month_is_only_supporting_evidence(): m = P.cn_year_month("客流汇总表(2026年9月)") assert (m.year, m.month) == (2026, 9) assert m.contains(P.Period(dt.date(2026, 9, 1), dt.date(2026, 9, 30))) assert m.contains(P.Period(dt.date(2026, 9, 1), dt.date(2026, 9, 15))) assert not m.contains(P.Period(dt.date(2026, 10, 1), dt.date(2026, 10, 31))) assert P.cn_year_month("2026年9月1日至9月30日") is None def test_filename_period(): assert P.filename_period("月报导出_2026-08-01_2026-08-31.xlsx").iso() == ("2026-08-01", "2026-08-31") assert P.filename_period("9月客流.xlsx") is None @pytest.mark.parametrize("value,expected", [ ("8月1日", (None, 8, 1, "text")), (" 8月1日 ", (None, 8, 1, "text")), ("2026年8月1日", (2026, 8, 1, "text")), ("2026-08-01", (2026, 8, 1, "text")), ("2026/8/1", (2026, 8, 1, "text")), (dt.datetime(2026, 8, 1), (2026, 8, 1, "date")), (dt.date(2026, 8, 1), (2026, 8, 1, "date")), ]) def test_axis_cells(value, expected): got = P.month_day_or_date(value) assert (got.year, got.month, got.day, got.form) == expected @pytest.mark.parametrize("value", ["8/1", "13月1日", dt.datetime(2026, 8, 1, 12), 45000, "合计", None]) def test_axis_cells_rejected(value): assert P.month_day_or_date(value) is None def test_complete_year_unique_solution_across_new_year(): period = P.Period(dt.date(2026, 12, 15), dt.date(2027, 1, 14)) assert P.complete_year(P.AxisDate(None, 1, 3, "text"), period) == dt.date(2027, 1, 3) assert P.complete_year(P.AxisDate(None, 12, 20, "text"), period) == dt.date(2026, 12, 20) assert P.complete_year(P.AxisDate(None, 2, 1, "text"), period) is None assert P.complete_year(P.AxisDate(2026, 11, 1, "date"), period) is None def test_unit_suffix(): assert P.split_unit_suffix("全日客流(人次)") == ("全日客流", "人次") assert P.split_unit_suffix("金额") == ("金额", None) assert P.split_unit_suffix("销量(箱)") == ("销量", "箱") assert P.unit_known("人次") and not P.unit_known("箱") @pytest.mark.parametrize("value,kind", [ ("客流汇总表", "text"), ("注:9月15日闸机故障,当日客流为估算值", "text_digits"), ("1,234", "number"), ("12.5%", "number"), ("50万", "number"), (12.0, "number"), (dt.date(2026, 9, 5), "text_digits"), ("单位:万元", "text"), ("补录(人次)", "text"), ]) def test_classify_outside(value, kind): assert P.classify_outside(value) == kind @pytest.mark.parametrize("text,numeric", [ ("1,234", True), ("12.5%", True), ("50万", True), ("¥1234", True), ("12kg", True), ("12万人次", True), ("3天", True), ("100元", True), # 日期、期间写法是文字(含数字),不是一个数(lab c04 的两行表头「2026年上半年」) ("2026年上半年", False), ("2026年度", False), ("2026上半年", False), ("9月", False), ("15日", False), ("7时", False), ("3号", False), ("2季度", False), ("3期", False), ]) def test_looks_numeric_text_date_suffix_is_text(text, numeric): assert P.looks_numeric_text(text) is numeric assert P.classify_outside(text) == ("number" if numeric else "text_digits") def test_candidate_words_strip_common_affixes(): assert P.candidate_words("日间时段客流(人次)", ["夜间时段客流(人次)"])[0] == "日间" assert P.candidate_words("夜间时段客流(人次)", ["日间时段客流(人次)"])[0] == "夜间" assert "早高峰" in P.candidate_words("工作日 早高峰", ["工作日 晚高峰"]) assert all(not any(ch.isdigit() for ch in w) for w in P.candidate_words("2026年日间", ["2026年夜间"])) def test_match_key_ignores_whitespace_and_width(): assert P.match_key("金 额") == P.match_key("销 售".replace("销 售", "金额")) == "金额" assert P.match_key("地区\u3000") == "地区" def test_flow_recipe_parses_and_derives_tables(): recipe = T.Recipe.model_validate(FLOW) tables, problems = T.derive_tables(recipe) assert problems == [] assert [c.name for c in tables["时段客流"]] == ["日期", "时段", "时段类别", "起始小时", "结束小时", "客流"] assert [c.name for c in tables["日客流"]] == ["日期", "全日客流", "分区甲", "分区乙"] assert tables["日客流"][1].unit == "人次" @pytest.mark.parametrize("mutate", [ lambda r: r["sheets"][0].__setitem__("regex", "x"), lambda r: r["sheets"][0]["blocks"][0]["segments"][1]["const"].__setitem__("时段类别", {"value": "日间"}), lambda r: r["sheets"][0]["blocks"][0]["values"]["placeholders"][0].__setitem__("to", 0), lambda r: r["sheets"][0]["blocks"][0]["axis"].__setitem__("year", 2026), ]) def test_closed_language_rejects_open_fields(mutate): data = json.loads(json.dumps(FLOW)) mutate(data) with pytest.raises(ValidationError): T.Recipe.model_validate(data) @pytest.mark.parametrize("text,ok", [ ("粒度:每个{列:日期}。{列:全日客流} 等于 {列:分区甲} 与 {列:分区乙} 之和(导入时已逐日核对)", True), ("单位:{单位:万元}", True), ("单位:万元", False), ("{列:3号门客流} 与 {列:指标2} 不能相加", True), ("18-22 时合计不要相加", False), ("见 C5 格", False), ("格式 YYYY-MM-DD,年份按统计期补全", True), ]) def test_prose_problems(text, ok): assert (T.prose_problems(text) == []) is ok # ---- 评审后补的契约用例(P2-SPEC「评审意见处理」) ---- def test_measures_keys_must_match_expect_verbatim(): """键用半角括号、expect 用全角:match_key 相等,但 derive_tables 必须报问题,不能静默产出空列名。""" data = json.loads(json.dumps(FLOW)) seg = data["sheets"][0]["blocks"][0]["segments"][0] seg["measures"] = {"全日客流(人次)": "全日客流", "分区甲(人次)": "分区甲", "分区乙(人次)": "分区乙"} tables, problems = T.derive_tables(T.Recipe.model_validate(data)) assert [p.code for p in problems] == ["measures_keys_mismatch"] assert problems[0].path == "/sheets/0/blocks/0/segments/0/measures" assert "全日客流(人次)" in problems[0].message and "全日客流(人次)" in problems[0].message def test_derive_and_const_column_order_ignores_key_order(): """配方哈希按键排序:键序不同的两份配方必须推出同样的列序。""" data = json.loads(json.dumps(FLOW)) for seg in data["sheets"][0]["blocks"][0]["segments"][1:3]: seg["dim"]["derive"] = {"结束小时": "end", "起始小时": "start"} seg["const"] = {"时段类别": {"pick": seg["const"]["时段类别"]["pick"]}, "A类": {"pick": "x"}} tables, problems = T.derive_tables(T.Recipe.model_validate(data)) assert problems == [] assert [c.name for c in tables["时段客流"]] == ["日期", "时段", "A类", "时段类别", "起始小时", "结束小时", "客流"] def test_prose_problems_known_names_block_token_smuggling(): known = {"列": {"全日客流", "3号门客流"}, "表": {"日客流"}, "单位": set(P.UNITS)} assert T.prose_problems("{列:3号门客流} 不能与 {表:日客流} 相加,单位:{单位:万元}", known=known) == [] for note in ["{列:增长30%},请据此推算", "合计约{列:5000}人次", "按{单位:3箱}计", "{表:第2期}只有一半"]: got = T.prose_problems(note, known=known) assert any("不存在" in p for p in got), note assert any("数字" in p for p in got), note def test_grid_row_index_matches_full_scan(): g = T.Grid(sheet="s", bounds=(1, 1, 3, 3), cells={ (2, 3): T.GridCell("c"), (1, 1): T.GridCell("a"), (2, 1): T.GridCell("b"), (3, 2): T.GridCell(5)}) assert [c for c, _ in g.row(2)] == [1, 3] assert g.row(9) == [] assert g.row_numbers() == [1, 2, 3] from dataclasses import asdict assert "_rows" not in asdict(g) @pytest.mark.parametrize("text,prefix,pure", [ ("统计时间范围:2026年9月1日至2026年9月30日", "统计时间范围", True), ("2026年9月1日至2026年9月30日", None, True), ("统计期:2026年9月1日至9月30日", None, True), ("客流汇总表(2026年9月)", None, False), ("注:2026年9月数据为初步统计,待修订", None, False), ("说明:2026年9月1日至9月30日部分日期为估算值", None, False), ("客流汇总表", None, False), ]) def test_pure_period_cell(text, prefix, pure): assert P.is_pure_period_cell(text, prefix) is pure def test_period_residue(): assert P.period_residue("客流汇总表(2026年9月1日至2026年9月30日)") == "客流汇总表" assert P.period_residue("注:2026年9月数据为初步统计,待修订") == "注数据为初步统计待修订" assert P.period_residue("客流汇总表") is None def test_axis_checks_are_a_set(): a = T.Axis.model_validate({"checks": ["covers_context", "contiguous", "contiguous"]}) assert a.checks == ["contiguous", "covers_context"] assert a.model_dump(exclude_defaults=True) == {} # ========================================================================== # 期 3 契约(P3-SPEC 9.2、12.1 WP-0):新字段的默认值等于旧行为、语言仍封闭、资格函数、字段名钉住 # ========================================================================== #: 参考配方的哈希(期 2 实测值):期 3 加了字段也不能变,期 2 的构建 id 才不失效 REF_RECIPE_SHA = "971a8eba5ac606bd0552c43ff83b5c361d134c77d471bfe2d28e440ebfcc07b4" P2_BASELINE = json.loads((Path(__file__).parent / "fixtures" / "recipes" / "p2_baseline.json").read_text(encoding="utf-8")) def _flow(**changes) -> dict: data = json.loads(json.dumps(FLOW)) data.update(changes) return data def test_reference_recipe_hash_unchanged_with_p3_fields(): recipe = T.Recipe.model_validate(FLOW) assert recipe_sha256(recipe) == REF_RECIPE_SHA == P2_BASELINE["recipe"]["recipe_sha256"] # 完整形式里新字段都在、都取默认值;再解析一遍哈希不变(新字段的默认值不进 canonical) full = recipe.model_dump(mode="json") sheet, block = full["sheets"][0], full["sheets"][0]["blocks"][0] assert sheet["ignore_outside"] == [] and block["ignore_rows"] == [] and block["ignore_columns"] == [] assert recipe_sha256(T.Recipe.model_validate(full)) == REF_RECIPE_SHA canon = json.dumps(canonical_recipe(recipe), ensure_ascii=False) assert "ignore_" not in canon # 用了新字段,哈希才变 full["sheets"][0]["blocks"][0]["ignore_rows"] = [{"label": "补录(人次)", "reason": "补录数据另行核对"}] assert recipe_sha256(T.Recipe.model_validate(full)) != REF_RECIPE_SHA def test_list_block_ignore_columns_default_keeps_hash(): data = json.loads(json.dumps(C01_LIKE)) base = recipe_sha256(T.Recipe.model_validate(data)) data["sheets"][0]["blocks"][0]["ignore_columns"] = [] data["sheets"][0]["ignore_outside"] = [] assert recipe_sha256(T.Recipe.model_validate(data)) == base data["sheets"][0]["blocks"][0]["ignore_columns"] = [{"header": "备注", "reason": "备注列不导入"}] parsed = T.Recipe.model_validate(data) assert parsed.sheets[0].blocks[0].ignore_columns[0].header == "备注" assert recipe_sha256(parsed) != base @pytest.mark.parametrize("where,key,item", [ ("block", "ignore_rows", {"label": "补录(人次)", "reason": "补录"}), ("block", "ignore_columns", {"header": "合计", "reason": "右侧合计列"}), ("sheet", "ignore_outside", {"anchor": "补录说明", "reason": "说明行"}), ]) def test_ignore_rules_parse_and_are_closed(where, key, item): def put(value): data = json.loads(json.dumps(FLOW)) target = data["sheets"][0]["blocks"][0] if where == "block" else data["sheets"][0] target[key] = value return data T.Recipe.model_validate(put([item])) with pytest.raises(ValidationError): # extra="forbid":不能多写字段(如坐标、正则) T.Recipe.model_validate(put([{**item, "cell": "B32"}])) with pytest.raises(ValidationError): T.Recipe.model_validate(put([{**item, "regex": ".*"}])) first = next(iter(item)) with pytest.raises(ValidationError): # 锚点文字不能为空 T.Recipe.model_validate(put([{**item, first: ""}])) with pytest.raises(ValidationError): # 理由必填 T.Recipe.model_validate(put([{k: v for k, v in item.items() if k != "reason"}])) with pytest.raises(ValidationError): T.Recipe.model_validate(put([{**item, "reason": "x" * 201}])) limit = 20 if key == "ignore_outside" else 50 T.Recipe.model_validate(put([item] * limit)) with pytest.raises(ValidationError): T.Recipe.model_validate(put([item] * (limit + 1))) def test_ignore_rule_lengths(): T.IgnoreRow(label="x" * 40, reason="r") T.IgnoreColumn(header="x" * 80, reason="r") T.IgnoreOutside(anchor="x" * 40, reason="r") for bad in (lambda: T.IgnoreRow(label="x" * 41, reason="r"), lambda: T.IgnoreColumn(header="x" * 81, reason="r"), lambda: T.IgnoreOutside(anchor="x" * 41, reason="r")): with pytest.raises(ValidationError): bad() def test_ignore_fields_only_where_the_spec_puts_them(): """ignore_rows 只在交叉表块上;列表块只有 ignore_columns;ignore_outside 只在工作表上。""" data = json.loads(json.dumps(C01_LIKE)) data["sheets"][0]["blocks"][0]["ignore_rows"] = [{"label": "合计", "reason": "r"}] with pytest.raises(ValidationError): T.Recipe.model_validate(data) data = json.loads(json.dumps(FLOW)) data["sheets"][0]["blocks"][0]["ignore_outside"] = [{"anchor": "注", "reason": "r"}] with pytest.raises(ValidationError): T.Recipe.model_validate(data) data = json.loads(json.dumps(FLOW)) data["sheets"][0]["ignore_columns"] = [{"header": "合计", "reason": "r"}] with pytest.raises(ValidationError): T.Recipe.model_validate(data) # ---- accumulate_blockers(P3-SPEC 2.2) #: c01 规则草稿的形状(列表块,表头 地区 产品 销量 金额,合计行另存;没有可解析的统计期区间) C01_LIKE = { "recipe_format": "agentlab-recipe/2", "sheets": [{ "id": "s1", "match": {"name": "月报"}, "blocks": [{ "id": "列表1", "layout": "list", "table": "月报", "columns": [{"header": "地区", "name": "地区", "type": "TEXT"}, {"header": "产品", "name": "产品", "type": "TEXT"}, {"header": "销量", "name": "销量", "type": "INTEGER"}, {"header": "金额", "name": "金额", "type": "INTEGER"}], "rows": {"total_row": {"label_column": "地区", "pick": "合计", "keep_as": "月报_表内合计"}}, }], }], "tables": [{"name": "月报", "grain": ["地区", "产品"], "units": {"金额": "万元"}}, {"name": "月报_表内合计", "grain": ["合计项"], "kind": "reported_total", "units": {"金额": "万元"}}], } def test_accumulate_blockers_reference_recipe_is_eligible(): assert T.accumulate_blockers(T.Recipe.model_validate(_flow(mode="accumulate"))) == [] # 不看 mode:替换模式的同一份配方也符合资格(起草器据此决定写不写 mode=accumulate) assert T.accumulate_blockers(T.Recipe.model_validate(FLOW)) == [] def test_accumulate_blockers_list_shape_is_unkeyed(): data = json.loads(json.dumps(C01_LIKE)) data["sheets"][0]["context"] = [{}] # 配了统计期,列表却没说每一行属于哪一期:不能累积 got = T.accumulate_blockers(T.Recipe.model_validate(data)) assert [(p.code, p.path) for p in got] == [("accumulate_unkeyed", "/tables/0"), ("accumulate_unkeyed", "/tables/1")] assert "没有指定每一行属于哪一期" in got[0].message # 合计行另存的表:各期的合计项相同,主键分不开各期(期 5 列表可以累积以后仍然不行) assert "合计行、小计行另存的表不能按期累积" in got[1].message assert "「月报」" in got[0].message and "「月报_表内合计」" in got[1].message # c01 的草稿本来就没有统计期:两条都报,统计期那条在前(起草卡片取第一条的人话) got = T.accumulate_blockers(T.Recipe.model_validate(C01_LIKE)) assert [p.code for p in got] == ["accumulate_needs_period", "accumulate_unkeyed", "accumulate_unkeyed"] def test_accumulate_blockers_needs_period(): data = _flow(mode="accumulate") data["sheets"][0]["context"] = [] got = T.accumulate_blockers(T.Recipe.model_validate(data)) assert [(p.code, p.path) for p in got] == [("accumulate_needs_period", "/mode")] assert "统计期" in got[0].message def test_accumulate_blockers_axis_checks_and_grain(): data = _flow(mode="accumulate") data["sheets"][0]["blocks"][0]["axis"]["checks"] = ["contiguous"] got = T.accumulate_blockers(T.Recipe.model_validate(data)) assert [(p.code, p.path) for p in got] == [("accumulate_unkeyed", f"/tables/{i}") for i in range(3)] assert all("恰好覆盖统计期" in p.message and "交叉表「交叉表」" in p.message for p in got) data = _flow(mode="accumulate") data["tables"][1]["grain"] = ["时段"] got = T.accumulate_blockers(T.Recipe.model_validate(data)) assert [(p.code, p.path) for p in got] == [("accumulate_unkeyed", "/tables/1")] assert "「时段客流」" in got[0].message and "主键不含日期列「日期」" in got[0].message def test_accumulate_blockers_messages_follow_copy_rules(): data = json.loads(json.dumps(C01_LIKE)) data["tables"][0]["grain"] = [] msgs = [p.message for p in T.accumulate_blockers(T.Recipe.model_validate(data))] for m in msgs: assert not any(w in m for w in ("跑", "后端", "放行", "钉", "accumulate", "covers_context")), m # ---- 新字段的默认值等于旧行为 def test_new_fields_default_to_old_behaviour(): assert T.RegionMark("s", "value", "C5").block is None assert T.Problem("x", "structure", "m").fix_args is None assert T.Extraction(ok=True).rows_excluded == [] assert T.SchemaNotes().fragments == {} assert T.ConfirmItem("mode", "导入模式").source == "recipe" assert T.RECIPE_ENGINE_VER == "recipe/1" and T.UNION_VER == "union/1" # 旧回执里没有 rows_excluded / block / fix_args:asdict 之后多出来的键都取默认值 ex = asdict(T.Extraction(ok=True, regions=[T.RegionMark("s", "value", "C5")], problems=[T.Problem("x", "structure", "m")])) assert ex["rows_excluded"] == [] and ex["regions"][0]["block"] is None and ex["problems"][0]["fix_args"] is None def test_region_mark_json_always_carries_block(): """RegionMark 的 JSON 一律带 block 键(None 也带)。期 2 的 test_recipe_imports.py 的 test_stage_first_does_not_create_the_source_and_keeps_the_raw 逐字比 marks、不含 block,WP-0 合并后会失败; 那个文件归 WP-5(P3-SPEC 12.0),由 WP-5 改期望值。这条测试防止有人为了让那条期 2 断言通过而去掉这个字段 或者改成不输出 None。""" assert asdict(T.RegionMark("甲表", "value", "A2:B3")) == {"sheet": "甲表", "role": "value", "ref": "A2:B3", "block": None} assert asdict(T.RegionMark("甲表", "value", "A2:B3", block="列表1"))["block"] == "列表1" def test_trial_receipt_view_carries_rows_excluded_once_wp5_lands(): """评审:TrialOut.receipt 只抄 recipe_imports._RECEIPT_VIEW 里的键。不把 rows_excluded 加进去,向导回执就一律 显示「这次导入未记录排除的行」。这一行归 WP-5(recipe_imports.py),所以这条测试在 WP-5 合并前跳过: 以 Pipeline 有没有 propose_fixes 字段(WP-5 按 P3-SPEC 12.6 加的接缝)判断 WP-5 是否已合并。""" from app.data import recipe_imports if "propose_fixes" not in {f.name for f in dataclasses.fields(recipe_imports.Pipeline)}: pytest.skip("WP-5 还没有合并:试运行回执的白名单由 WP-5 补 rows_excluded") rows = [asdict(T.ExcludedRows("甲表", "blank_skipped", [[5, 5]], 2, block="列表1"))] view = recipe_imports._receipt_view({"tables": [], "rows_excluded": rows}, None) assert view.get("rows_excluded") == rows, "TrialOut.receipt 缺 rows_excluded:把它加进 recipe_imports._RECEIPT_VIEW" def test_edit_result_breaking_is_internal_bool(): """EditResult.breaking 是布尔;EditPreview JSON 的 breaking 是「表名 → 人话列表」,由 WP-5 另算并覆盖(9.4)。 这里只钉住契约这一侧的类型,免得有人把两者改成同一个值。""" assert typing.get_type_hints(T.EditResult)["breaking"] is bool assert T.EditResult(True, "fix", "k", "t", [], [], [], [], []).breaking is False def test_snapshot_not_activatable_codes_match_versions_text(): """SnapshotOut.reason_code 的取值与文字(契约补充,7.1 只有人话 reason)。文字与附录 C 的 notActivatable 逐字相同:界面按 code 取 VERSIONS_TEXT(types.ts 的 SnapshotReasonCode 用 satisfies 钉住键),没有 code 时 显示 reason,两条路显示一样。顺序即几种同时成立时的优先顺序。""" assert typing.get_args(T.SnapshotReasonCode) == ("current", "retired", "file_lost", "contains_revoked") assert list(T.SNAPSHOT_NOT_ACTIVATABLE) == list(typing.get_args(T.SnapshotReasonCode)) assert T.SNAPSHOT_NOT_ACTIVATABLE == { "current": "已是当前版本", "retired": "已回收,无法启用", "file_lost": "数据文件已丢失,无法启用", "contains_revoked": "包含已作废接受的导入,无法启用", } def _literal(cls, name: str) -> tuple: return typing.get_args(typing.get_type_hints(cls)[name]) def test_closed_value_sets(): assert _literal(T.ConfirmItem, "source") == ( "recipe", "diff", "outside", "sheet", "context", "switch", "edit", "accumulate") assert {"union_rows", "union_pk", "union_period"} <= set(_literal(T.CheckResult, "kind")) assert "ignored" in typing.get_args(T.Role) and "ignored_column" in typing.get_args(T.Role) assert typing.get_args(T.ExcludedReason) == ( "hidden_excluded", "blank_skipped", "ignored_rows", "ignored_outside", "after_stop", "total_not_kept", "subtotal") assert _literal(T.FixAnchor, "kind") == ("problem", "recipe_problem", "sheet_renamed") assert _literal(T.Anchor, "kind") == ( "header", "row_label", "section_title", "total_word", "axis", "after_title", "outside_text") assert _literal(T.EditResult, "kind") == ("fix", "selection") assert _literal(T.ChangeClass, "change") == ("same", "compatible", "retire", "semantic") assert T.FIX_KINDS[-2:] == ("declare_subtotals", "declare_text_measure") # 期 5、文字指标依次加在末尾 assert T.FIX_KINDS[:-2] == ("remove_label", "add_label", "edit_members", "rename_title", "declare_total", "ignore_cells", "declare_placeholder", "declare_hidden", "rename_sheet") assert T.SELECTION_AS == ("list", "crosstab", "segment", "derived", "section_title", "ignore_rows", "ignore_columns", "ignore_outside") assert T.ACCUMULATE_ACTIONS == ("replace", "first", "append", "replace_period", "restart", "rejected") # ---- Selection:JSON 里的键是 as def test_selection_json_key_is_as(): body = {"sheet": "月报", "ref": "C5:F8", "as": "list", "options": {"header_rows": 1, "bottom": "box"}} sel = T.Selection.from_json(body) assert (sel.sheet, sel.ref, sel.as_, sel.options) == ("月报", "C5:F8", "list", {"header_rows": 1, "bottom": "box"}) out = sel.to_json() assert out == body and "as_" not in out assert T.Selection.from_json({"sheet": "月报", "ref": "C5", "as": "ignore_rows"}).options == {} assert T.Selection.from_json({"sheet": "月报", "ref": "C5", "as": "ignore_rows", "options": None}).options == {} # 写成 as_ 的请求不认(JSON 里的键是 as):和别的形状错误一样抛 ValueError with pytest.raises(ValueError): T.Selection.from_json({"sheet": "月报", "ref": "C5", "as_": "list"}) # 不经 to_json 直接 asdict 得到的是 as_:接口层必须用 to_json assert "as_" in asdict(sel) @pytest.mark.parametrize("body", [ None, [], ["月报", "C5", "list"], "月报", {"ref": "C5", "as": "list"}, {"sheet": "", "ref": "C5", "as": "list"}, {"sheet": " ", "ref": "C5", "as": "list"}, {"sheet": 3, "ref": "C5", "as": "list"}, {"sheet": "月报", "as": "list"}, {"sheet": "月报", "ref": "", "as": "list"}, {"sheet": "月报", "ref": 5, "as": "list"}, {"sheet": "月报", "ref": "月报!C5", "as": "list"}, {"sheet": "月报", "ref": "c5", "as": "list"}, {"sheet": "月报", "ref": "$C$5", "as": "list"}, {"sheet": "月报", "ref": "C0", "as": "list"}, {"sheet": "月报", "ref": "C5:", "as": "list"}, {"sheet": "月报", "ref": "C:F", "as": "list"}, {"sheet": "月报", "ref": "C5", "as": "table"}, {"sheet": "月报", "ref": "C5", "as": None}, {"sheet": "月报", "ref": "C5", "as": ["list"]}, {"sheet": "月报", "ref": "C5", "as": "list", "options": "x"}, {"sheet": "月报", "ref": "C5", "as": "list", "options": [1]}, {"sheet": "月报", "ref": "C5", "as": "list", "options": [["header_rows", 1]]}, {"sheet": "月报", "ref": "C5", "as": "list", "options": 1}, ]) def test_selection_from_json_rejects_malformed_with_value_error_only(body): """评审:options 写成字符串、列表时原来抛的是 dict() 的 ValueError / TypeError,文档却只说 KeyError,接口层照 文档只接 KeyError 的话这些请求会变成 500。现在任何形状不对都只抛 ValueError(不是 KeyError、TypeError 的 子类),消息是给人看的中文,接口层 except ValueError → 422 edit_invalid。""" with pytest.raises(ValueError) as exc: T.Selection.from_json(body) assert type(exc.value) is ValueError assert any("一" <= ch <= "鿿" for ch in str(exc.value)) for word in ("sheet", "ref", "options", "as_", "SELECTION_AS"): assert word not in str(exc.value) @pytest.mark.parametrize("ref", ["C5", "C5:F8", "AA10:AB12", "XFD1048576", "A1:A1"]) def test_selection_from_json_accepts_a1_ranges(ref): for as_ in T.SELECTION_AS: assert T.Selection.from_json({"sheet": "月报", "ref": ref, "as": as_}).to_json() == { "sheet": "月报", "ref": ref, "as": as_, "options": {}} # ---- 9.2 每个 dataclass 的字段名、顺序和默认值(防止实现者改名;REQ = 必填) REQ = "<必填>" FACTORY = "<默认工厂>" def _shape(cls) -> list[tuple[str, object]]: out = [] for f in dataclasses.fields(cls): if f.default is not MISSING: out.append((f.name, f.default)) elif f.default_factory is not MISSING: out.append((f.name, FACTORY)) else: out.append((f.name, REQ)) return out CONTRACT_SHAPES = { "ExcludedRows": [("sheet", REQ), ("reason", REQ), ("rows", REQ), ("cells", REQ), ("anchor", None), ("block", None)], "NoteFragment": [("key", REQ), ("subject", REQ), ("template", REQ)], "FixOption": [("value", REQ), ("label", REQ), ("detail", ""), ("needs_reason", False), ("breaking", False)], "FixAnchor": [("kind", REQ), ("index", None), ("sheet", None)], "FixProposal": [("id", REQ), ("kind", REQ), ("problem_code", REQ), ("title", REQ), ("cells", REQ), ("target", REQ), ("options", REQ), ("anchor", REQ)], "Selection": [("sheet", REQ), ("ref", REQ), ("as_", REQ), ("options", FACTORY)], "Anchor": [("kind", REQ), ("text", REQ), ("cell", None)], "EditResult": [("ok", REQ), ("kind", REQ), ("key", REQ), ("title", REQ), ("summary", REQ), ("ops", REQ), ("anchors", REQ), ("notes", REQ), ("problems", REQ), ("recipe_sha256_after", None), ("expected", None), ("block", None), ("breaking", False)], "ReplayCompare": [("expected", REQ), ("actual", REQ), ("match", REQ), ("diffs", REQ), ("window_rows", None)], "ChangeClass": [("change", REQ), ("added", REQ), ("retired_new", REQ), ("retired_existing", REQ), ("semantic", REQ), ("label_sets", REQ)], "AccumulatePlan": [(n, REQ) for n in ( "mode", "action", "period", "parts", "replaces", "dropped", "overlaps", "gaps", "backfill", "change", "added", "retired_new", "retired_existing", "semantic", "label_sets", "mode_switch", "reason", "union")], "PartInfo": [(n, REQ) for n in ( "import_id", "seq", "start", "end", "build_id", "db_path", "db_sha256", "manifest_db_sha256", "recipe_id", "recipe", "recipe_sha256", "raw_state", "file_name", "manifest_artifact")] + [("rows", FACTORY), ("overrides", 0), ("waivers", 0)], "UnionPart": [("import_id", REQ), ("start", REQ), ("end", REQ), ("db_path", REQ), ("recipe", REQ), ("db_sha256", REQ), ("manifest_db_sha256", None), ("table_hashes", FACTORY)], "UnionReport": [(n, REQ) for n in ( "tables", "grains", "rows", "part_rows", "table_hashes", "null_counts", "part_null_counts", "added", "retired", "checks", "ok", "db_sha256")], "UnionNotePart": [(n, REQ) for n in ( "recipe", "extraction", "checks", "acceptances", "null_counts", "start", "end")], } @pytest.mark.parametrize("name", sorted(CONTRACT_SHAPES)) def test_p3_dataclass_shapes(name): assert _shape(getattr(T, name)) == CONTRACT_SHAPES[name] def test_p3_fields_added_to_p2_dataclasses(): """期 2 已有的 dataclass 只在末尾追加字段(位置构造照旧成立),新字段都有默认值。""" assert _shape(T.RegionMark)[-1] == ("block", None) and [n for n, _ in _shape(T.RegionMark)] == [ "sheet", "role", "ref", "block"] assert _shape(T.Problem)[-2:] == [("fix", None), ("fix_args", None)] assert _shape(T.Extraction)[-1] == ("rows_excluded", FACTORY) assert _shape(T.SchemaNotes) == [("tables", FACTORY), ("templates", FACTORY), ("problems", FACTORY), ("kinds", FACTORY), ("fragments", FACTORY)] assert _shape(T.ConfirmItem) == [("id", REQ), ("label", REQ), ("detail", ""), ("required", True), ("source", "recipe")] def test_p3_json_shapes_match_spec_examples(): """asdict 出来的键与 P3-SPEC 9.4 的 JSON 示例一致(dataclass 字段与 JSON 同名)。""" proposal = T.FixProposal( id="fx-1a2b3c4d5e6f", kind="remove_label", problem_code="label_missing", title="在分段「日间」的期望标签中去掉「7-8」", cells=["客流汇总!B10"], target={"segment": "日间", "labels": ["7-8"]}, options=[T.FixOption("remove", "去掉标签「7-8」", detail="今后各期如果又出现「7-8」,会再次拒收")], anchor=T.FixAnchor("problem", 0)) d = asdict(proposal) assert list(d) == ["id", "kind", "problem_code", "title", "cells", "target", "options", "anchor"] assert d["options"][0] == {"value": "remove", "label": "去掉标签「7-8」", "needs_reason": False, "breaking": False, "detail": "今后各期如果又出现「7-8」,会再次拒收"} assert d["anchor"] == {"kind": "problem", "index": 0, "sheet": None} plan_keys = {"mode", "action", "period", "parts", "replaces", "dropped", "overlaps", "gaps", "backfill", "change", "added", "retired_new", "retired_existing", "semantic", "label_sets", "mode_switch", "reason", "union"} assert {f.name for f in dataclasses.fields(T.AccumulatePlan)} == plan_keys replay = asdict(T.ReplayCompare({"header": "C5:F5"}, {"header": "C5:F5"}, True, [])) assert set(replay) == {"expected", "actual", "match", "diffs", "window_rows"} ex_rows = asdict(T.ExcludedRows("客流汇总", "ignored_rows", [[32, 32]], 3, anchor="补录(人次)", block="交叉表")) assert ex_rows == {"sheet": "客流汇总", "reason": "ignored_rows", "rows": [[32, 32]], "cells": 3, "anchor": "补录(人次)", "block": "交叉表"} # ---- 期 2 基线(WP-1 的测试常量;这里先确认现在的代码能复现,免得基线本身算错) def test_p2_baseline_reproduces(): from app.data import raw_store, recipe_engine, table_versions, xlsx_scan from tests.fixtures.xlsx.flow import flow_workbook raw, name = flow_workbook(dt.date(2026, 8, 1), 31) assert name == P2_BASELINE["fixture"]["file_name"] assert hashlib.sha256(raw).hexdigest() == P2_BASELINE["fixture"]["raw_sha256"] with tempfile.TemporaryDirectory() as d: db = Path(d) / "d00.db" ex = recipe_engine.execute(T.Recipe.model_validate(FLOW), raw, name, xlsx_scan.scan(raw), str(db)) table_versions.settle_journal(db) assert ex.ok assert baseline_file_hash(db, writer_version=P2_BASELINE["sqlite_writer_version"]) == P2_BASELINE["db_sha256"] assert ex.table_hashes == P2_BASELINE["table_hashes"] assert {t.name: t.rows for t in ex.tables} == P2_BASELINE["rows"] ids = P2_BASELINE["ids"] raw_sha = P2_BASELINE["fixture"]["raw_sha256"] assert table_versions.recipe_build_id(ids["source_id"], raw_sha, REF_RECIPE_SHA, {}) == ids["recipe_build_id"] # 参考配方(交叉表)不带执行器语义标记(WP-8 评审意见 1):提交路径按配方算出的构建 id 仍是基线记的那个 marks = table_versions.recipe_engine_semantics(T.Recipe.model_validate(FLOW)) assert marks == {} assert table_versions.recipe_build_id(ids["source_id"], raw_sha, REF_RECIPE_SHA, {}, semantics=marks) == ids["recipe_build_id"] assert table_versions.snapshot_id(ids["source_id"], ids["import_ids"], T.RECIPE_ENGINE_VER) == ids["snapshot_id_recipe"] assert table_versions.snapshot_id(ids["source_id"], ids["import_ids"]) == ids["snapshot_id_simple"]