465 lines
32 KiB
Python
465 lines
32 KiB
Python
#!/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())
|