unis-oa/backend/scripts/check_embed_api.py

1685 lines
93 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
"""表单嵌外部页面(``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"<html><body>embed target</body></html>"
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:]))