#!/usr/bin/env python3 """表单嵌外部页面(``type=embed``)的**接口侧**验收:连真库、连一个真在跑的 API 进程。 python3 scripts/check_embed_api.py --base http://127.0.0.1:8000/api/v1 纯函数那一口的口径在 ``scripts/check_embed.py``(不连库)。这一份只钉那些"非得起服务、 非得过一遍路由与序列化才看得见"的事,而这几件恰好都是出了问题最容易只在集成层露出来的: 1. **短码用第二次必须失败**,而密钥不对时**不该**把它烧掉——对方系统重试一次很正常, 一重试就作废等于把人家的对接坑出来; 2. **参数白名单在接口上同样成立**:地址模板没写过的名字,前端配了、值也交上来了, 回来的 ``params`` 与拼好的地址里都不许有它(这是"别把整张单灌进查询串"那道闸的落点); 3. ``refresh=true`` **只回参数**:不发地址、不发短码、也不留痕——参数每动一下就记一条 "他打开了那个页面",台账就废了; 4. 探测(``POST /design/data-sources/test``)真去访问一次,按响应头下结论,并把结论写回注册表; 5. 注册表新增一条启用中的来源之后,本系统自己的 CSP ``frame-src`` 当场放行它, 而 ``frame-ancestors 'none'`` 与 ``blob:`` 一条都不能少(后者是附件 PDF 预览); 6. ``url_mode=api`` 那一档发出去的是**刚问接口要的那条链接**,而链接挂在一个没登记过的 域名上时,那条地址压根不出后端。 口令不从外面要:脚本用本部署的 ``app.security.create_access_token`` 现签一个会话, 因此**默认只对本机地址跑**(要指向别处得显式加 ``--allow-remote``)。它只建自己那几条 带时间戳编码的数据源,跑完连同自己发过的短码与留痕一起删掉。 """ from __future__ import annotations import argparse import json import pathlib import sys import threading import time import urllib.error import urllib.parse import urllib.request from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent)) #: 与对方约定的那把应用密钥,只在这一个脚本里出现(它本身就是"对方") SHARED_KEY = "check-embed-shared-key" #: 这一趟造的测试数据:一个基名 + 三条源的后缀 CREATED: list[str] = [] FAILS: list[str] = [] NOTES: list[str] = [] def ok(name: str, condition, detail=None) -> None: if not condition: FAILS.append(f"{name}:{detail if detail is not None else '条件不成立'}") def eq(name: str, got, want) -> None: if got != want: FAILS.append(f"{name}:期望 {want!r},实得 {got!r}") def note(text: str) -> None: NOTES.append(text) def _json(text: str) -> dict: try: value = json.loads(text or "") except ValueError: return {} return value if isinstance(value, dict) else {} def _msg(payload: dict) -> str: return str((payload or {}).get("message") or "")[:200] def header_value(headers: dict, wanted: str) -> str: for key, value in (headers or {}).items(): if str(key).lower() == wanted: return str(value) return "" # --------------------------------------------------------------------------- # 被嵌的那一侧:本机起一个最小页面,靠响应头摆出「让嵌 / 不让嵌」两种样本 # --------------------------------------------------------------------------- class Page(BaseHTTPRequestHandler): """三个路径三种响应头,正好对上 ``embed.frame_verdict`` 的几档判法。 ``/link`` 与 ``/link-elsewhere`` 是"取链接的那个接口"(``url_mode=api``)的替身: 回一段 JSON,把请求体里那个 ``no`` 原样嵌进返回的链接里——于是"发出去的那条链接 带的到底是哪一组值"在这头一眼看得出来,不用猜。前者的链接挂在本机(登记过的来源), 后者挂在 ``https://elsewhere.invalid``(没登记过),正好摆出来源白名单放行与挡住那两种结论。 """ def _link_payload(self) -> bytes: import json as _json # 顶部那份是本脚本自己的,这里要的只是同名的 dumps port = self.server.server_address[1] wanted = "" length = int(self.headers.get("Content-Length") or 0) if length: try: wanted = str(_json.loads(self.rfile.read(length).decode("utf-8", "replace")).get("no") or "") except (ValueError, AttributeError): wanted = "" # 那一台用 https:http 会被 url_problem 先挡下来(那不是"来源没登记"那句话), # 而这一条要验的恰好是来源那道闸 target = ("https://elsewhere.invalid/view" if str(self.path).startswith("/link-elsewhere") else f"http://127.0.0.1:{port}/allow") # 每被打一次就涨一号,并记在 server 上:这个接口是"每调一次建一张页"的那一类, # 页号变了就是对面真的多了一张页——"第二次打开不许再新建"只有靠这个数才验得出来 self.server.link_calls = int(getattr(self.server, "link_calls", 0) or 0) + 1 seq = int(self.server.link_calls) if str(self.path or "").startswith("/link-two"): # 同一次回三条:编辑页、查看页、打印页,指的是同一张新建出来的页(同一个 page= 号), # 外加两个不是地址的附带值——生产上那个建页接口回的就是这一种形状 return _json.dumps({"code": 0, "data": { "url": f"{target}/edit?no={wanted}&page={seq}", "viewUrl": f"{target}/view?no={wanted}&page={seq}", "printUrl": f"{target}/print?no={wanted}&page={seq}", "flow_number": f"RE-STUB-{seq}", "is_review_allowed": True}}).encode("utf-8") return _json.dumps({"code": 0, "data": {"url": f"{target}?no={wanted}"}}).encode("utf-8") def do_POST(self) -> None: # noqa: N802 - 取链接那一档默认就是 POST,桩不分方法 self.do_GET() def do_DELETE(self) -> None: # noqa: N802 - 「这一页被放弃时通知对方」默认就是 DELETE length = int(self.headers.get("Content-Length") or 0) raw = self.rfile.read(length).decode("utf-8", "replace") if length else "" try: body = json.loads(raw) if raw else {} except ValueError: body = {"__raw__": raw} self.server.last_deletion = {"path": str(self.path or ""), "body": body} payload = json.dumps({"code": 0}).encode("utf-8") self.send_response(200) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(payload))) self.end_headers() self.wfile.write(payload) def do_GET(self) -> None: # noqa: N802 - 名字是 BaseHTTPRequestHandler 定的 path = str(self.path or "") if path.startswith("/link"): body = self._link_payload() self.send_response(200) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) return body = b"embed target" self.send_response(200) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(body))) if path.startswith("/deny"): self.send_header("X-Frame-Options", "DENY") elif path.startswith("/same"): self.send_header("X-Frame-Options", "SAMEORIGIN") elif path.startswith("/odd"): # 一个浏览器早就不认的老写法:探的人既不能说让嵌也不能说不让嵌 self.send_header("X-Frame-Options", "ALLOW-FROM https://other.example.com") self.end_headers() self.wfile.write(body) def log_message(self, *args) -> None: return # 静音:验收输出里不该夹访问日志 def serve_page() -> ThreadingHTTPServer: server = ThreadingHTTPServer(("127.0.0.1", 0), Page) threading.Thread(target=server.serve_forever, daemon=True).start() return server # --------------------------------------------------------------------------- # 会话:用本部署的签名钥匙现签一个,不去猜任何人的口令 # --------------------------------------------------------------------------- def mint_token() -> tuple[str, str]: """挑一个同时有 ``design:datasource`` 与 ``design:form`` 的人,给他签个令牌。 签的是这个部署自己的 ``jwt_secret``(读同一份配置文件),服务端认它就是认这个人; 权限照旧每次现查库,脚本不伪造任何一条授权。回 ``(令牌, 这个人的 id)``。 """ from sqlalchemy import select from sqlalchemy.orm import joinedload from app import models from app.db import SessionLocal from app.deps import CurrentUser from app.security import create_access_token from app.service import personref db = SessionLocal() try: # 先扫管理员:CurrentUser.resolve 每人要查一轮权限,一个个人试过去太慢 rows = db.execute( select(models.User) .where(models.User.status.in_(sorted(models.UserStatus.LOGIN_ALLOWED))) .order_by(models.User.role, models.User.id) .limit(200) .options(joinedload(models.User.unit)) ).unique().scalars().all() for person in rows: user = CurrentUser.resolve(db, person, personref.ref_of(person)) if user.can("design:datasource") and user.can("design:form"): token, _ttl = create_access_token(str(person.id)) return str(token), str(person.id) finally: db.close() return "", "" def mint_ordinary_token() -> tuple[str, str]: """再签一个**不是管理员**的人的令牌,用来验"这个人与这张单没关系"那道闸。 管理员在这条路上永远算"有关系"(``api/embeds.py:_scope_of`` 里 ``related`` 直接为真), 拿管理员去试越权,试出来的一定是绿的。 """ from sqlalchemy import select from sqlalchemy.orm import joinedload from app import models from app.db import SessionLocal from app.deps import CurrentUser from app.security import create_access_token from app.service import personref db = SessionLocal() try: rows = db.execute( select(models.User) .where(models.User.status.in_(sorted(models.UserStatus.LOGIN_ALLOWED))) .order_by(models.User.id) .limit(300) .options(joinedload(models.User.unit)) ).unique().scalars().all() for person in rows: user = CurrentUser.resolve(db, person, personref.ref_of(person)) if user.is_admin: continue token, _ttl = create_access_token(str(person.id)) return str(token), str(person.id) finally: db.close() return "", "" def identity_ref_of(person_id: str) -> str: """这个人的**身份串**:待阅认的是身份,不是人员 id(``oa_read.identity``)。""" from sqlalchemy import select from app import models from app.db import SessionLocal from app.service import personref db = SessionLocal() try: person = db.get(models.User, person_id) return str(personref.ref_of(person)) if person is not None else "" finally: db.close() def unrelated_job(person_id: str, identity: str = "") -> str: """找一张**这个人与之无关**的在办单据(只读查询,不造数据)。 判据照 ``_scope_of`` 抄:不是他发起的、他名下没有这条单的待办、也没办过、 也没有属于他的待阅 / 已阅(给了 ``identity`` 才查后两条——待阅认的是身份)。 库里一张都没有就回空串,那一条断言自己跳过并说明原因。 """ from sqlalchemy import func, select from app import models from app.db import SessionLocal db = SessionLocal() try: rows = db.execute( select(models.Work.job, models.Work.creator) .where(models.Work.creator != person_id) .order_by(models.Work.id.desc()) .limit(300) ).all() for job, _creator in rows: open_tasks = db.execute( select(func.count()).select_from(models.Task) .where(models.Task.job == job, models.Task.person == person_id) ).scalar() or 0 done = db.execute( select(func.count()).select_from(models.TaskCompleted) .where(models.TaskCompleted.job == job, models.TaskCompleted.person == person_id) ).scalar() or 0 unread = read_done = 0 if identity: unread = db.execute( select(func.count()).select_from(models.Read) .where(models.Read.job == job, models.Read.identity == identity) ).scalar() or 0 read_done = db.execute( select(func.count()).select_from(models.ReadCompleted) .where(models.ReadCompleted.job == job, models.ReadCompleted.identity == identity) ).scalar() or 0 if not (open_tasks or done or unread or read_done): return str(job) finally: db.close() return "" def blocked_count(codes: list[str]) -> int: """这几条源名下"挡住了但也留了一笔"那类留痕的条数。""" from sqlalchemy import func, select from app import models from app.db import SessionLocal if not codes: return 0 db = SessionLocal() try: return int(db.execute( select(func.count()).select_from(models.DataSourceLog) .where(models.DataSourceLog.source.in_(codes), models.DataSourceLog.status == models.DataSourceLog.STATUS_BLOCKED) ).scalar() or 0) finally: db.close() def count_rows(codes: list[str]) -> tuple[int, int]: """这批编码名下的短码条数与留痕条数:``refresh`` 那条断言拿它做前后对比。""" from sqlalchemy import func, select from app import models from app.db import SessionLocal if not codes: return 0, 0 db = SessionLocal() try: tickets = db.execute( select(func.count()).select_from(models.EmbedTicket).where(models.EmbedTicket.source.in_(codes)) ).scalar() or 0 logs = db.execute( select(func.count()).select_from(models.DataSourceLog).where(models.DataSourceLog.source.in_(codes)) ).scalar() or 0 return int(tickets), int(logs) finally: db.close() def sweep(codes: list[str]) -> None: """把这一趟造出来的短码、嵌入会话与留痕清掉:它们只属于这几个临时编码。 嵌入会话那一条必须一起删。它是这段验收里唯一会被**反复复用**的表(同一个人同一格 两次打开要认成同一趟),留着上一趟那几条没清干净的,下一趟就会认到旧预受理号上—— "两次打开是不是同一趟"这一条断言就此变成永远为真的空话。 """ from sqlalchemy import delete from app import models from app.db import SessionLocal if not codes: return db = SessionLocal() try: db.execute(delete(models.EmbedTicket).where(models.EmbedTicket.source.in_(codes))) db.execute(delete(models.EmbedSession).where(models.EmbedSession.source.in_(codes))) db.execute(delete(models.DataSourceLog).where(models.DataSourceLog.source.in_(codes))) db.commit() finally: db.close() # --------------------------------------------------------------------------- # 最小的 HTTP 客户端(不引第三方:验收脚本要能在任何一台开发机上直接跑) # --------------------------------------------------------------------------- class Api: def __init__(self, base: str, token: str = "") -> None: self.base = str(base or "").rstrip("/") self.token = token # 一定直连,不走系统代理:开发机上挂着 Clash 这类代理时,urllib 会把 # 127.0.0.1 也交出去,换来一串莫名其妙的 502——验收脚本不该被这个带偏 self.opener = urllib.request.build_opener(urllib.request.ProxyHandler({})) def call(self, method: str, path: str, body=None, headers: dict | None = None): data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None req = urllib.request.Request(self.base + path, data=data, method=method) req.add_header("Content-Type", "application/json") if self.token: req.add_header("Authorization", f"Bearer {self.token}") for key, value in (headers or {}).items(): req.add_header(key, str(value)) try: with self.opener.open(req, timeout=30) as resp: return resp.status, _json(resp.read().decode("utf-8", "replace")), dict(resp.headers) except urllib.error.HTTPError as exc: return exc.code, _json(exc.read().decode("utf-8", "replace")), dict(exc.headers or {}) def run(self, method: str, path: str, body=None, headers: dict | None = None, *, expect: int = 200): """跑一次并拆成 ``(data, headers)``;状态码不对当场记一条,值仍还给调用方凑合用。""" status, payload, headers_out = self.call(method, path, body, headers) if status != expect: FAILS.append(f"{method} {path} 期望 HTTP {expect},实得 {status}:{_msg(payload)}") return payload.get("data"), headers_out def get_data(self, path: str, *, expect: int = 200): return self.run("GET", path, expect=expect)[0] def post_data(self, path: str, body=None, headers: dict | None = None, *, expect: int = 200): return self.run("POST", path, body, headers, expect=expect)[0] # --------------------------------------------------------------------------- # 各段断言 # --------------------------------------------------------------------------- def check_ping(api: Api) -> None: data = api.get_data("/ping") ok("服务可达且连得上库", bool(data) and bool((data or {}).get("database")), data) def create(api: Api, suffix: str, url: str, *, page_mode: str = "none", key: str = "") -> dict: """建一条这一趟专用的 embed 源并记住编码。""" code = f"{CREATED[0]}_{suffix}" CREATED.append(code) body = {"code": code, "name": f"接口验收·{suffix}", "system": "验收", "kind": "fetch", "provider": "embed", "url": url, "pageMode": page_mode} if key: body["authSecret"] = key return api.post_data("/design/data-sources", body) or {} def check_register(api: Api, port: int) -> dict: """注册表这一格的闸:存之前先挡,别等有人点开表单才发现配歪了。""" allow = create(api, "allow", f"http://127.0.0.1:{port}/allow") eq("provider 存成了 embed", allow.get("provider"), "embed") eq("免登方式回显", allow.get("pageMode"), "none") eq("参数清单来自地址模板(这条一个都没有)", allow.get("embedArgs"), []) ok("密钥没设就只说没设", allow.get("secretSet") is False, allow.get("secretSet")) create(api, "deny", f"http://127.0.0.1:{port}/deny") create(api, "odd", f"http://127.0.0.1:{port}/odd") status, payload, _ = api.call("POST", "/design/data-sources", { "code": f"{CREATED[0]}_nokey", "name": "接口验收·短码没密钥", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "ticket", }) ok("短码免登缺密钥时不许存", status == 400 and "密钥" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", { "code": f"{CREATED[0]}_hub", "name": "接口验收·走门户", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "hub", }) ok("还没开放的那档免登方式当场挡住", status == 400 and "还没开放" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", { "code": f"{CREATED[0]}_plain", "name": "接口验收·明文地址", "kind": "fetch", "provider": "embed", "url": "http://erp.example.com/contract", "pageMode": "none", }) ok("非本机的 http 地址挡住", status == 400 and "https" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", { "code": f"{CREATED[0]}_space", "name": "接口验收·地址带空格", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/a b", "pageMode": "none", }) ok("地址里有空格挡住", status == 400 and "空格" in _msg(payload), f"{status} {_msg(payload)}") ticket = create(api, "ticket", f"http://127.0.0.1:{port}/contract?no={{arg.contractNo}}" f"&who={{arg.name}}&batch={{arg.batch}}", page_mode="ticket", key=SHARED_KEY) eq("这条的参数清单按模板给出", ticket.get("embedArgs"), ["batch", "contractNo", "name"]) ok("设过密钥之后只说设过,不回明文", ticket.get("secretSet") is True and "authSecret" not in ticket, list(ticket)[:12]) # 「这一页被放弃时通知对方」那条地址:注册表这一格也得有闸,而且要回显得出来 status, payload, _ = api.call("POST", "/design/data-sources", { "code": f"{CREATED[0]}_odd_abandon", "name": "接口验收·通知地址写歪", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "none", "abandonUrl": "oa/delete-draft", }) ok("通知地址既不是完整地址也不是路径时不许存", status == 400 and "要么写完整" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", { "code": f"{CREATED[0]}_get_abandon", "name": "接口验收·通知方法用 GET", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "none", "abandonUrl": "/oa/delete-draft", "abandonMethod": "GET", }) ok("会改对方数据的那一句不给用 GET", status == 400 and "GET" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", { "code": f"{CREATED[0]}_plan", "name": "接口验收·配了通知地址", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "none", "abandonUrl": "/oa/delete-draft", "abandonExpr": "{form.流程编号}", "abandonBody": {"oa_flow_number": "{form.流程编号}", "project_number": "{form.项目号}"}, }) saved = (payload or {}).get("data") or {} eq("那条通知地址存得下也回显得出来", saved.get("abandonUrl"), "/oa/delete-draft") eq("方法留空时不回填,由后端按 DELETE 走", saved.get("abandonMethod"), "") eq("值那格配的取值写法也存得下也回显得出来", saved.get("abandonExpr"), "{form.流程编号}") eq("多键请求体存得下也整份回显得出来", saved.get("abandonBody"), {"oa_flow_number": "{form.流程编号}", "project_number": "{form.项目号}"}) brief = api.get_data("/embed/sources") or [] mine = next((item for item in brief if item.get("code") == f"{CREATED[0]}_plan"), {}) eq("属性面板看得知这一档配没配", mine.get("abandonSet"), True) eq("属性面板也看得知那个值取哪儿", mine.get("abandonExpr"), "{form.流程编号}") eq("属性面板也看得知那份多键请求体", mine.get("abandonBody"), {"oa_flow_number": "{form.流程编号}", "project_number": "{form.项目号}"}) ok("而那条地址本身不进浏览器", "abandonUrl" not in mine, {key: value for key, value in mine.items() if "abandon" in str(key).lower()}) # 更常走的那条路:挑一条现成的写回通道("按 OA 单号删草稿"这类接口常常本来就登记过)。 # 这一档真正要挡的是"挑了一条收不到这一句的记录"——那种配置发不出去还看着像配好了。 channel = f"{CREATED[0]}_abandonchan" CREATED.append(channel) status, payload, _ = api.call("POST", "/design/data-sources", { "code": channel, "name": "接口验收·按单号删草稿", "kind": "fetch", "provider": "http", "direction": "out", "method": "DELETE", "url": f"http://127.0.0.1:{port}/oa/delete-draft", "successPath": "code", "successValue": "0", }) ok("先备好那条写回通道", status < 400, f"{status} {_msg(payload)}") channel_row = (payload or {}).get("data") or {} bad = f"{CREATED[0]}_bad_via" CREATED.append(bad) for target, word in ((f"{CREATED[0]}_allow", "写回"), (f"{CREATED[0]}_nope", "不存在")): status, payload, _ = api.call("POST", "/design/data-sources", { "code": bad, "name": "接口验收·通知挑错了记录", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "none", "abandonSource": target, }) ok(f"挑到收不到这一句的记录时不许存({word})", status == 400 and word in _msg(payload), f"{status} {_msg(payload)}") self_code = f"{CREATED[0]}_self_via" CREATED.append(self_code) status, payload, _ = api.call("POST", "/design/data-sources", { "code": self_code, "name": "接口验收·把自己当出口", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "none", "abandonSource": self_code, }) ok("不能把这条「可嵌入页面」自己当通知出口", status == 400 and "自己" in _msg(payload), f"{status} {_msg(payload)}") via_code = f"{CREATED[0]}_via" CREATED.append(via_code) status, payload, _ = api.call("POST", "/design/data-sources", { "code": via_code, "name": "接口验收·通知走通道", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "none", "abandonSource": channel, }) via = (payload or {}).get("data") or {} eq("挑的那条通道存得下也回显得出来", via.get("abandonSource"), channel) eq("走通道就不用再抄一遍地址", via.get("abandonUrl"), "") brief = api.get_data("/embed/sources") or [] picked = next((item for item in brief if item.get("code") == via_code), {}) eq("只挑了通道也算配好了(面板会说会发那一句)", picked.get("abandonSet"), True) # 这层引用既不在表单上也不在写回模板里:接口要认得它,删除才挡得住(删掉了就是悄悄不发) usage = api.get_data(f"/design/data-sources/usage/{channel}") or {} ok("这条通道被哪条嵌入页面当成放弃通知出口,接口认得", any(str(item.get("code")) == via_code for item in usage.get("abandonBy") or []), usage) status, payload, _ = api.call("DELETE", f"/design/data-sources/{channel_row.get('id')}") ok("正被放弃通知用的那条通道删不掉,且说清是谁在用它", status == 400 and "放弃通知" in _msg(payload), f"{status} {_msg(payload)}") return {"allow": f"{CREATED[0]}_allow", "deny": f"{CREATED[0]}_deny", "odd": f"{CREATED[0]}_odd", "ticket": f"{CREATED[0]}_ticket"} def check_source_list(api: Api, codes: dict) -> None: """``GET /embed/sources`` 只给挑页面要的东西:地址与密钥一条都不许在里面。""" rows = api.get_data("/embed/sources") or [] by_code = {str(row.get("code")): row for row in rows} row = by_code.get(codes["ticket"]) or {} ok("清单里有这一趟建的那条短码源", bool(row), sorted(by_code)[:6]) eq("这一条要哪几个参数", row.get("args"), ["batch", "contractNo", "name"]) eq("既不回地址也不回密钥", [key for key in ("url", "authSecret", "secret", "headers", "appCode") if key in row], []) def check_probe(api: Api, codes: dict) -> None: """探测真去访问一次,按响应头下结论,结论还要写回注册表让人看见。""" # 「测试连通」这个弹窗只在 error / note 非空时才显示内容:结论落不进这两栏, # 探测就等于白做——清单那一行的角标与填单页要不要降级成卡片,都跟着这一句走 denied = api.post_data("/design/data-sources/test", {"code": codes["deny"], "ancestor": api.base}) or {} eq("对方写 X-Frame-Options: DENY 判成不让嵌", denied.get("verdict"), "denied") ok("不让嵌这句话给人看得懂", "拒绝" in str(denied.get("message") or ""), denied) ok("不让嵌这一条在弹窗里是红的(不能显示成「测试通过」)", denied.get("ok") is False and bool(denied.get("error")), denied) allowed = api.post_data("/design/data-sources/test", {"code": codes["allow"], "ancestor": api.base}) or {} eq("没有禁止头判成能嵌", allowed.get("verdict"), "ok") ok("能嵌这句话里带上「还要实际打开看一眼」——服务端探不出 JS 跳转", "实际打开" in str(allowed.get("message") or ""), allowed) eq("能嵌时 error / note 都空着", (allowed.get("error"), allowed.get("note")), ("", "")) odd = api.post_data("/design/data-sources/test", {"code": codes["odd"], "ancestor": api.base}) or {} eq("看不懂的写法不猜,判成说不准", odd.get("verdict"), "unknown") ok("说不准不算探测失败", odd.get("ok") is True, odd) ok("但那句话要落在 note 里,否则弹窗只会显示「测试通过」", bool(odd.get("note")), odd) saved = {str(row.get("code")): row for row in (api.get_data("/design/data-sources") or [])} eq("探测结论写回注册表(不让嵌那条)", (saved.get(codes["deny"]) or {}).get("lastTestStatus"), "denied") eq("探测结论写回注册表(能嵌那条)", (saved.get(codes["allow"]) or {}).get("lastTestStatus"), "ok") eq("探测结论写回注册表(说不准那条)", (saved.get(codes["odd"]) or {}).get("lastTestStatus"), "unknown") #: 字段上那一格要带哪些值:``salary`` 故意不在地址模板里 FIELD_CFG = {"height": 480, "params": { "contractNo": "{form.contractNo}", "name": "{form.name}", "salary": "{form.salary}", }} def check_launch(api: Api, codes: dict) -> dict: """发起页要地址:只认地址模板声明过的那几个参数,值一律编码,短码挂在 ``#`` 之后。""" data = api.post_data("/embed/launch", { "code": codes["ticket"], "field": "embed_view", "embed": FIELD_CFG, "params": {"contractNo": "HT-9&x=1", "name": "张三", "salary": "88888"}, }) or {} url = str(data.get("url") or "") parts = urllib.parse.urlsplit(url) query = urllib.parse.parse_qs(parts.query) eq("模板没写过的参数拼不进地址,也不回给界面", sorted(data.get("params") or {}), ["contractNo", "name"]) ok("那个没声明的参数连值都没回来", "88888" not in json.dumps(data, ensure_ascii=False), data) eq("地址里换进去的就是这两个值", (query.get("no"), query.get("who")), (["HT-9&x=1"], ["张三"])) ok("值里的 & 是编码过的,拼不出第二个查询项", parts.query.count("&") == 2 and "no=HT-9%26x%3D1" in parts.query, parts.query) eq("地址要、这一单没给的参数报出来", data.get("missing"), ["batch"]) eq("origin 就是那个页面的来源", data.get("origin"), f"http://127.0.0.1:{parts.port}" if parts.port else "") ok("内嵌框高度按配置回", data.get("height") == 480, data.get("height")) ok("免登短码在片段里而不在查询串里", "ticket=" in parts.fragment and "ticket=" not in parts.query, url) eq("免登方式回 ticket", data.get("mode"), "ticket") ok("短码有效期是个正数", int(data.get("ttl") or 0) > 0, data.get("ttl")) return data def latest_session_args(code: str) -> dict: """这一条源名下最近那一趟身上留着的那些参数值(``trip_args`` 的那一份)。""" from sqlalchemy import select from app import models from app.db import SessionLocal from app.service import embed_session db = SessionLocal() try: row = db.execute( select(models.EmbedSession) .where(models.EmbedSession.source == code) .order_by(models.EmbedSession.create_time.desc(), models.EmbedSession.id.desc()) ).scalars().first() return embed_session.trip_args(row) finally: db.close() def session_form(prekey: str) -> dict: """那一趟(按预受理号点名)身上留着的那份整张单表单值(``trip_form`` 的那一份)。""" from sqlalchemy import select from app import models from app.db import SessionLocal from app.service import embed_session db = SessionLocal() try: row = db.execute(select(models.EmbedSession) .where(models.EmbedSession.prekey == prekey)).scalar_one_or_none() return embed_session.trip_form(row) finally: db.close() def check_refresh(api: Api, codes: dict) -> None: """``refresh`` 只把参数按现在这份值再算一遍:不发地址、不发短码、也不留痕。""" before = count_rows(CREATED) data = api.post_data("/embed/launch", { "code": codes["ticket"], "field": "embed_view", "refresh": True, "embed": FIELD_CFG, "params": {"contractNo": "HT-10", "name": "李四", "salary": "99999"}, }) or {} after = count_rows(CREATED) eq("刷新这一趟就只回参数这件事", data.get("refresh"), True) eq("参数按新值重算了", sorted((data.get("params") or {}).items()), [("contractNo", "HT-10"), ("name", "李四")]) ok("不发地址", not data.get("url"), data) ok("不发短码也不留痕:库里这两张表的条数一条都没涨", before == after, f"{before} -> {after}") # 值也得留在这趟上:``refresh`` 正是"人在这一页上刚改了那几格"那一路, # 第三方从他们那边裸一句回写代发时,垫进去的就是这一份 api.post_data("/embed/launch", { "code": codes["ticket"], "field": "embed_view", "embed": FIELD_CFG, "params": {"contractNo": "HT-第一次打开", "name": "张三"}, }) eq("打开那一次把参数值留在了这一趟上", latest_session_args(codes["ticket"]), {"contractNo": "HT-第一次打开", "name": "张三"}) api.post_data("/embed/launch", { "code": codes["ticket"], "field": "embed_view", "refresh": True, "embed": FIELD_CFG, "params": {"contractNo": "HT-他后来改的那一份", "name": "李四"}, }) eq("人在页上改过之后,留下的跟着换成最新那一份(不是第一次打开那个旧样子)", latest_session_args(codes["ticket"]), {"contractNo": "HT-他后来改的那一份", "name": "李四"}) #: 「第三方拿 OA 占下的那个号发起、却没把预受理号当 bizKey 交上来」那一条用的号与假单 BY_SERIAL = "FYBXSTATE0002" BY_SERIAL_JOB = "job-embed-state-bys" def check_state(api: Api, codes: dict) -> None: """``/embed/state``:那一框问「我这一趟发起出去了没有」,只答这一句。 第三方是从服务端到服务端把单代发出去的,OA 这一屏原本听不见(``started`` 只挂在 ``launch`` 的 refresh 那一路,而人停手之后 refresh 就不再跑了)。这条是界面轮询专用的 轻档,所以钉两条:答得准,以及**轻**——不重算地址、不再外呼对方接口、不记"打开"留痕。 """ opened = api.post_data("/embed/launch", { "code": codes["ticket"], "field": "embed_view", "embed": FIELD_CFG, "params": {"contractNo": "HT-状态这一问", "name": "张三"}, }) or {} prekey = str(((opened.get("session") or {}).get("prekey")) or "") ok("打开这一趟拿到了预受理号(界面轮询问的就是它)", bool(prekey), opened.get("session")) body = {"code": codes["ticket"], "field": "embed_view", "prekey": prekey} before = count_rows(CREATED) state = api.post_data("/embed/state", body) or {} after = count_rows(CREATED) eq("认得出是这一趟", state.get("found"), True) ok("还没发起时 started 是空的,界面因此什么都不显", not state.get("started"), state) ok("问这一句不留痕、不发短码", before == after, f"{before} -> {after}") claim_state(api, codes, prekey) state = api.post_data("/embed/state", body) or {} started = state.get("started") or {} eq("第三方把这一趟代发成单之后,这一句立刻答得出单号", started.get("serial"), "FYBXSTATE0001") eq("连 job 一起给,界面那句「去看这张单」跳的就是它", started.get("job"), "job-state-check") ok("带时间:界面要说的是「什么时候发起的」,不是刚发生的", bool(started.get("at")), started) other = api.post_data("/embed/state", {"code": codes["ticket"], "field": "embed_other", "prekey": prekey}) or {} eq("格子对不上就不答:预受理号是话题不是凭据", other.get("found"), False) ghost = api.post_data("/embed/state", {"code": codes["ticket"], "field": "embed_view", "prekey": "PRE没这个号"}) or {} eq("号认不出来说 found=false(与「还没发起」分得开)", ghost.get("found"), False) # **按号也认一次**:第三方是拿 OA 占下的那个正式号发起的、而 bizKey 填的是他们自己那套 # 流水号(生产上就是这么对接的——号只出现在地址里)。那一刻这一趟账上是空的,界面那句 # 「已经发起成一张单了」就永远不亮,而单子明明就在库里。少了下面这几条,这条通道只对 # "肯把预受理号当 bizKey 用"的那一类对接方成立。 held = api.post_data("/embed/launch", { "code": codes["ticket"], "field": "embed_held", "embed": FIELD_CFG, "serial": BY_SERIAL, "params": {"contractNo": "HT-按号认单", "name": "张三"}, }) or {} held_key = str(((held.get("session") or {}).get("prekey")) or "") ok("占着一个正式号的那一趟也拿到了预受理号", bool(held_key), held.get("session")) # 上面那一次 launch 是**该**留痕的;从这里往后的每一句问话都不该再添一行 logged = count_rows(CREATED)[1] held_body = {"code": codes["ticket"], "field": "embed_held", "prekey": held_key} eq("这个号还没落在一张单上时,那句提示不亮", (api.post_data("/embed/state", held_body) or {}).get("started"), None) plant_work(BY_SERIAL, BY_SERIAL_JOB) try: by_serial = (api.post_data("/embed/state", held_body) or {}).get("started") or {} eq("号被一张单占了之后,这一句按号也答得出单号", by_serial.get("serial"), BY_SERIAL) eq("给的是那张真的单的 job,界面跳的就是它", by_serial.get("job"), BY_SERIAL_JOB) ok("问这一句仍然不留痕:它是 20 秒一次的轮询", count_rows(CREATED)[1] == logged, f"{logged} -> {count_rows(CREATED)[1]}") finally: drop_work(BY_SERIAL_JOB) def plant_work(serial: str, job: str) -> None: """摆一张占着这个号的单(不走引擎:这里要验的是"按号认单"那一句,不是引擎)。""" from app import models from app.db import SessionLocal drop_work(job) db = SessionLocal() try: db.add(models.Work(job=job, serial=serial, process="p-check-embed-state", title="按号认单那一条用的假单")) db.commit() finally: db.close() def drop_work(job: str) -> None: from sqlalchemy import delete from app import models from app.db import SessionLocal db = SessionLocal() try: db.execute(delete(models.Work).where(models.Work.job == job)) db.commit() finally: db.close() def claim_state(api: Api, codes: dict, prekey: str) -> None: """照第三方代发那一路把这一趟认领成一张单(记的就是 ``apply_start`` 那一笔记账)。""" from sqlalchemy import select from app import models from app.db import SessionLocal from app.service import embed_session db = SessionLocal() try: row = db.execute( select(models.EmbedSession).where(models.EmbedSession.prekey == prekey) ).scalars().first() ok("那一趟在库里", row is not None, prekey) if row is not None: embed_session.apply_start(db, row, job="job-state-check", serial="FYBXSTATE0001", work_id="work-state-check") db.commit() finally: db.close() def check_ticket(api: Api, codes: dict, launch: dict, person_id: str) -> None: """对方系统拿短码换身份:密钥不对不烧码,用第二次必须失败。""" fragment = urllib.parse.urlsplit(str(launch.get("url") or "")).fragment ticket = dict(urllib.parse.parse_qsl(fragment)).get("ticket") or "" ok("地址片段里带回了短码", bool(ticket), launch.get("url")) if not ticket: return body = {"code": codes["ticket"], "ticket": ticket} key_header = {"X-Oa-Integration-Key": SHARED_KEY} status, payload, _ = api.call("POST", "/embed/tickets/verify", body, {"X-Oa-Integration-Key": "the-wrong-key"}) ok("密钥不对时换不到身份", status == 400, f"{status} {_msg(payload)}") ok("失败只给一句笼统话,不告诉人这条短码存不存在", "无效或已过期" in _msg(payload), _msg(payload)) identity = api.post_data("/embed/tickets/verify", body, key_header) or {} ok("密钥对得上时换到了身份", bool(identity.get("sub")) and bool(identity.get("account")), identity) eq("换出去的是站在屏幕前的这个人", identity.get("sub"), person_id) ok("带了参数指纹,对方能核『要打开的那一单』有没有被换过", bool(identity.get("argsDigest")), identity) ok("audience 缺省用这条源的编码", identity.get("audience") in (codes["ticket"], ""), identity.get("audience")) status, payload, _ = api.call("POST", "/embed/tickets/verify", body, key_header) ok("同一条短码用第二次必须失败", status == 400, f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/embed/tickets/verify", {"code": codes["ticket"], "ticket": "猜的"}, key_header) ok("瞎编的短码换不到身份", status == 400, f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/embed/tickets/verify", {"code": codes["allow"], "ticket": ticket}) ok("没配密钥的那条源换不到身份", status == 400, f"{status} {_msg(payload)}") def check_launch_guard(api: Api, codes: dict, outsider: Api, person_id: str) -> None: """不存在的单据、不存在的页面、跟他没关系的那张单:三种都不给地址,第三种还要留一笔。""" status, payload, _ = api.call("POST", "/embed/launch", {"code": codes["ticket"], "field": "embed_view", "job": "JOB_NOT_EXIST_9"}) ok("单据不存在回 404", status == 404, f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/embed/launch", {"code": "embed_no_such_source", "field": "view"}) ok("页面不存在时说「已经不在了」", status == 400 and "不在了" in _msg(payload), f"{status} {_msg(payload)}") identity = identity_ref_of(person_id) job = unrelated_job(person_id, identity) if not job: note("库里找不到与这个人无关的在办单据,越权那一条这一趟没验到") return before = blocked_count([codes["ticket"]]) status, payload, _ = outsider.call("POST", "/embed/launch", {"code": codes["ticket"], "field": "embed_view", "job": job}) ok("这个人与这张单没关系就不给地址", status == 403, f"{status} {_msg(payload)}") ok("地址一个字节都没漏出去", not (_msg(payload).startswith("http")), _msg(payload)) eq("挡住了也留一笔(他当时到底看没看到,以后要能对答)", blocked_count([codes["ticket"]]), before + 1) check_reader_may_open(outsider, codes, job, identity) def check_reader_may_open(outsider: Api, codes: dict, job: str, identity: str) -> None: """只有待阅关系的人也必须开得开这一格。 钉的是两边口径要对得上:``GET /job/{job}`` 不问关系,被抄送的人打开详情页看得见整张 表单,唯独这一格回一句"你看不到它"——那一句在屏幕上是一张打不开的卡片,而他明明被 叫来看这一张单。这一档给的是**字段自己的权限**,不借别人那一环的权限。 """ if not identity: note("取不到这个人的身份串,待阅那一档这一趟没验到") return from sqlalchemy import select from app import models from app.db import SessionLocal db = SessionLocal() work = db.execute(select(models.Work).where(models.Work.job == job)).scalar_one_or_none() if work is None: db.close() note("那张无关单据已经不在了,待阅那一档这一趟没验到") return row = models.Read(job=job, work=str(work.id), process=str(work.process), identity=identity, identity_name="嵌入验收·待阅", title=str(work.title or "")) db.add(row) db.commit() try: status, payload, _ = outsider.call("POST", "/embed/launch", {"code": codes["ticket"], "field": "embed_view", "job": job}) got = (payload or {}).get("data") or {} ok("被抄送的人也开得开这一格(待阅就是关系)", status == 200 and bool(got.get("url")), f"{status} {_msg(payload)}") finally: db.delete(row) db.commit() db.close() def check_dynamic_link(api: Api, port: int, server) -> None: """地址由接口现给那一档(``url_mode=api``)在接口上长什么样。 这一段不需要任何真外部系统——那个"取链接的接口"就是本机那个桩。钉的是只有过一遍 路由与序列化才看得见的五件事:那三格存进去也回得出来;参数白名单把请求体算进去; 发出去的是**刚取回来的那条**、带的确实是渲染过的那一组入参;链接来源没登记时停在 400 并且留一笔;「测试连通」探的是取回来的那条链接,不是那个接口地址本身。 """ def make(suffix: str, **over): body = {"code": f"{CREATED[0]}_{suffix}", "name": f"接口验收·{suffix}", "system": "验收", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/link", "method": "POST", "bodyTemplate": {"no": "{arg.contractNo}"}, "urlMode": "api", "urlPath": "data.url"} body.update(over) CREATED.append(str(body["code"])) return api.post_data("/design/data-sources", body) or {} row = make("link", urlOrigins=[f"http://127.0.0.1:{port}/"]) code = str(row.get("code") or "") eq("地址来源存得住也回得来", row.get("urlMode"), "api") eq("链接在响应里的位置回得来", row.get("urlPath"), "data.url") eq("允许的来源归一化成 origin 再存", row.get("urlOrigins"), [f"http://127.0.0.1:{port}"]) eq("参数白名单把请求体里那几个也算上", row.get("embedArgs"), ["contractNo"]) got = api.post_data("/embed/launch", { "code": code, "field": "embed_link", "activity": "", "embed": {"source": code, "fit": "fill", "params": {"contractNo": "{form.contractNo}"}}, "params": {"contractNo": "HT-77"}, }) or {} url = str(got.get("url") or "") ok("发出去的是刚取回来的那条链接", "/allow" in url, got) ok("那条链接带的就是渲染过的入参", "no=HT-77" in url, url) ok("明说这一条地址是现取的", got.get("dynamic") is True, got) eq("origin 也跟着换成那条链接的", got.get("origin"), f"http://127.0.0.1:{port}") # 要带的那一格空着:这一次根本不该去问接口。问回来的多半是一句 "xxx is required", # 屏幕上就是一张红着的页面,而那一次失败还要记进熔断那本账(见 service/embed.py:unfinished_args) empty_body = {"code": code, "field": "embed_link", "embed": {"source": code, "params": {"contractNo": "{form.contractNo}"}}, "params": {"contractNo": ""}} before_empty = blocked_count([code]) status, payload, _ = api.call("POST", "/embed/launch", empty_body) ok("那一格空着就把这次取链接挡下来,并点出缺的是哪一个参数", status == 400 and "还空着" in _msg(payload) and "contractNo" in _msg(payload), f"{status} {_msg(payload)}") eq("挡下来也算一笔留痕(他当时看没看到这一页,以后要能对答)", blocked_count([code]), before_empty + 1) status, payload, _ = api.call("POST", "/embed/launch", {**empty_body, "embed": {**empty_body["embed"], "openWhen": "always"}}) ok("配成「任何时候」就照旧放行:界面上说让开,后端不能拦着", status == 200, f"{status} {_msg(payload)}") verdict = api.post_data("/design/data-sources/test", {"code": code, "args": {"contractNo": "HT-77"}}) or {} ok("「测试连通」探的是取回来的那条链接", verdict.get("verdict") == "ok" and "/allow" in str(verdict.get("raw") or ""), verdict) ok("测试结论里留着「接口回的地址」那一句", "接口回的地址" in str(verdict.get("raw") or ""), verdict) # 那份响应里有哪几栏跟着一起回来:界面拿它把「链接在响应里的位置」那一栏做成能挑的 found = {str(item.get('path') or ''): item for item in (verdict.get('paths') or [])} ok('「测试连通」把这份响应里有哪几栏一起带回来', 'data.url' in found, sorted(found)) ok('候选带着示例值:认位置靠的是那句值,不是猜键名', str(found.get('data.url', {}).get('sample') or '').startswith('http://127.0.0.1'), found.get('data.url')) elsewhere = make("link_elsewhere", url=f"http://127.0.0.1:{port}/link-elsewhere", urlOrigins=[]) bad_code = str(elsewhere.get("code") or "") before = blocked_count([bad_code]) status, payload, _ = api.call("POST", "/embed/launch", { "code": bad_code, "field": "embed_link", "embed": {"source": bad_code, "params": {"contractNo": "{form.contractNo}"}}, "params": {"contractNo": "HT-77"}, }) ok("链接挂在一个没登记过的域名上就不给", status == 400 and "不在这张源允许的来源里" in _msg(payload), f"{status} {_msg(payload)}") # 那句报错**会**说出它指向哪个域名(管理员要靠这句话去补白名单), # 但不会把那条现生成的、带着入参的完整链接交出去 ok("那条现生成的链接没跟着报错漏出去", "no=HT-77" not in _msg(payload), _msg(payload)) eq("挡住了也留一笔", blocked_count([bad_code]), before + 1) # 保存那一刻的三道:少一颗星、写歪一种,都当场说,别留到有人点开表单 status, payload, _ = api.call("POST", "/design/data-sources", {"code": f"{CREATED[0]}_nopath", "name": "少一格", "provider": "embed", "url": f"http://127.0.0.1:{port}/link", "urlMode": "api"}) ok("接口取链接却没说链接在哪一栏,保存就挡", status == 400 and "哪一栏" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", {"code": f"{CREATED[0]}_badorigin", "name": "来源写歪", "provider": "embed", "url": f"http://127.0.0.1:{port}/link", "urlMode": "api", "urlPath": "data.url", "urlOrigins": ["elsewhere.invalid"]}) ok("「允许的来源」写成光秃秃的域名,保存就挡", status == 400 and "要写成 https://" in _msg(payload), f"{status} {_msg(payload)}") # ---- 一次回两条 + 那两条存进库:用户那句「打开一次创建一次」就修在这里 ---- calls = lambda: int(getattr(server, "link_calls", 0) or 0) # noqa: E731 - 就近取那一个计数 two = make("link_two", url=f"http://127.0.0.1:{port}/link-two", viewUrlPath="data.viewUrl") two_code = str(two.get("code") or "") eq("查看页那条位置存得住也回得来", two.get("viewUrlPath"), "data.viewUrl") ok("这条源被认成「给得出查看页」(属性面板据此不报警)", two.get("viewLinkReady") is True, two) # 模板档那条地址在这一档没人读,保存那一刻被后端清掉(与接口档反过来同理) mixed = make("link_two_mixed", url=f"http://127.0.0.1:{port}/link-two", urlMode="api", urlPath="data.url", viewUrlPath="data.viewUrl", viewUrl="https://erp.invalid/view?no=1") eq("接口那一档不读第二条地址模板,保存时被清掉", mixed.get("viewUrl"), "") two_body = {"code": two_code, "field": "embed_link_two", "embed": {"source": two_code, "params": {"contractNo": "{form.contractNo}"}}, "params": {"contractNo": "HT-88"}} before = calls() first = api.post_data("/embed/launch", two_body) or {} ok("第一次确实去问了一次接口", calls() == before + 1, f"{before} → {calls()}") eq("发起那一路(手上还没这张单)给的是编辑页那条", first.get("link"), "edit") ok("取回来的是刚新建那一页的编辑地址", "/edit?no=HT-88&page=" in str(first.get("url")), first) again = api.post_data("/embed/launch", two_body) or {} eq("同一个人在同一趟上再点开,地址一个字都没变(对面没有新页)", again.get("url"), first.get("url")) ok("第二次一次接口都没打——对面那张页没被新建第二张", calls() == before + 1, f"{before} → {calls()}") ok("界面因此说得出「这一条是沿用之前的」", again.get("linkReused") is True, again) eq("沿用的还是编辑页那一条(这个人该拿的就是它)", again.get("link"), "edit") # 参数换了:旧地址作废,必须重新问一次,否则框里是一张"值还是上一刻的"旧页 changed = api.post_data("/embed/launch", {**two_body, "params": {"contractNo": "HT-99"}}) or {} ok("要带过去的值换了就重新问一次,不沿用旧值问出来的那一页", calls() == before + 2 and "no=HT-99" in str(changed.get("url")), f"{calls()} {changed}") # 这一格配成「每次开新的一页」(embed.reopen=new)时不沿用:那是这一档的语义本身 fresh = api.post_data("/embed/launch", {**two_body, "field": "embed_link_two_fresh", "embed": {**two_body["embed"], "reopen": "new"}}) or {} ok("翻成「每次开新的一页」就照旧每次新建,地址跟着换", calls() == before + 3, f"{before} → {calls()}") ok("而且它明说自己这一条不是沿用来的", fresh.get("linkReused") is False, fresh) # ---- 一次回三条:对方多回的那几条与那几个值,过去连看都看不见 ---- three = make("link_three", url=f"http://127.0.0.1:{port}/link-two", urlPath="data.url", viewUrlPath="data.viewUrl", urlLinks=[{"key": "print", "name": "打印页", "path": "data.printUrl"}], urlMeta={"对方单号": "data.flow_number"}) three_code = str(three.get("code") or "") eq("另登记的那一条存得住也回得来", [str(item.get("key")) for item in (three.get("urlLinks") or [])], ["print"]) eq("顺手带回的那几样同样存得住", three.get("urlMeta"), {"对方单号": "data.flow_number"}) brief = next((item for item in (api.get_data("/embed/sources") or []) if str(item.get("code") or "") == three_code), {}) eq("属性面板那份清单把它算进「有哪几条链接」里了", [str(item.get("key")) for item in (brief.get("links") or [])], ["edit", "view", "print"]) ok("那一条在清单里念的是管理员起的那个名字", any(str(item.get("name")) == "打印页" for item in (brief.get("links") or [])), brief) ok("位置与地址模板不进浏览器,清单里只有键名与名字", all("path" not in item and "template" not in item for item in (brief.get("links") or [])), brief) three_body = {"code": three_code, "field": "embed_link_three", "embed": {"source": three_code, "params": {"contractNo": "{form.contractNo}"}, "link": "print"}, "params": {"contractNo": "HT-123"}} before = calls() got = api.post_data("/embed/launch", three_body) or {} ok("这一格点名要那一条,就真的给那一条", got.get("link") == "print" and "/print?no=HT-123&page=" in str(got.get("url")), got) eq("点名要第三条只问了一次接口——三条地址从同一份响应里一起取回", calls(), before + 1) eq("灰字念的是那个名字,不是键名", got.get("linkName"), "打印页") meta = got.get("linkMeta") or {} ok("顺手带回的那个值跟着回来了", str(meta.get("对方单号") or "").startswith("RE-STUB-"), got) ok("对面那个不是地址的布尔没被当成值灌进来(只收点名要的那几个)", list(meta) == ["对方单号"], got) held = api.post_data("/embed/launch", three_body) or {} eq("同一个人同一趟再点开,还是那一页(一次接口都不打)", held.get("url"), got.get("url")) eq("沿用那一次也认得出给的是哪一条", held.get("link"), "print") ok("沿用那一次灰字不凭空变空,值还是那一次带回来的那份", held.get("linkReused") is True and held.get("linkMeta") == meta, held) # 点了这条源没登记过的那一条:不把人挡在门外,退回编辑页那句由界面与文档负责说 # 同一格、同一趟:会话按「人 + 源 + 那一格 + 这一张单」认领,换一格就是另一趟 ghost = api.post_data("/embed/launch", {**three_body, "embed": {**three_body["embed"], "link": "invoice"}}) or {} eq("这条源没登记那一条时退回编辑页", ghost.get("link"), "edit") eq("退回去这一次同样一个接口都不打——编辑页那条同一次就取回来了", calls(), before + 1) auto = api.post_data("/embed/launch", {**three_body, "embed": {**three_body["embed"], "link": "auto"}}) or {} eq("「按人自动选」照旧按人判,多登记几条链接不干扰它", auto.get("link"), "edit") # 那两栏写歪的两种,保存这一刻就挡:存下一条永远给不出的链接,露馅是有人点开表单那一刻 status, payload, _ = api.call("POST", "/design/data-sources", {"code": f"{CREATED[0]}_builtin_key", "name": "键名撞内置", "provider": "embed", "url": f"http://127.0.0.1:{port}/link", "urlMode": "api", "urlPath": "data.url", "urlLinks": [{"key": "edit", "name": "编辑页", "path": "data.url"}]}) ok("「还有哪几条链接」里写内置那两个键名,保存就挡", status == 400 and "留给上面那两栏" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", {"code": f"{CREATED[0]}_noshape", "name": "键名不成形", "provider": "embed", "url": f"http://127.0.0.1:{port}/link", "urlMode": "api", "urlPath": "data.url", "urlLinks": [{"key": "Print Page", "name": "打印页", "path": "data.printUrl"}]}) ok("键名写成大写带空格,保存就挡", status == 400 and "小写字母开头" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/design/data-sources", {"code": f"{CREATED[0]}_meta_only", "name": "只写了名字", "provider": "embed", "url": f"http://127.0.0.1:{port}/link", "urlMode": "api", "urlPath": "data.url", "urlMeta": {"对方单号": ""}}) ok("「顺手带回的那几个值」只写名字不写位置,保存就挡", status == 400 and "没写位置" in _msg(payload), f"{status} {_msg(payload)}") # ---- 「我不知道对方把东西放在哪一栏」的那一口答案:探测把整份响应的栏位摊出来 ---- probed = api.post_data("/design/data-sources/test", {"code": three_code, "args": {"contractNo": "HT-PATHS"}}) or {} found = {str(item.get("path") or ""): item for item in (probed.get("paths") or [])} for want in ("data.url", "data.viewUrl", "data.printUrl", "data.flow_number", "data.is_review_allowed"): ok(f"对方回三条地址时,这五栏都在候选清单里:{want}", want in found, sorted(found)) ok("候选带着示例值:认位置靠的是那句值,不是猜键名", str(found.get("data.flow_number", {}).get("sample") or "").startswith("RE-STUB-"), found.get("data.flow_number")) ok("摊出来的是取得到值的每一栏,不摆 data 那一层中间节点", "data" not in found and "code" in found, sorted(found)) def check_design_validate(api: Api, codes: dict) -> None: """设计期:回填白名单点了挂额度的那一格,保存之前就得说这一格收不下。""" def embed_field(fields: list[str]) -> dict: return {"fields": [ {"key": "view", "name": "外部合同页", "type": "embed", "embed": { "source": codes["ticket"], "mode": "frame", "height": 480, "params": {"contractNo": "{form.contractNo}"}, "writeback": {"enabled": True, "fields": fields}, }}, {"key": "contractNo", "name": "合同号", "type": "text"}, {"key": "budget", "name": "预算占用", "type": "money", "quota": {"def": "Q_NOT_EXIST"}}, {"key": "plain", "name": "备注", "type": "text"}, ]} data = api.post_data("/process/forms/validate", {"content": embed_field(["budget", "plain", "ghost"])}) or {} problems = [str(item) for item in (data.get("problems") or [])] ok("挂了额度的那一格当回填目标会被挡住", any("不能决定流转" in item for item in problems), problems) ok("点了一个表单里没有的字段也要说", any("ghost" in item for item in problems), problems) ok("收得下的那一格不该被牵连", not any("备注" in item and "回填" in item for item in problems), problems) data = api.post_data("/process/forms/validate", {"content": embed_field(["plain"])}) or {} problems = [str(item) for item in (data.get("problems") or [])] ok("只点收得下的字段时没有回填相关的抱怨", not any("回填" in item for item in problems), problems) # 状态词对照表配歪了也要在设计期说,而不是等对方回传时回一句"匹不到唯一出口" def mapped(decisions: dict) -> dict: content = embed_field(["plain"]) content["fields"][0]["embed"]["actions"] = { "enabled": True, "allow": ["decide"], "decisions": decisions} return content problems = [str(item) for item in ((api.post_data("/process/forms/validate", {"content": mapped({"PASS": "通过"})}) or {}).get("problems") or [])] ok("把对方状态词直接映射成出口名,保存之前就挡", any("只能翻成" in item for item in problems), problems) problems = [str(item) for item in ((api.post_data("/process/forms/validate", {"content": mapped({"PASS": "agree"})}) or {}).get("problems") or [])] ok("配对了就不吵这一句", not any("只能翻成" in item for item in problems), problems) # --------------------------------------------------------------------------- # 这一趟的凭据与那三档回写(docs/embed-action-design.md) # # 免登短码 60 秒、用一次即烧,它只回答"站在屏幕前的是谁"。三件真正要对答的事都发生在 # 验票**之后**,而这三件在接口上各有一个必须钉住的失效样子: # # 1. **发起页上第三方回写的值到底落不落得了格**。回填白名单是照着表单算的,发起页没有 # 单据可问,算不出来就只能对着空清单收值——最常见的场景静默失灵,屏幕上只有一句 # 「不在允许回写的字段里」,谁都不觉得是自己的问题; # 2. **变成一张单之后这一趟还认不认**。第三方报完 start、OA 这边重新打开同一格,必须还认得 # 是同一趟(同一个预受理号),否则 ERP 按旧号建的那份草稿从此没人认领; # 3. **没开放的那一档一律挡**。这一格没勾"提交本环节",回写审批结论就必须挡,而且要说明 # 去哪儿勾——对着自己那套枚举猜别人家配置的接口,报错不说人话就永远联不完。 # # 字段配置里的回填目标要写真实存在的字段名,否则"该收下的那几格"这一档根本没得验, # 所以那几格是从库里已发布流程的发起表单上读出来的。 # --------------------------------------------------------------------------- def pick_start_process() -> tuple[str, list[str]]: """找一条**已发布**的流程,带回它的 id 与发起表单上收得下回填的那几格字段名。 只读查询,不造数据。库里表单长什么样不归这个脚本定,所以字段名从库里读。 """ from sqlalchemy import select from app import models from app.db import SessionLocal from app.engine import definition as definition_module from app.service import embed, formruntime db = SessionLocal() try: rows = db.execute( select(models.Process) .where(models.Process.enabled == True, models.Process.published == True) # noqa: E712 .order_by(models.Process.id.desc()) .limit(20) ).scalars().all() for process in rows: try: definition = definition_module.load(db, process.id) except ValueError: continue form_id = str(definition.latest_form or "") or (definition.form_ids()[:1] or [""])[0] form_row = db.get(models.FormElement, form_id) if form_id else None fields = formruntime.fields_of(form_row.content) if form_row is not None else [] usable = [str(item.get("key") or "").strip() for item in fields if str(item.get("key") or "").strip() and not embed.writeback_refusal(item)] if usable: return str(process.id), usable[:3] finally: db.close() return "", [] def count_sessions(codes: list[str]) -> int: """这几条源名下开着的嵌入会话条数:验"两次打开是不是同一趟"用的就是它。""" from sqlalchemy import func, select from app import models from app.db import SessionLocal if not codes: return 0 db = SessionLocal() try: return int(db.execute( select(func.count()).select_from(models.EmbedSession) .where(models.EmbedSession.source.in_(codes)) ).scalar() or 0) finally: db.close() def age_session(prekey: str, seconds: int = 60) -> None: """把某一趟会话的到期时间挪到 ``seconds`` 秒之后:验"复用这一刻会不会续期"。 直接从库里改,不用等两个小时。改完再打开一次,回来的 ``ttl`` 要是还按老那条算, 说明复用没续期——同一个人上午看过一次、下午再点开就换了预受理号,对面就是一张新页面。 """ from datetime import datetime, timedelta from sqlalchemy import select from app import models from app.db import SessionLocal if not prekey: return db = SessionLocal() try: row = db.execute(select(models.EmbedSession) .where(models.EmbedSession.prekey == prekey)).scalars().first() if row is not None: row.expires_at = datetime.now() + timedelta(seconds=seconds) db.commit() finally: db.close() def ticket_of(launch_result: dict) -> str: """从拼好的地址片段里摸出那条免登短码。""" fragment = urllib.parse.urlsplit(str((launch_result or {}).get("url") or "")).fragment return str(dict(urllib.parse.parse_qsl(fragment)).get("ticket") or "") def check_session_and_callback(api: Api, codes: dict) -> None: """``POST /embed/launch`` 那份会话,以及 ``POST /embed/callback`` 那三档回写。""" process_id, keys = pick_start_process() if not process_id: note("库里找不到带可回写字段的已发布流程,这一趟没验发起页的回写与回写通道") return key_header = {"X-Oa-Integration-Key": SHARED_KEY} field_a = keys[0] cfg = { "height": 480, "params": {"contractNo": "{form.contractNo}"}, # 一格是真字段(该收下),一格表单上根本没有(该挡) "writeback": {"enabled": True, "fields": [field_a, "ghost_not_on_form"]}, "actions": {"enabled": True, "allow": ["submit", "save", "decide", "refresh"], "confirm": True}, } body = {"code": codes["ticket"], "field": "embed_view", "embed": cfg, "process": process_id, "params": {"contractNo": "HT-SESSION-1"}} first = api.post_data("/embed/launch", body) or {} session = first.get("session") or {} prekey = str(session.get("prekey") or "") ok("发起页那一趟也给了预受理号(这时还没有单据,它是双方唯一共有的标识)", prekey.startswith("PRE"), prekey) eq("开放了哪几件事由后端算:发起页上有回填与发起,没有待办所以不给提交本环节", session.get("scopes"), ["prefill", "start"]) ok("动作清单跟着回,界面上那几个按钮因此存在与否", sorted(first.get("actions") or []) == ["decide", "refresh", "save", "submit"], first.get("actions")) ok("这条源配了密钥,令牌就不从前端下发", not session.get("token"), session) ok("上下文里带着按这条流程的表单算出来的那几格白名单", field_a in ((session.get("context") or {}).get("fields") or []), session.get("context")) eq("还没人回写过时 staged 是空的", first.get("staged") or {}, {}) again = api.post_data("/embed/launch", body) or {} eq("同一个人同一格、既没单据也没草稿时,两次打开认成同一趟(预受理号不变)", (again.get("session") or {}).get("prekey"), prekey) # 那一屏上**整张单**的表单值也留在这趟上:第三方一句裸回写要代发的是整张单,而这一格 # 只引用了一个参数,其余那些人在同一屏上填好的必填格不靠这一份就到不了服务端 api.post_data("/embed/launch", dict(body, form={ keys[0]: ["数组得原样留着"], "codex_ghost_field": "这张表单上根本没这一格"})) eq("整份表单值只留这张表单定义的格名,而且留的是存储形状(选人是数组,不拼成人话)", session_form(prekey), {keys[0]: ["数组得原样留着"]}) api.post_data("/embed/launch", dict(body, refresh=True, form={keys[0]: "他后来改的那一份"})) eq("人在这一屏上改过之后,留下的跟着换成最新那一份", session_form(prekey), {keys[0]: "他后来改的那一份"}) api.post_data("/embed/launch", dict(body, refresh=True)) eq("那一句没带 form 就不动这一份:老前端与有单据那一路都不带,不该把底稿抹掉", session_form(prekey), {keys[0]: "他后来改的那一份"}) # 验票响应才是这把令牌唯一的交付通道:此刻确实是对面的服务器在说话 verified = api.post_data("/embed/tickets/verify", {"code": codes["ticket"], "ticket": ticket_of(first)}, key_header) or {} call = verified.get("callback") or {} token = str(call.get("token") or "") ok("验票响应带回写那一份凭据", token.startswith("oes_"), list(verified)) eq("它说的就是同一趟", call.get("prekey"), prekey) eq("能做哪几件事跟着令牌一起给", call.get("kind"), ["prefill", "start"]) callback = {"code": codes["ticket"], "token": token} # --- 鉴权:错密钥、假令牌,都只给一句笼统话 --- status, payload, _ = api.call("POST", "/embed/callback", dict(callback, kind="prefill", values={field_a: "1"}), {"X-Oa-Integration-Key": "the-wrong-key"}) ok("密钥不对时回写不进去", status == 400, f"{status} {_msg(payload)}") ok("失败只给一句笼统话,不告诉人这把令牌存不存在", "无效或已过期" in _msg(payload), _msg(payload)) status, payload, _ = api.call("POST", "/embed/callback", dict(callback, token="oes_guessed", kind="prefill", values={field_a: "1"}), key_header) ok("瞎编的会话令牌回写不进去", status == 400 and "无效或已过期" in _msg(payload), _msg(payload)) status, payload, _ = api.call("POST", "/embed/callback", dict(callback, kind="看心情"), key_header) ok("没说清是哪一种回写时要点名可以填什么", status == 400 and "kind" in _msg(payload), _msg(payload)) # --- prefill:白名单是闸,不在清单里的一条不收 --- done = api.post_data("/embed/callback", dict(callback, kind="prefill", values={field_a: "从 ERP 攒回来的一手", "ghost_not_on_form": "不收我"}), key_header) or {} eq("表单上真有的那一格收下了", done.get("accepted"), [field_a]) eq("表单上根本没有的那一格挡在外面(这一道在入库之前,不等前端去筛)", done.get("rejected"), ["ghost_not_on_form"]) # 对方真回传过哪几个键名,属性面板上「对方字段名」那一栏靠它当候选:值一个字都不入库 brief = next((item for item in (api.get_data("/embed/sources") or []) if str(item.get("code") or "") == codes["ticket"]), {}) names = [str(item) for item in (brief.get("remoteKeys") or [])] ok("回写过的键名进了那条源的候选清单", field_a in names, brief.get("remoteKeys")) ok("连被那道闸挡下的那一个也念出来(那正是配错时最该看见的样子)", "ghost_not_on_form" in names, names) ok("清单里只有键名,回传的那些值一个都没漏出去", all("ERP" not in item for item in names), names) other = next((item for item in (api.get_data("/embed/sources") or []) if str(item.get("code") or "") == codes["odd"]), {}) eq("还没人回写过的那条源,这一栏是空的(界面据此退回输入框)", other.get("remoteKeys") or [], []) staged = {field_a: "从 ERP 攒回来的一手"} eq("攒下来的那几格在下一次打开这一格时带回去,走与 oa:result 同一道闸落格", (api.post_data("/embed/launch", body) or {}).get("staged") or {}, staged) eq("参数刷新那一趟也搭同一班车(页面正开着、对方刚回写完,靠这一次带回)", (api.post_data("/embed/launch", dict(body, refresh=True)) or {}).get("staged") or {}, staged) # --- decide:这一趟没开放那一档就必须挡 --- status, payload, _ = api.call("POST", "/embed/callback", dict(callback, kind="decide", decision="agree"), key_header) ok("这一趟没开放「提交本环节」时,回写审批结论必须挡", status == 400, f"{status} {_msg(payload)}") ok("那句话要说清去哪儿勾,而不是只念一句没权限", "这一页能让 OA 做哪几件事" in _msg(payload), _msg(payload)) # --- start:报完"我们那边发起了",OA 这边重新打开必须还认得同一趟 --- claimed = api.post_data("/embed/callback", dict(callback, kind="start", job="JOB_FROM_ERP_9", serial="SER-9"), key_header) or {} eq("报上来的单号记在这一趟上", (claimed.get("job"), claimed.get("serial")), ("JOB_FROM_ERP_9", "SER-9")) eq("第一次报,不算重复", claimed.get("already"), False) reopened = api.post_data("/embed/launch", body) or {} ok("发起之后**新开**的那一页是另外一趟:不再捡上一趟的账(捡了就凭空显一句「已经在外部系统发起(单号 上一张)」)", (reopened.get("session") or {}).get("prekey") != prekey, reopened.get("session")) ok("那一页上也不显那句「已经发起了」——这一趟压根还没成单,那句是给隔壁那页说的", not reopened.get("started"), reopened.get("started")) pinned = api.post_data("/embed/launch", dict(body, refresh=True, prekey=prekey)) or {} eq("还开着的那一页按自己那一趟的号刷新,当场就听见「这一趟已经变成一张单了」", (pinned.get("started") or {}).get("job"), "JOB_FROM_ERP_9") stale = api.post_data("/embed/launch", dict(body, refresh=True)) or {} ok("没报号时答的是这一格最近那一趟(新开的那一页),不是被认领走的那一趟", not stale.get("started"), stale.get("started")) after = api.post_data("/embed/callback", dict(callback, kind="prefill", values={field_a: "发起之后又改了一次"}), key_header) or {} eq("已经变成一张单的那一趟仍然收得到回写值(发起不是这条通道的终点)", after.get("accepted"), [field_a]) # --- 没配密钥的那条源:能攒值,但不配替一个人表态 --- loose = {"height": 480, "writeback": {"enabled": True, "fields": [field_a]}, "actions": {"enabled": True, "allow": ["submit", "decide"]}} free = api.post_data("/embed/launch", {"code": codes["allow"], "field": "embed_view", "embed": loose, "process": process_id}) or {} free_session = free.get("session") or {} ok("没配密钥的源,令牌只能从前端下发(它拿不到别的通道)", str(free_session.get("token") or "").startswith("oes_"), free_session) eq("而它能做的事只有攒值:发起与提交本环节都要密钥", free_session.get("scopes"), ["prefill"]) ok("两个预受理号不是同一个(一条源一趟,互不串台)", free_session.get("prekey") != prekey, free_session.get("prekey")) # --- 失败即关:整档没开时一个动作都不给,也不发凭据 --- quiet_cfg = {"height": 480, "params": {"contractNo": "{form.contractNo}"}, "actions": {"enabled": False, "allow": ["submit"]}} quiet = api.post_data("/embed/launch", dict(body, field="embed_quiet", embed=quiet_cfg)) or {} eq("整档开关没开时一个动作都不给", quiet.get("actions"), []) eq("回填没开的那一格也不给攒值这一档", (quiet.get("session") or {}).get("scopes"), []) quiet_verified = api.post_data("/embed/tickets/verify", {"code": codes["ticket"], "ticket": ticket_of(quiet)}, key_header) or {} ok("一档都没开放时压根不发回写凭据:多一把钥匙就是多一份要人管的账", "callback" not in quiet_verified, list(quiet_verified)) # --- 「重复打开这一格时」那一档(放在最后:这几趟会让 latest_open 挑中别的会话)(``embed.reopen``):默认接上,翻成 new 才另起 --- fresh = dict(body, field="embed_reopen_fresh", embed=dict(cfg, reopen="new")) first_fresh = ((api.post_data("/embed/launch", fresh) or {}).get("session") or {}) second_fresh = ((api.post_data("/embed/launch", fresh) or {}).get("session") or {}) ok("这一格翻成「每次开新的一页」之后,两次打开拿到两个预受理号", str(first_fresh.get("prekey") or "").startswith("PRE") and first_fresh.get("prekey") != second_fresh.get("prekey"), (first_fresh.get("prekey"), second_fresh.get("prekey"))) third_fresh = ((api.post_data("/embed/launch", dict(body, field="embed_reopen_fresh")) or {}) .get("session") or {}) eq("同一格不写这一档就回到默认那一档:接着用最近那趟的号,不另发", third_fresh.get("prekey"), second_fresh.get("prekey")) # --- 复用这一刻续期:隔几个小时再点开同一张单,还是原来那一趟 --- # 拿上面那一格验,不用 ``embed_view`` 那一趟:它到这儿已经被 start 认领走了, # 认领走的那一趟**本该**让给新开的一页(上面刚钉过),拿它测续期只会测到那条规则。 aged = str(third_fresh.get("prekey") or "") age_session(aged) renewed = (api.post_data("/embed/launch", dict(body, field="embed_reopen_fresh")) or {}).get("session") or {} ok("复用同一趟时把存活期按这一次打开往前推(不推的话隔几小时就换号,对面多一张新页)", int(renewed.get("ttl") or 0) > 60, renewed) eq("推的只是存活期,不是换一趟", renewed.get("prekey"), aged) def pick_any_published_process() -> tuple[str, str]: """找任意一条**已发布**的流程,带回 id 与名称。存草稿只需要一个合法流程。""" from sqlalchemy import select from app import models from app.db import SessionLocal db = SessionLocal() try: row = db.execute( select(models.Process) .where(models.Process.enabled == True, models.Process.published == True) # noqa: E712 .order_by(models.Process.id.desc()) .limit(1) ).scalars().first() return (str(row.id), str(row.name or "")) if row is not None else ("", "") finally: db.close() def check_link_draft(api: Api, codes: dict, outsider: Api, same_person: bool, port: int, server) -> None: """存下草稿的那一刻,把还开着的那几趟嵌入会话挂到这份草稿上。 草稿箱「删除草稿」那一路按草稿号找会话,而发起页「先开页面 → 再存草稿」是先后两件事: 不挂上,删草稿那句就永远只找到「没有会话」,对面那张草稿没人删。这一段钉的是**挂接本身** 与挂接之后的行为口径(页面放弃腿被故意拦下、删草稿腿真把那句发出去);「删草稿时发的那句 长什么样」的纯函数口径在 ``check_embed_decide.py`` 里另有一组。 """ process_id, process_name = pick_any_published_process() if not process_id: note("库里找不到一条已发布的流程,这一趟没验存草稿挂接") return code = f"{CREATED[0]}_linkdraft" CREATED.append(code) api.post_data("/design/data-sources", { "code": code, "name": "接口验收·存草稿要挂接", "kind": "fetch", "provider": "embed", "url": f"http://127.0.0.1:{port}/allow", "pageMode": "none", "abandonUrl": "/oa/delete-draft", "abandonField": "no", }) first = api.post_data("/embed/launch", {"code": code, "field": "embed_link"}) or {} prekey = str((first.get("session") or {}).get("prekey") or "") ok("挂接用的这一趟也给了预受理号", prekey.startswith("PRE"), prekey) created = api.post_data("/draft", {"process": process_id, "title": "接口验收·挂接用草稿"}) or {} draft_id = str(created.get("id") or "") draft_serial = str(created.get("serial") or "") ok("这份草稿存下来了", bool(draft_id), created) res = api.post_data("/embed/link-draft", {"prekeys": [prekey], "draft": draft_id}) or {} eq("挂接成功,挂上的就是这一趟", res.get("linked"), 1) from app.db import SessionLocal from app.service import embed_session as embed_session_module db = SessionLocal() try: session = embed_session_module.by_prekey(db, prekey) eq("草稿号写进了那一份会话上", str(session.draft or "") if session is not None else "", draft_id) finally: db.close() if not same_person: other = outsider.post_data("/embed/launch", {"code": code, "field": "embed_link_other"}) or {} other_prekey = str((other.get("session") or {}).get("prekey") or "") res2 = api.post_data("/embed/link-draft", {"prekeys": [other_prekey], "draft": draft_id}) or {} eq("别人的那一趟挂不上(预受理号不是凭据)", res2.get("linked"), 0) db = SessionLocal() try: other_session = embed_session_module.by_prekey(db, other_prekey) eq("别人的会话上没被写上这份草稿", str(other_session.draft or "") if other_session else "", "") finally: db.close() else: note("签不出另一个人,这一趟没验「别人的那一趟挂不上」") status, payload, _ = api.call("POST", "/embed/link-draft", {"prekeys": [prekey], "draft": "no_such_draft"}) ok("挂到一份不存在的草稿上要说草稿不存在", status == 404 and "草稿不存在" in _msg(payload), f"{status} {_msg(payload)}") status, payload, _ = api.call("POST", "/embed/link-draft", {"prekeys": [], "draft": draft_id}) ok("一程都没报上来时要说清是哪几趟", status == 400 and "哪几趟" in _msg(payload), f"{status} {_msg(payload)}") abandon = api.post_data("/embed/abandon", {"prekeys": [prekey], "reason": "discard"}) or {} item = next((i for i in abandon.get("results") or [] if i.get("prekey") == prekey), {}) eq("挂上草稿之后,页面放弃那一腿故意不发(发了就是把还在用的对面草稿删了)", item.get("status"), "skipped") ok("那句话里说得出是因为挂着一份草稿", "草稿" in str(item.get("note") or ""), item) api.run("DELETE", f"/draft/{draft_id}") deletion = getattr(server, "last_deletion", None) ok("删掉这份草稿的那一刻,对面收到了一句删除", bool(deletion), deletion) if deletion: from app.db import SessionLocal from app.service import embed_session as embed_session_module db = SessionLocal() try: session = embed_session_module.by_prekey(db, prekey) session_serial = str(session.serial or "") if session else "" finally: db.close() expected = draft_serial or session_serial or prekey eq("发出去的那份请求体里带着对面建草稿用的那个号", deletion.get("body"), {"no": expected}) def check_csp(api: Api) -> None: """本系统自己的两道头:能嵌谁写在 ``frame-src``,我们自己绝不被人嵌。""" from app.config import settings if not settings.embed_csp: note("配置项 embed.csp 是关着的,这一趟没验 CSP 那两条头") return _data, headers = api.run("GET", "/ping") csp = header_value(headers, "content-security-policy") ok("响应带 CSP 头", bool(csp), headers) ok("frame-ancestors 是 none:OA 自己绝不被人嵌", "frame-ancestors 'none'" in csp, csp) ok("留着 blob:,附件 PDF 预览别被这道新闸顺手关掉", "blob:" in csp, csp) frame_src = csp.split("frame-src", 1)[1].split(";", 1)[0] if "frame-src" in csp else "" ok("刚注册的这一条来源当场进了 frame-src 白名单", "127.0.0.1" in frame_src, csp) def check_gone(api: Api, codes: dict) -> None: """删掉之后再点开那一格:要说「已经不在了」,不能回一条来历不明的地址。""" rows = api.get_data("/design/data-sources") or [] mine = [row for row in rows if str(row.get("code") or "").startswith(CREATED[0])] # 嵌入源可能把另一条当成放弃通知的出口,那种被引用的要最后删,不然删除会被自己的引用挡住 mine.sort(key=lambda row: 0 if str(row.get("provider")) == "embed" else 1) for row in mine: api.run("DELETE", f"/design/data-sources/{row.get('id')}") left = [str(row.get("code")) for row in (api.get_data("/design/data-sources") or []) if str(row.get("code") or "").startswith(CREATED[0])] eq("这一趟造的测试数据源都清干净了", left, []) status, payload, _ = api.call("POST", "/embed/launch", {"code": codes["ticket"], "field": "view"}) ok("源删掉之后那一格说「已经不在了」", status == 400 and "不在了" in _msg(payload), f"{status} {_msg(payload)}") # --------------------------------------------------------------------------- def main(argv: list[str]) -> int: parser = argparse.ArgumentParser(description="表单嵌外部页面的接口侧验收(需要一个跑着的 API)") parser.add_argument("--base", default="http://127.0.0.1:8000/api/v1", help="API 地址,默认本机 8000") parser.add_argument("--token", default="", help="自带一个访问令牌;不给就在本机现签一个") parser.add_argument("--allow-remote", action="store_true", help="允许 --base 指向非本机地址(探测那几段依赖本机页面,会跳过)") parser.add_argument("--keep", action="store_true", help="跑完不删这一趟造的测试数据") parser.add_argument("--outsider", default="", help="顶替「与这张单无关的那个人」的令牌(默认本机现签)") args = parser.parse_args(argv) host = str(urllib.parse.urlsplit(str(args.base)).hostname or "") if host not in ("127.0.0.1", "localhost", "::1") and not args.allow_remote: print(f"--base 指的不是本机({host or args.base})。要么换成 http://127.0.0.1:8000/api/v1," f"要么显式加 --allow-remote。") return 2 token, person_id = (args.token, "") if args.token else mint_token() if not token: print("拿不到会话:本机签不出令牌(配置或库连不上)。也可以先拿一个管理员令牌,用 --token 传进来。") return 2 server = serve_page() codes: dict = {} launch: dict = {} try: CREATED.append(f"embed_api_{int(time.time())}") api = Api(args.base, token) outsider_token, outsider_id = (args.outsider, "") if args.outsider else mint_ordinary_token() if not outsider_token: note("签不出一个普通人的令牌,越权那一条这一趟没验到") outsider_token, outsider_id = token, person_id outsider = Api(args.base, outsider_token) stages = [ ("服务可达", lambda: check_ping(api)), ("注册表那条 embed 源", lambda: codes.update(check_register(api, server.server_address[1]))), ("设计器那份可嵌入清单", lambda: check_source_list(api, codes)), ("能不能被嵌(真访问一次)", lambda: check_probe(api, codes)), ("地址由接口现给那一档", lambda: check_dynamic_link(api, server.server_address[1], server)), ("要地址:参数白名单与编码", lambda: launch.update(check_launch(api, codes))), ("参数刷新:只回参数", lambda: check_refresh(api, codes)), ("这一趟发起出去了没有(界面轮询那一条)", lambda: check_state(api, codes)), ("免登短码换身份", lambda: check_ticket(api, codes, launch, person_id)), ("要地址时的三条拒绝", lambda: check_launch_guard(api, codes, outsider, outsider_id)), ("设计期回填白名单", lambda: check_design_validate(api, codes)), ("这一趟的凭据与那三档回写", lambda: check_session_and_callback(api, codes)), ("存草稿那一步的挂接", lambda: check_link_draft(api, codes, outsider, outsider_token == token, server.server_address[1], server)), ("本系统自己的 CSP", lambda: check_csp(api)), ("清场", lambda: check_gone(api, codes)), ] for title, stage in stages: before = len(FAILS) try: stage() except Exception as exc: # noqa: BLE001 - 一段炸了不该拖累后面的段,但必须让人看见 FAILS.append(f"{title}:这一段跑挂了 {type(exc).__name__}: {exc}") print(f"[{'通过' if len(FAILS) == before else f'{len(FAILS) - before} 条不对'}] {title}") finally: server.shutdown() server.server_close() if not args.keep: try: sweep(CREATED) except Exception as exc: # noqa: BLE001 print(f"[提示] 短码与留痕没清干净,可以手工删 {CREATED}:{exc}") for line in NOTES: print(f"[提示] {line}") for line in FAILS: print(f"[FAIL] {line}") if FAILS: print(f"共 {len(FAILS)} 条不对({args.base})") return 1 print(f"通过:表单嵌外部页面这一格在接口上口径一致({args.base})") return 0 if __name__ == "__main__": raise SystemExit(main(sys.argv[1:]))