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