#!/usr/bin/env python3 """环节外部审批接口的**纯函数口径**验收(不连库)。 PYTHONPATH=. python3 scripts/check_node_approve.py 钉住那些"两边日志都写着成功、单子却走错分支"的判据:配置怎么合并、词怎么翻、 出口怎么钉、白名单怎么筛、意见怎么渲染、幂等怎么重放。连库跑真流程的那一段在 ``check_node_approve_api.py``,这一段只验"判据本身没有漂移"。 """ from __future__ import annotations import re import sys import time from pathlib import Path from types import SimpleNamespace from datetime import datetime from app.engine.definition import ActivityNode from app.service import embed_session, node_approve #: 校验脚本在 backend/scripts 下,仓库根在上一层的上一层 ROOT = Path(__file__).resolve().parents[2] FAILS: list[str] = [] PASSED = 0 def check(label: str, condition, detail="") -> None: global PASSED if condition: PASSED += 1 print(f"[通过] {label}") else: FAILS.append(label) print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}") def stub_activity(config: dict | None = None) -> SimpleNamespace: return SimpleNamespace(process="p1", id="a1", name="财务复核", config=config or {}) def stub_process(open_approve: dict | None = None) -> SimpleNamespace: return SimpleNamespace(id="p1", open_approve=open_approve or {}, latest_form="") class StubResult: """只够喂 ``db.execute(select(Route.name)...).scalars().all()`` 那一条查询。""" def __init__(self, names: list[str]) -> None: self._names = list(names) def scalars(self) -> "StubResult": return self def all(self) -> list[str]: return self._names class StubDb: """假库:记下每一条 SQL,回给定的出口名。这一段不连库。""" def __init__(self, names: list[str] | None = None) -> None: self.names = names or [] self.sql: list[str] = [] def execute(self, stmt) -> StubResult: self.sql.append(" ".join(str(stmt.compile(compile_kwargs={"literal_binds": True})).split())) return StubResult(self.names) def main() -> int: stamp = int(time.time()) now = datetime(2026, 10, 23, 14, 0, 0) # ---------------------------------------------------------------- 配置合并 process = stub_process({"enabled": True, "apps": ["erp"], "confirm": "auto", "decisions": {"APPROVED": "agree"}}) node = stub_activity({"openApprove": {"confirm": "confirm"}}) merged = node_approve.effective_config(process, node) check("环节显式配置逐键覆盖流程默认(confirm)", merged["confirm"] == "confirm", merged) check("没配的键继承流程默认(apps / decisions)", merged["apps"] == ["erp"] and merged["decisions"] == {"APPROVED": "agree"}, merged) node_off = stub_activity({"openApprove": {"enabled": False}}) check("流程默认开着、环节显式关掉 = 真的关", node_approve.is_enabled(node_approve.effective_config(process, node_off)) is False) check("两层都没配 = 关", node_approve.is_enabled(node_approve.effective_config(stub_process(), stub_activity())) is False) check("确认模式写歪收敛回 confirm", node_approve.confirm_mode({"confirm": "auto-ish"}) == "confirm") check("决策词表的大小写与空格不计较", node_approve.decisions_map({"decisions": {" APPROVED ": "Agree "}}) == {"approved": "agree"}) check("出口钉配留空就是空(没钉 = 按名匹配)", node_approve.routes_map({"routes": None}) == {}) # ---------------------------------------------------------------- 词翻结论、结论匹出口 cfg = {"decisions": {"APPROVED": "agree", "REJECTED": "refuse"}} check("对方词按对照表翻成 agree", embed_session.decision_kind("APPROVED", node_approve.decisions_map(cfg)) == "agree") check("对方词表里没有的原样交回给匹配那一步", embed_session.decision_kind("SOMETHING", node_approve.decisions_map(cfg)) == "SOMETHING") # 表里配的那一行排在内置三词前面:第三方只回 AGREE / REFUSE 那一套词、一个字不改时, # 开始环节唯一的活路就是管理员写一行 AGREE→submit(内置词先命中会把它读成死配置) override = {"decisions": {"AGREE": "submit", "REFUSE": "refuse"}} check("内置写法在表里被改判:AGREE 按配的表翻成 submit", embed_session.decision_kind("AGREE", node_approve.decisions_map(override)) == "submit") check("表里没写的内置写法照旧原样命中(不必自己映射自己)", embed_session.decision_kind("REFUSE", node_approve.decisions_map(cfg)) == "refuse") check("表里把值配空等于没配,交回原词", embed_session.decision_kind("AGREE", node_approve.decisions_map({"decisions": {"AGREE": " "}})) == "agree") names = ["通过", "退回修改"] route, problem = embed_session.match_route(names, decision="refuse", activity="财务复核") check("驳回应走「退回修改」,不能被「退回」里的「退」带偏", route == "退回修改" and problem is None, (route, problem)) route, problem = embed_session.match_route(["同意", "不同意", "退回修改"], decision="refuse", activity="财务复核") check("三个出口里驳回不唯一 → 不猜、回候选", route == "" and problem is not None and problem[1] == "EMBED_ROUTE_AMBIGUOUS", (route, problem)) route, problem = embed_session.match_route(["通过"], decision="submit", activity="财务复核") check("只有一个出口时 submit 就够", route == "通过" and problem is None, (route, problem)) route, problem = embed_session.match_route(names, decision="submit", activity="财务复核") check("多个出口时 submit 被挡(没方向的词不赌方向)", route == "" and problem is not None and problem[1] == "EMBED_ROUTE_AMBIGUOUS", (route, problem)) # 钉配优先:钉了 refuse,就必然走那条线,不走向最长匹配 pinned = node_approve.routes_map({"routes": {"refuse": "退回修改", "agree": "通过"}}) names2 = ["通过", "退回修改", "不同意并归档"] check("钉配把驳回钉在「退回修改」上", pinned.get("refuse") == "退回修改") check("没钉的结论仍走按名匹配", pinned.get("submit", "") == "" and embed_session.match_route(names2, decision="submit", activity="x")[1] is not None) # ---------------------------------------------------------------- 开始环节专用判据 check("开始环节映到同意的词点名挡下", node_approve.begin_problems({"decisions": {"PASSED": "agree", "SUBMITTED": "submit"}}) == ["决策词「passed」映到「agree」没有可走的出口"]) check("开始环节钉到同意出口的钉配点名挡下", node_approve.begin_problems({"routes": {"agree": "提交"}}) == [f"出口钉配「{node_approve.DECISION_LABELS['agree']}」没有可钉的出口"]) check("开始环节只认提交的配置干净", node_approve.begin_problems({"decisions": {"SUBMITTED": "submit"}, "routes": {"submit": "提交"}}) == []) check("开始环节对不认识的词不重复点名(通用那把尺报过了)", node_approve.begin_problems({"decisions": {"X": "bogus"}, "routes": {"bogus": "提交"}}) == []) check("开始环节的判据不吃流程默认档(配置合并之前是空档)", node_approve.begin_problems(None) == []) # ------------------------------------------------------------- 发布前体检:钉住的出口 # 环节有两种来路:保存流程时是库里的 ORM 行(有 process 这一列),发布校验时是设计稿 # 节点(ActivityNode,没有那一列)。后者一度把整次校验打成 500,两种来路都得钉住。 pinned_cfg = {"openApprove": {"enabled": True, "routes": {"agree": "同意"}}} draft = ActivityNode(id="a1", type="approval", name="财务复核", config=dict(pinned_cfg)) orm_row = SimpleNamespace(process="p9", id="a1", name="财务复核", type="approval", form="", config=dict(pinned_cfg)) db_hit = StubDb(["同意"]) check("设计稿节点也能过发布体检(不抛异常,出口对得上就没问题)", node_approve.problems(db_hit, stub_process(None), draft) == []) check("体检查出口时按调用方给的流程编号过滤,不摸环节对象的 process", db_hit.sql == ["SELECT oa_route.name FROM oa_route " "WHERE oa_route.from_activity = 'a1' AND oa_route.process = 'p1'"], db_hit.sql) db_miss = StubDb(["通过", "退回修改"]) missed = node_approve.problems(db_miss, stub_process(None), draft) check("钉到这一环不存在的出口时点名,并把现有的几条列出来", len(missed) == 1 and "钉到出口「同意」" in missed[0] and "这一环没有这条出口(现有:退回修改、通过)" in missed[0], missed) check("库里那条来路(ORM 行)体检口径一样", node_approve.problems(StubDb(["同意"]), stub_process(None), orm_row) == []) check("认不出归属流程时退回按环节查,不把真出口报成不存在", node_approve.problems(StubDb(["同意"]), None, draft) == []) db_off = StubDb(["同意"]) check("没开的环节不体检:一条 SQL 都不发", node_approve.problems(db_off, stub_process(None), ActivityNode(id="a1", type="approval", name="财务复核")) == [] and db_off.sql == [], db_off.sql) # ---------------------------------------------------------------- 白名单筛值 fields = [ {"key": "payAmount", "label": "金额"}, {"key": "payAccount", "label": "账号"}, {"key": "riskLevel", "label": "风险", "threshold": {"op": ">", "rightField": "limit"}}, ] data, dropped = node_approve.filter_data({"payAmount": 120, "riskLevel": "high", "unknown": 1}, {"fields": ["payAmount", "payAccount", "riskLevel"]}, fields) check("白名单内的键收下", data == {"payAmount": 120}, data) check("挂阈值的格子拒收、清单外的键丢弃", dropped == ["riskLevel", "unknown"], dropped) data, dropped = node_approve.filter_data({"payAmount": 1}, {"fields": []}, fields) check("白名单空 = 一条都不收", data == {} and dropped == ["payAmount"], (data, dropped)) # ---------------------------------------------------------------- 意见渲染 work = SimpleNamespace(serial="BX-2026-0091") cfg_op = {"opinion": {"agree": "对账一致,同意。单号 {serial},金额 {form.payAmount}。"}} text = node_approve.render_opinion(cfg_op, "agree", work, {"payAmount": "12800"}) check("意见模板渲染 {serial} 与 {form.字段名}", text == "对账一致,同意。单号 BX-2026-0091,金额 12800。", text) check("没配模板回空串(让引擎走它自己的口径)", node_approve.render_opinion({}, "agree", work, {}) == "") check("配了别的结论的模板不套到这一个上", node_approve.render_opinion(cfg_op, "refuse", work, {}) == "") # ---------------------------------------------------------------- 接口卡片 process2 = stub_process(None) activity2 = SimpleNamespace(process="p1", id="a2", name="财务复核", config={"openApprove": {"enabled": True, "routes": {"refuse": "退回修改"}}}) card = node_approve.card(process2, activity2, work=work) check("卡片带端点、确认模式与钉配(主地址点名环节,省那一段的那条挂在 alt 上)", card.get("interface") == "POST /api/v1/open/nodes/BX-2026-0091/a2/decide" and card.get("interfaceCurrent") == "POST /api/v1/open/nodes/BX-2026-0091/decide" and card.get("interfaceActivity") == card.get("interface") and card.get("routes") == {"refuse": "退回修改"}, card) check("卡片把那张单的单号填进样例", (card.get("sample") or {}).get("work") == "BX-2026-0091", card.get("sample")) # 开始环节那张卡片:样例与建单那句都得换一档口径——对方是照卡片抄的, # 摆一个这一环压根认不出的结论词、又不说"先建一张停着的单",就是这次联调撞的两堵墙 begin_activity = SimpleNamespace(process="p1", id="a1", name="发起人", type="begin", config={"openApprove": { "enabled": True, "confirm": "auto", "decisions": {"AGREE": "submit", "PASSED": "agree"}, "routes": {"submit": "提交"}}}) begin_card = node_approve.card(stub_process(None), begin_activity, work=work) works_row = next(row for row in begin_card["apis"] if row["path"] == "/api/v1/open/works") check("开始环节卡片:样例那格给的是这一环认得的词,不是 APPROVED", (begin_card.get("sample") or {}).get("result") == "AGREE", begin_card.get("sample")) check("开始环节卡片:建单那条说清先带 hold 建一张停着的单,再拿回包的号来表态", "hold" in works_row["when"] and "先" in works_row["when"], works_row["when"][:120]) check("人工环节卡片照旧:样例 APPROVED、建单那条是泛泛那句发起", (card.get("sample") or {}).get("result") == "APPROVED" and "hold" in node_approve.WORKS_WHEN_BEGIN and "hold" not in next(row for row in card["apis"] if row["path"] == "/api/v1/open/works")["when"], card.get("sample")) check("没配对照表时样例退回内置写法(开始环节 SUBMITTED / 其余 APPROVED)", node_approve.sample_result_word({}, activity=True) == "SUBMITTED" and node_approve.sample_result_word({}, activity=False) == "APPROVED") design_card = node_approve.card(process2, activity2) check("设计期没有单据,两条端点里都留 {流程编号} 占位", design_card.get("interface") == "POST /api/v1/open/nodes/{流程编号}/a2/decide" and design_card.get("interfaceCurrent") == "POST /api/v1/open/nodes/{流程编号}/decide", design_card) no_serial_card = node_approve.card(process2, activity2, work=SimpleNamespace(serial="", job="JOB-9")) check("编号没排出来就退回 job 号(那一段两处都认得)", no_serial_card.get("interface") == "POST /api/v1/open/nodes/JOB-9/a2/decide" and no_serial_card.get("interfaceCurrent") == "POST /api/v1/open/nodes/JOB-9/decide", no_serial_card) check("没开的外部审批不出卡", node_approve.card(process2, stub_activity()) == {}) apis = card.get("apis") or [] check("卡片给的是全套对接接口,顺序就是动手顺序:令牌 → 定位 → 表态 → 收尾", [(item.get("method"), item.get("path")) for item in apis[:3]] == [("POST", "/api/v1/open/token"), ("POST", "/api/v1/open/nodes/locate"), ("POST", "/api/v1/open/nodes/BX-2026-0091/a2/decide")] and apis[2].get("alt") == "/api/v1/open/nodes/BX-2026-0091/decide", apis) check("表态那一条标了 task:write 与开放平台那一档的名字(对方照卡片勾权限)", len(apis) == len(node_approve.THIRD_PARTY_APIS) + 1 and apis[2].get("scope") == "task:write" and bool(apis[2].get("scopeLabel")), apis[2:3]) check("每一条接口都写清什么时候用,卡片不留空文案", all(str(item.get("when") or "").strip() for item in apis), apis) check("卡片带事件订阅清单(推这一路;不订阅就靠 locate 拉)", [item.get("event") for item in card.get("events") or []][:1] == ["task.arrived"], card.get("events")) check("设计期那张卡也带清单:decide 那一条留 {流程编号} 与环节 id 两个占位,alt 是省掉环节的写法", str(((design_card.get("apis") or [{}])[2]).get("path") or "") == "/api/v1/open/nodes/{流程编号}/a2/decide" and str(((design_card.get("apis") or [{}])[2]).get("alt") or "") == "/api/v1/open/nodes/{流程编号}/decide", design_card.get("apis")) # ------------------------------------------------------------- OA 按钮锁定(§9 第一组) lock_cfg = {"enabled": True, "confirm": "confirm", "decisions": {"APPROVED": "agree"}, "oaLock": {"enabled": True, "actions": ["handle", "goBack", "recall"]}} check("锁只认形状对的 oaLock(非 dict 当没配)", node_approve.lock_of({"oaLock": ["handle"]}) == {} and node_approve.lock_of(None) == {}) check("actions 空 = 默认那一组(表态那四颗),不是一颗都不锁", node_approve.locked_actions({"oaLock": {"enabled": True}}) == node_approve.LOCK_ACTIONS_DEFAULT and node_approve.locked_actions({"oaLock": {"enabled": True, "actions": []}}) == node_approve.LOCK_ACTIONS_DEFAULT) check("actions 里认不出的动作丢掉(勾错字不该把整段作废)", node_approve.locked_actions({"oaLock": {"actions": ["handle", "nope"]}}) == ("handle",)) check("没开外部审批的锁算没开(锁是给外部那半边配的)", node_approve.lock_enabled({"oaLock": {"enabled": True}}) is False) proc_lock = stub_process({"enabled": True, "oaLock": {"enabled": True, "allowConfirm": False}}) inherited = node_approve.effective_config(proc_lock, stub_activity({"openApprove": {"note": "ERP"}})) check("锁也从流程默认档继承(逐键合并走 effective_config 那一句)", node_approve.lock_enabled(inherited) is True and node_approve.allow_confirm(inherited) is False, inherited) check("环节显式关掉锁就真关掉,不被默认档翻回来", node_approve.lock_enabled(node_approve.effective_config( proc_lock, stub_activity({"openApprove": {"oaLock": {"enabled": False}}}))) is False) check("那句说明按 note → 应用名 → 外部系统 三级取词", node_approve.lock_where({"note": "ERP 合同系统", "apps": ["erp"]}) == "ERP 合同系统" and node_approve.lock_where({"apps": ["erp"]}, names={"erp": "ERP 合同系统"}) == "ERP 合同系统" and node_approve.lock_where({"apps": ["erp"]}) == "外部系统") check("text 自己写就用自己写的,不再自动拼", node_approve.lock_text({"oaLock": {"enabled": True, "text": "去 ERP 点"}}) == "去 ERP 点") # 通道判定表:同一份锁配置 × 四种 via,只有 OA 界面那条该被挡 via_cases = {"oa": False, "oa_confirm": True, "open": True, "embed": True} got = {via: node_approve.lock_block(lock_cfg, action="handle", via=via, activity_name="财务复核") == "" for via in via_cases} check("同一份锁配置:OA 挡住,替第三方点头那条与外部两条通道放行", got == via_cases, got) check("挡回来那句点名去哪儿办,并给出路(流程监控干预)", "ERP 合同系统" in node_approve.lock_block( dict(lock_cfg, note="ERP 合同系统"), action="handle", via="oa", activity_name="财务复核"), node_approve.lock_block(dict(lock_cfg, note="ERP"), action="handle", via="oa")) check("没锁的动作放行:只锁表态那几颗时转办照点得动", node_approve.lock_block(lock_cfg, action="transfer", via="oa") == "") check("开始环节那句说的是「提交」那颗钮", "提交" in node_approve.lock_block( {"enabled": True, "note": "ERP", "oaLock": {"enabled": True, "actions": ["start"]}}, action="start", via="oa")) # 开始环节只有一颗「提交」:handle 与 start 在这一环是同一颗,勾一颗算锁两颗; # 发起那一刻(单子还没建出来)与"单已停在开始环节"要分两句说。 begin_handle = {"enabled": True, "note": "ERP", "oaLock": {"enabled": True, "actions": ["handle"]}} begin_recall = {"enabled": True, "note": "ERP", "oaLock": {"enabled": True, "actions": ["recall"]}} begin_start = {"enabled": True, "note": "ERP", "oaLock": {"enabled": True, "actions": ["start"]}} check("开始环节上只勾 handle 也算锁住那颗提交,换到人工环节就不成立", node_approve.locks_action(begin_handle, "start", activity_type="begin") is True and node_approve.locks_action(begin_handle, "handle", activity_type="begin") is True and node_approve.locks_action(begin_handle, "start", activity_type="manual") is False and node_approve.locks_action(begin_recall, "start", activity_type="begin") is False) check("简报在开始环节把两颗一起报出去,在人工环节照原样报(界面只摆不推)", node_approve.lock_view(begin_handle, activity_type="begin")["actions"] == ["handle", "start"] and node_approve.lock_view(begin_handle)["actions"] == ["handle"]) started_text = node_approve.lock_block(begin_start, action="start", via="oa", activity_name="发起申请", starting=True) parked_text = node_approve.lock_block(begin_start, action="start", via="oa", activity_name="发起申请") check("发起那一刻那句说「OA 里发起不了」,不拿「这张单还停在开始环节」糊弄人", "发起不了" in started_text and "还停在开始环节" not in started_text and "还停在开始环节" in parked_text and "发起不了" not in parked_text, f"{started_text} / {parked_text}") no_nod = dict(lock_cfg, oaLock={"enabled": True, "actions": ["handle"], "allowConfirm": False}) closed = node_approve.lock_block(no_nod, action="handle", via="oa_confirm", activity_name="财务复核") check("关掉「外部表态仍可在 OA 确认」时确认那条路也挡,句子点名是配置关的", "外部表态仍可在 OA 确认" in closed, closed) dead = dict(lock_cfg, oaLock={"enabled": True, "actions": ["handle"], "allowConfirm": False}) check("锁掉 handle + 确认模式 + 关掉点头 = 点名那条死锁", len(node_approve.lock_problems(dead)) == 1 and "没人能点头" in node_approve.lock_problems(dead)[0], node_approve.lock_problems(dead)) check("同样配法改成自动办理就不是死锁", node_approve.lock_problems(dict(dead, confirm="auto")) == []) check("锁掉 handle 却一个决策词都没配 = 这一环没有表态通路", any("没有任何表态通路" in item for item in node_approve.lock_problems( {"enabled": True, "oaLock": {"enabled": True, "actions": ["handle"]}}))) check("开始环节认 start 那一颗:只锁 handle 不该报开始环节的死锁", node_approve.lock_problems({"enabled": True, "decisions": {"SUBMITTED": "submit"}, "oaLock": {"enabled": True, "actions": ["handle"]}}, activity=SimpleNamespace(type="begin")) == []) check("没开外部审批却开锁:problems 点名,且一条 SQL 都不发", node_approve.problems(StubDb(), stub_process(None), stub_activity({"openApprove": {"oaLock": {"enabled": True}}})) == ["环节「财务复核」没开外部审批却打开了 OA 按钮锁定:锁上之后这一环没人办得动"] and StubDb().sql == []) from app.engine import engine as engine_module check("引擎那四个 VIA_* 与这里的判据同名(漏传 via 落在锁住那一边)", (engine_module.VIA_OA, engine_module.VIA_OA_CONFIRM, engine_module.VIA_OPEN, engine_module.VIA_EMBED) == (node_approve.VIA_OA, node_approve.VIA_OA_CONFIRM, node_approve.VIA_OPEN, node_approve.VIA_EMBED) and node_approve.OA_VIAS == (engine_module.VIA_OA, engine_module.VIA_OA_CONFIRM)) locked_card = node_approve.card( stub_process(None), SimpleNamespace(process="p1", id="a2", name="财务复核", type="approval", form="", config={"openApprove": dict(lock_cfg, note="ERP 合同系统")}), work=work) check("接口卡片带 oaLocked(对方据此知道 OA 里不会有人点,必须回调)", locked_card.get("oaLocked") is True and (locked_card.get("oaLock") or {}).get("where") == "ERP 合同系统" and (locked_card.get("oaLock") or {}).get("actions") == ["handle", "goBack", "recall"], locked_card.get("oaLock")) check("没开锁时卡片那格是假的,actions 空", node_approve.card(stub_process(None), activity2, work=work).get("oaLocked") is False) # ---------------------------------------------------------------- 定位那份瘦身响应 full_payload = { "found": True, "work": {"job": "J-1", "id": "W-1", "serial": "BX-2026-0091", "title": "一张单", "status": "running", "process": "p1", "processName": "费用报销"}, "process": {"id": "p1", "name": "费用报销"}, "activity": {"id": "a2", "name": "财务复核"}, "pending": True, "task": {"id": "t1", "identity": "zhangsan"}, "openApprove": {"interface": "POST /api/v1/open/nodes/BX-2026-0091/a2/decide"}, } brief = node_approve.brief_view(full_payload) check("定位默认那份只留号与能不能表态:卡片、待办、标题都不带", brief == {"found": True, "work": {"job": "J-1", "serial": "BX-2026-0091", "status": "running"}, "process": {"id": "p1", "name": "费用报销"}, "activity": {"id": "a2", "name": "财务复核"}, "pending": True}, brief) check("归档那条只有 note:瘦身那份也把它留着(对方的机器人靠这句话停手)", node_approve.brief_view({"found": True, "work": {"job": "J", "serial": ""}, "pending": False, "note": "这张单已办结并归档"}).get("note", "") .startswith("这张单已办结"), node_approve.brief_view({"found": True})) # ---------------------------------------------------------------- 幂等重放 staged = SimpleNamespace(id="d1", status="staged", route="退回修改", activity_name="财务复核", create_time=now, expires_at=None, app="erp", app_name="ERP", decision="REJECTED", kind="refuse", opinion="", data={}, biz_key="B1", confirm_name="") check("停在等确认的再调 = 回「已经停在那」", node_approve.replay(staged).get("alreadyStaged") is True) handled = SimpleNamespace(id="d2", status="handled", response={"handled": True, "route": "通过"}, route="", activity_name="财务复核", create_time=now, expires_at=None) payload = node_approve.replay(handled) check("办掉的再调 = 原样回第一份响应 + alreadyHandled", payload.get("alreadyHandled") is True and payload.get("route") == "通过", payload) rejected = SimpleNamespace(id="d3", status="rejected", response={}, route="", activity_name="财务复核", create_time=now, expires_at=None, confirm_name="张三") try: node_approve.replay(rejected) check("被驳回的再调 = 回一句人话(不静默重办)", False) except Exception as exc: check("被驳回的再调 = 回一句人话(不静默重办)", getattr(exc, "reason", "") == "NODE_DECISION_CLOSED", str(exc)[:120]) # ---------------------------------------------------------------- 任务信息(事件信封那一块) task = SimpleNamespace(id="t1", identity="zhangsan", identity_name="张三", expire_time=now, route_name_list=["通过", "退回修改"]) info = node_approve.task_info(task) row_view = node_approve.view(SimpleNamespace( id="d0", app="erp", app_name="ERP", decision="APPROVED", kind="agree", route="通过", opinion="", data={}, biz_key="B0", status="staged", create_time=now, expires_at=None)) check("表态记录里原话那一格与请求同名(result),生命周期那格叫 state 不叫 status", row_view.get("result") == "APPROVED" and row_view.get("state") == "staged" and "status" not in row_view and "decision" not in row_view, row_view) check("待办信息带号、处理人、期限与出口", info == { "id": "t1", "identity": "zhangsan", "identityName": "张三", "dueAt": "2026-10-23 14:00:00", "routes": ["通过", "退回修改"]}, info) # ---------------------------------------------------------------- 拉取式定位(纯函数那一段) check("查找字段读取并归一化空格", node_approve.lookup_fields({"lookup": [" erpNo ", "", "contractNo"]}) == ["erpNo", "contractNo"]) check("没配查找键就是空表(serial / job 仍恒可用,不在这张表里)", node_approve.lookup_fields({}) == []) check("查找键配成非列表按空处理", node_approve.lookup_fields({"lookup": "erpNo"}) == []) w1 = SimpleNamespace(data={"erpNo": "ERP-2026-0091-A", "amount": 1200}) w2 = SimpleNamespace(data={"erpNo": "ERP-2026-0091-B", "amount": 300}) w3 = SimpleNamespace(data={}) check("查找键的值按字符串比对、多键全中才算中", node_approve._data_matches(w1, {"erpNo": "ERP-2026-0091-A"}) is True and node_approve._data_matches(w1, {"erpNo": "ERP-2026-0091-A", "amount": "1200"}) is True and node_approve._data_matches(w1, {"erpNo": "ERP-2026-0091-B"}) is False and node_approve._data_matches(w1, {"nope": "x"}) is False) check("数字值与字符串值按同一把尺比(1200 对 '1200')", node_approve._data_matches(w1, {"amount": 1200}) is True) check("没这格的单据对不上", node_approve._data_matches(w3, {"erpNo": "ERP-2026-0091-A"}) is False) # -------------------------------------------------------- 前后端两处清单:漂了就红 # 事件与定位递出的卡片由 THIRD_PARTY_APIS 生成,设计器里那一份由前端 constants 翻译 # 文案。地址与顺序必须同一套,否则对方手里两份卡片各说一套话。 front = (ROOT / "frontend/src/constants/openApproveApis.ts").read_text(encoding="utf-8") ts_paths = [item for item in re.findall(r"path: '([^']*)'", front) if item] check("前端清单的地址与顺序照抄后端(decide 那条按环节现填,不参与比对)", ts_paths == [item["path"] for item in node_approve.THIRD_PARTY_APIS], ts_paths) check("前端清单也带那几条事件订阅", all(f"'{key}'" in front for key, _ in node_approve.CARD_EVENTS), front[:200]) zh = (ROOT / "frontend/src/i18n/locales/zh.ts").read_text(encoding="utf-8") en = (ROOT / "frontend/src/i18n/locales/en.ts").read_text(encoding="utf-8") keys = re.findall(r"whenKey: 'openApprove\.(\w+)'", front) + [ "cardApisTitle", "cardApiNoScope", "cardEventsTitle", # 开始环节那几档是面板按 beginOnly 现挑的 key,不在这份 constants 清单里,得单独点名 "apiWorksBegin", "decisionsBeginHint", "autoStart", "autoStartHint", "cardAutoStart", "cardAutoStartOn", "cardAutoStartOff"] missing = [key for key in keys if f" {key}:" not in zh or f" {key}:" not in en] check("每一条接口的说明中英文都有,卡片不会把 i18n key 名露给对方", bool(keys) and not missing, missing) print() if FAILS: print(f"{len(FAILS)} 条没对上:") for item in FAILS: print(f" - {item}") return 1 print(f"全部 {PASSED} 条对上。") return 0 if __name__ == "__main__": sys.exit(main())