unis-oa/backend/scripts/check_node_approve.py

465 lines
32 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.

#!/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())