Files
AgentLab/backend/tests/test_masking_reformatted_numbers.py
T
ThearchyHelios 099473cd6d K3 复核修正(第 1 轮):后面的查询按此前遮掉的值遮、质询工件照回答时记下的位置重放;表值函数拆开遮罩列也认;汇总遮罩列的指标不派盲算;反方理由按值遮
复核发现质询工件接口相对基线回退:agent 自己的查询快照在工具边界遮好之后,事后取质询工件收不到它另一次查询里的号码,
没设遮罩的备注、联系方式列原样给出。另有几处模型照样看得到遮罩值、或者遮多了的地方。

- 工具边界(tools/datasource、engine/masking.mask_query_result):此前已经认出的遮罩值(这个 agent 前面的查询遮掉的、
  调用方交进来的)也用来按值遮后面的结果,数据源没设遮罩的也一样。审批质询、反方审稿在派 agent 之前把报告快照里的
  遮罩值交进来(inquiry.snapshot_secrets,run_verify_agent 的 masked_values),模型从第一条查询起就看不到。已经摆在
  读者眼前的值(提问人写的、报告指标、被审的结论原文)跟着并进来的值一起免遮(_Secrets.protected);这份结果自己写
  的分档标签不按前面收的值换。
- 先查备注、后查出号码的:回答时只靠内存里的值才换掉的地方按快照记成位置(不含值,masking.view_edits),写进质询
  事件的 masked_cells,质询工件接口先照着重放(replay_edits)再按原来的办法遮。工具边界按值换掉的整格照样画成遮罩列。
  agent 查到的值先收、报告快照的后收:上限收满时不丢 agent 自己查到的。
- _derived_hidden 认 FROM、JOIN、LATERAL 里拆开遮罩列的表值函数(json_each、json_tree、unnest、jsonb_each_text、
  regexp_split_to_table、JSON_TABLE、LATERAL VALUES):按出列名认,不认得的函数又没写列名表的整份遮。
- 汇总里的 CASE 只在条件里用到遮罩列的不算取自遮罩列(同写在 WHERE 里)。双盲复算按同一套认法认出指标取自遮罩列
  (SUM(amount)、amount 设了遮罩)时,派盲算之前就记为无法复算并说清原因,不白花一次盲算(nodes/dual_check 的
  _query_input,改动在文件所有权之外,只加这一处判断)。
- 反方审稿:理由正文和理由文档按值换掉遮罩值(换了写法的也认),这句结论原文里写着的不换;重新组装时引用到的格子按
  遮好的快照渲染。
- 换了写法的号码另认不换行空格、窄空格、细空格、制表符、减号,最多四个分隔符;SQL 的字符串、带引号的名字、注释里
  也认(不带引号的数照旧是算式),字符串里换掉的号码同一条 SQL 里写成阈值的也不留;列名同样认。
- 查询失败时报错原话里的值换掉(mask_error_text:引号里、不带引号的长数,SQL 里写着的照留)。
- 快照的 mask_columns 只记数据源设的列名,改了名字的结果列只在 masked_at_query:证据面板并各份快照的这一项从表的
  字段清单里去列,混进别名会误藏同源别的表里同名的真实字段。
- * 展开数据源里的表时按冻结的表结构认它带不带同名列,没有的照常认分档标签(J2 收紧之后的多遮)。
- 格子引用指到按值换掉的格子时照实说;上万个值的合并、免遮放进线程。

测试:质询 agent 先查号码后查备注、先查备注后查号码、另一张表的号码列两种先后,质询工件、通用工件接口、事件都没有
原值;报告快照里的值在第一条查询就遮;表值函数(SQLite、Postgres、MySQL 的写法)、汇总里 CASE 的条件、* 连着的表按
表结构认标签、新的分隔符、SQL 字符串和注释和列名、报错原话、mask_columns 不混别名、遮罩列汇总的指标不派盲算、反方
理由按值遮且免遮结论原文、上限收满时 agent 的值先收。逐处去掉实现(24 处)对应的用例都会变红。
2026-10-06 19:11:14 +08:00

210 lines
12 KiB
Python
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""换了写法的号码(engine/masking.py 的 _Secrets):按值认得出的长数字(SECRET_DIGITS 位以上)被写成带空格、连字符、
点、括号、全角数字或全角标点、带 +86 / 0086 / 86 前缀的样子,模型写的正文(审批质询的回答)里照样认得出,换成
「已遮罩」;最后一道关(inquiry._leaked)、质询工件里文字格夹着的号码同样认得出。
验收准备时复现过:模型把号码写成 199-1474-2785、199 1474 2785、199.1474.2785、(199)1474-2785、+8619914742785、
全角数字,回答正文、事件、回答文档原样带着,最后一道关也拦不住,正式运行里永久封存。
认法是在正文里找允许夹分隔符的数字串,规范化(全角转半角、去分隔符、去国家码)后在「遮罩值的纯数字写法」集合里
查——集合查找,不现编正则。日期、小数、更长的数里的一截、连字符连着的编号照旧不动。
数据都是虚构的:手机号、金额。
"""
from __future__ import annotations
import time
import pytest
from app.engine import inquiry as inquiry_mod
from app.engine.masking import _masked_view, _Secrets
MASKED = "已遮罩"
PHONE = "19914742785"
#: 同一个号码的各种写法(换了写法的号码)
REFORMATTED = [
pytest.param("199-1474-2785", id="连字符"),
pytest.param("199 1474 2785", id="空格"),
pytest.param("199.1474.2785", id="点"),
pytest.param("(199)1474-2785", id="括号"),
pytest.param("(199) 1474 2785", id="括号加空格"),
pytest.param("+8619914742785", id="+86"),
pytest.param("+86 199 1474 2785", id="+86 加空格"),
pytest.param("(+86)19914742785", id="(+86)"),
pytest.param("0086 199 1474 2785", id="0086"),
pytest.param("0086-19914742785", id="0086 连字符"),
pytest.param("86-199-1474-2785", id="86"),
pytest.param("8619914742785", id="86 连写"),
pytest.param("19914742785", id="全角数字"),
pytest.param("199-1474-2785", id="全角数字和连字符"),
pytest.param("199 1474 2785", id="全角空格"),
pytest.param("199.1474.2785", id="全角点"),
pytest.param("(199)1474-2785", id="全角括号"),
pytest.param("+86 199 1474 2785", id="全角加号"),
]
def secrets_of(values: list, *, hidden: str = "phone") -> _Secrets:
secrets = _Secrets()
secrets.add({"columns": [hidden], "rows": [[v] for v in values]}, {hidden})
return secrets
@pytest.mark.parametrize("written", REFORMATTED)
@pytest.mark.parametrize("stored", [PHONE, int(PHONE), "199-1474-2785"], ids=["文本", "整数", "存的就带连字符"])
def test_a_long_number_in_another_shape_is_masked_in_prose(stored, written):
secrets = secrets_of([stored])
assert secrets.scrub(f"金额最高的一笔来自 {written},共 3 笔", prose=True) == f"金额最高的一笔来自 {MASKED},共 3 笔"
assert secrets.scrub(f"客户{written}来电", prose=True) == f"客户{MASKED}来电"
@pytest.mark.parametrize("text, shown", [
("来自(19914742785),共 3 笔", f"来自({MASKED}),共 3 笔"),
("来自(+86 199 1474 2785),共 3 笔", f"来自({MASKED}),共 3 笔"),
("电话(+86)199 1474 2785。", f"电话{MASKED}。"),
("(电话 199-1474-2785)", f"(电话 {MASKED})"),
])
def test_brackets_around_a_number_are_kept_and_brackets_inside_it_are_replaced(text, shown):
"""整个号码外面套着的一对括号是标点,留着;号码里的括号(区号、国家码)和号码一起换掉。"""
assert secrets_of([PHONE]).scrub(text, prose=True) == shown
@pytest.mark.parametrize("text", [
# 日期、时间、小数、千分位、更长的数里的一截、连字符连着的编号、别的号码
"2026-10-06 19:14 下单", "金额 19914.74 元", "共 1,991,474 笔", "号码 1991474278512", "批次 19914742785-2",
"199-1474-2786", "单号 2026199-1474-2785", "共 199 笔 1474 元 2785 次",
])
def test_other_numbers_and_number_like_text_are_left_alone(text):
secrets = secrets_of([PHONE])
assert secrets.scrub(text, prose=True) == text
def test_reformatted_numbers_are_only_read_in_prose_and_text_cells():
"""SQL 里 199-1474-2785 是一个算式,不当成号码换(SQL 里的号码按字面量的用法换,见 inquiry._scrub_sql)。"""
secrets = secrets_of([PHONE])
assert secrets.scrub("SELECT 199-1474-2785 AS x") == "SELECT 199-1474-2785 AS x"
assert secrets.scrub("备注 199-1474-2785", loose=True) == f"备注 {MASKED}"
def test_a_text_cell_holding_a_reformatted_number_is_masked_whole_or_in_part():
"""快照里别的列(没设遮罩)写着换了写法的号码:整格就是号码的整格遮;质询工件里夹在一段文字里的只换那一截。"""
secrets = secrets_of([PHONE])
snapshot = {"columns": ["联系方式", "备注"], "rows": [["199-1474-2785", "客户 (199)1474-2785 来电改址"],
["138-0000-0000", "例行回访"]]}
view, masked = _masked_view(snapshot, set(), secrets)
assert view["rows"] == [[MASKED, "客户 (199)1474-2785 来电改址"], ["138-0000-0000", "例行回访"]]
assert masked == ["联系方式"]
view, masked = _masked_view(snapshot, set(), secrets, embedded=True)
assert view["rows"] == [[MASKED, f"客户 {MASKED} 来电改址"], ["138-0000-0000", "例行回访"]]
assert masked == ["联系方式"]
@pytest.mark.parametrize("written", REFORMATTED)
def test_the_last_gate_stops_an_answer_still_showing_a_reformatted_number(written):
"""组装之后还认得出(渲染进单元格引用的一格文字里夹着换了写法的号码):不交出去。正文里的在组装之前就换掉了。"""
secrets = secrets_of([PHONE])
entry = {"alias": "Q1", "kind": "query", "artifact": "a1", "source": "shop", "columns": ["备注"], "rows": 1,
"truncated": False}
views = {"a1": _masked_view({"columns": ["备注"], "rows": [[f"客户{written}来电改址"]]}, set(), secrets)[0]}
with pytest.raises(inquiry_mod._Leak):
inquiry_mod._compose("回访备注是 [[v:Q1.r0.备注]]。", {"Q1": entry}, run_id="r1", views=views, secrets=secrets,
allow=[])
doc = inquiry_mod._compose(f"来电的是 {written}。", {}, run_id="r1", views={}, secrets=secrets, allow=[])
assert doc["markdown"] == f"来电的是 {MASKED}。"
assert inquiry_mod._leaked({"markdown": f"来电的是 {written}。", "blocks": []}, secrets)
def test_a_number_the_asker_wrote_in_another_shape_is_left_alone():
"""提问人自己写的号码(换了写法也一样)已经摆在读者眼前:回答里照原样,别的号码照遮。"""
secrets = secrets_of([PHONE, "13800000000"])
secrets.protect(["199-1474-2785 这位客户还买过别的吗?"])
assert secrets.scrub("199 1474 2785 另有 138-0000-0000 的单", prose=True) == f"199 1474 2785 另有 {MASKED} 的单"
def test_a_threshold_left_in_the_sql_is_shown_in_the_prose_whatever_the_shape():
"""SQL 里照原样留着的阈值,回答正文里复述不遮,换了写法也一样(只免正文)。"""
secrets = secrets_of([20000, 35000], hidden="amount")
secrets.show({"20000"})
assert secrets.scrub("金额不低于 20 000 元,最高一笔 35 000 元", prose=True) == f"金额不低于 20 000 元,最高一笔 {MASKED} 元"
def test_many_masked_numbers_are_matched_without_stalling():
"""遮罩值上万个:集合查找,不现编上万个分支的正则。"""
secrets = secrets_of([str(19900000000 + i) for i in range(20_000)])
text = ";".join(f"客户 199-0000-{i:04d} 来电" for i in range(0, 4000, 7)) * 3
began = time.perf_counter()
out = secrets.scrub(text, prose=True)
assert time.perf_counter() - began < 2.0
assert "199-0000" not in out and out.count(MASKED) == text.count("199-0000")
#: 复核第 1 轮:别的空白、减号作分隔符的写法(模型输出里不换行空格、窄空格并不少见)
OTHER_SEPARATORS = [
pytest.param("199 1474 2785", id="不换行空格"),
pytest.param("199 1474 2785", id="窄不换行空格"),
pytest.param("199 1474 2785", id="细空格"),
pytest.param("199 1474 2785", id="发丝空格"),
pytest.param("199\t1474\t2785", id="制表符"),
pytest.param("199−1474−2785", id="减号"),
pytest.param("199 1474 2785", id="四个空格"),
pytest.param("199 - 1474 - 2785", id="连字符两边带空格"),
pytest.param("+86 199 1474 2785", id="+86 加不换行空格"),
]
@pytest.mark.parametrize("written", OTHER_SEPARATORS)
def test_numbers_split_by_other_spaces_and_minus_signs_are_masked_too(written):
secrets = secrets_of([PHONE])
assert secrets.scrub(f"客户 {written} 来电", prose=True) == f"客户 {MASKED} 来电"
assert inquiry_mod._leaked({"markdown": f"来电的是 {written}。", "blocks": []}, secrets)
assert secrets.hit(written), "整格就是这个号码的,格子按值认"
def test_a_line_break_still_ends_a_number():
"""不跨行:两行各写一截的不拼成一个号码。"""
secrets = secrets_of([PHONE])
assert secrets.scrub("编号 199\n1474 2785", prose=True) == "编号 199\n1474 2785"
@pytest.mark.parametrize("sql, sealed", [
pytest.param("SELECT COUNT(*) AS 笔数 FROM callbacks WHERE note LIKE '%199-1474-2785%'",
f"SELECT COUNT(*) AS 笔数 FROM callbacks WHERE note LIKE '%{MASKED}%'", id="LIKE 里的一截"),
pytest.param("SELECT COUNT(*) AS 笔数 FROM callbacks WHERE note = '客户 199 1474 2785 来电'",
f"SELECT COUNT(*) AS 笔数 FROM callbacks WHERE note = '客户 {MASKED} 来电'", id="字符串里夹着"),
pytest.param('SELECT note AS "199-1474-2785 的备注" FROM callbacks',
f'SELECT note AS "{MASKED} 的备注" FROM callbacks', id="带引号的列名"),
pytest.param("SELECT COUNT(*) AS 笔数 FROM callbacks /* 客户 199-1474-2785 */",
f"SELECT COUNT(*) AS 笔数 FROM callbacks /* 客户 {MASKED} */", id="块注释"),
pytest.param("SELECT COUNT(*) AS 笔数 FROM callbacks -- 客户 199 1474 2785\n WHERE id = 1",
f"SELECT COUNT(*) AS 笔数 FROM callbacks -- 客户 {MASKED}\n WHERE id = 1", id="行注释"),
])
def test_a_reformatted_number_in_sql_strings_names_and_comments_is_masked(sql, sealed):
"""SQL 里字符串、带引号的名字、注释里换了写法的号码也认(以前只有整个字面量就是号码的才换)。"""
assert inquiry_mod._scrub_sql(sql, secrets_of([PHONE]), set(), "sqlite") == sealed
def test_a_bare_number_expression_in_sql_is_still_left_alone():
"""不带引号的 199-1474-2785 在 SQL 里是一个算式(三个数相减),照旧不按号码认。"""
sql = "SELECT 199-1474-2785 AS x FROM callbacks"
assert inquiry_mod._scrub_sql(sql, secrets_of([PHONE]), set(), "sqlite") == sql
def test_a_threshold_matching_a_number_swapped_in_a_string_is_not_kept():
"""字符串里按换了写法认出、换掉的号码,同一条 SQL 里写成阈值的同一个数也不留(不然阈值把它露了)。"""
sql = f"SELECT COUNT(*) AS 笔数 FROM callbacks WHERE note LIKE '%199-1474-2785%' AND phone_no >= {PHONE}"
sealed = inquiry_mod._scrub_sql(sql, secrets_of([PHONE]), set(), "sqlite")
assert PHONE not in sealed and "1474" not in sealed
def test_a_reformatted_number_in_a_column_name_is_masked_like_the_sql():
"""agent 把换了写法的号码写进列名(AS "139-0000-0001 的单"):质询工件的列名、回答里引用这一列的标记照 SQL 里带引号
的名字一样换,三处对得上。"""
secrets = secrets_of(["13900000001"])
snapshot = {"columns": ["139-0000-0001 的单"], "rows": [[3]]}
view, _ = _masked_view(snapshot, set(), secrets)
assert view["columns"] == [f"{MASKED} 的单"]
assert inquiry_mod._scrub_sql('SELECT COUNT(*) AS "139-0000-0001 的单" FROM sales', secrets, set(), "sqlite") == (
f'SELECT COUNT(*) AS "{MASKED} 的单" FROM sales')
assert inquiry_mod._scrubbed_source("共 [[v:Q1.r0.139-0000-0001 的单]] 单。", secrets) == f"共 [[v:Q1.r0.{MASKED} 的单]] 单。"