M2 证据面板和推演认得出改了名字的遮罩列,指标本身的原值也不露:查询步骤、指标的输入、推演的勾行与遮罩、合并查询按 SQL 认取自遮罩列的结果列(c.phone AS tel 这类别名、函数、子查询、WITH),和可验证报告、核查 agent 同一套认法;用到遮罩列的指标,推演答复里的 old、rendered_old 和证据面板指标步骤的 value 写「已遮罩」

验收里证据面板对 c.phone AS tel 的快照给出 masked=[]、三个号码原样交出;推演把 phone_raw 判成 masked、输入置空,指标的 old 却还是那串号码。现在:
- 认遮罩列只有一个函数 api/evidence.py 的 _snapshot_masks(查询当时记下的加数据源现在设的,再经 engine/masking.py 的 _derived_hidden 按 SQL 认改了名字的;SQL 解析不了又写着遮罩列的整份遮),查询步骤、_InputMasks、推演的 _mask_of 都调它;_Masks 顺带记数据源类型,按它的方言解析
- 合并查询按逐格来历遮:输入快照里改了名字的遮罩列(输入是合并结果的再往下追)也遮到合并结果里
- 指标的原值按 recompute.hides_value 一个判断:有输入取自遮罩列(含只嵌在下标里的),或者最外层的输入遮没遮核对不了;推演结果标 withheld,报告里引用它的地方 rendered_old 同样写「已遮罩」
- 面板底下的遮罩说明改成「这些列取自数据源中设置了遮罩的列」:遮的可能是别名列
This commit is contained in:
ThearchyHelios
2026-10-07 00:13:50 +08:00
parent a45ca28c6b
commit 76fa42849c
5 changed files with 731 additions and 44 deletions
@@ -0,0 +1,309 @@
"""证据面板认得出改了名字的遮罩列:查询步骤、指标的输入、推演的勾行和遮罩,按 SQL 认。
验收发现:正式运行的报告没写号码,可验证报告也把 top 查询(c.phone AS tel)的快照只给了哈希,点开正文里的消费额,
片段接口的查询步骤却是 columns=[customer, tel, spend]、masked=[],三个号码原样交出来。证据面板以前只遮列名恰好等于
遮罩列的那几列;可验证报告、核查 agent 早已按 SQL 认出别名、函数、子查询、WITH 转一道得来的结果列。现在证据面板
按同一套认法(engine/masking.py 的 _derived_hidden):
- 查询步骤:c.phone AS tel 的 tel 列遮掉,面板底下的遮罩说明带上它
- 指标的输入:cell() 取 tel 那一格、按位置取的 vars.res.rows[0][1] 都不给值;指标本身的值也不给
- 推演:勾行接口遮 tel,用到 tel 的指标推演不了、原值不给
- SQL 解析不了、里面又写着遮罩列的,整份快照的列都遮(保守规则);没写着的只遮遮罩列本身
- 合并查询:输入快照里改了名字的遮罩列,按逐格来历遮到合并结果里
- 没设遮罩时一切照旧
真跑一遍图(虚构的 SQLite 商城库,号码是编的),报告由 MockChatModel 照剧本写。
"""
from __future__ import annotations
import asyncio
import json
import sqlite3
import pytest
from httpx import ASGITransport, AsyncClient
from langchain_core.messages import AIMessage
from sqlalchemy import select
from app.core import artifact_store
from app.data.engine import engines
from app.db.base import SessionLocal
from app.db.models import DataSource, Run
from app.engine.evidence import iter_segments
from app.engine.runner import run_manager
from app.main import app
CUSTOMERS = [(1, "客户甲", "199-0000-0101"), (2, "客户乙", "199-0000-0102"), (3, "客户丙", "199-0000-0103"),
(4, "客户丁", "199-0000-0104")]
ORDERS = [(1, 1, 120.5), (2, 2, 300.0), (3, 2, 80.0), (4, 3, 210.25), (5, 4, 50.0), (6, 1, 99.5)]
PHONES = [c[2] for c in CUSTOMERS]
#: 验收原样的写法:号码起了别名 tel,和消费额排在同一份结果里
SQL_TOP = ("SELECT c.name AS customer, c.phone AS tel, ROUND(SUM(o.amount), 2) AS spend "
"FROM orders o JOIN customers c ON c.id = o.customer_id GROUP BY c.id, c.name, c.phone ORDER BY spend DESC")
TEL_CELL = "cell(nodes.top, 0, 'tel')"
#: 号码那一格按位置取:vars.res 是数据整形解析好的查询结果,第 1 列是 tel
TEL_POS = "vars.res.rows[0][1]"
METRICS = [
{"id": "top_spend", "name": "最高消费", "unit": "元", "decimals": 2, "format": "thousands",
"expression": "cell(nodes.top, 0, 'spend')"},
{"id": "tel_len", "name": "号码位数", "unit": "位", "format": "thousands", "expression": f"len({TEL_CELL})"},
{"id": "tel_pos2", "name": "号码位数两倍", "unit": "位", "format": "thousands", "expression": f"len({TEL_POS}) * 2"},
]
TEXT = "消费最高的客户花了 [[v:Q1.r0.spend]],口径卡记 [[m:top_spend]];号码 [[m:tel_len]],两倍 [[m:tel_pos2]]。"
@pytest.fixture(autouse=True)
async def engine_up():
await run_manager.setup()
yield
await run_manager.shutdown()
@pytest.fixture
async def client():
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c:
yield c
async def set_source(path, options=None):
async with SessionLocal() as session:
row = (await session.execute(select(DataSource).where(DataSource.name == "mall"))).scalar_one_or_none()
if row is None:
row = DataSource(name="mall", kind="sqlite", database=str(path), readonly=True, enabled=True)
session.add(row)
row.database, row.kind, row.enabled, row.readonly = str(path), "sqlite", True, True
row.options = dict(options or {})
await session.commit()
return row.id
@pytest.fixture
async def mall(tmp_path):
path = tmp_path / "mall.db"
db = sqlite3.connect(path)
db.executescript("CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT, phone TEXT);"
"CREATE TABLE orders (id INTEGER PRIMARY KEY, customer_id INTEGER, amount REAL);")
db.executemany("INSERT INTO customers VALUES (?, ?, ?)", CUSTOMERS)
db.executemany("INSERT INTO orders VALUES (?, ?, ?)", ORDERS)
db.commit()
db.close()
source_id = await set_source(path)
await engines.invalidate(source_id)
yield path
await engines.invalidate(source_id)
def node(nid, ntype, **config):
return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0}, "data": {"label": nid, "config": config}}
def chain(*nodes) -> dict:
return {"nodes": list(nodes), "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
def graph() -> dict:
return chain(
node("start", "input"),
node("top", "tool", tool="db_query__mall", args={"sql": SQL_TOP}),
node("parse", "transform", mode="json", template="{{ nodes.top }}", assign_to="res"),
node("card", "metrics", caliber="商城口径", caliber_version="v1", metrics=METRICS),
node("write", "report", instructions="写一句", on_violation="flag"),
node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}]),
)
async def run_graph(monkeypatch, spec: dict | None = None, text: str = TEXT) -> Run:
from app.providers import mock_model
monkeypatch.setattr(mock_model.MockChatModel, "_decide", lambda self, messages: AIMessage(content=text))
run_id = (await run_manager.start(graph=spec or graph(), input_payload={})).id
for _ in range(400):
await asyncio.sleep(0.05)
async with SessionLocal() as session:
row = await session.get(Run, run_id)
if row.status in ("succeeded", "failed") and row.manifest_seq is not None:
assert row.status == "succeeded", row.error
return row
raise AssertionError(f"运行 {run_id} 没跑完:{row.status}")
async def doc_of(client, run_id: str) -> dict:
[report] = (await client.get(f"/api/runs/{run_id}/evidence")).json()["reports"]
return artifact_store.load(report["doc_artifact"])
async def segment(client, run_id: str, *, text: str | None = None, ref: str | None = None) -> dict:
"""按正文里的字或者引用(v:Q1.r0.spend)找片段,取片段接口的答复。"""
doc = await doc_of(client, run_id)
seg = next(s for s in iter_segments(doc) if (text is not None and s["text"] == text)
or (ref is not None and s.get("ref") == ref))
res = await client.get(f"/api/runs/{run_id}/evidence/segments/{seg['id']}")
assert res.status_code == 200, res.text
return res.json()
def leaks(body) -> list[str]:
raw = json.dumps(body, ensure_ascii=False)
return [p for p in PHONES if p in raw]
def steps(body: dict, kind: str) -> list[dict]:
return [s for s in body["chain"] if s["step"] == kind]
# --------------------------------------------------------------------------
# 查询步骤
# --------------------------------------------------------------------------
async def test_a_renamed_masked_column_is_masked_in_the_query_step(client, monkeypatch, mall):
"""验收原样:点开正文里直接引用的消费额,查询步骤里 c.phone AS tel 的 tel 列遮掉,号码一个都不交出来。"""
await set_source(mall, {"mask_columns": ["phone"]})
row = await run_graph(monkeypatch)
body = await segment(client, row.id, ref="v:Q1.r0.spend")
[query] = steps(body, "query")
assert query["columns"] == ["customer", "tel", "spend"] and query["masked"] == ["tel"], query["masked"]
assert [r[1] for r in query["rows"]] == ["已遮罩"] * len(query["rows"]) and query["rows"][0][2] == 380.0
assert body["redacted"]["columns"] == ["tel"] and body["redacted"]["note"]
assert leaks(body) == []
async def test_the_metric_chain_masks_the_renamed_column_too(client, monkeypatch, mall):
"""口径卡指标 → 输入 → 查询:查询步骤同一套认法,tel 列同样遮掉(验收的 s13)。"""
await set_source(mall, {"mask_columns": ["phone"]})
row = await run_graph(monkeypatch)
body = await segment(client, row.id, text="380.00元")
[query] = steps(body, "query")
assert query["masked"] == ["tel"] and leaks(body) == []
[amount] = steps(body, "input")
assert amount["value"] == 380.0 and "masked" not in amount
async def test_an_input_taken_from_a_renamed_masked_column_is_withheld(client, monkeypatch, mall):
"""cell() 取 tel 那一格:输入不给值、写明取自哪一列,代入式里那一处写「已遮罩」,指标本身的值也不给。"""
await set_source(mall, {"mask_columns": ["phone"]})
row = await run_graph(monkeypatch)
body = await segment(client, row.id, text="13位")
metric = body["chain"][0]
assert metric["step"] == "metric" and metric["substituted"] == "len(已遮罩)"
assert metric["value"] == "已遮罩" and metric["rendered"] == "13位"
[cell] = steps(body, "input")
assert cell["value"] == "已遮罩" and cell["masked"] == ["tel"] and cell["path"] == TEL_CELL
assert body["redacted"]["columns"] == ["tel"] and leaks(body) == []
async def test_a_scalar_taken_by_position_from_a_renamed_masked_column_is_withheld(client, monkeypatch, mall):
"""vars.res.rows[0][1]:没有定位,顺着取值链认出取自查询结果的 tel 列,tel 又是 phone 改的名字。"""
await set_source(mall, {"mask_columns": ["phone"]})
row = await run_graph(monkeypatch)
body = await segment(client, row.id, text="26位")
assert body["chain"][0]["substituted"] == "len(已遮罩) * 2" and body["chain"][0]["value"] == "已遮罩"
[pos] = steps(body, "input")
assert pos["path"] == TEL_POS and pos["value"] == "已遮罩" and pos["masked"] == ["tel"]
assert leaks(body) == []
async def test_without_masks_nothing_changes(client, monkeypatch, mall):
row = await run_graph(monkeypatch)
body = await segment(client, row.id, ref="v:Q1.r0.spend")
[query] = steps(body, "query")
assert query["masked"] == [] and query["rows"][0][1] == "199-0000-0102" and body["redacted"] == {"columns": []}
plen = await segment(client, row.id, text="13位")
assert plen["chain"][0]["value"] == 13 and plen["chain"][0]["substituted"] == "len('199-0000-0102')"
async def test_a_mask_set_after_the_run_also_reaches_renamed_columns(client, monkeypatch, mall):
"""事后才给数据源加的遮罩:按数据源现在设的列认 SQL,改了名字的照样遮。"""
row = await run_graph(monkeypatch)
await set_source(mall, {"mask_columns": "phone"})
body = await segment(client, row.id, ref="v:Q1.r0.spend")
assert steps(body, "query")[0]["masked"] == ["tel"] and leaks(body) == []
# --------------------------------------------------------------------------
# 推演:勾行接口、用到 tel 的指标
# --------------------------------------------------------------------------
async def test_the_whatif_masks_the_renamed_column(client, monkeypatch, mall):
await set_source(mall, {"mask_columns": ["phone"]})
row = await run_graph(monkeypatch)
body = await segment(client, row.id, ref="v:Q1.r0.spend")
snapshot = steps(body, "query")[0]["artifact"]
page = (await client.get(f"/api/runs/{row.id}/evidence/whatif/rows", params={"artifact": snapshot})).json()
assert page["masked"] == ["tel"] and all(r[1] == "已遮罩" for r in page["rows"]) and leaks(page) == []
res = await client.post(f"/api/runs/{row.id}/evidence/whatif", json={"card": "card"})
assert res.status_code == 200, res.text
metrics = {m["id"]: m for m in res.json()["metrics"]}
assert metrics["tel_len"]["status"] == "masked" and metrics["tel_pos2"]["status"] == "masked"
assert metrics["top_spend"]["status"] == "unchanged" and metrics["top_spend"]["old"] == 380.0
assert leaks(res.json()) == []
res = await client.post(f"/api/runs/{row.id}/evidence/whatif",
json={"card": "card", "overrides": {"inputs": {TEL_CELL: 1}}})
assert res.status_code == 422 and "遮罩" in res.json()["detail"]
# --------------------------------------------------------------------------
# 合并查询:输入里改了名字的遮罩列,按逐格来历遮到合并结果里
# --------------------------------------------------------------------------
async def test_a_merged_result_masks_a_column_renamed_in_its_input(client, monkeypatch, mall):
await set_source(mall, {"mask_columns": ["phone"]})
spec = chain(
node("start", "input"),
node("q_cust", "tool", tool="db_query__mall", args={"sql": "SELECT id, phone AS tel FROM customers ORDER BY id"}),
node("q_ord", "tool", tool="db_query__mall",
args={"sql": "SELECT customer_id AS id, SUM(amount) AS amount FROM orders GROUP BY customer_id ORDER BY id"}),
node("merged", "merge", inputs={"a": "q_cust", "b": "q_ord"},
sql="SELECT a.id, a.tel, b.amount FROM a JOIN b ON a.id = b.id ORDER BY a.id"),
node("write", "report", instructions="写一句", on_violation="flag"),
node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}]),
)
row = await run_graph(monkeypatch, spec, text="一号客户共消费 [[v:Q3.r0.amount]]。")
body = await segment(client, row.id, ref="v:Q3.r0.amount")
merged = next(s for s in steps(body, "query") if s.get("merge"))
assert "tel" in merged["masked"] and all(r[merged["columns"].index("tel")] == "已遮罩" for r in merged["rows"])
assert leaks(body) == []
# --------------------------------------------------------------------------
# 手搭的快照:SQL 的几种写法,解析不了时的保守规则
# --------------------------------------------------------------------------
#: 库里没有这个数据源:遮罩只有查询当时记在快照里的那一份(phone)
GHOST = "ghost_mall"
async def query_step(sql: str, columns: list[str], rows: list[list]) -> dict:
"""手搭一份封存范围内的查询快照(查询当时记下了遮罩列 phone),直接走查询步骤(evidence._query_step)。"""
from app.api import evidence
snap = await artifact_store.put_json({"columns": columns, "rows": rows, "source": GHOST, "sql": sql,
"mask_columns": ["phone"]}, kind="query")
sealed = evidence._Sealed(run_id="syn-alias", graph={}, events=[],
seal={"sealed": True, "ok": True, "manifest_seq": 1, "legacy": False})
sealed.queries = {snap: {"node_id": "q", "tool": f"db_query__{GHOST}", "source": GHOST}}
return await evidence._query_step(snap, [(0, columns[0])], {"catalog": {}}, sealed, evidence._Masks())
@pytest.mark.parametrize("sql, columns, masked", [
# 函数套一层再经 WITH 转一道
("WITH t AS (SELECT name, UPPER(phone) AS p FROM customers) SELECT name AS customer, p AS contact FROM t",
["customer", "contact"], ["contact"]),
# 子查询里起的别名,外层再选出来
("SELECT x.who, x.num FROM (SELECT name AS who, phone AS num FROM customers) x", ["who", "num"], ["num"]),
# 截一段再拼上星号:值仍取自遮罩列
("SELECT name, substr(phone, 1, 3) || '****' AS short_tel FROM customers", ["name", "short_tel"], ["short_tel"]),
# 只数个数:带不出值,不遮
("SELECT COUNT(DISTINCT phone) AS n FROM customers", ["n"], []),
# 解析不了、又写着遮罩列:整份快照的列都遮
("SELECT name, phone AS p FROM customers WHERE ((", ["name", "p"], ["name", "p"]),
# 解析不了、没写着遮罩列:只遮遮罩列本身(结果里没有)
("SELECT name, id AS p FROM customers WHERE ((", ["name", "p"], []),
])
async def test_the_query_step_reads_the_sql_like_the_bundle_and_the_verify_agent(sql, columns, masked):
rows = [["客户甲" if i == 0 else "199-0000-0101" for i in range(len(columns))]]
step = await query_step(sql, columns, rows)
assert step["masked"] == masked, step["masked"]
assert [v == "已遮罩" for v in step["rows"][0]] == [c in masked for c in columns]
+268
View File
@@ -0,0 +1,268 @@
"""推演和证据面板不露指标本身的原值:指标的输入取自遮罩格(或者指标的值本身就是遮罩格)时,原值写「已遮罩」。
验收发现:phone_raw = cell(nodes.q_cust, 0, 'phone') 推演时判成 masked,输入里置了空,指标的 old、rendered_old 却还是那串
号码;按位置取的 phone_pos 也一样。同一份答复里输入拿掉了、指标上照给,等于没遮。现在:
- 推演(engine/recompute.py):用到了遮罩列的指标(哪怕只嵌在下标里),old、rendered_old 写「已遮罩」,标 withheld,
原因照旧写在 reason 里;new、rendered_new 本来就是空的(推演不了);报告里引用它的地方 rendered_old 同样写「已遮罩」
- 最外层的输入遮没遮核对不了(快照读不出来)的也一样;只嵌在下标里、遮没遮核对不了的那一格不碍事,原值照给
- 证据面板的指标步骤:value 按同一个判断写「已遮罩」(recompute.hides_value),报告上的字(rendered)照旧
- 没用到遮罩列的指标一字不差
前半是纯函数(手写的虚构卡和快照),后半真跑一遍图(虚构的 SQLite 客户库,号码是编的)。
"""
from __future__ import annotations
import asyncio
import json
import sqlite3
import pytest
from httpx import ASGITransport, AsyncClient
from langchain_core.messages import AIMessage
from sqlalchemy import select
from app.core import artifact_store
from app.data.engine import engines
from app.db.base import SessionLocal
from app.db.models import DataSource, Run
from app.engine import recompute
from app.engine.evidence import iter_segments
from app.engine.recompute import Changes, Sources, whatif
from app.engine.runner import run_manager
from app.main import app
# --------------------------------------------------------------------------
# 纯函数:手写的卡和快照
# --------------------------------------------------------------------------
SNAP, OTHER = "a1" * 32, "b2" * 32
STORE = {
SNAP: {"columns": ["id", "phone", "amount"], "source": "crm", "sql": "SELECT id, phone, amount FROM members",
"rows": [[1, "19900000201", 120.5], [2, "19900000202", 80.0]]},
OTHER: {"columns": ["n"], "source": "crm", "sql": "SELECT 2 AS n", "rows": [[2]]},
}
PHONE = "cell(nodes.crm, 0, 'phone')"
AMOUNT = "cell(nodes.crm, 0, 'amount')"
def cell(row, column, value, artifact=SNAP):
return {"path": f"cell(nodes.crm, {row}, '{column}')", "value": value, "node_id": "crm", "via": "tool_cell",
"locator": {"row": row, "column": column}, "artifact": artifact, "status": "verified"}
def scalar(path, value):
return {"path": path, "value": value, "node_id": "fetch", "via": "transform", "status": "ok"}
def card(mid, expression, substituted, value, inputs, unit=""):
return {"kind": "metric_set", "caliber": "会员口径", "caliber_version": "v1", "metrics": [
{"id": mid, "name": mid, "unit": unit, "value": value, "format": "plain", "expression": expression,
"substituted": substituted, "inputs": inputs, "status": "ok"}]}
def sources(**kw):
base = {"load": STORE.get, "queries": (SNAP, OTHER), "masked": {SNAP: frozenset({"phone"})}}
return Sources(**{**base, **kw})
def text_of(result) -> str:
return json.dumps(result, ensure_ascii=False)
def test_the_value_of_a_metric_that_is_a_masked_cell_is_withheld():
"""验收的 phone_raw:指标就是遮罩列的那一格。old、rendered_old 都写「已遮罩」,号码不出现在答复的任何地方。"""
result = whatif(card("phone_raw", PHONE, "19900000201", 19900000201, [cell(0, "phone", 19900000201)]),
Changes(), sources())
[m] = result["metrics"]
assert (m["status"], m["old"], m["rendered_old"], m["withheld"]) == ("masked", "已遮罩", "已遮罩", True)
assert [m[k] for k in ("new", "rendered_new", "delta", "rendered_delta", "changed", "substituted")] == [None] * 6
assert "遮罩" in m["reason"] and m["inputs"][0]["masked"] is True and m["inputs"][0]["old"] is None
assert "19900000201" not in text_of(result)
def test_a_metric_computed_from_a_masked_cell_withholds_its_value_too():
"""号码位数这类算出来的数同样不给:改一个别的输入、拿指标的值一减,就能算出遮住的那一格(宁可多遮)。"""
[m] = whatif(card("mix", f"len({PHONE}) + {AMOUNT}", "len('19900000201') + 120.5", 131.5,
[cell(0, "phone", "19900000201"), cell(0, "amount", 120.5)]), Changes(), sources())["metrics"]
assert (m["status"], m["old"], m["rendered_old"]) == ("masked", "已遮罩", "已遮罩")
inputs = {i["path"]: i for i in m["inputs"]}
assert inputs[AMOUNT]["old"] == 120.5 and inputs[PHONE]["old"] is None
def test_a_missing_value_stays_missing():
"""本来就没有值的(缺输入)照旧是空的、显示「—」:缺输入还得看得出来。"""
[m] = whatif(card("gone", PHONE, None, None, [cell(0, "phone", None)]), Changes(), sources())["metrics"]
assert m["status"] == "masked" and m["old"] is None and m["rendered_old"] == "—" and m["withheld"] is True
def test_a_top_level_cell_on_an_unreadable_snapshot_withholds_the_value():
"""那一格所在的快照读不出来:遮没遮核对不了,输入不给值,指标的原值同样不给(和代入式一样)。"""
[m] = whatif(card("east", AMOUNT, "120.5", 120.5, [cell(0, "amount", 120.5)]), Changes(),
sources(load=lambda a: None if a == SNAP else STORE.get(a)))["metrics"]
assert m["status"] == "unsupported" and m["old"] == "已遮罩" and m["withheld"] is True
assert "120.5" not in text_of(m)
def test_a_cell_only_choosing_a_row_on_an_unreadable_snapshot_does_not_hide_the_value():
"""只嵌在下标里、遮没遮核对不了的那一格:它只决定取哪一项,取到的值卡上另记着,原值照给、照样推演。"""
pick = f"vars.kpi.list[{AMOUNT.replace('amount', 'id')}] + vars.kpi.k"
top = f"vars.kpi.list[{AMOUNT.replace('amount', 'id')}]"
metric = card("pick", pick, "20 + 2", 22, [scalar(top, 20), cell(0, "id", 1), scalar("vars.kpi.k", 2)])
[m] = whatif(metric, Changes(), sources(load=lambda a: None if a == SNAP else STORE.get(a)))["metrics"]
assert m["status"] == "unchanged" and m["old"] == 22 and "withheld" not in m
[m] = whatif(metric, Changes(inputs={"vars.kpi.k": 5}), sources(load=lambda a: None if a == SNAP else STORE.get(a)))[
"metrics"]
assert (m["status"], m["old"], m["new"]) == ("ok", 22, 25)
def test_an_unmasked_metric_is_unchanged():
result = whatif(card("east", AMOUNT, "120.5", 120.5, [cell(0, "amount", 120.5)]), Changes(), sources())
[m] = result["metrics"]
assert (m["status"], m["old"], m["rendered_old"]) == ("unchanged", 120.5, "120.5") and "withheld" not in m
def test_report_segments_of_a_withheld_metric_do_not_carry_the_value():
"""报告里引用了原值不给的指标:推演答复里那一处的 rendered_old 同样写「已遮罩」。"""
metric = card("phone_raw", PHONE, "19900000201", 19900000201, [cell(0, "phone", 19900000201)])
result = whatif(metric, Changes(), sources())
entry = {"kind": "metric", "node_id": "card", "artifact": "c" * 64, "locator": {"metric": "phone_raw"}}
doc = {"catalog": {"m:phone_raw": entry}, "blocks": [{"units": [{"id": "u0", "segments": [
{"id": "s0", "kind": "number", "text": "19900000201", "state": "deterministic",
"cite": {"alias": "m:phone_raw", "kind": "metric", "status": "resolved"}}]}]}]}
[seg] = recompute.report_segments([("write", doc)], card_node="card", card_artifact="c" * 64,
results=result["metrics"])
assert (seg["rendered_old"], seg["rendered_new"], seg["changed"]) == ("已遮罩", None, None)
@pytest.mark.parametrize("masked, unverified, expected", [
({PHONE}, set(), True), # 取自遮罩列
({"vars.kpi.i"}, set(), True), # 遮罩列的那一格只嵌在下标里:推演整个按遮罩处理,原值也不给
(set(), {AMOUNT}, True), # 最外层的输入遮没遮核对不了
(set(), {"vars.kpi.i"}, False), # 只嵌在下标里、遮没遮核对不了:不碍事
(set(), set(), False),
])
def test_hides_value_is_one_rule_for_the_whatif_and_the_evidence_panel(masked, unverified, expected):
metric = {"expression": f"{AMOUNT} + vars.kpi.list[vars.kpi.i]"}
assert recompute.hides_value(metric, masked, unverified) is expected
# 表达式读不懂:有一个遮没遮核对不了的就不给
assert recompute.hides_value({"expression": "1 +"}, set(), {AMOUNT}) is True
# --------------------------------------------------------------------------
# 真跑:验收原样的口径卡(单格原值、按位置取、按位置取的位数、编号)
# --------------------------------------------------------------------------
CUSTOMERS = [(1, "客户甲", "19900000301"), (2, "客户乙", "19900000302"), (3, "客户丙", "19900000303")]
PHONES = [c[2] for c in CUSTOMERS]
CARD_METRICS = [
{"id": "phone_raw", "name": "首位客户手机号(单格原值)", "format": "plain",
"expression": "cell(nodes.q_cust, 0, 'phone')"},
{"id": "phone_pos", "name": "首位客户手机号(按位置)", "format": "plain", "expression": "vars.cust.rows[0][2]"},
{"id": "phone_pos_len", "name": "首位客户手机号位数", "unit": "位", "format": "plain",
"expression": "len(str(vars.cust.rows[0][2]))"},
{"id": "id0", "name": "首位客户编号", "format": "plain", "expression": "cell(nodes.q_cust, 0, 'id')"},
]
TEXT = "首位客户编号 [[m:id0]],号码位数 [[m:phone_pos_len]]。"
@pytest.fixture
async def engine_up():
await run_manager.setup()
yield
await run_manager.shutdown()
@pytest.fixture
async def client(engine_up):
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c:
yield c
@pytest.fixture
async def members(tmp_path):
path = tmp_path / "members.db"
db = sqlite3.connect(path)
db.executescript("CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT, phone TEXT);")
db.executemany("INSERT INTO customers VALUES (?, ?, ?)", CUSTOMERS)
db.commit()
db.close()
async with SessionLocal() as session:
row = (await session.execute(select(DataSource).where(DataSource.name == "members"))).scalar_one_or_none()
if row is None:
row = DataSource(name="members", kind="sqlite", database=str(path), readonly=True, enabled=True)
session.add(row)
row.database, row.kind, row.enabled, row.readonly = str(path), "sqlite", True, True
row.options = {"mask_columns": ["phone"]}
await session.commit()
source_id = row.id
await engines.invalidate(source_id)
yield path
await engines.invalidate(source_id)
def node(nid, ntype, **config):
return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0}, "data": {"label": nid, "config": config}}
def graph() -> dict:
nodes = [
node("start", "input"),
node("q_cust", "tool", tool="db_query__members",
args={"sql": "SELECT id, name, phone FROM customers ORDER BY id LIMIT 5"}),
node("parse_cust", "transform", mode="json", template="{{ nodes.q_cust }}", assign_to="cust"),
node("card_c", "metrics", caliber="遮罩取法对照", caliber_version="v1", metrics=CARD_METRICS),
node("write", "report", instructions="写一句", on_violation="flag"),
node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}]),
]
return {"nodes": nodes, "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
async def run_graph(monkeypatch) -> Run:
from app.providers import mock_model
monkeypatch.setattr(mock_model.MockChatModel, "_decide", lambda self, messages: AIMessage(content=TEXT))
run_id = (await run_manager.start(graph=graph(), input_payload={})).id
for _ in range(400):
await asyncio.sleep(0.05)
async with SessionLocal() as session:
row = await session.get(Run, run_id)
if row.status in ("succeeded", "failed") and row.manifest_seq is not None:
assert row.status == "succeeded", row.error
return row
raise AssertionError(f"运行 {run_id} 没跑完:{row.status}")
def leaks(raw: str) -> list[str]:
return [p for p in PHONES if p in raw]
async def test_the_whatif_answer_carries_no_masked_value(client, monkeypatch, members):
"""验收原样:推演答复里号码一个都没有(以前在 phone_raw、phone_pos 的 old、rendered_old 里)。"""
row = await run_graph(monkeypatch)
res = await client.post(f"/api/runs/{row.id}/evidence/whatif", json={"card": "card_c"})
assert res.status_code == 200, res.text
assert leaks(res.text) == [], leaks(res.text)
metrics = {m["id"]: m for m in res.json()["metrics"]}
for mid in ("phone_raw", "phone_pos", "phone_pos_len"):
m = metrics[mid]
assert (m["status"], m["old"], m["rendered_old"], m["withheld"]) == ("masked", "已遮罩", "已遮罩", True), m
assert m["new"] is None and m["rendered_new"] is None and "遮罩" in m["reason"]
assert (metrics["id0"]["status"], metrics["id0"]["old"]) == ("unchanged", 1) and "withheld" not in metrics["id0"]
# 报告里引用了号码位数:那一处的原值也写「已遮罩」
[seg] = [s for s in res.json()["segments"] if s["metric"] == "phone_pos_len"]
assert seg["rendered_old"] == "已遮罩" and seg["rendered_new"] is None
async def test_the_evidence_panel_withholds_the_metric_value_by_the_same_rule(client, monkeypatch, members):
"""证据面板的指标步骤:用到遮罩列的指标 value 写「已遮罩」,报告上的字照旧;没用到的照给。"""
row = await run_graph(monkeypatch)
[report] = (await client.get(f"/api/runs/{row.id}/evidence")).json()["reports"]
doc = artifact_store.load(report["doc_artifact"])
by_text = {s["text"]: s["id"] for s in iter_segments(doc) if s.get("ref")}
body = (await client.get(f"/api/runs/{row.id}/evidence/segments/{by_text['11位']}")).json()
metric = body["chain"][0]
assert (metric["step"], metric["value"], metric["rendered"]) == ("metric", "已遮罩", "11位")
assert leaks(json.dumps(body, ensure_ascii=False)) == []
plain = (await client.get(f"/api/runs/{row.id}/evidence/segments/{by_text['1']}")).json()
assert plain["chain"][0]["value"] == 1