1685 lines
93 KiB
Python
1685 lines
93 KiB
Python
#!/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:]))
|