mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-18 23:31:59 +00:00
证据接入按 W1-a、W1-c 的实际接口对齐:复算就是真的 app.analysis.recompute——load 交查询快照工件的原内容、load_result 交上一层结论(只认封存范围内交回过的查询、台账记过的结论,取不回照实说取不回哪一份),方法升没升版按结论里的 method 和现在的 contract.METHODS 比(升了版、复算成立的写结果同不同,现在的方法复算不了的写明原因),去掉为算子没落地准备的那一套;关键数的代入式按真的具名的数写(乘积拆解补上,波动基线按变化率比的按百分比写,负数加括号)。口径卡指标上的可比性结论(不进台账、只从卡上引用)点得开:证据面板的指标步骤带它整条出处链(判定 → 方法 → 计算 → 输入 → 复算 → 封存,封存按卡上记的 sha256 认),报告导出收在一个可展开的块里,可验证报告随附带的卡一起附上、④ 按已核对的卡认它、数字详情里展示各项检查和服务端复算;裁判的指标摘录、写作目录照卡上记的判定语写。现查结果分清按运行当天现算的界、一列一个值都没有、表的范围;可验证报告里分析工具的 tool.end、分析卡的 analysis.end 和结论同一个认法才带内容,输入的角色写叫法。测试改用真算的结论(run 交的输入照分析入口的写法,复算交工件原内容),下钻、总数闭合、方法升版、可比性端到端都过真的复算
This commit is contained in:
@@ -1,6 +1,9 @@
|
||||
"""分析结论进可验证报告(第 1 波 W1-b):bundle/build.py 带上结论工件和它的输入快照,verifier.js 在 node 里核对。
|
||||
|
||||
- 报告引用的分析结论按原字节嵌入,连同输入快照;服务端导出时按封存的输入复算一遍,结果记在工件条目上(recheck)
|
||||
- 报告引用的分析结论按原字节嵌入,连同输入快照;服务端导出时按封存的输入复算一遍(真的 app.analysis.recompute),结果记在
|
||||
工件条目上(recheck)
|
||||
- 口径卡指标上的可比性结论(不进台账、只从卡上引用)随卡附带,④ 按「已核对的口径卡记着的可比性」认它
|
||||
- 分析工具的 tool.end、分析卡一项的 analysis.end:结论随文件附带得了才带规范字符串
|
||||
- 页面只核哈希、核判定语和数是不是结论里写的那几个字(不在浏览器里重算统计):原样导出全部通过,只改显示文字的伪造
|
||||
点名不通过
|
||||
- 输入快照只给 id(证明不了没碰遮罩列)的,结论本身也只给 id,引用它的判定语、数无法核对
|
||||
@@ -14,13 +17,12 @@ from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
from app import analysis
|
||||
from app.analysis.contract import ARTIFACT_KIND, ledger_entry
|
||||
from app.analysis.testing import fake_result
|
||||
from app.bundle.build import build_bundle
|
||||
from app.core.artifact_store import canonical_json, content_hash, manifest_hash
|
||||
from app.engine.evidence import build_catalog, compose_doc, iter_segments
|
||||
from tests.test_analysis_evidence import SNAPSHOT
|
||||
from tests.test_analysis_evidence import SNAPSHOT, analyzed, real_result, run_sync
|
||||
from tests.test_analysis_evidence_api import LAST_WEEK, THIS_WEEK
|
||||
from tests.test_bundle_shown import NODE, node, reseal
|
||||
|
||||
pytestmark = pytest.mark.skipif(NODE is None, reason="没有 node,无法执行页面上的核对脚本")
|
||||
@@ -47,14 +49,15 @@ class Files(dict):
|
||||
|
||||
|
||||
def bundle_of(text: str = TEXT, *, snapshot: dict[str, Any] | None = None, doc_extra: dict[str, Any] | None = None,
|
||||
source_masks: dict[str, list[str]] | None = None,
|
||||
graph: dict[str, Any] | None = None) -> tuple[dict[str, Any], Files, str]:
|
||||
"""一次封存好的运行的页面数据:(bundle, 工件, 分析结论的 id)。"""
|
||||
source_masks: dict[str, list[str]] | None = None, graph: dict[str, Any] | None = None,
|
||||
extra_events: list[tuple[str, str | None, dict[str, Any]]] = (),
|
||||
drop: tuple[str, ...] = ()) -> tuple[dict[str, Any], Files, str]:
|
||||
"""一次封存好的运行的页面数据:(bundle, 工件, 分析结论的 id)。结论按快照真算(app.analysis.run);extra_events 接在
|
||||
分析节点完成之后({analysis} 换成结论的 id),drop 是导出时服务端已经没有的工件("query":输入快照)。"""
|
||||
files = Files()
|
||||
snap = snapshot or SNAPSHOT
|
||||
q = files.put(snap)
|
||||
result = fake_result(inputs=[{"ref": "Q2", "artifact": q, "role": "data", "columns": ["region", "week", "gmv"],
|
||||
"rows": "all"}])
|
||||
result = real_result(q, snap)
|
||||
a = files.put(result)
|
||||
qentry = {"kind": "query", "node_id": "fetch", "exec": 1, "artifact": q, "tool": "db_query__shop",
|
||||
"source": snap.get("source"), "columns": snap["columns"], "rows": len(snap["rows"]), "truncated": False}
|
||||
@@ -74,10 +77,14 @@ def bundle_of(text: str = TEXT, *, snapshot: dict[str, Any] | None = None, doc_e
|
||||
add("tool.end", "fetch", {"tool": "db_query__shop", "duration_ms": 5, "query_artifact": q, "preview": "…"})
|
||||
add("node.finished", "fetch", {"duration_ms": 6, "attempt": 1, "evidence": [qentry]})
|
||||
add("node.finished", "an", {"duration_ms": 8, "attempt": 1, "evidence": [aentry]})
|
||||
for etype, node_id, data in extra_events:
|
||||
add(etype, node_id, json.loads(json.dumps(data).replace("{analysis}", a)))
|
||||
add("report.checked", "write", {"doc_artifact": doc_id, "ok": True})
|
||||
add("node.finished", "write", {"duration_ms": 9, "attempt": 1, "preview": {"text": "(报告正文)", "doc_artifact": doc_id}})
|
||||
add("issuance", "out", {"tier": "formal", "mode": "citations"})
|
||||
add("run.finished", None, {"output": {"周报": "(报告正文)"}})
|
||||
if "query" in drop:
|
||||
files.pop(q)
|
||||
bundle = build_bundle(RUN, events, manifest_seq=len(events), manifest_hash=manifest_hash(events), read=files.get,
|
||||
exported_at="2026-10-21T08:00:00+00:00", graph=graph or GRAPH,
|
||||
source_masks=source_masks or {})
|
||||
@@ -96,8 +103,9 @@ def test_the_analysis_and_its_input_travel_with_the_file_and_verify():
|
||||
bundle, files, a = bundle_of()
|
||||
analysis_item = item(bundle, a)
|
||||
assert analysis_item["kind"] == ARTIFACT_KIND and "b64" in analysis_item and analysis_item["node_id"] == "an"
|
||||
assert analysis_item["recheck"] == {"status": "failed", "method": "decompose.additive@1",
|
||||
"text": "复算失败:系统里还没有这种分析的复算实现"}
|
||||
# 导出时服务端真的复算了一遍:按封存的输入快照(这份文件里哈希对得上的原字节)重算,逐字段相同
|
||||
assert analysis_item["recheck"] == {"status": "same", "method": "decompose.additive@1",
|
||||
"text": "复算一致:按封存的输入重新计算,结论逐项相同"}
|
||||
[query] = [x for x in bundle["artifacts"] if x["kind"] == "query"]
|
||||
assert "b64" in query
|
||||
|
||||
@@ -106,17 +114,17 @@ def test_the_analysis_and_its_input_travel_with_the_file_and_verify():
|
||||
numbers = {n["ref"]: n for n in got["numbers"]}
|
||||
assert set(numbers) == {"a:A1", "a:A1.top_share|pct", "v:A1.r0.delta"}
|
||||
assert all(n["result"] == "pass" and n["expected"] == n["text"] for n in numbers.values()), numbers
|
||||
assert numbers["a:A1"]["text"] == "销售额下降 194 万(-8.7%),主要来自华东(-120 万,占 62%)"
|
||||
assert numbers["a:A1"]["text"] == "销售额下降 194(-8.7%),主要来自华东(-120,占 61.9%)"
|
||||
assert got["overall"]["result"] == "pass"
|
||||
|
||||
|
||||
def test_the_server_recheck_is_recorded_when_the_operators_answer(monkeypatch):
|
||||
monkeypatch.setattr(analysis, "recompute", lambda result, load, *, load_result=None: dict(result))
|
||||
bundle, _, a = bundle_of()
|
||||
assert item(bundle, a)["recheck"]["text"] == "复算一致:按封存的输入重新计算,结论逐项相同"
|
||||
def test_an_analysis_whose_input_is_gone_travels_only_as_a_hash():
|
||||
"""导出时服务端已经没有输入快照:证明不了没碰遮罩列,结论只给 id,也就不顺着它复算、不附带别的。"""
|
||||
bundle, _, a = bundle_of(drop=("query",))
|
||||
assert item(bundle, a) == {"id": a, "kind": ARTIFACT_KIND, "node_id": "an", "masked": True}
|
||||
|
||||
|
||||
@pytest.mark.parametrize("ref, text", [("a:A1", "销售额下降 194 万(-8.7%),主要来自华南(-120 万,占 62%)"),
|
||||
@pytest.mark.parametrize("ref, text", [("a:A1", "销售额下降 194(-8.7%),主要来自华南(-120,占 61.9%)"),
|
||||
("a:A1.top_share|pct", "71.9%"), ("v:A1.r0.delta", "-220")])
|
||||
def test_forging_the_shown_text_fails_by_name(ref, text):
|
||||
bundle, _, _ = bundle_of()
|
||||
@@ -173,3 +181,88 @@ def test_an_analysis_card_event_shows_its_content_only_when_its_conclusions_trav
|
||||
assert not shown(bundle_of(graph=card, snapshot=masked)[0])
|
||||
got = verdicts(bundle_of(graph=card)[0])
|
||||
assert all(r == "pass" for key in ("events", "manifest", "artifacts", "chain") for r in got[key])
|
||||
|
||||
|
||||
def test_analysis_tool_and_card_events_show_content_only_when_the_conclusion_travels():
|
||||
"""分析工具的 tool.end(预览里是结论的前一截)、分析卡一项的 analysis.end(带判定语):和结论随文件附带同一个认法。"""
|
||||
events = [("tool.end", "an", {"tool": "analysis_decompose", "duration_ms": 3, "analysis_artifact": "{analysis}",
|
||||
"preview": "{\"analysis_artifact\": \"{analysis}\"}"}),
|
||||
("analysis.end", "an", {"item": "drop", "op": "decompose", "mode": "additive", "status": "ok",
|
||||
"verdict": "driver", "direction": "down", "phrase": "主要来自华东",
|
||||
"reason_code": None, "analysis_artifact": "{analysis}"})]
|
||||
|
||||
def shown(bundle: dict[str, Any]) -> dict[str, bool]:
|
||||
return {e["type"]: "canonical" in e for e in bundle["events"] if e["type"] in ("tool.end", "analysis.end")
|
||||
and e["node_id"] == "an"}
|
||||
|
||||
open_ = bundle_of(extra_events=events)[0]
|
||||
assert shown(open_) == {"tool.end": True, "analysis.end": True}
|
||||
got = verdicts(open_)
|
||||
assert all(r == "pass" for key in ("events", "manifest", "artifacts", "chain") for r in got[key]), got["why"]
|
||||
masked = {**SNAPSHOT, "mask_columns": ["phone"], "columns": ["region", "phone", "week", "gmv"],
|
||||
"sql": "SELECT region, phone, week, SUM(gmv) AS gmv FROM orders GROUP BY 1, 2, 3",
|
||||
"rows": [[r[0], "000-0001", r[1], r[2]] for r in SNAPSHOT["rows"]]}
|
||||
assert shown(bundle_of(snapshot=masked, extra_events=events)[0]) == {"tool.end": False, "analysis.end": False}
|
||||
|
||||
|
||||
def card_bundle() -> tuple[dict[str, Any], Files, str, str]:
|
||||
"""跨两周算环比的口径卡,指标上记着口径卡执行时自动做的可比性检查(结论落成工件,不进台账):
|
||||
(bundle, 工件, 可比性结论的 id, 口径卡的 id)。"""
|
||||
files = Files()
|
||||
last, this = files.put(LAST_WEEK), files.put(THIS_WEEK)
|
||||
result = run_sync(analyzed({"fetch·base": (LAST_WEEK, last), "fetch·target": (THIS_WEEK, this)},
|
||||
{"op": "comparable", "mode": None, "params": {}},
|
||||
base_query="fetch·base", target_query="fetch·target"))
|
||||
found = files.put(result)
|
||||
card = {"kind": "metric_set", "caliber": "周报口径", "caliber_version": "v1", "metrics": [
|
||||
{"id": "wow", "name": "环比", "value": -0.0874, "unit": "", "format": "percent_of_ratio", "decimals": 3,
|
||||
"expression": "cell(nodes.fetch, 0, 'gmv') / cell(nodes.fetch, 0, 'gmv') - 1",
|
||||
"substituted": "2026 / 2220 - 1", "recompute_ok": True, "status": "ok",
|
||||
"inputs": [{"path": "cell(nodes.fetch, 0, 'gmv')", "value": 2026, "node_id": "fetch", "via": "tool_cell",
|
||||
"artifact": this, "locator": {"row": 0, "column": "gmv"}},
|
||||
{"path": "cell(nodes.fetch, 0, 'gmv')", "value": 2220, "node_id": "fetch", "via": "tool_cell",
|
||||
"artifact": last, "locator": {"row": 0, "column": "gmv"}}],
|
||||
"comparability": {"artifact": found, "verdict": result["verdict"]["code"], "phrase": result["phrase"],
|
||||
"reasons": []}}]}
|
||||
card_id = files.put(card)
|
||||
qentries = [{"kind": "query", "node_id": "fetch", "exec": 1, "artifact": x, "tool": "db_query__shop",
|
||||
"source": "shop", "columns": ["gmv"], "rows": 1, "truncated": False} for x in (last, this)]
|
||||
mentry = {"kind": "metric_set", "node_id": "card", "exec": 1, "artifact": card_id}
|
||||
catalog = build_catalog(nodes={"card": {**card, "artifact": card_id}}, ledger=[*qentries, mentry],
|
||||
loader=files.load)
|
||||
doc = compose_doc("## 环比\n\n销售额环比 [[m:wow]]。", catalog, node_id="write", run_id=RUN_ID, loader=files.load)
|
||||
doc_id = files.put(doc)
|
||||
events: list[tuple[int, str, str | None, Any]] = []
|
||||
|
||||
def add(etype: str, node_id: str | None, data: dict[str, Any]) -> None:
|
||||
events.append((len(events) + 1, etype, node_id, data))
|
||||
|
||||
add("run.started", None, {"nodes": 4, "resumed": False, "memory_scope": "default", "collection": "default",
|
||||
"approval_default": None, "tool_trust": "formal", "agent_limits": {},
|
||||
"data_versions": None, "replay_protocol": 2})
|
||||
for x in (last, this):
|
||||
add("tool.end", "fetch", {"tool": "db_query__shop", "duration_ms": 5, "query_artifact": x, "preview": "…"})
|
||||
add("node.finished", "fetch", {"duration_ms": 6, "attempt": 1, "evidence": qentries})
|
||||
add("node.finished", "card", {"duration_ms": 7, "attempt": 1, "evidence": [mentry]})
|
||||
add("report.checked", "write", {"doc_artifact": doc_id, "ok": True})
|
||||
add("node.finished", "write", {"duration_ms": 9, "attempt": 1, "preview": {"text": "(报告正文)", "doc_artifact": doc_id}})
|
||||
add("run.finished", None, {"output": {"周报": "(报告正文)"}})
|
||||
graph = {"nodes": [{"id": n, "type": t, "data": {"label": label}} for n, t, label in [
|
||||
("fetch", "tool", "按周取数"), ("card", "metrics", "周报口径"), ("write", "report", "写周报")]]}
|
||||
bundle = build_bundle(RUN, events, manifest_seq=len(events), manifest_hash=manifest_hash(events), read=files.get,
|
||||
exported_at="2026-10-21T08:00:00+00:00", graph=graph, source_masks={})
|
||||
return bundle, files, found, card_id
|
||||
|
||||
|
||||
def test_the_comparability_on_a_card_travels_with_the_card_and_is_chained_through_it():
|
||||
bundle, _, found, card_id = card_bundle()
|
||||
assert "b64" in item(bundle, card_id)
|
||||
comparability = item(bundle, found)
|
||||
assert comparability["kind"] == ARTIFACT_KIND and "b64" in comparability and comparability["node_id"] == "card"
|
||||
assert comparability["recheck"]["status"] == "same"
|
||||
got = verdicts(bundle)
|
||||
assert all(r == "pass" for key in ("events", "manifest", "artifacts", "chain") for r in got[key]), got["why"]
|
||||
assert {w["kind"] for w in got["why"]["chain"]} >= {"metric_set", ARTIFACT_KIND, "query"}
|
||||
[wow] = got["numbers"]
|
||||
assert wow["result"] == "pass", wow
|
||||
|
||||
|
||||
@@ -8,23 +8,27 @@
|
||||
- 写作目录的「分析结论」一段:判定语、判定标准、具名的数、结果表前 table_top_k 段、附带说明、算不了的原因、来自哪几个 Q,
|
||||
放不下时结果表的各段排在查询的行前面补
|
||||
- 分析结论的输入查询上的 SQL 检查问题随 A 条目出现;口径卡指标上的可比性照实写进写作目录
|
||||
- 复算(analysis_recheck)、代入式(analysis_formulas)
|
||||
- 复算(analysis_recheck)、代入式(analysis_formulas):用 app.analysis 真算的结论(run 交的输入照分析入口的写法,复算交
|
||||
工件原内容),也用 fake_result 测目录和引用的写法
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from datetime import date
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
from app import analysis
|
||||
from app.analysis.contract import CallError, ledger_entry
|
||||
from app.analysis import contract
|
||||
from app.analysis.contract import CallError, effective_settings, ledger_entry
|
||||
from app.analysis.testing import fake_result
|
||||
from app.core.artifact_store import canonical_json, content_hash
|
||||
from app.engine.evidence import (
|
||||
ANALYSIS_CELLS_REASON,
|
||||
StreamRenderer,
|
||||
analysis_formulas,
|
||||
analysis_input_snapshot,
|
||||
analysis_recheck,
|
||||
build_catalog,
|
||||
compose_doc,
|
||||
@@ -58,6 +62,59 @@ class Store(dict):
|
||||
return self.get(artifact)
|
||||
|
||||
|
||||
#: 运行当天(服务端时区):真算的结论记进 params.today,复算按它
|
||||
TODAY = date(2026, 10, 21)
|
||||
#: 按 SNAPSHOT 真算一份按地区拆的可加拆解
|
||||
REQUEST: dict[str, Any] = {
|
||||
"op": "decompose", "mode": "additive", "hypothesis": "华东拖累",
|
||||
"params": {"query": "Q2", "by": ["region"], "period": "week", "base": "W41", "target": "W42", "measure": "gmv",
|
||||
"label": "销售额"}}
|
||||
#: 华东按渠道再拆一层(下钻):两个渠道之和 820 → 700,和 A1 里华东那一段闭合
|
||||
CHANNELS: dict[str, Any] = {
|
||||
"columns": ["channel", "week", "gmv"], "column_types": {"channel": "text", "week": "text", "gmv": "number"},
|
||||
"rows": [["线上", "W41", 500], ["线上", "W42", 410], ["线下", "W41", 320], ["线下", "W42", 290]],
|
||||
"sql": "SELECT channel, week, SUM(gmv) AS gmv FROM orders WHERE region = '华东' GROUP BY channel, week",
|
||||
"source": "shop", "truncated": False, "row_count": 4,
|
||||
}
|
||||
|
||||
|
||||
def input_snapshot(content: dict[str, Any], *, ref: str, artifact: str, node_id: str = "fetch") -> dict[str, Any]:
|
||||
"""照分析入口(tools/analysis.input_snapshot)的写法交给 run:列的类型按列序写成列表,加上出处,遮罩列留空。复算交的是
|
||||
工件原内容(类型是 {列: 类型}):两边算出来要逐字段相同。"""
|
||||
types = content.get("column_types") or {}
|
||||
return {**content, "ref": ref, "artifact": artifact, "node_id": node_id,
|
||||
"column_types": [types.get(c) for c in content["columns"]], "masked": []}
|
||||
|
||||
|
||||
async def analyzed(snapshots: dict[str, tuple[dict[str, Any], str]], request: dict[str, Any] | None = None, *,
|
||||
parents: dict[str, Any] | None = None, hypothesis: str | None = None,
|
||||
**params: Any) -> dict[str, Any]:
|
||||
"""app.analysis.run 真算一份结论。snapshots:{调用里写的名字: (快照内容, 工件 id)};params 盖在请求的参数上,hypothesis
|
||||
换掉请求里 agent 写的假设(不进复算的比较,用来让一份结论的内容独一份)。"""
|
||||
request = request or REQUEST
|
||||
by_ref = {ref: input_snapshot(content, ref=ref, artifact=sha) for ref, (content, sha) in snapshots.items()}
|
||||
asked = {**request, "params": {**request["params"], **params}}
|
||||
if hypothesis is not None:
|
||||
asked["hypothesis"] = hypothesis
|
||||
return dict(await analysis.run(asked, by_ref.get, settings=effective_settings(None), context={"today": TODAY},
|
||||
parents=(parents or {}).get))
|
||||
|
||||
|
||||
def run_sync(coro: Any) -> Any:
|
||||
"""在同步的地方等一个协程:没有正在跑的事件循环就直接 asyncio.run,协程测试里调用(已经在循环里)换一个线程跑。"""
|
||||
try:
|
||||
asyncio.get_running_loop()
|
||||
except RuntimeError:
|
||||
return asyncio.run(coro)
|
||||
with ThreadPoolExecutor(1) as pool:
|
||||
return pool.submit(asyncio.run, coro).result()
|
||||
|
||||
|
||||
def real_result(q: str, snapshot: dict[str, Any] | None = None, **params: Any) -> dict[str, Any]:
|
||||
"""同步的 analyzed:按 SNAPSHOT(工件 q)真算 REQUEST。"""
|
||||
return run_sync(analyzed({"Q2": (snapshot or SNAPSHOT, q)}, **params))
|
||||
|
||||
|
||||
def setup(*, item: str | None = "drop", call_id: str | None = None, result: dict[str, Any] | None = None,
|
||||
snapshot: dict[str, Any] | None = None) -> tuple[Store, list[dict[str, Any]], str, str]:
|
||||
"""一次查询(Q1)加一份按地区拆的分析结论(A1):(工件库, 台账, 查询快照, 分析结论)。"""
|
||||
@@ -451,71 +508,139 @@ def test_sql_check_problems_of_the_input_queries_follow_the_analysis():
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_recheck_says_plainly_when_the_operators_are_not_there_yet():
|
||||
store, ledger, q, a = setup()
|
||||
out = analysis_recheck(store[a], lambda sha: analysis_input_snapshot(store.get(sha), sha))
|
||||
assert out == {"status": "failed", "method": "decompose.additive@1",
|
||||
"text": "复算失败:系统里还没有这种分析的复算实现"}
|
||||
|
||||
|
||||
def test_recheck_compares_field_by_field_and_names_the_method_versions(monkeypatch):
|
||||
store, _, q, a = setup()
|
||||
sealed = store[a]
|
||||
seen: list[Any] = []
|
||||
|
||||
def same(result, load, *, load_result=None):
|
||||
seen.append(load(q))
|
||||
return {**result, "hypothesis": "复算时没有假设"}
|
||||
|
||||
monkeypatch.setattr(analysis, "recompute", same)
|
||||
out = analysis_recheck(sealed, lambda sha: analysis_input_snapshot(store.get(sha), sha, ref="Q2", node_id="fetch"))
|
||||
assert out == {"status": "same", "method": "decompose.additive@1", "text": "复算一致:按封存的输入重新计算,结论逐项相同"}
|
||||
assert seen[0]["rows"] == SNAPSHOT["rows"] and seen[0]["masked"] == [] and seen[0]["node_id"] == "fetch"
|
||||
|
||||
monkeypatch.setattr(analysis, "recompute", lambda r, load, *, load_result=None: {**r, "phrase": "别的判定"})
|
||||
assert analysis_recheck(sealed, store.get)["text"] == "复算不一致:判定语和封存的不同"
|
||||
|
||||
monkeypatch.setattr(analysis, "recompute",
|
||||
lambda r, load, *, load_result=None: {**r, "method": "decompose.additive@2"})
|
||||
def test_recheck_with_the_real_operators_says_a_sealed_result_holds():
|
||||
"""真算的结论按封存的输入复算(load 交工件原内容),逐字段相同;agent 写的假设不比。"""
|
||||
store = Store()
|
||||
q = store.put(SNAPSHOT)
|
||||
sealed = real_result(q)
|
||||
assert sealed["phrase"] == "销售额下降 194(-8.7%),主要来自华东(-120,占 61.9%)"
|
||||
out = analysis_recheck(sealed, store.get)
|
||||
assert out["status"] == "different" and out["method_now"] == "decompose.additive@2"
|
||||
assert out == {"status": "same", "method": "decompose.additive@1", "text": "复算一致:按封存的输入重新计算,结论逐项相同"}
|
||||
assert analysis_recheck({**sealed, "hypothesis": "别的假设"}, store.get)["status"] == "same"
|
||||
|
||||
|
||||
def test_recheck_follows_the_parent_of_a_drill_down_by_hash():
|
||||
store = Store()
|
||||
q, c = store.put(SNAPSHOT), store.put(CHANNELS)
|
||||
top = real_result(q)
|
||||
a = store.put(top)
|
||||
child = asyncio.run(analyzed({"Q3": (CHANNELS, c)}, parents={"A1": top}, query="Q3", by=["channel"],
|
||||
parent={"of": "A1", "key": ["华东"]}))
|
||||
assert [i["role"] for i in child["inputs"]] == ["parent", "data"] and child["inputs"][0]["artifact"] == a
|
||||
assert analysis_recheck(child, store.get, load_result=store.get)["status"] == "same"
|
||||
# 上一层取不回:照实说取不回哪一份,不说两遍「复算」
|
||||
out = analysis_recheck(child, store.get, load_result=lambda sha: None)
|
||||
assert out == {"status": "failed", "method": "decompose.additive@1", "text": "复算失败:取不回上一层的分析结论 A1"}
|
||||
|
||||
|
||||
def test_recheck_says_what_differs_and_what_is_missing():
|
||||
store = Store()
|
||||
q = store.put(SNAPSHOT)
|
||||
sealed = real_result(q)
|
||||
# 封存的那份和按输入算出来的不一样(判定语被改过、哈希也就是另一份):点名哪几项不同
|
||||
out = analysis_recheck({**sealed, "phrase": "销售额下降,主要来自华南"}, store.get)
|
||||
assert out["status"] == "different" and out["fields"] == ["phrase"]
|
||||
assert out["text"] == "复算不一致:判定语和封存的不同"
|
||||
# 输入快照取不回(不在封存范围、哈希对不上的调用方都交 None)
|
||||
out = analysis_recheck(sealed, lambda sha: None)
|
||||
assert out == {"status": "failed", "method": "decompose.additive@1", "text": "复算失败:取不回 Q2 的查询快照"}
|
||||
# 输入快照换了一份(同一个 sha256 交回了别的内容):复算照样算,结果和封存的不同
|
||||
other = {**SNAPSHOT, "rows": [["华东", "W41", 820], ["华东", "W42", 650], *SNAPSHOT["rows"][2:]]}
|
||||
assert analysis_recheck(sealed, lambda sha: other)["status"] == "different"
|
||||
|
||||
|
||||
def test_recheck_names_both_versions_when_the_method_was_upgraded(monkeypatch):
|
||||
store = Store()
|
||||
q = store.put(SNAPSHOT)
|
||||
sealed = real_result(q)
|
||||
monkeypatch.setitem(contract.METHODS, ("decompose", "additive"), "decompose.additive@2")
|
||||
out = analysis_recheck(sealed, store.get)
|
||||
assert out == {"status": "same", "method": "decompose.additive@1", "method_now": "decompose.additive@2",
|
||||
"text": "运行时用的是 decompose.additive@1,现在是 decompose.additive@2,复算结果相同"}
|
||||
out = analysis_recheck({**sealed, "phrase": "别的判定"}, store.get)
|
||||
assert out["status"] == "different" and out["fields"] == ["phrase"]
|
||||
assert out["text"] == "运行时用的是 decompose.additive@1,现在是 decompose.additive@2,复算结果不同"
|
||||
|
||||
def refuse(r, load, *, load_result=None):
|
||||
raise CallError("missing_column", "Q2 里没有列「gmv」")
|
||||
def refuse(result, load, *, load_result=None):
|
||||
raise CallError("unknown_mode", "变化拆解要写模式:additive / ratio / factor")
|
||||
|
||||
monkeypatch.setattr(analysis, "recompute", refuse)
|
||||
assert analysis_recheck(sealed, store.get)["text"] == "复算失败:Q2 里没有列「gmv」"
|
||||
out = analysis_recheck(sealed, store.get)
|
||||
assert out["status"] == "failed" and out["method_now"] == "decompose.additive@2"
|
||||
assert out["text"] == ("运行时用的是 decompose.additive@1,现在是 decompose.additive@2:现在的方法按封存的输入复算不了"
|
||||
"(变化拆解要写模式:additive / ratio / factor)")
|
||||
|
||||
def broken(r, load, *, load_result=None):
|
||||
raise RuntimeError("输入快照取不回来")
|
||||
|
||||
def test_recheck_errors_are_said_plainly(monkeypatch):
|
||||
store = Store()
|
||||
q = store.put(SNAPSHOT)
|
||||
sealed = real_result(q)
|
||||
seen: list[Any] = []
|
||||
|
||||
def broken(result, load, *, load_result=None):
|
||||
seen.append(load(q))
|
||||
raise ZeroDivisionError("division by zero")
|
||||
|
||||
monkeypatch.setattr(analysis, "recompute", broken)
|
||||
assert analysis_recheck(sealed, store.get)["text"] == "复算失败:输入快照取不回来"
|
||||
|
||||
|
||||
def test_input_snapshots_for_recompute_keep_the_masks_of_the_query_time():
|
||||
snap = analysis_input_snapshot({**SNAPSHOT, "mask_columns": ["Phone", "email"]}, "a" * 64, ref="Q1")
|
||||
assert snap["masked"] == ["email", "phone"] and snap["artifact"] == "a" * 64 and snap["ref"] == "Q1"
|
||||
assert analysis_input_snapshot({"columns": []}, "a" * 64) is None
|
||||
out = analysis_recheck(sealed, store.get)
|
||||
assert out["status"] == "failed" and out["text"].startswith("复算失败:") and seen == [SNAPSHOT]
|
||||
monkeypatch.setattr(analysis, "recompute", lambda result, load, *, load_result=None: None)
|
||||
assert analysis_recheck(sealed, store.get)["text"] == "复算失败:复算没有交回结论"
|
||||
|
||||
|
||||
def test_formulas_substitute_the_key_numbers():
|
||||
formulas = {f["label"]: f["text"] for f in analysis_formulas(fake_result())}
|
||||
store = Store()
|
||||
q = store.put(SNAPSHOT)
|
||||
formulas = {f["label"]: f["text"] for f in analysis_formulas(real_result(q))}
|
||||
assert formulas == {
|
||||
"总变化": "总变化 = 本期合计 − 基期合计 = 2,026 − 2,220 = -194",
|
||||
"变化率": "变化率 = 总变化 ÷ 基期合计 = -194 ÷ 2,220 = -8.7%",
|
||||
"占比": "华东的占比 = 华东的变化 ÷ 总变化 = -120 ÷ -194 = 61.9%",
|
||||
"占比": "华东的占比 = 华东的变化 ÷ 总变化 = -120 ÷ (-194) = 61.9%",
|
||||
}
|
||||
baseline = fake_result("baseline", verdict="outside_band", values={
|
||||
"x": "-0.087", "median": "-0.004", "band_lo": "-0.061", "band_hi": "0.053", "z": "-2.9", "n_history": "12"})
|
||||
texts = [f["text"] for f in analysis_formulas(baseline)]
|
||||
assert texts == ["常规波动范围 = 中位数 ± 2 倍稳健标准差 = -0.061 至 0.053(中位数 -0.004,过去 12 期)",
|
||||
"稳健 z = (本期 − 中位数)÷ 稳健标准差 = (-0.087 − -0.004)÷ 稳健标准差 = -2.9"]
|
||||
assert analysis_formulas(fake_result(status="refused", reason_code="history_short")) == []
|
||||
assert analysis_formulas(fake_result(values={})) == []
|
||||
|
||||
|
||||
def test_formulas_for_factor_ratio_and_baseline():
|
||||
store = Store()
|
||||
factor_snap = {"columns": ["week", "gmv", "orders", "aov"],
|
||||
"rows": [["W41", 1000, 10, 100], ["W42", 1320, 12, 110]],
|
||||
"sql": "SELECT week, SUM(amount) AS gmv, COUNT(*) AS orders, ROUND(AVG(amount), 2) AS aov "
|
||||
"FROM orders GROUP BY week", "source": "shop", "truncated": False}
|
||||
factor = asyncio.run(analyzed({"Q1": (factor_snap, store.put(factor_snap))},
|
||||
{"op": "decompose", "mode": "factor", "params": {}}, query="Q1", period="week",
|
||||
base="W41", target="W42", product="gmv", factors=["orders", "aov"], label="销售额"))
|
||||
texts = {f["label"]: f["text"] for f in analysis_formulas(factor)}
|
||||
assert texts["总变化"] == "总变化 = 本期合计 − 基期合计 = 1,320 − 1,000 = 320"
|
||||
assert texts["占比"].startswith("orders的占比 = orders的贡献 ÷ 总变化 = 210.1449167") and texts["占比"].endswith(" = 65.7%")
|
||||
|
||||
ratio_snap = {"columns": ["channel", "week", "refunds", "orders"],
|
||||
"rows": [["线上", "W41", 50, 1000], ["线上", "W42", 80, 1000], ["线下", "W41", 20, 1000],
|
||||
["线下", "W42", 26, 1000]],
|
||||
"sql": "SELECT channel, week, SUM(refund_flag) AS refunds, COUNT(*) AS orders FROM orders "
|
||||
"GROUP BY 1, 2", "source": "shop", "truncated": False}
|
||||
ratio = asyncio.run(analyzed({"Q1": (ratio_snap, store.put(ratio_snap))},
|
||||
{"op": "decompose", "mode": "ratio", "params": {}}, query="Q1", by="channel",
|
||||
period="week", base="W41", target="W42", numerator="refunds", denominator="orders",
|
||||
label="退款率"))
|
||||
assert [f["text"] for f in analysis_formulas(ratio)] == [
|
||||
"结构效应占比 = 结构效应合计 ÷ 比率的变化 = 0 ÷ 0.018 = 0.0%",
|
||||
"自身效应占比 = 自身效应合计 ÷ 比率的变化 = 0.018 ÷ 0.018 = 100.0%"]
|
||||
|
||||
weeks = [f"2026-{m:02d}-{d:02d}" for m, d in ((6, 8), (6, 15), (6, 22), (6, 29), (7, 6), (7, 13), (7, 20), (7, 27),
|
||||
(8, 3), (8, 10))]
|
||||
series = {"columns": ["week", "orders"], "column_types": {"week": "text", "orders": "number"},
|
||||
"rows": [[w, v] for w, v in zip(weeks, [100, 102, 98, 101, 99, 103, 100, 97, 102, 130])],
|
||||
"sql": "SELECT week, COUNT(*) AS orders FROM orders GROUP BY 1", "source": "shop", "truncated": False}
|
||||
baseline = asyncio.run(analyzed({"Q1": (series, store.put(series))}, {"op": "baseline", "mode": None, "params": {}},
|
||||
query="Q1", period="week", measure="orders", label="订单数"))
|
||||
assert baseline["params"]["basis"] == "change" and baseline["status"] == "ok"
|
||||
band, z = [f["text"] for f in analysis_formulas(baseline)]
|
||||
assert band == "常规波动范围 = 中位数 ± 2 倍稳健标准差 = -9.0% 至 9.0%(中位数 0.01%,过去 8 期)"
|
||||
assert z == "稳健 z = (本期 − 中位数)÷ 稳健标准差 = (27.5% − 0.01%)÷ 稳健标准差 = 6.1072657902"
|
||||
assert analysis_recheck(baseline, store.get)["status"] == "same"
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 血缘(D16):分析卡的结果不是口径卡的原料
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
@@ -1,13 +1,14 @@
|
||||
"""分析结论进证据链(第 1 波 W1-b):证据接口、审计、报告导出。
|
||||
|
||||
运行是直接落库的虚构封存运行(虚构零售库 shop):一次查询(Q1)、一份按地区拆的分析结论(A1,分析卡或 Agent 做的),
|
||||
报告引用判定语、具名标量、结果表的格。算子第 1 波还没落地,复算按 monkeypatch 换。
|
||||
报告引用判定语、具名标量、结果表的格。结论用 app.analysis 真算(tests.test_analysis_evidence.analyzed),出处链里的复算是
|
||||
真的 recompute:按 sha256 取回封存的输入快照、下钻的上一层结论,逐字段比。只有要它出错、升版的几处用 monkeypatch。
|
||||
|
||||
- 证据图:A1 条目带算子、判定;「派生自」的边 A1 → Q1
|
||||
- 片段接口:判定 → 方法 → 计算 → 输入(接查询步骤)→ 复算 → 封存;Agent 写的假设标出来;复算不了照实写,不让接口出错
|
||||
- 审计:分析判定、分析结论的叫法;分析说法核对的违规单列一行
|
||||
- 报告导出:数据块里有分析结论那几步;文档带「分析范围」的,正文后面渲染、编号点得开
|
||||
- 指标步骤带可比性
|
||||
- 指标步骤带可比性:口径卡指标上的可比性结论(不进台账)照卡上记的 sha256 取回,点得开(判定 → … → 复算 → 封存)
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
@@ -16,21 +17,22 @@ import io
|
||||
import json
|
||||
import re
|
||||
import uuid
|
||||
from collections.abc import Sequence
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
from httpx import ASGITransport, AsyncClient
|
||||
|
||||
from app import analysis
|
||||
from app.analysis import contract
|
||||
from app.analysis.contract import ARTIFACT_KIND, ledger_entry
|
||||
from app.analysis.testing import fake_result
|
||||
from app.core import artifact_store
|
||||
from app.core.artifact_store import manifest_hash
|
||||
from app.db.base import SessionLocal
|
||||
from app.db.models import Run, RunEvent
|
||||
from app.engine.evidence import build_catalog, compose_doc, iter_segments
|
||||
from app.main import app
|
||||
from tests.test_analysis_evidence import SNAPSHOT
|
||||
from tests.test_analysis_evidence import CHANNELS, SNAPSHOT, analyzed
|
||||
|
||||
GRAPH = {"nodes": [{"id": n, "type": t, "data": {"label": label}} for n, t, label in [
|
||||
("fetch", "tool", "按地区取数"), ("an", "agent", "分析"), ("card", "metrics", "周报口径"),
|
||||
@@ -43,28 +45,38 @@ async def client():
|
||||
yield c
|
||||
|
||||
|
||||
def _query_entry(content: dict[str, Any], artifact: str) -> dict[str, Any]:
|
||||
return {"kind": "query", "node_id": "fetch", "exec": 1, "artifact": artifact, "tool": "db_query__shop",
|
||||
"source": "shop", "columns": content["columns"], "rows": len(content["rows"]), "truncated": False}
|
||||
|
||||
|
||||
async def sealed_run(text: str, *, item: str | None = "drop", call_id: str | None = None,
|
||||
result: dict[str, Any] | None = None, doc_extra: dict[str, Any] | None = None,
|
||||
card: dict[str, Any] | None = None) -> dict[str, Any]:
|
||||
"""落一次封存好的运行:查询快照、分析结论、(可选)口径卡、报告文档都按真实的工件写,事件按 runner 的算法封存。"""
|
||||
card: dict[str, Any] | None = None, queries: Sequence[dict[str, Any]] = (),
|
||||
parents: Sequence[dict[str, Any]] = ()) -> dict[str, Any]:
|
||||
"""落一次封存好的运行:查询快照(SNAPSHOT,再加 queries)、分析结论(parents 在前,result 在后;result 缺省按 SNAPSHOT
|
||||
真算一份按地区拆的可加拆解)、(可选)口径卡、报告文档都按真实的工件写,事件按 runner 的算法封存。"""
|
||||
run_id = uuid.uuid4().hex
|
||||
q = await artifact_store.put_json(SNAPSHOT, kind="query_snapshot", run_id=run_id, node_id="fetch")
|
||||
res = result or fake_result(inputs=[{"ref": "Q2", "artifact": q, "role": "data",
|
||||
"columns": ["region", "week", "gmv"], "rows": "all"}])
|
||||
more = [await artifact_store.put_json(c, kind="query_snapshot", run_id=run_id, node_id="fetch") for c in queries]
|
||||
res = result or await analyzed({"Q2": (SNAPSHOT, q)})
|
||||
qentries = [_query_entry(SNAPSHOT, q), *(_query_entry(c, a) for c, a in zip(queries, more))]
|
||||
aentries = []
|
||||
for i, parent in enumerate(parents):
|
||||
found = await artifact_store.put_json(parent, kind=ARTIFACT_KIND, run_id=run_id, node_id="an")
|
||||
aentries.append(ledger_entry(parent, node_id="an", exec_no=1, artifact=found, item=f"up{i}"))
|
||||
a = await artifact_store.put_json(res, kind=ARTIFACT_KIND, run_id=run_id, node_id="an")
|
||||
qentry = {"kind": "query", "node_id": "fetch", "exec": 1, "artifact": q, "tool": "db_query__shop",
|
||||
"source": "shop", "columns": SNAPSHOT["columns"], "rows": len(SNAPSHOT["rows"]), "truncated": False}
|
||||
aentry = ledger_entry(res, node_id="an", exec_no=1, artifact=a, item=item, call_id=call_id)
|
||||
aentries.append(ledger_entry(res, node_id="an", exec_no=1, artifact=a, item=item, call_id=call_id))
|
||||
nodes: dict[str, Any] = {}
|
||||
events: list[tuple[int, str, str | None, dict[str, Any]]] = [
|
||||
(1, "run.started", None, {"input": {}}), (2, "node.finished", "fetch", {"evidence": [qentry]}),
|
||||
(3, "node.finished", "an", {"evidence": [aentry]})]
|
||||
(1, "run.started", None, {"input": {}}), (2, "node.finished", "fetch", {"evidence": qentries}),
|
||||
(3, "node.finished", "an", {"evidence": aentries})]
|
||||
if card is not None:
|
||||
card_id = await artifact_store.put_json(card, kind="metric_set", run_id=run_id, node_id="card")
|
||||
nodes["card"] = {**card, "artifact": card_id}
|
||||
events.append((4, "node.finished", "card", {"evidence": [{"kind": "metric_set", "node_id": "card",
|
||||
"exec": 1, "artifact": card_id}]}))
|
||||
catalog = build_catalog(nodes=nodes, ledger=[qentry, aentry])
|
||||
catalog = build_catalog(nodes=nodes, ledger=[*qentries, *aentries])
|
||||
doc = compose_doc(text, catalog, node_id="write", run_id=run_id)
|
||||
doc.update(doc_extra or {})
|
||||
doc_id = await artifact_store.put_json(doc, kind="report_doc", run_id=run_id, node_id="write")
|
||||
@@ -78,7 +90,7 @@ async def sealed_run(text: str, *, item: str | None = "drop", call_id: str | Non
|
||||
for s, etype, node, data in events:
|
||||
session.add(RunEvent(run_id=run_id, seq=s, type=etype, node_id=node, ts=float(s), data=data))
|
||||
await session.commit()
|
||||
return {"run": run_id, "doc": doc, "query": q, "analysis": a, "result": res}
|
||||
return {"run": run_id, "doc": doc, "query": q, "analysis": a, "result": res, "queries": more}
|
||||
|
||||
|
||||
def seg_id(doc: dict[str, Any], ref: str) -> str:
|
||||
@@ -118,11 +130,13 @@ async def test_the_phrase_opens_judgment_method_calculation_inputs_recompute_and
|
||||
assert [s["step"] for s in chain] == ["analysis", "analysis_method", "analysis_calc", "analysis_input", "query",
|
||||
"analysis_recompute", "analysis_seal"]
|
||||
judged, method, calc, given, query, again, seal = chain
|
||||
assert judged["phrase"] == made["result"]["phrase"] and judged["criterion"] == "一段占总变化一半以上算主要来源"
|
||||
assert judged["phrase"] == made["result"]["phrase"] == "销售额下降 194(-8.7%),主要来自华东(-120,占 61.9%)"
|
||||
assert judged["criterion"].startswith("一段占总变化的一半以上算主要来源")
|
||||
assert judged["verdict"] == {"code": "driver", "subjects": [["华东"]], "direction": "down"}
|
||||
assert judged["cited"] == {"what": "phrase"} and judged["render_ok"] is True and judged["eid_ok"] is True
|
||||
assert judged["origin"] == "card" and judged["item"] == "drop" and judged["label"] == "分析"
|
||||
assert judged["hypothesis"] == "地区拖累" and judged["hypothesis_note"].startswith("Agent 写的假设")
|
||||
assert judged["hypothesis"] == "华东拖累" and judged["hypothesis_note"].startswith("Agent 写的假设")
|
||||
assert {c["code"] for c in judged["caveats"]} == {"measure_unlabeled", "headline_basis"}
|
||||
assert method["method"] == "decompose.additive@1" and method["method_label"] == "变化拆解(可加)"
|
||||
assert {s["key"]: s["label"] for s in method["settings"]}["main_share"] == "「主要来源」的占比"
|
||||
assert {s["key"] for s in method["settings"]} >= {"main_share", "concentration", "table_top_k"}
|
||||
@@ -130,28 +144,30 @@ async def test_the_phrase_opens_judgment_method_calculation_inputs_recompute_and
|
||||
assert calc["table"]["columns"][0] == "region" and calc["table"]["labels"]["share"] == "占变化的比重"
|
||||
assert calc["table"]["total_rows"] == 4 and calc["table"]["rows"][0][:2] == ["华东", "820"]
|
||||
assert {f["label"]: f["text"] for f in calc["formulas"]}["占比"] == \
|
||||
"华东的占比 = 华东的变化 ÷ 总变化 = -120 ÷ -194 = 61.9%"
|
||||
"华东的占比 = 华东的变化 ÷ 总变化 = -120 ÷ (-194) = 61.9%"
|
||||
assert given == {"step": "analysis_input", "of": "A1", "ref": "Q2", "role": "data", "role_label": "数据",
|
||||
"artifact": made["query"], "columns": ["region", "week", "gmv"], "rows": "all", "query": "Q1",
|
||||
"node_id": "fetch", "sealed": True}
|
||||
assert query["alias"] == "Q1" and query["input_of"] == "A1" and query["total_rows"] == 8
|
||||
assert query["highlight"]["cols"] == ["region", "week", "gmv"]
|
||||
assert again["status"] == "failed" and again["text"] == "复算失败:系统里还没有这种分析的复算实现"
|
||||
# 真的复算:按 sha256 取回封存的输入快照,逐字段和封存的比
|
||||
assert again == {"step": "analysis_recompute", "alias": "A1", "status": "same", "method": "decompose.additive@1",
|
||||
"text": "复算一致:按封存的输入重新计算,结论逐项相同"}
|
||||
assert seal["sealed"] is True and seal["ledger"] is True and seal["hash_ok"] is True
|
||||
assert body["seal"]["covered"] is True
|
||||
assert body["note"].startswith("判定语由系统按平台的方法算出判定")
|
||||
assert body["segment"]["kind"] == "analysis"
|
||||
|
||||
|
||||
async def test_named_values_and_result_cells_point_at_what_they_cite(client, monkeypatch):
|
||||
monkeypatch.setattr(analysis, "recompute", lambda result, load, *, load_result=None: dict(result))
|
||||
async def test_named_values_and_result_cells_point_at_what_they_cite(client):
|
||||
made = await sealed_run(TEXT)
|
||||
value = (await client.get(
|
||||
f"/api/runs/{made['run']}/evidence/segments/{seg_id(made['doc'], 'a:A1.top_share|pct')}")).json()
|
||||
assert value["chain"][0]["cited"] == {"what": "value", "key": "top_share", "raw": "0.6186", "conv": "pct"}
|
||||
assert value["chain"][0]["cited"] == {"what": "value", "key": "top_share", "raw": "0.618556701031", "conv": "pct"}
|
||||
assert value["segment"]["text"] == "61.9%" and value["chain"][0]["render_ok"] is True
|
||||
calc = value["chain"][2]
|
||||
assert next(v for v in calc["values"] if v["key"] == "top_share") == {
|
||||
"key": "top_share", "raw": "0.6186", "rendered": "0.6186", "cited": True}
|
||||
"key": "top_share", "raw": "0.618556701031", "rendered": "0.618556701", "cited": True}
|
||||
assert value["chain"][-2]["text"] == "复算一致:按封存的输入重新计算,结论逐项相同"
|
||||
assert value["note"] == "这个数取自分析结论的具名的数,由系统按固定规则显示,未经模型转写"
|
||||
|
||||
@@ -163,20 +179,41 @@ async def test_named_values_and_result_cells_point_at_what_they_cite(client, mon
|
||||
|
||||
|
||||
async def test_the_recompute_gets_the_sealed_inputs_by_hash(client, monkeypatch):
|
||||
"""复算的 load 交工件原内容(不加出处、不改列的类型),只认封存范围内交回过的查询;别的一律当取不回。"""
|
||||
seen: dict[str, Any] = {}
|
||||
real = analysis.recompute
|
||||
|
||||
def recompute(result, load, *, load_result=None):
|
||||
seen["input"] = load(result["inputs"][0]["artifact"])
|
||||
seen["missing"] = load("0" * 64)
|
||||
return {**result, "method": "decompose.additive@2"}
|
||||
return real(result, load, load_result=load_result)
|
||||
|
||||
monkeypatch.setattr(analysis, "recompute", recompute)
|
||||
made = await sealed_run(TEXT)
|
||||
body = (await client.get(f"/api/runs/{made['run']}/evidence/segments/{seg_id(made['doc'], 'a:A1')}")).json()
|
||||
again = next(s for s in body["chain"] if s["step"] == "analysis_recompute")
|
||||
assert again["text"] == "运行时用的是 decompose.additive@1,现在是 decompose.additive@2,复算结果不同"
|
||||
assert seen["input"]["rows"] == SNAPSHOT["rows"] and seen["input"]["node_id"] == "fetch"
|
||||
assert seen["missing"] is None
|
||||
assert again["status"] == "same" and seen["input"] == SNAPSHOT and seen["missing"] is None
|
||||
|
||||
|
||||
async def test_an_input_outside_the_sealed_scope_is_not_recomputed_from(client):
|
||||
"""结论记着的输入快照不是这次运行交回过的(台账里没有):复算照实说取不回,不去工件库里捞。"""
|
||||
stray = {**SNAPSHOT, "sql": SNAPSHOT["sql"] + " -- 另一次"}
|
||||
s_id = await artifact_store.put_json(stray, kind="query_snapshot")
|
||||
made = await sealed_run(TEXT, result=await analyzed({"Q2": (stray, s_id)}))
|
||||
body = (await client.get(f"/api/runs/{made['run']}/evidence/segments/{seg_id(made['doc'], 'a:A1')}")).json()
|
||||
again = next(s for s in body["chain"] if s["step"] == "analysis_recompute")
|
||||
assert again["status"] == "failed" and again["text"] == "复算失败:取不回 Q2 的查询快照"
|
||||
given = next(s for s in body["chain"] if s["step"] == "analysis_input")
|
||||
assert given["sealed"] is False and given["query"] is None
|
||||
|
||||
|
||||
async def test_an_upgraded_method_names_both_versions(client, monkeypatch):
|
||||
made = await sealed_run(TEXT)
|
||||
monkeypatch.setitem(contract.METHODS, ("decompose", "additive"), "decompose.additive@2")
|
||||
body = (await client.get(f"/api/runs/{made['run']}/evidence/segments/{seg_id(made['doc'], 'a:A1')}")).json()
|
||||
again = next(s for s in body["chain"] if s["step"] == "analysis_recompute")
|
||||
assert again["method"] == "decompose.additive@1" and again["method_now"] == "decompose.additive@2"
|
||||
assert again["text"] == "运行时用的是 decompose.additive@1,现在是 decompose.additive@2,复算结果相同"
|
||||
|
||||
|
||||
async def test_recompute_errors_do_not_break_the_panel(client, monkeypatch):
|
||||
@@ -194,7 +231,8 @@ async def test_recompute_errors_do_not_break_the_panel(client, monkeypatch):
|
||||
async def test_a_tampered_result_is_said_and_not_shown(client):
|
||||
# 工件按内容寻址:改的是这一次独有的那份结论(别的测试的结论内容相同、是同一个文件)
|
||||
q = await artifact_store.put_json(SNAPSHOT, kind="query_snapshot")
|
||||
own = fake_result(inputs=[{"ref": "Q2", "artifact": q, "role": "data"}], criterion=f"只给这一次:{uuid.uuid4().hex}")
|
||||
own = await analyzed({"Q2": (SNAPSHOT, q)}, hypothesis=f"只给这一次:{uuid.uuid4().hex}")
|
||||
assert own["hypothesis"].startswith("只给这一次:")
|
||||
made = await sealed_run(TEXT, result=own)
|
||||
path = artifact_store._path_of(made["analysis"])
|
||||
path.write_text(path.read_text("utf-8").replace("华东", "华南"), "utf-8")
|
||||
@@ -210,27 +248,97 @@ async def test_agent_analyses_are_marked_as_such(client):
|
||||
assert body["chain"][0]["origin"] == "agent" and body["chain"][0]["call_id"] == "call-9"
|
||||
|
||||
|
||||
async def test_headline_inputs_show_the_closure_and_drill_downs_the_parent(client):
|
||||
base = fake_result()
|
||||
made = await sealed_run(TEXT)
|
||||
q, a = made["query"], made["analysis"]
|
||||
child = fake_result(inputs=[{"ref": "Q2", "artifact": q, "role": "data", "columns": ["region", "gmv"],
|
||||
"rows": [0, 1]},
|
||||
{"ref": "Q2.r1.gmv", "artifact": q, "role": "headline_target", "row": 1,
|
||||
"column": "gmv", "value": "2026"},
|
||||
{"ref": "A3", "artifact": a, "role": "parent"}],
|
||||
values={**base["values"], "target_total": "2026"})
|
||||
drilled = await sealed_run("[[a:A1]]。", result=child)
|
||||
body = (await client.get(f"/api/runs/{drilled['run']}/evidence/segments/{seg_id(drilled['doc'], 'a:A1')}")).json()
|
||||
async def test_headline_inputs_show_the_closure(client):
|
||||
"""给了总数(headline)的拆解:两格各是一份输入,和结论里的总数闭合;复算照样按 sha256 取回两份快照。"""
|
||||
totals = {"columns": ["gmv_base", "gmv"], "column_types": {"gmv_base": "number", "gmv": "number"},
|
||||
"rows": [[2220, 2026]], "sql": "SELECT 2220 AS gmv_base, 2026 AS gmv", "source": "shop",
|
||||
"truncated": False}
|
||||
t = artifact_store.content_hash(artifact_store.canonical_json(totals))
|
||||
q = artifact_store.content_hash(artifact_store.canonical_json(SNAPSHOT))
|
||||
result = await analyzed({"Q2": (SNAPSHOT, q), "Q5": (totals, t)}, headline=["Q5.r0.gmv_base", "Q5.r0.gmv"])
|
||||
made = await sealed_run("[[a:A1]]。", result=result, queries=[totals])
|
||||
body = (await client.get(f"/api/runs/{made['run']}/evidence/segments/{seg_id(made['doc'], 'a:A1')}")).json()
|
||||
inputs = [s for s in body["chain"] if s["step"] == "analysis_input"]
|
||||
assert [s["role"] for s in inputs] == ["data", "headline_target", "parent"]
|
||||
assert [s["role"] for s in inputs] == ["headline_base", "headline_target", "data"]
|
||||
assert inputs[0]["closure"] == {"total_key": "base_total", "total": "2,220", "headline": "2,220", "closed": True}
|
||||
assert inputs[1]["closure"] == {"total_key": "target_total", "total": "2,026", "headline": "2,026", "closed": True}
|
||||
assert inputs[2]["phrase"] == base["phrase"] and inputs[2]["role_label"] == "上一层拆解"
|
||||
query = next(s for s in body["chain"] if s["step"] == "query")
|
||||
assert [0, "region"] in query["highlight"]["cells"] and [1, "gmv"] in query["highlight"]["cells"]
|
||||
assert inputs[1]["query"] == "Q2" and inputs[1]["sealed"] is True and inputs[2]["query"] == "Q1"
|
||||
assert next(s for s in body["chain"] if s["step"] == "analysis_recompute")["status"] == "same"
|
||||
|
||||
|
||||
async def test_the_metric_step_shows_the_comparability(client):
|
||||
async def test_a_drill_down_points_at_its_parent_and_recomputes_from_it(client):
|
||||
"""下钻(华东按渠道再拆):输入里有上一层结论(parent),落到报告目录的 A1;复算按 sha256 取回台账记过的上一层。"""
|
||||
q = artifact_store.content_hash(artifact_store.canonical_json(SNAPSHOT))
|
||||
c = artifact_store.content_hash(artifact_store.canonical_json(CHANNELS))
|
||||
top = await analyzed({"Q2": (SNAPSHOT, q)})
|
||||
child = await analyzed({"Q3": (CHANNELS, c)}, parents={"A1": top}, query="Q3", by=["channel"],
|
||||
parent={"of": "A1", "key": ["华东"]})
|
||||
made = await sealed_run("[[a:A2]]。", result=child, parents=[top], queries=[CHANNELS])
|
||||
body = (await client.get(f"/api/runs/{made['run']}/evidence/segments/{seg_id(made['doc'], 'a:A2')}")).json()
|
||||
inputs = [s for s in body["chain"] if s["step"] == "analysis_input"]
|
||||
assert [s["role"] for s in inputs] == ["parent", "data"]
|
||||
assert inputs[0]["alias"] == "A1" and inputs[0]["phrase"] == top["phrase"] and inputs[0]["sealed"] is True
|
||||
assert inputs[0]["role_label"] == "上一层拆解" and inputs[1]["query"] == "Q2"
|
||||
again = next(s for s in body["chain"] if s["step"] == "analysis_recompute")
|
||||
assert again["status"] == "same", again
|
||||
graph = (await client.get(f"/api/runs/{made['run']}/evidence")).json()
|
||||
edges = {(e["from"], e["to"], e["rel"]) for e in graph["edges"]}
|
||||
assert {("A2", "A1", "derived_from"), ("A2", "Q2", "derived_from"), ("A1", "Q1", "derived_from")} <= edges
|
||||
|
||||
|
||||
#: 本周、上周两份同形查询(只差日期):口径卡跨这两份算环比时自动做可比性检查
|
||||
WINDOW = "SELECT SUM(gmv) AS gmv FROM orders WHERE order_date >= '{a}' AND order_date < '{b}'"
|
||||
LAST_WEEK = {"columns": ["gmv"], "column_types": {"gmv": "number"}, "rows": [[2220]],
|
||||
"sql": WINDOW.format(a="2026-10-05", b="2026-10-12"), "source": "shop", "truncated": False}
|
||||
THIS_WEEK = {**LAST_WEEK, "rows": [[2026]], "sql": WINDOW.format(a="2026-10-12", b="2026-10-19")}
|
||||
|
||||
|
||||
async def comparability_card() -> tuple[dict[str, Any], dict[str, Any]]:
|
||||
"""一张跨两周算环比的口径卡,指标上记着口径卡执行时自动做的可比性检查(结论落成工件,不进台账):(卡, 可比性结论)。"""
|
||||
last = artifact_store.content_hash(artifact_store.canonical_json(LAST_WEEK))
|
||||
this = artifact_store.content_hash(artifact_store.canonical_json(THIS_WEEK))
|
||||
result = await analyzed({"fetch·base": (LAST_WEEK, last), "fetch·target": (THIS_WEEK, this)},
|
||||
{"op": "comparable", "mode": None, "params": {}},
|
||||
base_query="fetch·base", target_query="fetch·target")
|
||||
found = await artifact_store.put_json(result, kind=ARTIFACT_KIND, node_id="card")
|
||||
verdict = result["verdict"]["code"]
|
||||
card = {"kind": "metric_set", "caliber": "周报口径", "caliber_version": "v1", "metrics": [
|
||||
{"id": "wow", "name": "环比", "value": -0.0874, "unit": "",
|
||||
"expression": "cell(nodes.fetch, 0, 'gmv') / cell(nodes.fetch, 0, 'gmv') - 1",
|
||||
"substituted": "2026 / 2220 - 1", "recompute_ok": True,
|
||||
"inputs": [{"path": "cell(nodes.fetch, 0, 'gmv')", "value": 2026, "node_id": "fetch", "via": "tool_cell",
|
||||
"artifact": this, "locator": {"row": 0, "column": "gmv"}},
|
||||
{"path": "cell(nodes.fetch, 0, 'gmv')", "value": 2220, "node_id": "fetch", "via": "tool_cell",
|
||||
"artifact": last, "locator": {"row": 0, "column": "gmv"}}],
|
||||
"comparability": {"artifact": found, "verdict": verdict, "phrase": result["phrase"], "reasons": []}}]}
|
||||
return card, result
|
||||
|
||||
|
||||
async def test_the_metric_step_opens_the_comparability_result(client):
|
||||
"""可比性结论不进台账、只从口径卡的指标集里引用:照卡上记的 sha256 取回,随卡封存;点得开它的整条出处链,复算是真的。"""
|
||||
card, result = await comparability_card()
|
||||
made = await sealed_run("环比 [[m:wow]]。", card=card, queries=[LAST_WEEK, THIS_WEEK])
|
||||
body = (await client.get(f"/api/runs/{made['run']}/evidence/segments/{seg_id(made['doc'], 'm:wow')}")).json()
|
||||
view = body["chain"][0]["comparability"]
|
||||
assert view["verdict"] == result["verdict"]["code"] and view["phrase"] == result["phrase"]
|
||||
assert view["sealed"] is True and view["hash_ok"] is True and view["method"] == "comparable@1"
|
||||
steps = view["steps"]
|
||||
assert [s["step"] for s in steps] == ["analysis", "analysis_method", "analysis_calc", "analysis_input",
|
||||
"analysis_input", "analysis_recompute", "analysis_seal"]
|
||||
judged, method, calc, base, target, again, seal = steps
|
||||
assert judged["origin"] == "metric" and judged["cited"] == {"what": "phrase"} and judged["render_ok"] is True
|
||||
assert judged["method_label"] == "可比性检查" and judged["node_id"] == "card"
|
||||
assert [r[0] for r in calc["table"]["rows"]] == ["同口径", "窗口长度", "整期", "星期构成", "数据问题"]
|
||||
assert (base["role"], target["role"]) == ("base", "target")
|
||||
assert base["query"] == "Q2" and target["query"] == "Q3" and base["sealed"] is True
|
||||
assert again["status"] == "same" and again["text"] == "复算一致:按封存的输入重新计算,结论逐项相同"
|
||||
assert seal["via"] == "metric_set" and seal["ledger"] is False and seal["sealed"] is True
|
||||
assert seal["note"].startswith("这份可比性结论不进台账")
|
||||
# 两份输入快照的查询步骤在指标链里(指标的输入就是这两份),可比性的链里不再给
|
||||
assert [s["step"] for s in body["chain"]].count("query") == 2 and "query" not in [s["step"] for s in steps]
|
||||
|
||||
|
||||
async def test_a_card_without_the_comparability_artifact_says_only_what_it_recorded(client):
|
||||
card = {"kind": "metric_set", "caliber": "周报口径", "caliber_version": "v1", "metrics": [
|
||||
{"id": "wow", "name": "环比", "value": -0.087, "unit": "", "expression": "1", "inputs": [],
|
||||
"comparability": {"artifact": "", "verdict": "incomparable", "phrase": "两期不可比:本期只有 3 天数据",
|
||||
@@ -242,6 +350,15 @@ async def test_the_metric_step_shows_the_comparability(client):
|
||||
"artifact": None, "hash_ok": None, "sealed": False}
|
||||
|
||||
|
||||
async def test_the_app_metric_endpoint_opens_the_comparability_too(client):
|
||||
card, _ = await comparability_card()
|
||||
made = await sealed_run("环比 [[m:wow]]。", card=card, queries=[LAST_WEEK, THIS_WEEK])
|
||||
body = (await client.get(f"/api/runs/{made['run']}/evidence/metrics/card/wow")).json()
|
||||
view = body["chain"][0]["comparability"]
|
||||
assert view["sealed"] is True and view["steps"][-2]["status"] == "same"
|
||||
assert [s["query"] for s in view["steps"] if s["step"] == "analysis_input"] == [None, None]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 审计
|
||||
# --------------------------------------------------------------------------
|
||||
@@ -286,7 +403,7 @@ def test_audit_labels_cover_the_new_violation_codes():
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
SCOPE = {"analysis_scope": {
|
||||
"phenomena": [{"alias": "A1", "op": "decompose", "phrase": "销售额下降 194 万(-8.7%),主要来自华东(-120 万,占 62%)"}],
|
||||
"phenomena": [{"alias": "A1", "op": "decompose", "phrase": "销售额下降 194(-8.7%),主要来自华东(-120,占 61.9%)"}],
|
||||
"decomposed": [{"alias": "A1", "op": "decompose", "mode": "additive", "dims": ["地区"], "verdict": "driver",
|
||||
"phrase": "主要来自华东"}],
|
||||
"excluded": [], "refused": [{"alias": "A1", "op": "baseline", "reason": "历史只有 5 期,至少要 8 期"}],
|
||||
|
||||
@@ -97,3 +97,21 @@ def test_a_report_citing_only_analyses_has_nothing_to_label():
|
||||
assert ledger_labels.label_doc(doc, {}, {}, lambda _: None) == {}
|
||||
assert ledger_labels.referenced_columns([doc], lambda _: None) == {}
|
||||
assert ledger_labels.whole_of({}, {})["reason"] == "报告里没有可标口径的数"
|
||||
|
||||
|
||||
def test_the_judge_and_the_writer_see_the_comparability_of_a_metric():
|
||||
"""口径卡指标上的可比性(口径卡执行时自动做的检查):裁判的摘录里原样给判定语;写作目录没记原因的照判定语写,不重复判定。"""
|
||||
from app.core.artifact_store import canonical_json, content_hash
|
||||
from app.engine.evidence import writer_catalog
|
||||
|
||||
card = {"kind": "metric_set", "caliber": "周报", "caliber_version": "v1", "metrics": [
|
||||
{"id": "wow", "name": "环比", "value": -0.087, "unit": "", "expression": "1", "inputs": [],
|
||||
"comparability": {"artifact": "d" * 64, "verdict": "incomparable", "phrase": "两期不可比:本期只有 3 天数据",
|
||||
"reasons": []}}]}
|
||||
sha = content_hash(canonical_json(card))
|
||||
catalog = build_catalog(nodes={"card": {**card, "artifact": sha}}, ledger=[])
|
||||
assert "环比 = -0.087(两期不可比:本期只有 3 天数据。这个比较不能当结论" in writer_catalog(catalog).text
|
||||
doc = compose_doc("环比 [[m:wow]],需求走弱。", catalog)
|
||||
request = judging.prepare(doc, catalog, loader={sha: card}.get)
|
||||
[excerpt] = request.excerpts.values()
|
||||
assert "两期可比性(系统检查):两期不可比:本期只有 3 天数据" in excerpt
|
||||
|
||||
@@ -19,8 +19,8 @@ from httpx import ASGITransport, AsyncClient
|
||||
import app.bundle
|
||||
import app.report_export
|
||||
from app.main import app as asgi
|
||||
from tests.test_analysis_bundle import bundle_of
|
||||
from tests.test_analysis_evidence_api import SCOPE, TEXT, sealed_run, seg_id
|
||||
from tests.test_analysis_bundle import bundle_of, card_bundle
|
||||
from tests.test_analysis_evidence_api import LAST_WEEK, SCOPE, TEXT, THIS_WEEK, comparability_card, sealed_run, seg_id
|
||||
|
||||
NODE = shutil.which("node")
|
||||
pytestmark = pytest.mark.skipif(NODE is None, reason="没有 node,无法执行页面上的脚本")
|
||||
@@ -129,15 +129,27 @@ async def test_the_export_page_opens_the_analysis_steps_and_the_scope_numbers():
|
||||
segs = [{"seg": phrase, "kind": "analysis", "state": "deterministic", "text": made["result"]["phrase"]},
|
||||
{"seg": cell, "kind": "number", "state": "deterministic", "text": "-120"},
|
||||
{"seg": "scope:A1", "kind": "analysis", "state": "deterministic", "text": "A1"}]
|
||||
out = run_node(RUN_RUNTIME, RUNTIME, {"data": json.loads(json.dumps(data)), "segs": segs})
|
||||
# 现查结果的三种写法:按运行当天现算的界、一列一个值都没有、表的范围(结论里的 probes 原样交给页面)
|
||||
parsed = json.loads(data)
|
||||
method = next(s for s in parsed["chains"][parsed["refs"][phrase]] if s["step"] == "analysis_method")
|
||||
method["probes"] = [
|
||||
{"source": "shop", "expr": "date('now', '-7 days')", "value": "2026-10-14", "basis": "live",
|
||||
"at": "2026-10-21T09:00:00"},
|
||||
{"source": "shop", "table": "orders", "column": "refund_date", "min": None, "max": None, "basis": "live",
|
||||
"at": "2026-10-21T09:00:00"},
|
||||
{"source": "shop", "table": "orders", "column": "order_date", "min": "2025-01-01", "max": "2026-10-20",
|
||||
"basis": "profile", "at": "2026-10-21T09:00:00"}]
|
||||
out = run_node(RUN_RUNTIME, RUNTIME, {"data": json.dumps(parsed, ensure_ascii=False), "segs": segs})
|
||||
opened = out[phrase]
|
||||
assert opened["steps"] == ["analysis", "analysis_method", "analysis_calc", "analysis_input", "query",
|
||||
"analysis_recompute", "analysis_seal"]
|
||||
assert opened["title"].startswith("判定「销售额下降")
|
||||
body = opened["body"]
|
||||
for text in ("判定标准一段占总变化一半以上算主要来源", "Agent 写的假设地区拖累", "实际用的阈值", "「主要来源」的占比",
|
||||
"华东的占比 = 华东的变化 ÷ 总变化 = -120 ÷ -194 = 61.9%", "结果表(列出 4 行,共 4 行)",
|
||||
"复算失败:系统里还没有这种分析的复算实现", "封存范围内的台账记过这份分析结论"):
|
||||
for text in ("判定标准一段占总变化的一半以上算主要来源", "Agent 写的假设华东拖累", "实际用的阈值", "「主要来源」的占比",
|
||||
"华东的占比 = 华东的变化 ÷ 总变化 = -120 ÷ (-194) = 61.9%", "结果表(列出 4 行,共 4 行)",
|
||||
"复算一致:按封存的输入重新计算,结论逐项相同", "封存范围内的台账记过这份分析结论",
|
||||
"按运行当天现算的界 date('now', '-7 days') = 2026-10-14(现查 · 2026-10-21T09:00:00)",
|
||||
"orders.refund_date:这一列一个值都没有(现查", "orders.order_date:2025-01-01 至 2026-10-20(剖析"):
|
||||
assert text in body, text
|
||||
assert "结果表第 1 行「delta」" in out[cell]["body"]
|
||||
assert out["scope:A1"]["steps"] == opened["steps"]
|
||||
@@ -151,10 +163,40 @@ async def test_the_bundle_page_shows_the_analysis_detail_and_the_scope():
|
||||
assert scope.startswith("分析范围") and "现象A1:销售额下降" in scope and "拆过A1(按地区):主要来自华东" in scope
|
||||
assert "没拆渠道" in scope and "这次做了 2 次差异检验" in scope
|
||||
phrase = next(text for text in out["opened"].values() if "出处分析结论 A1 的判定语" in text)
|
||||
assert "核对结果✓ 通过" in phrase and "分析结论里的值「销售额下降 194 万" in phrase
|
||||
assert "判定语销售额下降 194 万" in phrase and "方法与版本decompose.additive@1" in phrase
|
||||
assert "复算失败:系统里还没有这种分析的复算实现(导出时服务端按封存的输入复算的结论;本页只核哈希" in phrase
|
||||
assert "核对结果✓ 通过" in phrase and "分析结论里的值「销售额下降 194(-8.7%)" in phrase
|
||||
assert "判定语销售额下降 194(-8.7%)" in phrase and "方法与版本decompose.additive@1" in phrase
|
||||
assert "输入数据 · Q1" in phrase # 输入的角色写叫法,不写 data
|
||||
assert "复算一致:按封存的输入重新计算,结论逐项相同(导出时服务端按封存的输入复算的结论;本页只核哈希" in phrase
|
||||
value = next(text for text in out["opened"].values() if "具名的数「top_share」" in text)
|
||||
assert "引用的值0.6186" in value and "正文显示61.9%(与按显示规则渲染的结果一致)" in value
|
||||
assert "引用的值0.618556701031" in value and "正文显示61.9%(与按显示规则渲染的结果一致)" in value
|
||||
scope_item = next(text for key, text in out["opened"].items() if key.endswith("|scope:A1"))
|
||||
assert "核对结果✓ 通过" in scope_item and "正文显示" not in scope_item
|
||||
|
||||
|
||||
async def test_the_export_page_opens_the_comparability_on_a_metric():
|
||||
"""口径卡指标上的可比性:指标那一步里写判定,点得开那份可比性结论(同分析结论的几步,收在一个可展开的块里)。"""
|
||||
card, result = await comparability_card()
|
||||
made = await sealed_run("环比 [[m:wow]]。", card=card, queries=[LAST_WEEK, THIS_WEEK])
|
||||
async with AsyncClient(transport=ASGITransport(app=asgi), base_url="http://test") as client:
|
||||
html = (await client.get(f"/api/runs/{made['run']}/report.html")).text
|
||||
data = re.search(r'<script type="application/json" id="report-data">(.*?)</script>', html, re.S).group(1)
|
||||
wow = seg_id(made["doc"], "m:wow")
|
||||
out = run_node(RUN_RUNTIME, RUNTIME, {"data": data, "segs": [
|
||||
{"seg": wow, "kind": "number", "state": "deterministic", "text": "-0.0874"}]})
|
||||
opened = out[wow]
|
||||
assert opened["steps"][:1] == ["metric"]
|
||||
assert opened["steps"][opened["steps"].index("analysis"):] [:3] == ["analysis", "analysis_method", "analysis_calc"]
|
||||
for text in ("两期可比性", "展开这份可比性结论", "可比性检查", "口径卡执行时自动做的可比性检查", result["phrase"],
|
||||
"同口径", "复算一致:按封存的输入重新计算,结论逐项相同", "记在口径卡的指标集里,随卡封存(不进台账)"):
|
||||
assert text in opened["body"], text
|
||||
|
||||
|
||||
def test_the_bundle_page_shows_the_comparability_in_the_metric_detail():
|
||||
bundle, _, _, _ = card_bundle()
|
||||
out = run_node(RUN_VERIFIER, VERIFIER, {"data": json.dumps(bundle), "seal": bundle["meta"]["manifest_hash"]})
|
||||
assert out["verified"] == ""
|
||||
[detail] = out["opened"].values()
|
||||
for text in ("两期可比性", "判定两期可比", "判定标准只差日期", "方法与版本comparable@1", "各项检查", "同口径",
|
||||
"复算一致:按封存的输入重新计算,结论逐项相同(导出时服务端按封存的输入复算的结论"):
|
||||
assert text in detail, text
|
||||
|
||||
|
||||
Reference in New Issue
Block a user