unis-oa/backend/scripts/check_tabs.py

357 lines
21 KiB
Python
Raw Permalink 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.

"""表单上的「标签页」(``type=tabs``)的验收脚本(不连库,跑在 backend 目录下)::
python3 scripts/check_tabs.py
方案见 ``docs/form-tabs-embed-design.md``。四件事必须一直成立:
1. **归属记在格子身上**:``tab_of`` 只认那张标签页上真的有的页签,写了别的(页签被删了)
一律回落到第一页——回落是看得见的,"在某页上但谁也找不到"才是查不出来的;
2. **外部页面那一页伪装出来的那一"格",key 必须是标签页那一格自己的 key**。发地址前
后端按这个 key 重算可见性(``api/embeds.py:_field_perm``),查不到这一格就当没有约束
放行。这条写错不会报错,只会把环节那一道闸静静拆掉;
3. **外部页面那一页上还压着格子=保存那一刻就挡**:那些格子还参与必填与提交校验,
却在这一页上根本不显示,等于发一张填不完的表单;
4. **环节把"整片"或"某一页"藏起来时,要落到每个格子头上**:前端早就按这条藏格子了,可
引擎算必填、发免登地址读的是 ``formPerms`` 那份平字典。不展开就是人看不见那一格、
引擎还在要那一格——那张"填不完的表单"只摆在标签页的表单上出现,最难复现;
5. **页签角标只在对照表里才有话可说**:外部系统哪天多回一种状态,页签上冒出一句
``partial_v2`` 比什么都不挂更吓人,所以认不出就什么都不挂;
6. **前后端各写一遍的那几句措辞对一遍**:漂了这里就红(前端那份在 utils/tabPages.ts)。
"""
from __future__ import annotations
import pathlib
import re
import sys
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
from app.service import embed, formruntime, tabpages # noqa: E402
ROOT = pathlib.Path(__file__).resolve().parent.parent.parent
def tabs_field(tabs, *, key="pages", label="标签页", **extra):
return {"key": key, "label": label, "type": "tabs", "tabs": tabs, **extra}
def field(key, **extra):
return {"key": key, "label": key, "type": "text", **extra}
# ---------------------------------------------------------------------------
def check_tab_shape():
"""补齐那一套:缺 key、缺名字、kind 乱写都得读成能用的一页。"""
rows = tabpages.tabs_of(tabs_field([{}, {"key": "x", "label": "第二页", "kind": "nope"}]))
eq("补齐 key", [row["key"] for row in rows], ["tab_1", "x"])
eq("补齐名字", [row["label"] for row in rows], ["第 1 页", "第二页"])
eq("认不出的 kind 一律当表单页", [row["kind"] for row in rows], ["form", "form"])
eq("没摆这一格就是没摆", tabpages.tabs_of({"type": "text"}), [])
def check_membership():
tabs = tabpages.tabs_of(tabs_field([{"key": "tab_1", "label": "第一页"}, {"key": "tab_2", "label": "第二页"}]))
eq("没写归属在第一页", tabpages.tab_of(field("a"), tabs), "tab_1")
eq("写了就在那一页", tabpages.tab_of(field("b", tab="tab_2"), tabs), "tab_2")
eq("页签被删了回落到第一页", tabpages.tab_of(field("c", tab="gone"), tabs), "tab_1")
eq("一页都没有回空串", tabpages.tab_of(field("a"), []), "")
rows = [tabs_field(tabs), field("a"), field("b", tab="tab_2")]
eq("按页分格子不含标签页自己", [row["key"] for row in tabpages.fields_of_tab(rows, tabs, "tab_1")], ["a"])
eq("第二页只有 b", [row["key"] for row in tabpages.fields_of_tab(rows, tabs, "tab_2")], ["b"])
def check_embed_tab_key():
"""那条安全不变量:伪装成的那一格,key 是标签页那一格的 key。"""
host = tabs_field([{"key": "tab_1", "label": "第一页"},
{"key": "tab_2", "label": "合同", "kind": "embed",
"embed": {"source": "erp_contract", "params": {"no": "{form.contractNo}"}}}])
fake = tabpages.as_embed_field(host, tabpages.tabs_of(host)[1])
eq("key 用的是标签页那一格的", fake["key"], "pages")
eq("配置带过去了", embed.source_code_of(fake), "erp_contract")
eq("整页默认都给这个页面", embed.fit_of(fake), embed.FIT_FILL)
eq("窄屏默认也嵌进去", embed.mobile_of(fake), embed.MOBILE_FRAME)
# 页签自己那份没写 fit 时才是 fill;写了就照它给的
short = tabpages.as_embed_field(host, {"key": "tab_2", "label": "矮", "kind": "embed",
"embed": {"source": "erp_contract", "fit": "fixed"}})
eq("页签自己说了算", embed.fit_of(short), embed.FIT_FIXED)
def check_problems():
say = lambda rows: ";".join(tabpages.problems(rows, None, at="标签页")) # noqa: E731
ok("一页都没有要挡", tabpages.problems(tabs_field([]), None, at="标签页") == ["「标签页」还没添加任何一页"])
ok("只有一页要挡", "至少要有 2 页" in say(tabs_field([{"key": "tab_1", "label": "一页"}])))
named = say(tabs_field([{"key": "tab_1", "label": ""}, {"key": "tab_1", "label": "重了"}]))
ok("没名字要点名", "第 1 页没有名字" in named, named)
ok("标识重复要点名", "第 2 页的标识与第 1 页重复" in named, named)
ok("kind 不认识要说", "类型不认识:nope" in say(tabs_field([{"key": "a", "label": "一", "kind": "nope"},
{"key": "b", "label": "二"}])))
no_source = say(tabs_field([{"key": "tab_2", "label": "合同", "kind": "embed", "embed": {}}]))
ok("外部页面没挑页面要说", "「标签页」第 1 页「合同」还没选择要嵌入哪个页面" in no_source, no_source)
height_out = say(tabs_field([{"key": "t1", "label": "合同", "kind": "embed",
"embed": {"source": "erp_contract", "height": 40}},
{"key": "t2", "label": "二"}]))
ok("高度出格跟着页签名说", f"的内嵌框高度要在 {embed.MIN_HEIGHT}-{embed.MAX_HEIGHT}px 之间" in height_out, height_out)
fit_bad = say(tabs_field([{"key": "t1", "label": "合同", "kind": "embed",
"embed": {"source": "erp_contract", "fit": "huge"}},
{"key": "t2", "label": "二"}]))
ok("高度方式不认识要说", "内嵌框高度方式不认识:huge" in fit_bad, fit_bad)
# 那条最要紧的:外部页面那一页上还压着格子
host = tabs_field([{"key": "tab_1", "label": "第一页"}, {"key": "tab_2", "label": "合同", "kind": "embed",
"embed": {"source": "erp_contract"}}])
rows = [host, field("a"), field("b", tab="tab_2"), field("c", tab="tab_2")]
say2 = ";".join(tabpages.problems(host, None, at="标签页", field_keys={"a", "b", "c"}, targets=rows))
ok("压着格子要说,还要说几个", "压在它上面的 2 个格子不会被显示出来" in say2, say2)
ok("回填点了不存在的字段要说", "要回填的字段「ghost」在表单上找不到" in ";".join(
tabpages.problems(
tabs_field([{"key": "t1", "label": "合同", "kind": "embed",
"embed": {"source": "erp_contract", "writeback": {"enabled": True, "fields": ["ghost"]}}},
{"key": "t2", "label": "二"}]),
None, at="标签页", field_keys={"amount"})))
ok("页签超出上限要说", "最多 10 页" in say(tabs_field(
[{"key": f"tab_{n}", "label": f"第{n}页"} for n in range(1, 12)])))
# 归属写了不存在的页签不报错:运行时回落第一页,是看得见的
ok("归属越界不报错", tabpages.problems(
tabs_field([{"key": "tab_1", "label": "一"}, {"key": "tab_2", "label": "二"}]),
None, at="标签页", field_keys={"a"}, targets=[field("a", tab="gone")]) == [])
def _host_with_two_tabs():
return tabs_field([{"key": "tab_1", "label": "第一页"},
{"key": "tab_2", "label": "票据", "badge": {"field": "check",
"map": {"passed": {"text": "初审通过", "tone": "green"}}}}])
def check_perm_expansion():
"""藏整片 / 藏一页要落到每个格子头上(前端 expandPerms 是同一份判据)。"""
host = _host_with_two_tabs()
rows = [host, field("a"), field("b", tab="tab_2"), field("c", tab="tab_2")]
eq("没配权限就原样回", tabpages.expand_perms(rows, {}), {})
eq("没摆标签页就原样回", tabpages.expand_perms([field("a")], {"a": "readonly"}), {"a": "readonly"})
whole = tabpages.expand_perms(rows, {"pages": "hidden"})
eq("藏整片连页里的格子一起藏", sorted(whole), ["a", "b", "c", "pages"])
eq("藏整片时格子盖不过隐藏", whole["b"], "hidden")
eq("藏整片不改标签页自己那格", whole["pages"], "hidden")
one = tabpages.expand_perms(rows, {tabpages.slot_key("pages", "tab_2"): "hidden"})
eq("藏一页只藏那一页的格子", sorted(one), ["b", "c", "pages#tab_2"])
eq("另一页的格子不受牵连", "a" in one, False)
eq("没写归属的格子算第一页,跟着第一页走",
"a" in tabpages.expand_perms(rows, {tabpages.slot_key("pages", "tab_1"): "hidden"}), True)
mixed = tabpages.expand_perms(rows, {"a": "editable", tabpages.slot_key("pages", "tab_2"): "readonly"})
eq("页签只认隐藏这一档,别的档不动格子", mixed, {"a": "editable", "pages#tab_2": "readonly"})
eq("展开不改传进来的那份字典", rows[1].get("key"), "a")
# 发地址那一条链:页签那一档得能挡住
eq("页签权限挂点是这个形状", tabpages.slot_key("pages", "tab_2"), "pages#tab_2")
eq("没配过回空串", tabpages.slot_perm({"pages": "readonly"}, "pages", "tab_2"), "")
def check_badge():
"""角标:跟着某一格的值走,认不出就什么都不挂。"""
tab = tabpages.tabs_of(_host_with_two_tabs())[1]
eq("配了才有", tabpages.badge_of(tabpages.tabs_of(_host_with_two_tabs())[0]), {})
eq("值为空不挂", tabpages.badge_view(tab, {"check": ""}), None)
eq("还没回传不挂", tabpages.badge_view(tab, {}), None)
eq("命中对照表", tabpages.badge_view(tab, {"check": "passed"}), {"text": "初审通过", "tone": "green"})
eq("不在表里且没兜底就不挂", tabpages.badge_view(tab, {"check": "partial_v2"}), None)
wildcard = {"key": "t", "label": "t", "badge": {"field": "check",
"map": {"passed": "通过", "*": {"tone": "amber"}}}}
wt = tabpages.tabs_of(tabs_field([wildcard]))[0]
eq("兜底那一档接住其余值", tabpages.badge_view(wt, {"check": "whatever"}), {"text": "whatever", "tone": "amber"})
eq("值可以就是一句话", tabpages.badge_view(wt, {"check": "passed"}), {"text": "通过", "tone": "gray"})
weird = tabpages.tabs_of(tabs_field([{"key": "t", "label": "t",
"badge": {"field": "check", "map": {"x": {"tone": "rainbow"}}}}]))[0]
eq("颜色不认识退回灰", tabpages.badge_view(weird, {"check": "x"}), {"text": "x", "tone": "gray"})
say = lambda rows: ";".join(tabpages.problems(rows, None, at="标签页", field_keys={"check"})) # noqa: E731
ok("没写跟哪一格要说", "的角标没写要跟着哪一格的值走" in say(
tabs_field([{"key": "t1", "label": "一", "badge": {}}, {"key": "t2", "label": "二"}])), )
ok("指到没有的格子要说", "的角标要跟着「ghost」的值走,表单上没有这一格" in say(
tabs_field([{"key": "t1", "label": "一", "badge": {"field": "ghost"}}, {"key": "t2", "label": "二"}])))
ok("颜色不认识要说", "的角标颜色不认识:pink" in say(
tabs_field([{"key": "t1", "label": "一", "badge": {"field": "check", "map": {"a": {"tone": "pink"}}}},
{"key": "t2", "label": "二"}])))
ok("角标配得对就不啰嗦", tabpages.problems(
tabs_field([{"key": "t1", "label": "一", "badge": {"field": "check"}}, {"key": "t2", "label": "二"}]),
None, at="标签页", field_keys={"check"}) == [])
def check_registry():
"""两边的清单都认这一类,而且它进的是"没有值"那一族。"""
from app.api import design # 局部导入:这一份脚本只读常量
ok("design 认这个类型", "tabs" in design.FIELD_TYPES)
ok("纯排版不能勾必填", "tabs" in design.LAYOUT_ONLY_TYPES)
ok("没有录入控件", "tabs" in formruntime.NON_INPUT_TYPES)
problems = formruntime.validate_schema([
tabs_field([{"key": "tab_1", "label": "一"}, {"key": "tab_2", "label": "二"}]),
tabs_field([{"key": "tab_1", "label": "一"}, {"key": "tab_2", "label": "二"}]),
])
ok("两个标签页要挡", any("标签页字段只能有一个" in item for item in problems), problems)
ok("一个标签页不挡", not any("标签页字段只能有一个" in item for item in
formruntime.validate_schema([tabs_field([{"key": "a", "label": "一"},
{"key": "b", "label": "二"}])])))
ok("标签页不往 data 里写值", not formruntime.fillable({"type": "tabs"}))
def check_display_mode():
"""两种排法:默认档、认错时的回落、以及"进来先合着"只在该档下算数。"""
eq("没写就是页签", tabpages.mode_of(tabs_field([{"key": "a", "label": "一"}])), "tabs")
eq("收折档读得出来", tabpages.mode_of(tabs_field([], tabsMode="collapse")), "collapse")
eq("认不出的排法回页签", tabpages.mode_of(tabs_field([], tabsMode="carousel")), "tabs")
rows = [{"key": "tab_1", "label": "第一页"}, {"key": "tab_2", "label": "第二页", "collapsed": True}]
eq("收折档才认「进来先合着」", tabpages.collapsed_keys(tabs_field(rows, tabsMode="collapse")), ["tab_2"])
eq("页签档不算这件事", tabpages.collapsed_keys(tabs_field(rows)), [])
eq("覆盖只认真布尔值", tabpages.collapsed_keys(tabs_field(
[{"key": "tab_1", "label": "一"}, {"key": "tab_2", "label": "二", "collapsed": "yes"}],
tabsMode="collapse")), [])
# 默认那一档 + 段上覆盖:两处配的是同一件事,必须合成一份结论
three = [{"key": "tab_1", "label": "一"}, {"key": "tab_2", "label": "二"}, {"key": "tab_3", "label": "三"}]
eq("默认没写就是全展开", tabpages.default_of(tabs_field(three, tabsMode="collapse")), "expand")
eq("认不出的默认回全展开", tabpages.default_of(tabs_field(three, tabsMode="collapse", tabsDefault="up")), "expand")
eq("默认全展开=都合不上", tabpages.collapsed_keys(tabs_field(three, tabsMode="collapse")), [])
eq("默认全收起=全合着", tabpages.collapsed_keys(
tabs_field(three, tabsMode="collapse", tabsDefault="collapse")), ["tab_1", "tab_2", "tab_3"])
eq("只展开第一段", tabpages.collapsed_keys(
tabs_field(three, tabsMode="collapse", tabsDefault="first")), ["tab_2", "tab_3"])
eq("第一段被环节藏了就换看得见的第一段", tabpages.collapsed_keys(
tabs_field(three, tabsMode="collapse", tabsDefault="first"), "tab_2"), ["tab_1", "tab_3"])
eq("段上覆盖赢过默认", tabpages.collapsed_keys(tabs_field(
[{"key": "tab_1", "label": "一", "collapsed": False}, {"key": "tab_2", "label": "二"},
{"key": "tab_3", "label": "三", "collapsed": False}],
tabsMode="collapse", tabsDefault="collapse")), ["tab_2"])
eq("默认全收起时段上能反过来先展开", tabpages.collapsed_keys(tabs_field(
[{"key": "tab_1", "label": "一", "collapsed": False}, {"key": "tab_2", "label": "二"}],
tabsMode="collapse", tabsDefault="collapse")), ["tab_2"])
ok("默认写歪要挡", any("的默认开合不认识:sideways" in item for item in tabpages.problems(
tabs_field(three, tabsMode="collapse", tabsDefault="sideways"), None, at="标签页")))
ok("默认认得就不挡", not any("默认开合" in item for item in tabpages.problems(
tabs_field(three, tabsMode="collapse", tabsDefault="first"), None, at="标签页")))
problems = tabpages.problems(tabs_field([{"key": "a", "label": "一"}, {"key": "b", "label": "二"}],
tabsMode="carousel"), None, at="标签页")
ok("排法认错要挡", any("的排列方式不认识:carousel" in item for item in problems), problems)
ok("排法认得就不挡",
not any("排列方式" in item for item in tabpages.problems(
tabs_field([{"key": "a", "label": "一"}, {"key": "b", "label": "二"}], tabsMode="collapse"),
None, at="标签页")))
def check_wording_parity():
"""前后端各写一遍的那几句,措辞必须一字不差。
两句不在同一层里:页签那些话在 ``tabpages.py`` / ``tabPages.ts``,那一页外部页面
的毛病(没挑页面、高度出格、回填点了收不下的格子)是 ``embed`` 那层说的,「只能有一个
标签页」又在 ``formruntime`` / ``formLayout`` 那一边数。所以两边各拼一份文本再比——
比的仍是同一句人话在两边都在,只是不假设它写在同一个文件里。
"""
backend = "".join(_read(path) for path in [
"backend/app/service/tabpages.py",
"backend/app/service/embed.py",
"backend/app/service/formruntime.py",
])
frontend = "".join(_read(path) for path in [
"frontend/src/utils/tabPages.ts",
"frontend/src/utils/formRuntime.ts",
"frontend/src/utils/formLayout.ts",
])
phrases = [
"还没添加任何一页",
"没有名字",
"的标识是空的",
"的标识与第",
"页重复",
"的类型不认识:",
"的排列方式不认识:",
"的默认开合不认识:",
"的内嵌框高度方式不认识:",
"这一页是外部页面,压在它上面的",
"个格子不会被显示出来",
"把它们挪去别的页",
"至少要有",
"页,只有一页就用不上标签页",
"标签页字段只能有一个(第",
"还没选择要嵌入哪个页面",
"的内嵌框高度要在",
"要回填的字段",
"在表单上找不到",
"的角标没写要跟着哪一格的值走",
"的角标要跟着「",
"的值走,表单上没有这一格",
"的角标取值对照表得是一个对象",
"的角标颜色不认识:",
]
for phrase in phrases:
missing = [] if phrase in backend else ["后端缺"]
if phrase not in frontend:
missing.append("前端缺")
ok(f"「{phrase}」两边都在", not missing, "、".join(missing))
# 页数上限也得是一份话
for name, backend_value, frontend_value in [
("MIN_TABS", tabpages.MIN_TABS, _ts_number("TAB_MIN_COUNT")),
("MAX_TABS", tabpages.MAX_TABS, _ts_number("TAB_MAX_COUNT")),
]:
ok(f"{name} 两边一样", backend_value == frontend_value, f"后端 {backend_value} / 前端 {frontend_value}")
def _read(relative: str) -> str:
return (ROOT / relative).read_text(encoding="utf-8")
def _ts_number(name: str) -> int:
source = (ROOT / "frontend/src/types/index.ts").read_text(encoding="utf-8")
match = re.search("export const " + name + " = ([0-9]+)", source)
if not match:
raise AssertionError(f"前端找不到 {name}")
return int(match.group(1))
# ---------------------------------------------------------------------------
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_tab_shape),
("两种排法", check_display_mode),
("谁在哪一页", check_membership),
("外部页面那一页的权限挂点", check_embed_tab_key),
("保存那一刻要挡的", check_problems),
("环节藏整片与藏一页", check_perm_expansion),
("页签状态角标", check_badge),
("类型清单与'没有值'那一族", check_registry),
("前后端措辞对齐", 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:]))