"""证据内核:引用标记的解析、目录、渲染、切块切句切片段、裸数字,以及独立复核。 这一层是纯函数,报告节点自查、出口契约复核、证据接口都用它。所以这里守的是 「同样的输入永远得到同样的结果」和「复核不信任文档自己的说法」两件事。 """ from __future__ import annotations import copy import pytest from app.core.artifact_store import canonical_json, content_hash from app.engine.evidence import ( DOC_SCHEMA, LATER_REASON, MARKER_MAX, RenderError, StreamRenderer, build_catalog, catalog_prompt, compose_doc, describe_violations, find_segment, input_eid, iter_segments, make_eid, parse_markers, render_markers, render_number, verify_doc, ) # -------------------------------------------------------------------------- # 夹具:一张口径卡的产出(形状同 metrics 节点),外加运行输入 # -------------------------------------------------------------------------- ART = "a" * 64 def metric(mid, name, value, unit="", decimals=None, fmt="thousands", status="ok"): return {"id": mid, "name": name, "unit": unit, "value": value, "decimals": decimals, "format": fmt, "status": status, "expression": "…"} CARD = { "kind": "metric_set", "caliber": "周报口径", "caliber_version": "v2", "artifact": ART, "metrics": [ metric("gmv", "销售额", 45678.5, "元", 1), metric("wow", "环比增幅", 8.7, "%", 1, "plain"), metric("orders", "订单数", 1234, "单"), metric("aov", "客单价", 37, "元", 1), metric("refund_rate", "退款率", 0.0235, "", 4, "percent_of_ratio"), metric("big", "大数", 45678.5), metric("gone", "缺数", None, status="missing_input"), ], } LEDGER = [{"kind": "metric_set", "node_id": "caliber", "exec": 1, "artifact": ART, "caliber": "周报口径", "version": "v2", "metrics": [m["id"] for m in CARD["metrics"]]}] NODES = {"caliber": CARD, "fetch": {"text": "上游笔记 999"}} INPUTS = {"week": "2026-W37", "region": "华东", "rows": [1, 2]} @pytest.fixture def catalog(): return build_catalog(nodes=NODES, ledger=LEDGER, inputs=INPUTS) def texts(doc): return [s["text"] for s in iter_segments(doc)] def codes(doc): return [v["code"] for v in doc["violations"]] # -------------------------------------------------------------------------- # 标记语法 # -------------------------------------------------------------------------- def test_markers_parse(): text = ("销售额 [[m:gmv]],折合 [[m:gmv|万]]。[[see:m:gmv, m:wow,Q4]] 周期 [[i:week]]," "[[v:Q4.r0.amount]] [[t:orders]] [[c:orders.amount]] [[q:K2|原话。]] " "[[table:Q4 cols=a,b rows=0-4]] [[metric:gmv]] [[注意]]") found = parse_markers(text) assert [(m["kind"], m.get("ref")) for m in found] == [ ("m", "gmv"), ("m", "gmv"), ("see", None), ("i", "week"), ("v", "Q4.r0.amount"), ("t", "orders"), ("c", "orders.amount"), ("q", "K2"), ("table", "Q4"), ("metric", "gmv")] assert found[1]["conv"] == "万" assert found[2]["refs"] == ["m:gmv", "m:wow", "Q4"] assert found[7]["quote"] == "原话。" assert found[8]["options"] == {"cols": "a,b", "rows": "0-4"} for m in found: assert text[m["start"]:m["end"]] == m["raw"] # -------------------------------------------------------------------------- # 目录与 eid # -------------------------------------------------------------------------- def test_catalog_entries_and_stable_eids(catalog): gmv = catalog["m:gmv"] assert gmv["kind"] == "metric" and gmv["node_id"] == "caliber" and gmv["artifact"] == ART assert gmv["locator"] == {"metric": "gmv"} and gmv["caliber"] == "周报口径" and gmv["version"] == "v2" assert gmv["rendered"] == "45,678.5元" and gmv["label"] == "销售额 = 45,678.5元" assert gmv["eid"] == make_eid("metric", ART, {"metric": "gmv"}) assert gmv["eid"].startswith("ev:metric:") and len(gmv["eid"]) == len("ev:metric:") + 16 assert catalog["i:week"]["value"] == "2026-W37" and catalog["i:week"]["kind"] == "input" assert "i:rows" not in catalog # 容器型输入没法写进一句话 # 同一输入,eid 一个字不差 again = build_catalog(nodes=copy.deepcopy(NODES), ledger=copy.deepcopy(LEDGER), inputs=dict(INPUTS)) assert {k: v["eid"] for k, v in again.items()} == {k: v["eid"] for k, v in catalog.items()} # 内容变了,eid 跟着变 other = build_catalog(nodes={"caliber": {**CARD, "artifact": "b" * 64}}, ledger=[{**LEDGER[0], "artifact": "b" * 64}], inputs=INPUTS) assert other["m:gmv"]["eid"] != gmv["eid"] def test_catalog_respects_metrics_from_and_allowed(): second = {**CARD, "caliber": "月报口径", "artifact": "c" * 64, "metrics": [metric("gmv", "销售额", 1.0), metric("mau", "月活", 9)]} nodes = {**NODES, "monthly": second} ledger = [*LEDGER, {**LEDGER[0], "node_id": "monthly", "artifact": "c" * 64}] both = build_catalog(nodes=nodes, ledger=ledger) # 两张卡都有 gmv:不许按先来后到默认给一个,只登记带卡名的写法 assert "m:gmv" not in both assert both["m:caliber.gmv"]["value"] == 45678.5 and both["m:monthly.gmv"]["value"] == 1.0 assert both["m:mau"]["node_id"] == "monthly" only = build_catalog(nodes=nodes, ledger=ledger, metrics_from=["monthly"]) assert only["m:gmv"]["node_id"] == "monthly" and "m:orders" not in only upstream = build_catalog(nodes=nodes, ledger=ledger, allowed={"caliber"}) assert "m:mau" not in upstream and upstream["m:gmv"]["node_id"] == "caliber" # -------------------------------------------------------------------------- # 渲染 # -------------------------------------------------------------------------- def test_rendering(catalog): raw = ("本周([[i:week]])销售额 [[m:gmv]],环比 [[m:wow]];订单 [[m:orders]],客单价 [[m:aov]]。" "[[see:m:gmv,m:wow]]\n\n退款率 [[m:refund_rate]],大数折合 [[m:big|万]],销售额折合 [[m:gmv|万]]。") doc = compose_doc(raw, catalog, node_id="write", run_id="r1") assert doc["schema"] == DOC_SCHEMA and doc["node_id"] == "write" and doc["run_id"] == "r1" assert doc["markdown"] == ("本周(2026-W37)销售额 45,678.5元,环比 8.7%;订单 1,234单,客单价 37.0元。" "\n\n退款率 2.35%,大数折合 4.57万,销售额折合 4.57万元。") assert doc["violations"] == [] and doc["stats"]["numbers_cited"] == 7 seg = next(s for s in iter_segments(doc) if s["text"] == "45,678.5元") assert seg["kind"] == "number" and seg["state"] == "deterministic" and seg["ref"] == "m:gmv" assert seg["cite"]["status"] == "resolved" and seg["cite"]["value"] == 45678.5 assert seg["cite"]["eid"] == catalog["m:gmv"]["eid"] and seg["cite"]["alias"] == "m:gmv" week = next(s for s in iter_segments(doc) if s["text"] == "2026-W37") assert week["kind"] == "value" and week["ref"] == "i:week" def _one_metric_catalog(value, unit="", decimals=None, fmt="thousands"): card = {**CARD, "metrics": [metric("small", "小值", value, unit, decimals, fmt)]} return build_catalog(nodes={"caliber": card}, ledger=LEDGER) @pytest.mark.parametrize("value, unit, decimals, fmt, conv", [ (29, "单", None, "thousands", "万"), # 0.0029万 → 显示成「0万单」 (45678.5, "元", 1, "thousands", "亿"), # 0.000456785亿 → 「0亿元」 (0.004, "", None, "thousands", "int"), (-0.004, "", None, "thousands", ".2"), (0.00004, "", None, "thousands", "pct"), # 0.004% 按一位小数是 0.0% (0.00004, "", 4, "percent_of_ratio", "万"), # 比率不能换算(这条本来就解析不了) ]) def test_conversions_never_show_a_nonzero_value_as_zero(value, unit, decimals, fmt, conv): """系统渲染的数带着「有出处」的实线:把 29 单换算成「0万单」再标成有出处,比模型 自己编一个数还糟——读者没有任何理由怀疑它。显示成 0 的非零值一律算解析不了。""" cat = _one_metric_catalog(value, unit, decimals, fmt) doc = compose_doc(f"数值 [[m:small|{conv}]]。", cat) seg = next(s for s in iter_segments(doc) if s.get("ref")) assert seg["state"] == "none" and seg["issue"] == "unresolved_ref", seg assert seg["cite"]["status"] == "unresolved" assert codes(doc) == ["unresolved_ref"] assert seg["text"] == f"⟦?m:small|{conv}⟧" if fmt != "percent_of_ratio": assert "显示为 0" in seg["cite"]["reason"] and "精度不够" in seg["cite"]["reason"] def test_values_that_cannot_be_shown_are_flagged_in_the_catalog_and_prompt(): cat = _one_metric_catalog(1e-12) assert cat["m:small"]["rendered"] == "—" and cat["m:small"]["value"] == 1e-12 assert "[[m:small]] 小值:按口径卡的格式显示不出来,不要引用" in catalog_prompt(cat) doc = compose_doc("小值 [[m:small]]。", cat) assert codes(doc) == ["unresolved_ref"] and "显示为 0" in doc["violations"][0]["message"] def test_zero_guard_only_fires_for_nonzero_values(): assert render_number(0, conv="万") == "0万" assert render_number(0.0, conv="int") == "0" assert render_number(-0.0, conv=".2") == "0.00" assert render_number(50, unit="单", conv="万") == "0.01万单" # 四舍五入到 0.01,不是 0 assert render_number(0.005, conv=".2") == "0.01" with pytest.raises(RenderError, match="显示为 0"): render_number(1e-12) # 不写小数位时最多留 10 位 with pytest.raises(RenderError, match="显示为 0"): render_number(29, decimals=-2) # 口径卡自己的小数位把它抹成 0 也一样 @pytest.mark.parametrize("value, expected", [ (1e55, f"{10 ** 55:,}"), (9e14 ** 4, f"{6561 * 10 ** 56:,}"), (10 ** 70 + 1, f"{10 ** 70 + 1:,}"), # 超过 60 位有效数字也不能被悄悄舍入 (-(10 ** 65) - 7, f"{-(10 ** 65) - 7:,}"), ]) def test_huge_values_render_exactly(value, expected): assert render_number(value) == expected def test_huge_values_with_conversions_and_decimals(): assert render_number(10 ** 40 + 12345, conv="万") == f"{10 ** 36 + 1:,}.23万" assert render_number(10 ** 40 + 1, conv="pct") == f"{(10 ** 40 + 1) * 100:,}.0%" assert render_number(1e55, decimals=2) == f"{10 ** 55:,}.00" assert render_number(12345.678, decimals=-2) == "12,300" with pytest.raises(RenderError): render_number(10 ** 5000) # 大到不像话:说清楚,而不是抛 InvalidOperation with pytest.raises(RenderError): render_number(1.5, decimals=10 ** 6) def test_input_eids_are_derived_from_the_value(): w37 = build_catalog(nodes={}, inputs={"week": "2026-W37"})["i:week"] w38 = build_catalog(nodes={}, inputs={"week": "2026-W38"})["i:week"] again = build_catalog(nodes={}, inputs={"week": "2026-W37"})["i:week"] assert w37["eid"] != w38["eid"] and w37["eid"] == again["eid"] assert w37["eid"] == input_eid("week", "2026-W37") # 目录条目自己就能复算:值被改过,eid 就对不上 assert w37["eid"] == make_eid("input", content_hash(canonical_json(w37["value"])), w37["locator"]) # 同一个值换一个字段名也是另一件证据 assert build_catalog(nodes={}, inputs={"period": "2026-W37"})["i:period"]["eid"] != w37["eid"] @pytest.mark.parametrize("empty", [[], ""]) def test_empty_metrics_from_means_every_card(empty): """validate_graph 把 metrics_from=[] 当成「所有上游口径卡」,目录要是当成「一张都不要」, 报告就一个数都写不出来,而画布上什么都不提示。两边必须同一个意思。""" full = build_catalog(nodes=NODES, ledger=LEDGER, metrics_from=None) assert build_catalog(nodes=NODES, ledger=LEDGER, metrics_from=empty) == full assert "m:gmv" in full def test_unresolved_references(catalog): doc = compose_doc("销售额 [[m:gmvx]],缺数 [[m:gone]],单元格 [[v:Q4.r0.amount]]," "输入 [[i:nope]],换算 [[m:wow|pct]],[[metric:gmv]]。", catalog) assert doc["markdown"] == ("销售额 ⟦?m:gmvx⟧,缺数 —,单元格 ⟦?v:Q4.r0.amount⟧," "输入 ⟦?i:nope⟧,换算 ⟦?m:wow|pct⟧,⟦?metric:gmv⟧。") bad = [v for v in doc["violations"] if v["code"] == "unresolved_ref"] assert [v["ref"] for v in bad] == ["m:gmvx", "m:gone", "v:Q4.r0.amount", "i:nope", "m:wow|pct", "metric:gmv"] reasons = {v["ref"]: v["message"] for v in bad} assert "gmvx" in reasons["m:gmvx"] assert "没有值" in reasons["m:gone"] assert "查询结果 Q4 不存在" in reasons["v:Q4.r0.amount"] # 单元格二期起支持,这份目录里没有 Q4 assert "百分数" in reasons["m:wow|pct"] for s in iter_segments(doc): if s.get("ref"): assert s["state"] == "none" and s["cite"]["status"] == "unresolved" and s["issue"] == "unresolved_ref" assert doc["stats"]["unresolved"] == 6 and doc["stats"]["numbers_cited"] == 0 def test_see_refs_are_checked_but_not_rendered(catalog): doc = compose_doc("销售额见口径卡。[[see:m:gmv,i:week,gmv,m:nope,t:refunds]]下面看退款。", catalog) assert doc["markdown"] == "销售额见口径卡。下面看退款。" first = doc["blocks"][0]["units"][0] assert [c["alias"] for c in first["see"] if c["status"] == "resolved"] == ["m:gmv", "i:week", "m:gmv"] assert first["cites"] == ["m:gmv", "i:week"] bad = {v["ref"]: v["message"] for v in doc["violations"]} assert set(bad) == {"m:nope", "t:refunds"} and LATER_REASON in bad["t:refunds"] assert doc["blocks"][0]["units"][1]["cites"] == [] # -------------------------------------------------------------------------- # 裸数字 # -------------------------------------------------------------------------- def test_bare_numbers_are_violations_with_offsets(catalog): doc = compose_doc("销售额 [[m:gmv]],增长 12%,客户两千五百家。", catalog) bare = [v for v in doc["violations"] if v["code"] == "uncited_number"] assert [v["text"] for v in bare] == ["12%", "两千五百"] for v in bare: assert doc["markdown"][v["span"][0]:v["span"][1]] == v["text"] assert v["unit"] == "u0" and v["segment"] seg = next(s for s in iter_segments(doc) if s["text"] == "12%") assert seg["kind"] == "number" and seg["state"] == "none" and seg["issue"] == "uncited_number" assert "ref" not in seg assert doc["stats"]["uncited_numbers"] == 2 and doc["stats"]["numbers"] == 3 def test_dates_weeks_structural_and_allowed_numbers_pass(catalog): doc = compose_doc("2026-09-27 发布,覆盖 2026-W37,2026年9月的数据。前 3 名、第 2 季度、Top 5、" "从 3 个方面看,时间 10:30。客单价 37 元,编号 120。原因有两点:1、价格(2)渠道。", catalog, allow_numbers=["37", "120"]) assert codes(doc) == [], doc["violations"] # 结构性数字限 20 以内:前 30 名就得有出处 doc = compose_doc("前 30 名。", catalog) assert [v["text"] for v in doc["violations"]] == ["30"] def test_numbers_in_structure_do_not_count_and_cannot_hide(catalog): """行首序号按出具校验的规则放过(1–2 位);再大的序号前端照样显示成
    , 不能借「这是列表语法」躲过裸数字检查。""" raw = ("1. 第一项 [[m:orders]]\n2. 第二项 7 单\n\n| 区域 | 金额 |\n| --- | --- |\n| 甲 | 8 |\n\n" "100. 编号从这里开始的列表\n101. 下一项") doc = compose_doc(raw, catalog) assert [v["text"] for v in doc["violations"]] == ["7", "8", "100", "101"] assert doc["blocks"][-1]["start"] == 100 assert not INTEGRITY & set(codes(doc)) # 违规指向的是那个序号所在的结构片段,偏移切得回原字 for v in doc["violations"][2:]: assert doc["markdown"][v["span"][0]:v["span"][1]] == v["text"] seg = find_segment(doc, v["segment"])[2] assert seg["kind"] == "structural" and v["text"] in seg["text"] @pytest.mark.parametrize("raw, bare", [ ("45678. 本周销售额创新高", ["45678"]), ("段落\n\n98765) 订单", ["98765"]), ("12. 序号照旧放过\n13. 下一项", []), (" 3) 缩进的序号", []), ("```45678\nx\n```", ["45678"]), # 代码块的语言标签显示在块头上 ("```py3\nx\n```", []), # 和正文同一条规则:v2 / py3 这类标识符不算数字 ("```\nx\n```", []), ("1234567890. 很长的序号", ["1234567890"]), # 切块认它是列表,复核也得认它是语法 # 表格第一格不在行首:竖线涂白后不能让「12.」沾行首序号免检的光 ("| 序号 | 区域 |\n| --- | --- |\n| 12. | 华东 |", ["12"]), ("> 3. 引用里的序号", []), ]) def test_ordinals_and_fence_labels_follow_the_prose_rules(catalog, raw, bare): doc = compose_doc(raw, catalog) assert [v["text"] for v in doc["violations"] if v["code"] == "uncited_number"] == bare assert not INTEGRITY & set(codes(doc)), doc["violations"] again = verify_doc(copy.deepcopy(doc), catalog) assert again["violations"] == doc["violations"] # -------------------------------------------------------------------------- # 切块、切句、切片段 # -------------------------------------------------------------------------- REPORT = """## 本周概览 本周([[i:week]])销售额 [[m:gmv]],环比 [[m:wow]]。[[see:m:gmv,m:wow]]增长主要来自新客首单。下面看退款情况。 - 订单 [[m:orders]] (含预售) - 客单价 **[[m:aov]]** | 指标 | 值 | | --- | :-: | | 退款率 | [[m:refund_rate]] | | 大数 | [[m:big|万]] | > 口径说明:[[i:region]]。 > 第二行。 ``` code 块 ``` ---""" def test_segments_tile_the_markdown(catalog): doc = compose_doc(REPORT, catalog) joined = "".join(texts(doc)) assert joined == doc["markdown"] pos = 0 for seg in iter_segments(doc): assert seg["span"][0] == pos and doc["markdown"][seg["span"][0]:seg["span"][1]] == seg["text"] pos = seg["span"][1] assert pos == len(doc["markdown"]) assert doc["violations"] == [], doc["violations"] def test_doc_is_json_and_content_addressable(catalog): """报告节点要把文档 put_json 成 report_doc 工件:必须能序列化,同样的原文得到同样的哈希。""" from app.core.artifact_store import canonical_json, content_hash first = content_hash(canonical_json(compose_doc(REPORT, catalog, node_id="write", run_id="r1"))) fresh = build_catalog(nodes=copy.deepcopy(NODES), ledger=copy.deepcopy(LEDGER), inputs=dict(INPUTS)) assert content_hash(canonical_json(compose_doc(REPORT, fresh, node_id="write", run_id="r1"))) == first def test_blocks_units_and_kinds(catalog): doc = compose_doc(REPORT, catalog) blocks = doc["blocks"] assert [b["type"] for b in blocks] == ["heading", "paragraph", "list", "table", "quote", "code", "hr"] assert [b["id"] for b in blocks] == [f"b{i}" for i in range(7)] heading, para, lst, table, quote, code, hr = blocks assert heading["level"] == 2 and heading["units"][0]["kind"] == "heading" h_unit = heading["units"][0] assert doc["markdown"][h_unit["span"][0]:h_unit["span"][1]] == "本周概览" # 句子按句号切;[[see:]] 挂在它前面那一句;连接性的话单独成一句 sentences = [doc["markdown"][u["span"][0]:u["span"][1]] for u in para["units"]] assert sentences == ["本周(2026-W37)销售额 45,678.5元,环比 8.7%。", "增长主要来自新客首单。", "下面看退款情况。"] assert [u["kind"] for u in para["units"]] == ["claim", "claim", "connective"] assert para["units"][0]["cites"] == ["i:week", "m:gmv", "m:wow"] # 列表每项一个 unit,续行接在同一项里 assert lst["ordered"] is False and len(lst["units"]) == 2 first_item = "".join(s["text"] for s in lst["units"][0]["segments"] if s["kind"] != "structural") assert first_item == "订单 1,234单\n(含预售)" # **[[m:aov]]** 归一成 strong,正文里不留星号 aov = next(s for s in iter_segments(doc) if s.get("ref") == "m:aov") assert aov["strong"] is True and "**" not in doc["markdown"] # 表格每格一个 unit,带行列;表头 row = -1 locs = [(u["loc"]["row"], u["loc"]["col"]) for u in table["units"]] assert locs == [(-1, 0), (-1, 1), (0, 0), (0, 1), (1, 0), (1, 1)] assert any(s.get("ref") == "m:big|万" for s in table["units"][5]["segments"]) assert [u["kind"] for u in quote["units"]] == ["claim", "connective"] assert code["units"][0]["kind"] == "code" and hr["units"][0]["kind"] == "connective" # 编号全局连续 unit_ids = [u["id"] for b in blocks for u in b["units"]] assert unit_ids == [f"u{i}" for i in range(len(unit_ids))] seg_ids = [s["id"] for s in iter_segments(doc)] assert seg_ids == [f"s{i}" for i in range(len(seg_ids))] block, unit, seg = find_segment(doc, aov["id"]) assert block["id"] == "b2" and unit["id"] == lst["units"][1]["id"] and seg is aov def test_bold_around_markers_becomes_strong_segments(catalog): """**销售额 [[m:gmv]]**:数字切成单独的片段后,两边各剩半对星号,前端只能原样显示。 星号去掉、里面的每一段都标 strong;不含标记的粗体原样留在文字里。""" doc = compose_doc("前面 **销售额 [[m:gmv]]** 后面,__[[m:refund_rate]]__,**重点** 不动。", catalog) assert doc["markdown"] == "前面 销售额 45,678.5元 后面,2.35%,**重点** 不动。" flags = [(s["text"], bool(s.get("strong"))) for s in iter_segments(doc)] assert flags == [("前面 ", False), ("销售额 ", True), ("45,678.5元", True), (" 后面,", False), ("2.35%", True), (",**重点** 不动。", False)] assert doc["violations"] == [] def test_sentence_ends_inside_code_links_bold_and_markers_do_not_split(catalog): doc = compose_doc("看 `x. y` 和 [链接](http://a.b/?q=1) 还有 **重点。强调** 以及 [[q:K2|原话。]] 结束。第二句。", catalog) sentences = [doc["markdown"][u["span"][0]:u["span"][1]] for u in doc["blocks"][0]["units"]] assert sentences == ["看 `x. y` 和 [链接](http://a.b/?q=1) 还有 **重点。强调** 以及 ⟦?q:K2|原话。⟧ 结束。", "第二句。"] # 链接地址以问号结尾:问号在链接里,不能因为它后面紧跟链接的右括号就在链接后面断句 doc = compose_doc("见[文档](http://a.b/?) 然后继续。", catalog) assert len(doc["blocks"][0]["units"]) == 1 def test_offsets_are_code_points(catalog): doc = compose_doc("😀🎉 销售额 [[m:gmv]],另有 7 单。", catalog) seg = next(s for s in iter_segments(doc) if s.get("ref") == "m:gmv") assert seg["span"] == [7, 16] and doc["markdown"][7:16] == "45,678.5元" assert doc["violations"][0]["span"] == [20, 21] and doc["markdown"][20] == "7" def test_pipes_inside_markers_do_not_split_table_cells(catalog): doc = compose_doc("| a | b |\n| - | - |\n| [[m:gmv|万]] | x |", catalog) cells = doc["blocks"][0]["units"] assert [u["loc"] for u in cells][2:] == [{"row": 0, "col": 0}, {"row": 0, "col": 1}] assert doc["markdown"] == "| a | b |\n| - | - |\n| 4.57万元 | x |" # -------------------------------------------------------------------------- # verify_doc:独立复核,不信任文档自己的说法 # -------------------------------------------------------------------------- def test_verify_doc_agrees_with_compose(catalog): doc = compose_doc(REPORT + "\n\n另有 7 单。", catalog) again = verify_doc(copy.deepcopy(doc), catalog) assert again["violations"] == doc["violations"] and again["stats"] == doc["stats"] assert again["ok"] is False and [v["code"] for v in again["violations"]] == ["uncited_number"] def test_verify_doc_catches_tampering(catalog): doc = compose_doc("销售额 [[m:gmv]],订单 [[m:orders]]。", catalog) assert verify_doc(doc, catalog)["ok"] is True # 1) 数字片段的字被改了:重渲染对不上 forged = copy.deepcopy(doc) seg = next(s for s in iter_segments(forged) if s.get("ref") == "m:gmv") shift = len("99,999.9元") - len(seg["text"]) old_end = seg["span"][1] forged["markdown"] = forged["markdown"].replace("45,678.5元", "99,999.9元") seg["text"], seg["span"][1] = "99,999.9元", seg["span"][1] + shift for s in iter_segments(forged): if s["span"][0] >= old_end: s["span"] = [s["span"][0] + shift, s["span"][1] + shift] assert "render_mismatch" in [v["code"] for v in verify_doc(forged, catalog)["violations"]] # 2) 把裸数字塞进文字片段、又不标出来:复核自己去正文里找 hidden = copy.deepcopy(doc) last = list(iter_segments(hidden))[-1] last["text"] += "另有 7 单" hidden["markdown"] += "另有 7 单" last["span"][1] = len(hidden["markdown"]) assert [v["code"] for v in verify_doc(hidden, catalog)["violations"]] == ["uncited_number"] # 3) 片段接不上正文 broken = copy.deepcopy(doc) broken["markdown"] = broken["markdown"] + "尾巴" assert "segment_mismatch" in [v["code"] for v in verify_doc(broken, catalog)["violations"]] # 3b) 中间一段的字和它记的位置对不上 / 少了一段 swapped = copy.deepcopy(doc) next(s for s in iter_segments(swapped) if s["kind"] == "text")["text"] = "换掉的" assert "segment_mismatch" in [v["code"] for v in verify_doc(swapped, catalog)["violations"]] dropped = copy.deepcopy(doc) dropped["blocks"][0]["units"][0]["segments"].pop(1) assert "segment_mismatch" in [v["code"] for v in verify_doc(dropped, catalog)["violations"]] # 4) 结构片段里夹带数字 smuggled = copy.deepcopy(doc) first = next(iter_segments(smuggled)) smuggled["markdown"] = "12345" + smuggled["markdown"] for s in iter_segments(smuggled): s["span"] = [s["span"][0] + 5 if s is not first else 0, s["span"][1] + 5] first["text"] = "12345" + first["text"] first["kind"] = "structural" assert "structural_text" in [v["code"] for v in verify_doc(smuggled, catalog)["violations"]] # 5) 目录里的 eid 被换了 fake = copy.deepcopy(doc) next(s for s in iter_segments(fake) if s.get("ref") == "m:gmv")["cite"]["eid"] = "ev:metric:0000000000000000" assert "eid_mismatch" in [v["code"] for v in verify_doc(fake, catalog)["violations"]] # 6) 状态标错:没有出处的地方标成「有出处」,界面就会画成确定的实线 lying = copy.deepcopy(compose_doc("销售额 [[m:gmv]],另有 7 单。", catalog)) bare = next(s for s in iter_segments(lying) if s.get("issue") == "uncited_number") bare["state"] = "deterministic" next(s for s in iter_segments(lying) if s["kind"] == "text")["state"] = "deterministic" assert sorted(v["code"] for v in verify_doc(lying, catalog)["violations"]) \ == ["state_mismatch", "state_mismatch", "uncited_number"] # 7) 不认识的文档 assert [v["code"] for v in verify_doc({**doc, "schema": "x"}, catalog)["violations"]][:1] == ["bad_schema"] def test_verify_doc_uses_the_catalog_it_is_given(catalog): """出口复核拿自己重建的目录:口径卡的值变了,文档里的旧数字就对不上。""" doc = compose_doc("销售额 [[m:gmv]]。", catalog) changed = build_catalog( nodes={"caliber": {**CARD, "metrics": [metric("gmv", "销售额", 1.5, "元", 1)]}}, ledger=LEDGER, inputs=INPUTS) assert [v["code"] for v in verify_doc(doc, changed)["violations"]] == ["render_mismatch"] assert [v["code"] for v in verify_doc(doc, {})["violations"]] == ["unresolved_ref"] # -------------------------------------------------------------------------- # 流式渲染 # -------------------------------------------------------------------------- @pytest.mark.parametrize("cut", range(1, 12)) def test_stream_renderer_never_leaks_raw_markers(catalog, cut): raw = "销售额 [[m:gmv]],折合 [[m:gmv|万]]。[[see:m:gmv]] 未知 [[m:x]] 字面 [[ 和 [ 结束" chunks = [raw[i:i + cut] for i in range(0, len(raw), cut)] renderer = StreamRenderer(catalog) out = [renderer.feed(c) for c in chunks] + [renderer.flush()] for piece in out: assert "[[m:" not in piece and "[[see:" not in piece, out assert "".join(out) == render_markers(raw, catalog) assert "".join(out) == "销售额 45,678.5元,折合 4.57万元。 未知 ⟦?m:x⟧ 字面 [[ 和 [ 结束" @pytest.mark.parametrize("body", [ "x" * 170, # 比能缓冲的还长:两边都当普通文字 "x" * (MARKER_MAX - len("[[m:]]")), # 恰好到上限:两边都当标记 "x" * (MARKER_MAX - len("[[m:]]") + 1), # 超出一个字 "gmv|万" + " " * (MARKER_MAX - len("[[m:gmv|万]]")), ]) def test_stream_output_equals_the_full_render_for_markers_of_any_length(catalog, body): raw = f"a [[m:{body}]] b [[see:{body}]] c" full = render_markers(raw, catalog) for size in (1, 2, 7, 50, len(raw)): renderer = StreamRenderer(catalog) out = [renderer.feed(raw[i:i + size]) for i in range(0, len(raw), size)] + [renderer.flush()] assert "".join(out) == full, (size, out) over = len(f"[[m:{body}]]") > MARKER_MAX assert (f"[[m:{body}]]" in full) is over # 超长的不是标记,原样留着 assert all(len(m["raw"]) <= MARKER_MAX for m in parse_markers(raw)) def _stream_corpus(n: int) -> list[str]: import random rng = random.Random(20260929) pieces = ["[[m:gmv]]", "[[m:gmv|万]]", "[[see:m:wow]]", "[[", "]]", "[", "]", "\n", "文字", " ", "[[m:" + "y" * 150, "[[see:" + "z" * 160 + "]]", "[[i:week]]", "[[m:x" + "q" * 155 + "]]"] return ["".join(rng.choice(pieces) for _ in range(rng.randint(1, 12))) for _ in range(n)] @pytest.mark.parametrize("raw", _stream_corpus(120)) def test_stream_renderer_matches_render_markers_on_random_input(catalog, raw): import random rng = random.Random(raw) for _ in range(3): renderer, out, i = StreamRenderer(catalog), [], 0 while i < len(raw): step = rng.randint(1, 40) out.append(renderer.feed(raw[i:i + step])) i += step out.append(renderer.flush()) assert "".join(out) == render_markers(raw, catalog) def test_stream_renderer_releases_a_long_unclosed_bracket(catalog): renderer = StreamRenderer(catalog) first = renderer.feed("开头 [[" + "很长的正文" * 40) assert first.startswith("开头 [[") # 不会一直憋着不发 assert renderer.feed("\n下一行") and renderer.flush() == "" # -------------------------------------------------------------------------- # 给报告节点用的辅助 # -------------------------------------------------------------------------- def test_catalog_prompt_and_violation_text(catalog): prompt = catalog_prompt(catalog) assert "[[m:gmv]]" in prompt and "45,678.5元" in prompt and "周报口径 @ v2" in prompt assert "[[i:week]]" in prompt and "2026-W37" in prompt assert "[[m:gone]]" in prompt and "没有值" in prompt doc = compose_doc("增长 12%,[[m:gmvx]]。", catalog) text = describe_violations(doc["violations"]) assert "12%" in text and "gmvx" in text # -------------------------------------------------------------------------- # 性质:什么样的原文进来,片段都铺满正文,组装和复核的结论一致,自己不制造完整性问题 # -------------------------------------------------------------------------- AWKWARD = [ "", " \n\n ", "[[see:m:gmv]]", "---", "```py\nx = 1", "```\n```", "| a | |\n|---|---|\n| | [[m:gmv]] |", "- a\n - b [[m:orders]]\n 续行\n- c", "3. 三\n4. 四", "# 标题 [[m:gmv]] ", "## ", "[[m:orders]]. 第一句。", "a\r\nb\r\n", "开头 [[ 没闭合", "**加粗 [[m:gmv]] 里面**。", "> a\n>\n> b [[m:gmv]]", "[[see:m:gmv]] 开头。", "e.g. 3.5 和 v2. 结束", "表格 | 不是 | 表格", "| x |\n| y |", "__[[m:gmv]]__ 与 ** [[m:wow]] **", "`code 12` 和 [link](http://x.y/12)", "多个\n\n\n\n段落", "[[m:gmv|万]]|[[m:gmv]]", "1) 一\n2) 二", ] def _random_corpus(n: int) -> list[str]: import random rng = random.Random(20260928) alphabet = [*"我们。!?\n- *#>|`[]:0123456789 .,,、()_", "[[m:gmv]]", "[[see:m:wow]]", "[[i:week]]", "[[m:refund_rate]]", "**", "__", "```", "---", "| a |", "\n\n", "[[v:Q1.r0.x]]"] return ["".join(rng.choice(alphabet) for _ in range(rng.randint(1, 40))) for _ in range(n)] INTEGRITY = {"segment_mismatch", "structural_text", "state_mismatch", "render_mismatch", "eid_mismatch", "bad_schema"} @pytest.mark.parametrize("raw", AWKWARD + _random_corpus(400)) def test_composition_invariants(catalog, raw): doc = compose_doc(raw, catalog) assert "".join(texts(doc)) == doc["markdown"] again = verify_doc(copy.deepcopy(doc), catalog) assert again["violations"] == doc["violations"] and again["stats"] == doc["stats"] assert not INTEGRITY & set(codes(doc)), doc["violations"]