unis-oa/backend/scripts/check_binding.py

781 lines
46 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""取数内核与候选来源校验的验收脚本(不连库,跑在 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:]))