"""取数内核与候选来源校验的验收脚本(不连库,跑在 backend 目录下):: python3 scripts/check_binding.py 「候选来源」与「字段上的外部取数」收成一层内核之后(分层见 ``docs/data-binding-unification-design.md`` §4~§6),下面四件事必须一直成立: 1. **写法只有一种认法**:``{form.x}`` / ``{ form.x }`` / ``{form:x}`` / ``{auto:…}`` / ``{const:…}`` / ``{arg.x}``,以及「整段引用之外还要拼一句话」——过去后端四份解析器 有的认空格、有的不拼接,两边各错一半,现在都得跟前端 ``utils/binding.ts`` 一样; 2. **多源清单与合并只有一份形状**:``sources`` 合集与单源老写法收成同一份 ``{source, args, picks}``,金额按分合,空值不参与; 3. **源的健康判据只有一句话**:不存在 / 停用 / 类型不对 / 方向只在往外写,全出自 ``binding.source_problem``,而且「没事」时回空串——空串绝不能被塞进报错清单; 4. **候选来源校验得住交叉配法**:除了配得半截,还要挡住候选入参引用悬空,以及 「值由外部取数写入 + 候选又判越界」那组各自都对、凑一起必定拦填单人的配置。 5. **带出取哪一列只有一种认法**:``pick`` 留空取名称、``value`` 取键值、``extra.x`` 走点路径、 裸键名仍旧先按附加值读——与前端 ``src/utils/optionMap.ts:pickFillValue`` 同一把尺子, 「界面一个值、提交另一个值」是这类映射最难查的一种错。 6. **带出的目标格子被删之后不写**:`picks` / 字典带出的 `to` / 额度的 `show` / 阈值的 `flag` 记的都是字段名,格子没了那份指向还留着(设计器现在会清,改之前存下的表单靠这道闸兜住), 往不存在的格子里写不算什么,键名被新字段复用之后把别人的数盖掉才是事。 7. **关联审批单默认只给归档通过的单子**:字段上那三档(归档通过 / 还在办 / 已终止或作废) 说清能挂哪几种状态的单据,前端 ``utils/optionSource.ts`` 与后端 ``service/dicts.py`` 同一份;这一档只管候选列表,已存的值不判非法。 8. **选人字段当 SQL 入参要包一层 account**:``type=user`` 那一格交出来的永远是账号 **数组**,``= :applicant`` 绑不进数组,运行时只能 blocked。病根在配置里,所以设计期 (``binding.arg_ref_problems`` 的 ``person_keys``)就要报出「改成 ``{account:form.x}``」, 而且只对真带 SQL 的那张源说——HTTP 报文里放数组是正当写法。 最后再把前后端那几句共用的措辞对一遍:两边各写一遍迟早会漂,漂了这里就红。 """ from __future__ import annotations import pathlib import sys sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent)) from app import models # noqa: E402 (需要上面那行把 backend 目录放进 sys.path) from app.api import design as design_api # noqa: E402 (保存那一刻真正走的那两步清洗) from app.service import binding, dicts, fetch, formruntime, mapping, quota # noqa: E402 class Source: """顶替 ``DataSource`` 那一行:``source_problem`` 只用 getattr 读几个属性。""" def __init__(self, code: str, name: str = "", enabled: bool = True, kind: str = models.DataSource.KIND_FETCH, direction: str = models.DataSource.DIRECTION_IN) -> None: self.code = code self.name = name or code self.enabled = enabled self.kind = kind self.direction = direction class FakeDB: """顶替 ``Session``:这几处查源只走 ``db.execute(select(...)).scalar_one_or_none()``。 一个用例只查一张源,所以直接把要给它的那一行(或 ``None`` 表示源被删了)存好就行。 """ def __init__(self, row: Source | None) -> None: self.row = row def execute(self, _statement): row = self.row class _Result: def scalar_one_or_none(self): return row return _Result() class Work: """顶替流程单据那一行,给 ``{work.x}`` 用。""" id = "PO-0001" creator_name = "张三" # --------------------------------------------------------------------------- # 1. 写法解析 # --------------------------------------------------------------------------- def check_parsing() -> None: data = {"amount": 1200, "a": "K1", "empty": "", "none": None} # 整段就是一个引用:给原类型,数字入参不该在这一步变成字符串 eq("整段引用给原类型", binding.resolve(None, "{form.amount}", data), 1200) eq("花括号里的空格也认", binding.resolve(None, "{ form.amount }", data), 1200) eq("{form:x} 与 {form.x} 同义", binding.resolve(None, "{form:amount}", data), 1200) # 整段之外还要拼一句话:过去后端原样发出、前端会拼,填单页与提交各对一半 eq("引用混在句子里要拼开", binding.resolve(None, "{form.a}-x", data), "K1-x") eq("引用前后有字也拼", binding.resolve(None, "单号 {form.a} / {work:id}", data, work=Work()), "单号 K1 / PO-0001") eq("取不到值拼成空串", binding.resolve(None, "[{form.none}]", data), "[]") # 常量能当 JSON 标量读就给原类型:{const:1} 是数字 1,上游声明了 int 的字段才接得住 eq("数字常量给数字", binding.resolve(None, "{const:1}", data), 1) eq("布尔常量给布尔", binding.resolve(None, "{const:true}", data), True) eq("小数常量给小数", binding.resolve(None, "{const:1.5}", data), 1.5) eq("空常量是空串", binding.resolve(None, "{const:}", data), "") # 读不动的照旧原样给:空格是配的人自己要的;对象不给,不给它变形的机会 eq("常量原样给", binding.resolve(None, "{const: A }", data), " A ") eq("列表常量原样给", binding.resolve(None, "{const:[1,2]}", data), "[1,2]") eq("花括号进不了常量(既有语义)", binding.resolve(None, "{const:{}}", data), "{const:{}}") eq("百分号这种读不动的也是原样", binding.resolve(None, "{const:13%}", data), "13%") # 写回模板(``Integration.payload``)走的是另一份渲染器,但同一种写法必须是同一个类型: # 曾经这里是字符串 "1",于是数据源测试点着是绿的、真写回上游就 400 # (报销那个 Go 服务:``boolean value must be 0, 1, false or true``)。 rendered = mapping.render_template( None, {"fields": [{"to": "n", "from": "{const:1}"}, {"to": "b", "from": "{const:true}"}, {"to": "s", "from": "共 {const:1} 项"}, {"to": "p", "from": "{const:13%}"}, {"to": "a", "from": "{const:[1,2]}"}]}, data={}, ) eq("写回里的数字常量也给数字", rendered["n"], 1) eq("写回里的布尔常量也给布尔", rendered["b"], True) eq("写回里混着文字仍拼成字符串", rendered["s"], "共 1 项") eq("写回里读不动的常量照旧原样", [rendered["p"], rendered["a"]], ["13%", "[1,2]"]) eq("日期只留年份那档", len(binding.resolve_text(None, "{auto:today:YYYY}", data)), 4) eq("认不出的写法当字面量", binding.resolve(None, "{nonsense.x}", data), "{nonsense.x}") eq("字符串化时空值变空串", binding.resolve_text(None, "{form.none}", data), "") eq("字段名提取", binding.form_ref("{ form.amount }"), "amount") eq("一句话里的引用都数出来", binding.form_refs("{form.a} 与 {form:b}"), ["a", "b"]) # 请求体模板:{arg.x} 读的是本次调用入参,{form.x} 在这里等价 eq("模板里的入参引用", binding.render(None, {"q": "{arg.kw}", "f": "{form.kw}", "n": 3}, {"kw": "abc"}), {"q": "abc", "f": "abc", "n": 3}) eq("模板里的数组也解析", binding.render(None, ["{form.a}", "{const:x}"], data), ["K1", "x"]) eq("入参表算成这次的调用参数", binding.resolve_args(None, {"args": {"kw": "{form.a}"}}, data), {"kw": "K1"}) eq("模板真正读到的入参名", sorted(binding.referenced_args({"a": "{arg.x}", "b": ["{arg:y}"]})), ["x", "y"]) fetch_row = Source("erp", kind=models.DataSource.KIND_FETCH) fetch_row.body_template = {"costCenter": "{arg.costCenter}", "kw": "{arg.keyword}"} eq("单值取数缺的入参", binding.missing_args(fetch_row, {"keyword": ""}), ["costCenter", "keyword"]) eq("列表型源不挡空关键词", binding.missing_args(Source("erp", kind=models.DataSource.KIND_SEARCH), {"keyword": ""}), []) # --------------------------------------------------------------------------- # 2. 多源清单与合并 # --------------------------------------------------------------------------- def check_entries_merge() -> None: single = binding.entries({"source": "erp", "args": {"kw": "{form.a}"}, "picks": {"name": "supplier"}}) eq("单源老写法收成一份形状", single, [{"source": "erp", "args": {"kw": "{form.a}"}, "picks": {"name": "supplier"}}]) multi = binding.entries({"source": "erp", "sources": [ {"source": "erp", "args": {"kw": "1"}}, {"source": "", "args": {}}, "不是字典", {"source": "crm"}, ]}) eq("合集按配置顺序、丢掉没编码的", [row["source"] for row in multi], ["erp", "crm"]) eq("合集里每个源各带一份入参", multi[0]["args"], {"kw": "1"}) eq("合集最多挂的内核上限", len(binding.entries({"sources": [ {"source": f"s{index}"} for index in range(binding.MAX_FIELD_SOURCES + 3)]})), binding.MAX_FIELD_SOURCES) eq("没配源就是空清单", binding.entries({"args": {}}), []) # 这一格对解析规则的两处覆盖(取哪一列 / 还想带出哪几列) eq("没填覆盖时不写这两个键(老配置形状不变)", binding.entries({"source": "erp", "pick": " ", "extras": {}}), [{"source": "erp", "args": {}, "picks": {}}]) covered = binding.entries({"source": "erp", "pick": "data.ownerName", "extras": {"owner": "data.ownerName", "空值行": "", "": "x"}})[0] eq("单源写法带上本格取值路径", covered["pick"], "data.ownerName") eq("没写路径的那行带出列不算配了", covered["extras"], {"owner": "data.ownerName"}) per_source = binding.entries({"sources": [ {"source": "erp", "pick": "data.a"}, {"source": "crm", "pick": "data.b"}]}) eq("合集里每个源各覆盖各的", [row.get("pick") for row in per_source], ["data.a", "data.b"]) eq("不是字符串的覆盖不算配了", binding.entries({"source": "erp", "pick": 123})[0].get("pick"), None) eq("空值不参与合并", binding.merge("first", [None, "", "有值"]), "有值") eq("0 是有值,不是空值", binding.merge("first", [0, "有值"]), 0) eq("全是空值回 None", binding.merge("first", ["", None]), None) eq("按分相加不漂", binding.merge("sum", [0.1, 0.2]), 0.3) eq("取最小", binding.merge("min", ["3,000", 12.5, None]), 12.5) eq("取最大", binding.merge("max", [1, "2.5"]), 2.5) eq("文本按分隔符拼", binding.merge("join", ["A", None, "B"], separator="/"), "A/B") eq("合并模式默认按第一个", binding.merge("", ["甲", "乙"]), "甲") eq("金额换成分", binding.to_cents("1,234.56"), 123456) eq("分换回元", binding.from_cents(123456), 1234.56) # --------------------------------------------------------------------------- # 3. 源的健康判据(全系统只有这一句) # --------------------------------------------------------------------------- def source_with_extra(**values) -> Source: """一张声明过可带出键的源:``entry_problems`` 判"这个键声明过没有"要读它。""" row = Source("erp", "ERP 余额") row.map_extra = dict(values) row.body_template = {} return row def check_source_problem() -> None: search = models.DataSource.KIND_SEARCH fetch = models.DataSource.KIND_FETCH eq("没选源", binding.source_problem("", None), "还没选要用哪一张外部数据源") eq("源被删了", binding.source_problem("gone", None), "引用的数据源不存在:gone(先到「外部数据源」页建好)") eq("源停用了", binding.source_problem("erp", Source("erp", "ERP 物料", enabled=False)), "引用的数据源「ERP 物料」已停用") eq("取一个值的源拿来当候选", binding.source_problem( "erp", Source("erp", "ERP 物料", kind=fetch), want=binding.WANT_SEARCH, want_noun="候选"), "引用的数据源「ERP 物料」是取一个值的,候选要的是列表型数据源") eq("列表型源取不出单值", binding.source_problem( "erp", Source("erp", "ERP 物料", kind=search), want=binding.WANT_FETCH), "引用的数据源「ERP 物料」是列表型,取不出单个值") eq("方向只在往外写(候选)", binding.source_problem( "erp", Source("erp", "ERP 物料", kind=search, direction=models.DataSource.DIRECTION_OUT), want=binding.WANT_SEARCH, want_noun="字典"), "引用的数据源「ERP 物料」的方向是往外写,字典取不到东西(要往表单里带值," "到「外部数据源」把这张源的方向改成「双向」)") # 取一个值那一支同样挡:往外写的源没有取值路径可言,请求体是写回模板渲染的 ok("方向只在往外写(取一个值也挡)", "往外写" in binding.source_problem( "erp", Source("erp", "ERP 物料", kind=fetch, direction=models.DataSource.DIRECTION_OUT)), binding.source_problem( "erp", Source("erp", "ERP 物料", kind=fetch, direction=models.DataSource.DIRECTION_OUT))) # 双向的源照旧能拿来取值 eq("方向是双向就不说", binding.source_problem( "erp", Source("erp", "ERP 物料", kind=fetch, direction=models.DataSource.DIRECTION_BOTH)), "") # 这一条是空串回归的把柄:健康的那张源必须回空串,且调用方不许把空串收进报错清单 eq("配得没毛病就回空串", binding.source_problem( "erp", Source("erp", "ERP 物料", kind=search), want=binding.WANT_SEARCH, want_noun="候选"), "") rows = binding.entry_problems(None, {"source": "erp", "args": {"dept": "{form.nope}"}, "picks": {"name": "ghost"}}, {"dept"}, "外部取数") ok("带出去向引用不存在的字段", any("ghost" in text for text in rows), rows) ok("入参引用不存在的字段", any("外部取数的入参「dept」引用了不存在的字段「nope」" == text for text in rows), rows) eq("没给 self 时引用自己不算毛病", binding.arg_ref_problems({"dept": "{form.dept}"}, {"dept"}, "外部取数"), []) eq("给了 self 就单独说一句(取数那一路不传,候选那一路传)", binding.arg_ref_problems({"dept": "{form.dept}"}, {"dept"}, "外部取数", self_ref="dept"), ["外部取数的入参「dept」引用了这一格自己:候选按这一格筛,这一格又只能从候选里挑,绕成圈筛不出东西"]) # --------------------------------------------------------------------------- # 3.5 选人字段当 SQL 入参:设计期就得说要包 account # --------------------------------------------------------------------------- def sql_row(code: str = "cs") -> Source: """一条真带 SQL 的源(``entry_problems`` 读 ``getattr(row, "sql_text")`` 判通道)。""" row = Source(code, "账户信息") row.sql_text = "select account, bank_name from oa_bank_account where account = :applicant" row.body_template = {"applicant": "{form.applicant}"} row.map_extra = {"bank_name": "bank_name"} return row def check_person_args() -> None: """选人字段那一格是**数组**:谁把它原值绑进 SQL 的 ``=``,配置期就要点名。 一条真实故障:费用表单「带出银行信息」的入参写 ``{form:applicant}``,运行时永远 blocked。数组绑不进标量参数是运行时的闸(``fetch._run_sql``),但配错的人在填单页 只看得到「没查到数据」,所以这一句必须提前在设计器与保存校验里说清楚,还要说清该换成谁。 """ fields = [ {"key": "applicant", "label": "申请人", "type": "user"}, {"key": "amount", "label": "金额", "type": "number"}, {"key": "owner", "label": "负责人", "type": "user"}, {"key": "items", "type": "table"}, "不是字段", ] eq("选人字段只挑 type=user", binding.person_field_keys(fields), {"applicant", "owner"}) eq("字段清单缺东西也不炸", binding.person_field_keys(None), set()) eq("裸写要认出来", binding.bare_person_refs("{form.applicant}", {"applicant"}), ["applicant"]) eq("包了 account 壳的不再说", binding.bare_person_refs("{account:form.applicant}", {"applicant"}), []) eq("空格与点号写法同样算包过", binding.bare_person_refs( "{ account : form.applicant }", {"applicant"}), []) eq("一句话里裸写的那一格还是要说", binding.bare_person_refs( "X{account:form.applicant}Y{form.owner}", {"applicant", "owner"}), ["owner"]) eq("不是选人字段就不管", binding.bare_person_refs("{form.amount}", {"applicant"}), []) eq("没给选人字段清单就一句不说", binding.bare_person_refs("{form.applicant}", set()), []) eq("非字符串不当写法看", binding.bare_person_refs(3, {"applicant"}), []) person_line = binding.arg_ref_problems( {"applicant": "{form.applicant}"}, {"applicant"}, "外部取数", person_keys={"applicant"}) eq("报的那一句要点名换成哪一格", person_line, ["外部取数的入参「applicant」取的是选人字段「applicant」的原值:那一格是登录账号" "数组,绑进 SQL 的 = 永远比不中。这一栏的取值写法改成 {account:form.applicant}," "平台按人换成账号(单选取头一个)"]) eq("包过壳的配置干净", binding.arg_ref_problems( {"applicant": "{account:form.applicant}"}, {"applicant"}, "外部取数", person_keys={"applicant"}), []) eq("没给 person_keys 时不多嘴(候选那一路与前端镜像都这样)", binding.arg_ref_problems( {"applicant": "{form.applicant}"}, {"applicant"}, "外部取数"), []) entry = {"source": "cs", "args": {"applicant": "{form.applicant}"}} keyed = {"applicant"} sql_hit = binding.entry_problems(FakeDB(sql_row()), entry, keyed, "外部取数", person_keys=keyed) ok("SQL 源 + 裸选取人字段 = 报一句", any("account:form.applicant" in text for text in sql_hit), sql_hit) http_hit = binding.entry_problems(FakeDB(Source("cs", "账户信息")), entry, keyed, "外部取数", person_keys=keyed) eq("HTTP 源不报(报文里放数组是正当写法)", http_hit, []) no_db = binding.entry_problems(None, entry, keyed, "外部取数", person_keys=keyed) eq("拿不到库时也不报(判不了通道)", no_db, []) eq("不传 person_keys 时 SQL 源也照旧", binding.entry_problems( FakeDB(sql_row()), entry, keyed, "外部取数"), []) # 运行时那道闸与配置期这句话得出同一个出路:数组进 SQL 通道是 blocked,不是"没查到数据" runtime_text = (pathlib.Path(__file__).resolve().parents[1] / "app/service/fetch.py").read_text(encoding="utf-8") ok("运行时那句也指向同一个写法", "取值写法改成 {account:form." in runtime_text) # --------------------------------------------------------------------------- # 4. 候选来源校验(含交叉规则与候选入参) # --------------------------------------------------------------------------- def option_field(**extra) -> dict: field = {"key": "material", "label": "物料", "type": "select"} field.update(extra) return field def check_option_source_problems() -> None: # 配得半截:选了字典没挑字典、选项没填要存的值 half = formruntime.option_source_problems(option_field(optionSource="dict")) eq("选了字典没挑字典", half, ["还没选择要用的数据字典"]) blank = formruntime.option_source_problems( option_field(optionSource="manual", options=[{"label": "甲", "value": ""}])) eq("选项没填要存的值", blank, ["有 1 个选项没填要存的值,填了会存成空白"]) eq("手填选项配齐了没毛病", formruntime.option_source_problems( option_field(optionSource="manual", options=[{"label": "甲", "value": "A"}])), []) # 拿不到库那一条路(设计器镜像):只判写法,不判源 eq("不查库时不说源的事", formruntime.option_source_problems( option_field(optionSource="dataSource", dataSourceCode="erp"), db=None), []) # 查库且源是健康的:必须一句话都不说(空串混进清单的话,这里就会变成 ['']) eq("源健康就一句不说", formruntime.option_source_problems( option_field(optionSource="dataSource", dataSourceCode="erp"), db=FakeDB(Source("erp", "ERP 物料", kind=models.DataSource.KIND_SEARCH))), []) deleted = formruntime.option_source_problems( option_field(optionSource="dataSource", dataSourceCode="erp"), db=FakeDB(None)) eq("源被删了要说", deleted, ["引用的数据源不存在:erp(先到「外部数据源」页建好)"]) disabled = formruntime.option_source_problems( option_field(optionSource="dataSource", dataSourceCode="erp"), db=FakeDB(Source("erp", "ERP 物料", kind=models.DataSource.KIND_SEARCH, enabled=False))) eq("源停用了要说", disabled, ["引用的数据源「ERP 物料」已停用"]) wrong_kind = formruntime.option_source_problems( option_field(optionSource="dataSource", dataSourceCode="erp"), db=FakeDB(Source("erp", "ERP 物料"))) eq("源是取一个值的要说", wrong_kind, ["引用的数据源「ERP 物料」是取一个值的,候选要的是列表型数据源"]) # 候选入参里的 {form.x} 引用有没有掉在地上 args_field = option_field(optionSource="dataSource", dataSourceCode="erp", dataSourceArgs={"dept": "{form.nope}", "ok": "{form.dept}"}) reasons = formruntime.option_source_problems(args_field, db=None, keys={"dept"}) eq("候选入参引用悬空要说", reasons, ["候选来源那张数据源的入参「dept」引用了不存在的字段「nope」"]) eq("引用得着的入参不说", formruntime.option_source_problems(args_field, db=None, keys={"dept", "nope"}), []) self_field = option_field(optionSource="dataSource", dataSourceCode="erp", dataSourceArgs={"category": "{form.material}"}) eq("候选入参引用这一格自己要说", formruntime.option_source_problems( self_field, db=None, keys={"material", "dept"}), ["候选来源那张数据源的入参「category」引用了这一格自己:候选按这一格筛," "这一格又只能从候选里挑,绕成圈筛不出东西"]) # 交叉规则:值由外部取数写入,候选又是判越界的那两种来源。 # ``pick`` 写的是**这一格自己**——只配 picks 往别处写的取数不会盖这一格挑中的值,不算打脸 cross = formruntime.option_source_problems( option_field(optionSource="manual", options=[{"label": "甲", "value": "A"}], fetch={"source": "erp", "pick": "level"})) eq("取数写值 + 手填候选要说交叉规则", [text for text in cross if "外部取数写入" in text], ["这一格的值由外部取数写入,候选又来自手填选项:取回来的编码必须在那份清单里," "否则提交时会被判「取值已不在可选范围内」。请把带回来的值补进这份清单," "把候选来源改成外部数据源 / 流程单据," "或勾上「带出的值不在候选里也收下」"]) dict_cross = formruntime.option_source_problems( option_field(optionSource="dict", dictCode="mat", fetch={"source": "erp", "pick": "level"})) ok("取数写值 + 字典候选也要说", any("候选又来自数据字典" in text for text in dict_cross), dict_cross) eq("取数只往别的格子写,不盖这一格挑中的值,不说打脸", [text for text in formruntime.option_source_problems( option_field(optionSource="dict", dictCode="mat", fetch={"source": "erp", "picks": {"price": "amount"}})) if "打脸" in text or "外部取数写入" in text], []) no_clash = formruntime.option_source_problems( option_field(optionSource="dataSource", dataSourceCode="erp", fetch={"source": "crm"}), db=None) eq("候选本身也是外部数据源时不打脸,不说", no_clash, []) eq("不是选择类的字段不管", formruntime.option_source_problems( {"key": "amount", "type": "number", "fetch": {"source": "erp"}}), []) # 那句「或勾上」给的这一档真能把交叉规则关掉:勾了就不再拦填单的人(见 check_option_routes.py) opened = formruntime.option_source_problems( option_field(optionSource="manual", options=[{"label": "甲", "value": "A"}], fetch={"source": "erp", "pick": "level"}, allowOutsideValue=True)) eq("勾了「带出的值也收下」之后不再说交叉规则", opened, []) idle = formruntime.option_source_problems( option_field(optionSource="manual", options=[{"label": "甲", "value": "A"}], allowOutsideValue=True)) eq("什么都没带出却勾了这一档,要说它不起作用", idle, ["这一格没配任何带出(外部取数 / 关联单据带出 / 字典带出)," "「带出的值不在候选里也收下」这一档暂时不起作用"]) eq("这一档只认真布尔值", formruntime.option_source_problems( option_field(optionSource="manual", options=[{"label": "甲", "value": "A"}], fetch={"source": "erp", "pick": "level"}, allowOutsideValue="true"))[0], "「带出的值不在候选里也收下」这一档要勾成是或否") # --------------------------------------------------------------------------- # 4.4 关联审批单能挂哪几种状态的单据 # --------------------------------------------------------------------------- def check_relation_statuses() -> None: """「关联已审批流程」挑到一张半路被终止的单子——这一档管的就是这件事。 单据只活两张表:在办表只有 ``running``,归档表里躺着 ``completed`` / ``terminated`` / ``canceled``。默认只给归档通过的,界面上三档由字段上说;这一档只管候选列不列它, 已存的值不判非法(单据是挂上之后才被终止的,回显照样念得出标题)。 """ relation = {"key": "rel", "type": "relation"} # 没配、配空、配了认不出的:都退回默认那一档,别把候选捞成空的 eq("没配过就只给归档通过", dicts.relation_statuses(relation), ("completed",)) eq("配空了退回默认", dicts.relation_statuses({**relation, "relationStatuses": []}), ("completed",)) eq("认不出的那档丢掉,别牵连别的", dicts.relation_statuses( {**relation, "relationStatuses": ["closed", "bogus", "completed"]}), ("completed", "closed")) eq("写成别的形状也退回默认", dicts.relation_statuses({**relation, "relationStatuses": "running"}), ("completed",)) # 接口上那句 status:档位与单据状态原值都认,全给等于不限 eq("空是不限", dicts.relation_status_query(""), ()) eq("只给归档通过", dicts.relation_status_query("completed"), ("completed",)) eq("在办与半路停下的并档", dicts.relation_status_query("closed,running"), ("running", "closed")) eq("老写法传状态原值也认", dicts.relation_status_query("terminated"), ("closed",)) eq("三档全给等于不限", dicts.relation_status_query("completed,running,closed"), ()) eq("只认得出的那几档进清单", dicts.relation_status_query("completed,bogus"), ("completed",)) # 摊成两张表各挑哪几个状态:一张表一个都不沾就别去查它 eq("不限时两张表都不加状态条件", dicts.relation_status_tables(()), (None, None)) eq("只给归档通过时不查在办表", dicts.relation_status_tables(("completed",)), (None, ("completed",))) eq("在办 + 半路停下", dicts.relation_status_tables(("running", "closed")), (("running",), ("terminated", "canceled"))) # 设计期校验:措辞与前端 utils/optionSource.ts 一字不差(下面第 5 段逐句对) eq("没写这一格不说", formruntime.option_source_problems(relation, db=None), []) eq("一种都不勾要说", formruntime.option_source_problems( {**relation, "relationStatuses": []}, db=None), ["至少勾一种状态:一种都不勾,这一格永远搜不到候选"]) eq("档位认不出要说", formruntime.option_source_problems( {**relation, "relationStatuses": ["archieved"]}, db=None), ["能挂哪几种状态的单据里有认不出的档位:archieved"]) eq("配得对不说", formruntime.option_source_problems( {**relation, "relationStatuses": ["completed", "running"]}, db=None), []) # 换了来源就不该留着上一家的这一档 eq("换来源时这一档一起清", design_api.SOURCE_OWNED_KEYS[dicts.SOURCE_PROCESS][:2], ("relationProcess", "relationStatuses")) # --------------------------------------------------------------------------- # 4.5 字段上的解析覆盖(接口回多列时,这一格要哪一列) # --------------------------------------------------------------------------- def check_parse_override() -> None: """同一张源被几格各取一列:覆盖只改这一格,源上那一份一个字不动。""" row = models.DataSource(code="pms", name="PMS 预算", kind=models.DataSource.KIND_FETCH) row.pick = "data.balance" row.map_extra = {"name": "data.costCenterName"} row.map_value, row.map_label, row.items_path, row.message_path = "value", "label", "", "" body = {"code": 0, "data": {"balance": 12800.5, "costCenterName": "研发部", "ownerName": "张三"}} base = fetch.parse(row, body) eq("不覆盖就是源上那一份", base.value, 12800.5) eq("不覆盖时可带出键也只有源上那个", base.extras, {"name": "研发部"}) owner = fetch.parse(row, body, pick="data.ownerName") eq("这一格改取另一列", owner.value, "张三") eq("覆盖主值不动源上的声明", row.pick, "data.balance") both = fetch.parse(row, body, pick="data.ownerName", extras={"owner": "data.ownerName"}) eq("字段上补的带出列并进来", both.extras, {"name": "研发部", "owner": "张三"}) eq("并进来时同名以字段上的为准", fetch.parse(row, body, extras={"name": "data.ownerName"}).extras, {"name": "张三"}) eq("空路径那行不覆盖源上同名键", fetch.parse(row, body, extras={"name": " "}).extras, {"name": "研发部"}) eq("覆盖成响应里没有的路径就是没取到", fetch.parse(row, body, pick="data.nope").ok, False) # 列表型那一支的可带出键也吃同一份并法 rows = models.DataSource(code="pms2", name="成本中心", kind=models.DataSource.KIND_SEARCH) rows.items_path, rows.map_value, rows.map_label, rows.message_path = "data.rows", "code", "name", "" rows.map_extra = {} listed = fetch.parse(rows, {"data": {"rows": [{"code": "CC001", "name": "研发部", "owner": "张三"}]}}, extras={"owner": "owner"}) eq("列表型每一行也带得上补的那一列", listed.items[0]["extra"], {"owner": "张三"}) # 缓存键:同一张源同一份入参,两格各取一列时不能共用同一份缓存 eq("没覆盖时那份指纹一个字不变(升级不冲掉已经在用的缓存)", fetch._key_args({"k": "1"}), {"k": "1"}) ok("换了取哪一列就是另一份缓存", fetch._args_key("pms", fetch._key_args({"k": "1"})) != fetch._args_key("pms", fetch._key_args({"k": "1"}, "data.ownerName"))) ok("补的带出列不同也是另一份缓存", fetch._args_key("pms", fetch._key_args({"k": "1"}, "", {"a": "x"})) != fetch._args_key("pms", fetch._key_args({"k": "1"}, "", {"a": "y"}))) eq("多出来的那一格只进指纹,不进真发出去的入参", [key for key in fetch._key_args({"k": "1"}, "data.a") if key != "__shape"], ["k"]) # 设计期校验:字段上补的列也算"声明过",谁都没声明过的才该被点名 declared = binding.entry_problems(FakeDB(source_with_extra(name="data.costCenterName")), {"source": "erp", "picks": {"name": "a"}}, {"a"}, "外部取数") eq("源上声明过的带出键不说", declared, []) local = binding.entry_problems(FakeDB(source_with_extra(name="data.costCenterName")), {"source": "erp", "picks": {"owner": "b"}, "extras": {"owner": "data.ownerName"}}, {"b"}, "外部取数") eq("这一格自己补的带出键也算声明过", local, []) ghost = binding.entry_problems(FakeDB(source_with_extra(name="data.costCenterName")), {"source": "erp", "picks": {"ghost": "b"}}, {"b"}, "外部取数") ok("两处都没声明的带出键要点名", any("不在该数据源声明的可带出键里" in text for text in ghost), ghost) half = binding.entry_problems(None, {"source": "erp", "extras": {"owner": " "}}, set(), "外部取数") eq("补了名字没写路径要说", half, ["外部取数额外带出的「owner」没写它在响应里的路径"]) # --------------------------------------------------------------------------- # 4.5 带出的目标格子被删之后 # --------------------------------------------------------------------------- def check_live_targets() -> None: """格子删了、指向它的带出还留着:设计器现在会清(前端 utils/formPrune), 改之前存下的老表单靠运行时这道闸兜住——那一格的名字会被新字段复用。 """ fields = [{"key": "amount", "type": "money"}, {"key": "owner", "type": "text"}, "不是字段"] eq("字段名清单只认字典形状的字段", binding.field_keys(fields), {"amount", "owner"}) eq("字段清单没给时不挡原有的写", binding.field_keys(None), set()) eq("格子还在就照写", binding.live_target("owner", {"owner"}), "owner") eq("格子删了就不写", binding.live_target("field_text_2", {"owner"}), "") eq("没配目标就是空", binding.live_target(" ", {"owner"}), "") eq("拿不到字段清单时不挡原有的写", binding.live_target("field_text_2", None), "field_text_2") # 字典带出:目标格子没了就不写,同名字段后来被加上也不会被盖 fields = [ {"key": "price", "type": "money"}, {"key": "goods", "type": "select", "autoFill": [ {"field": "goods", "pick": "", "to": "price"}, {"field": "goods", "pick": "", "to": "field_text_2"}, ]}, ] data = {"goods": "M-1"} touched = dicts.apply_auto_fill(fields, data, None) eq("还在的格子照常带出", (touched, data.get("price")), (["price"], "M-1")) ok("删掉的格子没被写", "field_text_2" not in data, data) # 额度三个数:同样只写在还存在的展示格上 data = {} quota.write_show(None, {"show": {"total": "quotaTotal", "avail": "field_text_2"}}, data, total=100.0, used=30.0, after=70.0, keys={"quotaTotal"}) eq("额度的展示格也判活", data, {"quotaTotal": 100.0}) data = {} quota.write_show(None, {"show": {"avail": "field_text_2"}}, data, total=100.0, used=30.0, after=70.0) eq("没给字段清单时额度照旧写", data, {"field_text_2": 70.0}) class Cache: """顶替 ``DictCache``:这几行只认字典码,取的是手边写死的那几项。""" def __init__(self, **items: list[dict]) -> None: self._items = items def items(self, code: str) -> list[dict]: return list(self._items.get(code, [])) def index(self, code: str) -> dict[str, dict]: return {str(item.get("value")): item for item in self.items(code)} def check_fill_columns() -> None: """带出取哪一列(口径与前端 ``optionMap.pickFillValue`` 一字不差)。 「把字典的键值也写到别的格子上」这件事以前在后端没有认的写法——``pick`` 只往 ``extra`` 里找。放开成跟「显示 / 存值」同一套列写法之后,最要紧的还是那句: **老表单里写的裸键名仍旧是附加值那一列**,一个字节都不用改。 """ item = { "value": "M-1", "label": "六角螺栓", "parent": "bolt", "order_number": 3, "extra": {"price": 12.5, "value": "EX-9", "spec": {"unit": "个"}}, } eq("留空取名称", dicts.pick_fill_value(item, ""), "六角螺栓") eq("value 取键值", dicts.pick_fill_value(item, "value"), "M-1") eq("label 也取名称", dicts.pick_fill_value(item, "label"), "六角螺栓") eq("裸键名仍旧先按附加值读(老配置不改)", dicts.pick_fill_value(item, "price"), 12.5) eq("附加值里那个同名的键要写全", dicts.pick_fill_value(item, "extra.value"), "EX-9") eq("候选自己另几列走点路径", dicts.pick_fill_value(item, "parent"), "bolt") eq("再往里一层也认", dicts.pick_fill_value(item, "extra.spec.unit"), "个") eq("取不到是 None,不是空串(不覆掉格子里原有的话)", dicts.pick_fill_value(item, "nope"), None) ok("带出去的是原值:数字没被转成字符串", isinstance(dicts.pick_fill_value(item, "price"), float)) # 目标格子得在表单上:带出只往还存在的格子上写(上面那条闸) fields = [{"key": key, "type": "text"} for key in ("code", "name", "price", "unit", "note")] + [{ "key": "goods", "type": "select", "dictCode": "material", "autoFill": [ {"pick": "value", "to": "code"}, {"to": "name"}, {"pick": "price", "to": "price"}, {"pick": "extra.spec.unit", "to": "unit"}, {"pick": "missing", "to": "note"}, ], }] data = {"goods": "M-1", "note": "原来那句"} touched = dicts.apply_auto_fill(fields, data, Cache(material=[item])) eq("选了物料:键值、名称、附加值三档各写各的格子", [data.get("code"), data.get("name"), data.get("price"), data.get("unit")], ["M-1", "六角螺栓", 12.5, "个"]) eq("取不到那一列的格子原样留着,也不算被带出", [data.get("note"), "note" in touched], ["原来那句", False]) def check_validate_schema() -> None: fields = [ {"key": "material", "label": "物料", "type": "select", "optionSource": "dataSource", "dataSourceCode": "erp"}, {"key": "items", "label": "明细", "type": "table", "columns": [ {"key": "goods", "label": "货品", "type": "select", "optionSource": "dict"}, ]}, ] reasons = formruntime.validate_schema(fields, db=FakeDB(None)) eq("字段上的源毛病带上了字段名", [text for text in reasons if text.startswith("「物料」")], ["「物料」引用的数据源不存在:erp(先到「外部数据源」页建好)"]) ok("明细列的半截配置带上了列名", any( "「明细」的列「货品」还没选择要用的数据字典" == text for text in reasons), reasons) clean = [{"key": "material", "label": "物料", "type": "select", "optionSource": "dataSource", "dataSourceCode": "erp"}] eq("源健康时校验干净", formruntime.validate_schema( clean, db=FakeDB(Source("erp", "ERP 物料", kind=models.DataSource.KIND_SEARCH))), []) def check_save_pipeline_keeps_cascader_dict() -> None: """按保存那一刻的真实管线(清洗 → 校验)过一遍级联字段。 级联只挂层级字典,而它不在"候选来源"那四类里:清洗按"这一类型挑不了来源就整份撤掉" 处理,会把级联自己的 ``dictCode`` 一起抹掉,紧接着校验又要它,于是凡带级联字段 (含明细里那一列)的表单**一律存不下去**,报的还是句让人去重选字典的「还没选择要用的层级字典」。 """ fields = [ {"key": "cate", "label": "采购品类", "type": "cascader", "dictCode": "purchase"}, {"key": "items", "label": "明细", "type": "table", "columns": [ {"key": "cate2", "label": "品类", "type": "cascader", "dictCode": "purchase", "cascadeFrom": "cate"}, ]}, ] saved = design_api.clean_option_source(design_api.clean_formats({"fields": fields}))["fields"] eq("级联字段的字典编码活得过清洗", [saved[0].get("dictCode"), saved[1]["columns"][0].get("dictCode")], ["purchase", "purchase"]) eq("级联自己的级联上级也留着", saved[1]["columns"][0].get("cascadeFrom"), "cate") eq("清洗完的级联表单存得下去", formruntime.validate_schema(saved, db=FakeDB(None)), []) # --------------------------------------------------------------------------- # 5. 前后端措辞对齐 # --------------------------------------------------------------------------- #: 两边各写一遍、必须一字不差的几句:一份写在后端,一份镜像在前端 PARALLEL: list[tuple[tuple[str, str], list[str]]] = [ (("backend/app/service/binding.py", "frontend/src/utils/binding.ts"), ["还没选要用哪一张外部数据源", "(先到「外部数据源」页建好)", "」已停用", "是取一个值的,", "要的是列表型数据源", "是列表型,取不出单个值", "的方向是往外写,", "取不到东西", "把这张源的方向改成「双向」", # 入参那份引用检查也出自内核这一份 "的入参「", "」引用了不存在的字段「", "引用了这一格自己"]), (("backend/app/service/formruntime.py", "frontend/src/utils/optionSource.ts"), # 「由谁写入」那句两边都是拼出来的(``{filled_by}`` / ``${filledBy}``), # 能逐句对的只有拼出来的那几段常量 ["写入,候选又来自", "否则提交时会被判「取值已不在可选范围内」", "把候选来源改成外部数据源 / 流程单据", "或勾上「带出的值不在候选里也收下」", "这一格没配任何带出(外部取数 / 关联单据带出 / 字典带出),", "还没选择要用的数据字典", "还没选择要用哪一张外部数据源", "个选项没填要存的值,填了会存成空白"]), # 关联审批单能挂哪几种状态的单据:档位说得不一样,两边就会各判各的 # (这句判据后端写在 service/dicts.py,由 formruntime 转调) (("backend/app/service/dicts.py", "frontend/src/utils/optionSource.ts"), ["能挂哪几种状态的单据里有认不出的档位", "至少勾一种状态:一种都不勾,这一格永远搜不到候选", "能挂哪几种状态的单据要写成一份清单", # 候选来源的条件路由:清单本身那几句两边也必须一模一样(判据见 check_option_routes.py) "的候选来源清单要写成一份列表", " 条,多出来的不会被用上", "的来源这类字段挑不了", "一条选项都没填,选到它就是一只空下拉"]), # 报错里怎么称呼那份候选入参表,两边也得是同一个说法 (("backend/app/service/formruntime.py", "frontend/src/utils/binding.ts"), ["候选来源那张数据源"]), ] def check_wording_parity() -> None: """同一句判据在两边各写了一份(前端拿不到库,只能自己算),措辞必须一样。 共用的是**句子**而不是算法——真漂移起来没人看得出来,所以这里逐句对一遍。 """ root = pathlib.Path(__file__).resolve().parents[2] for (backend_file, frontend_file), phrases in PARALLEL: right = root / frontend_file if not right.exists(): print(f"[跳过] 找不到前端那份 {right}(只部署后端时正常)") continue left_text = (root / backend_file).read_text(encoding="utf-8") right_text = right.read_text(encoding="utf-8") for phrase in phrases: missing = "后端缺" if phrase not in left_text else "" if phrase not in right_text: missing = missing or "前端缺" ok(f"「{phrase}」前后端都在", not missing, f"{missing}:{backend_file} / {frontend_file}") # --------------------------------------------------------------------------- FAILS: list[str] = [] def eq(name: str, got, want) -> None: """取值相等;不等就把两边都打出来,方便一眼看出是形状变了还是值变了。""" if got != want: FAILS.append(f"{name}:期望 {want!r},实得 {got!r}") def ok(name: str, condition, detail=None) -> None: if not condition: FAILS.append(f"{name}:{detail if detail is not None else '条件不成立'}") def main(argv: list[str]) -> int: stages = [ ("取值写法", check_parsing), ("多源清单与合并", check_entries_merge), ("源的健康判据", check_source_problem), ("选人字段当 SQL 入参", check_person_args), ("候选来源校验", check_option_source_problems), ("关联审批单能挂哪几种状态的单据", check_relation_statuses), ("字段上的解析覆盖", check_parse_override), ("带出的目标格子被删之后", check_live_targets), ("带出取哪一列", check_fill_columns), ("表单定义校验", check_validate_schema), ("保存管线不吞级联字段的字典", check_save_pipeline_keeps_cascader_dict), ("前后端措辞对齐", check_wording_parity), ] for title, stage in stages: before = len(FAILS) stage() marks = "通过" if len(FAILS) == before else f"{len(FAILS) - before} 条不对" print(f"[{marks}] {title}") for line in FAILS: print(f"[FAIL] {line}") if FAILS: print(f"共 {len(FAILS)} 条不对") return 1 print("通过:取数内核与候选来源校验口径一致") return 0 if __name__ == "__main__": raise SystemExit(main(sys.argv[1:]))