467 lines
25 KiB
Python
467 lines
25 KiB
Python
#!/usr/bin/env python3
|
||
"""嵌页面那一屏问的第二句:我打开的那一环、那条待办,现在还在原地吗。
|
||
|
||
PYTHONPATH=. python3 scripts/check_embed_moved.py
|
||
|
||
用户那句原话是在生产上试出来的:「在嵌入的报销页面里点了提交,OA 这一页没反应,我以为没
|
||
提交成功。」链路是这样断的:人在对面点下提交,对面自己的后端过一两秒才把结论送到 OA;而
|
||
那一屏上 ``POST /embed/state`` 原本只答一句"这一趟变成单了没"(``started``),挂在单据上开出
|
||
来的那些趟问这一句永远得到 null —— 会话就是挂在这张单上开出来的,"这一趟发起出去了没"根本
|
||
不成其为问题(:func:`app.api.embeds._started_of` 因此直接回 null)。于是那一屏连一句可轮询的
|
||
话都没有,那两秒里它和提交前一模一样,人看到的仍然是"没反应"。
|
||
|
||
修法是在同一条轻路上补第二句:拿会话**打开那一刻的快照**(work / job / activity / task 四列)
|
||
去对此刻,任一条对不上就算"动了"(判据 :func:`app.api.embeds.work_moved`)。这一条钉的就是那
|
||
句判据本身,十二句里每一句都对得上一种看得见的坏法:
|
||
|
||
1. 一切还在原地 → 没动。这一条是"不许界面白刷"那半边,缺了它,前面几条怎么过都没意义;
|
||
2. 单据走去了别的环节 → 动了(人在对面提交成功,OA 这一步已经交棒);
|
||
3. 那条待办不再挂在待办表里 → 动了,**无论谁办的**:他自己、抢先的人、会签凑够了数、还是第
|
||
三方服务端代点的那一路 —— 后者正是生产上等的那一句;
|
||
4. 这张单落定了(办结 / 终止 / 作废)→ 动了,而且 ``state.status`` 说得出是哪一种;
|
||
5. 这张单整个不在了(连归档行都没有)→ 动了:这一屏没有东西可以留着看了;
|
||
6. 挂在开始环节、手上根本没有待办的那些趟(第三方接管开始环节建的那一单,见 engine.start 的
|
||
hold_at_begin)不能因为"待办查不到"就被判成已经动了;
|
||
7. 并行环节时 ``work.activity`` 是逗号串,认自己那一环要用串里的成员,不能用整串相等;
|
||
8. **回看一张早就办结的单**(会话上环节与待办都是空的)→ 没动:那种屏没有可比的东西,判成
|
||
动了就是每点开一次白刷一次整屏,而前端那道 movedOut 闸一次装载只挡得住一次;
|
||
9. 认不出那一趟(假预受理号)→ found=false 且 moved=false、state=null,不抛异常;
|
||
10. 挂在单据上的那一趟,``started`` 照旧是 null 而 ``moved`` 答得出话 —— 两句互不顶替,这一条
|
||
就是这次改动存在的全部理由;
|
||
11. 发起页那些还没变成单的趟 → 第二句答不出(state=null、moved=false),归 started 那一路管;
|
||
12. 问这一句**一行都不写**:不发短码、不记"打开"留痕、连会话自己的 update_time 都不许挪 ——
|
||
这一条是成串追问的轮询,写一行就是往台账里掺一条假的"他打开了那个页面"。
|
||
|
||
判据本身(1-8)收在一个纯函数里;现场那四个键的内容(含 11、含"一句问话发几条语句")收在
|
||
:func:`_moved_of` 里,配一条按表名回话的假库;9 还走一次真路由(把 get_db / current_user 两个
|
||
依赖换掉就行)。这三段**都不需要数据库**,MySQL 不可达的机器跑的就是它们。10 与第 12 句要
|
||
一张真单、一条真待办与一趟真会话;连不上库时脚本自己说清跳过了什么,不含糊过去。跑完连自己
|
||
造的那条源、那张单、那条待办与那几趟会话一起删干净(清场口径照 ``check_write_payload.py``)。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import logging
|
||
import time
|
||
from datetime import datetime
|
||
|
||
from sqlalchemy import delete, select
|
||
from sqlalchemy.exc import OperationalError
|
||
from starlette.testclient import TestClient
|
||
|
||
from app import models
|
||
from app.api.embeds import _moved_of, work_moved
|
||
from app.db import SessionLocal
|
||
from app.main import app
|
||
from app.security import create_access_token
|
||
from app.service import embed_session
|
||
|
||
#: 这一趟专用的源编码:会话、短码、留痕与这条源本身都按它清场,别人的行一条不碰
|
||
SOURCE = f"check_embed_moved_{int(time.time())}"
|
||
FIELD = "approve_page"
|
||
#: 会话都挂在管理员身上:接口那一路按"打开这一页的那个人"认趟(match_prekey),用 1 号就是一
|
||
#: 个 token 走到底,不必为流程里的审批人再凑一个能登录的账号
|
||
PERSON = "1"
|
||
|
||
FAILS: list[str] = []
|
||
PASSED = 0
|
||
|
||
|
||
def check(label: str, condition, detail="") -> None:
|
||
global PASSED
|
||
if condition:
|
||
PASSED += 1
|
||
print(f"[通过] {label}")
|
||
else:
|
||
FAILS.append(label)
|
||
print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}")
|
||
|
||
|
||
def same(label, got, want) -> None:
|
||
"""比值的一句:不等就把两边都念出来,光说"条件不成立"看不出差在哪一格。"""
|
||
check(label, got == want, f"期望 {want!r},实得 {got!r}")
|
||
|
||
|
||
def verdict(**over) -> bool:
|
||
"""一句判据:默认那份"全都在原地"的现场,按需要改一样。"""
|
||
args = dict(snapshot_activity="a-dept", snapshot_task="t-1",
|
||
now_status="running", now_activity="a-dept", task_open=True)
|
||
args.update(over)
|
||
return work_moved(**args)
|
||
|
||
|
||
class _Reply:
|
||
"""假库的回话:first() 与 scalar() 两个口子,够把 _moved_of 走一遍。"""
|
||
|
||
def __init__(self, value):
|
||
self._value = value
|
||
|
||
def first(self):
|
||
return self._value
|
||
|
||
def scalar(self):
|
||
return self._value
|
||
|
||
|
||
class _FakeDb:
|
||
"""只按语句里那张表名回话的假库。
|
||
|
||
为的是把 ``state`` 那四个键的**内容**也钉进不连库的这一半:真表上要凑出"归档行还在、运行
|
||
行没了"这种现场,得真跑一张流程再把它办结,代价与这一条要钉的东西不成比例。顺带把"一句
|
||
问话发几条语句"数下来 —— 那正是"必须还是一条便宜的读路"这句话唯一的抓手。
|
||
"""
|
||
|
||
def __init__(self, *, work=None, archived=None, task_open=True):
|
||
self.work = work
|
||
self.archived = archived
|
||
self.task_open = task_open
|
||
self.statements: list = []
|
||
|
||
def execute(self, statement):
|
||
text = str(statement)
|
||
self.statements.append(text)
|
||
if "oa_work_completed" in text:
|
||
return _Reply(self.archived)
|
||
if "oa_task" in text:
|
||
return _Reply("t-1" if self.task_open else None)
|
||
return _Reply(self.work)
|
||
|
||
|
||
def _running(job="FYBX0001", activity="a-dept", status="running"):
|
||
"""假库里那一行还在跑的单据:只带 _moved_of 要读的那三列。"""
|
||
return type("Row", (), {"job": job, "status": status, "activity": activity})()
|
||
|
||
|
||
def _trip(**over):
|
||
"""一趟挂在单据上的会话,默认"打开时看的是 a-dept 那一环、手上那条待办叫 t-1"。"""
|
||
args = dict(prekey="PRE-MOVED-1", source=SOURCE, person=PERSON, field=FIELD,
|
||
work="w-1", job="FYBX0001", activity="a-dept", task="t-1")
|
||
args.update(over)
|
||
return models.EmbedSession(**args)
|
||
|
||
|
||
def pure_checks() -> None:
|
||
"""判据本身。这一整段不碰数据库 —— MySQL 不可达的机器跑的就是它。"""
|
||
print("--- 判据(不连库)")
|
||
check("1 一切还在原地 → 没动", verdict() is False, verdict())
|
||
check("2 单据走去别的环节 → 动了", verdict(now_activity="a-finance"))
|
||
check("3 那条待办不挂着了 → 动了", verdict(task_open=False))
|
||
check("4 单据已办结 → 动了", verdict(now_status="completed"))
|
||
check("4 单据已终止 → 动了", verdict(now_status="terminated"))
|
||
check("4 单据已作废 → 动了", verdict(now_status="canceled"))
|
||
check("5 这张单两张表里都没有了 → 动了", verdict(now_status=""))
|
||
# 6 与 8 是同一种坏法的两面:手上没有可比的东西时,"查不到"不等于"已经动了"。那种趟
|
||
# (停在开始环节、第三方接管开始环节建的那一单,见 engine.start 的 hold_at_begin,以及
|
||
# 回看一张早就办结的单)压根没有待办可查,一问就永远是"不在了"
|
||
check("6 开始环节那趟本来没待办:不许误判成动了",
|
||
verdict(snapshot_task="", task_open=False) is False,
|
||
verdict(snapshot_task="", task_open=False))
|
||
check("6 同一档,环节一走就真的动了", verdict(snapshot_task="", now_activity="a-finance"))
|
||
check("8 回看一张早就办结的单(环节与待办都没快照)→ 没动",
|
||
verdict(snapshot_activity="", snapshot_task="", now_status="",
|
||
task_open=None) is False,
|
||
verdict(snapshot_activity="", snapshot_task="", now_status="", task_open=None))
|
||
check("7 并行逗号串里认得出自己那一环",
|
||
verdict(snapshot_activity="a-b", now_activity="a-b,a-c") is False,
|
||
verdict(snapshot_activity="a-b", now_activity="a-b,a-c"))
|
||
check("7 并行逗号串里没有自己那一环 → 动了",
|
||
verdict(snapshot_activity="a-b", now_activity="a-c,a-d"))
|
||
check("待办被办掉而环节没变 → 仍算动了(第三方服务端代点就是这一种)",
|
||
verdict(snapshot_activity="a-dept", task_open=False))
|
||
|
||
# --- 现场那四个键的内容:假库按表名回话,同样不连库 ---
|
||
moved, state = _moved_of(_FakeDb(work=_running()), _trip())
|
||
same("1 现场说的就是此刻:job / activity / status / task_open 四格齐全且都是此刻的值",
|
||
(moved, state and state.model_dump()),
|
||
(False, {"job": "FYBX0001", "activity": "a-dept", "status": "running",
|
||
"task_open": True}))
|
||
moved, state = _moved_of(_FakeDb(work=_running()), _trip(task=""))
|
||
same("会话没带待办号时 task_open 是 null,不猜一个 false",
|
||
(moved, state and state.task_open), (False, None))
|
||
moved, state = _moved_of(_FakeDb(work=_running(activity="a-finance")), _trip())
|
||
same("2 环节走了:说得出动了,也说得出走去哪一环",
|
||
(moved, state and state.activity), (True, "a-finance"))
|
||
moved, state = _moved_of(_FakeDb(work=_running(), task_open=False), _trip())
|
||
same("3 待办没了:动了,且 task_open=false",
|
||
(moved, state and state.task_open), (True, False))
|
||
# 归档那一行还在、运行那一行没了 = 这张单落定了。状态要照念,只报一个空串说不出为什么
|
||
moved, state = _moved_of(_FakeDb(archived="completed"), _trip())
|
||
same("4 单已归档:动了,state.status 念得出 completed(activity 是空串,归档行没这一列)",
|
||
(moved, state and (state.status, state.activity)), (True, ("completed", "")))
|
||
moved, state = _moved_of(_FakeDb(), _trip())
|
||
same("5 两张表里都没有:动了,state.status=gone",
|
||
(moved, state and state.status), (True, "gone"))
|
||
# 会话上的主键查不到(办结得飞快、归档行又被删)时按单号再问一次,别说成 gone
|
||
moved, state = _moved_of(_FakeDb(archived="terminated"), _trip(work="没有这个主键"))
|
||
same("5 主键查不到时按单号再问归档表,终止就说终止",
|
||
(moved, state and state.status), (True, "terminated"))
|
||
# 快照是空的那一趟挂在一张不存在的单上:判据要说"没动",不是硬写 True
|
||
moved, state = _moved_of(_FakeDb(), _trip(activity="", task=""))
|
||
same("8 快照为空 + 单没了 → 没动(这里判据没被绕过去)",
|
||
(moved, state and state.status), (False, "gone"))
|
||
# 认不出那一趟、以及那一趟压根没挂在单据上:都不碰库就答"没动 + 现场留空"。传进去的库
|
||
# 是 None —— 判据只要敢碰一下就当场崩,等于顺手钉死了"不碰库"
|
||
same("9 认不出那一趟 → 说没动、现场留空", _moved_of(None, None), (False, None))
|
||
same("11 发起页那些还没变成单的趟 → 这一句答不出,算没动",
|
||
_moved_of(None, _trip(work="", job="", activity="", task="")), (False, None))
|
||
|
||
# --- 那条读路真的便宜吗:一句问话最多两条语句 ---
|
||
full = _FakeDb(work=_running())
|
||
_moved_of(full, _trip())
|
||
same("12 挂在待办上的一趟:一句问话两条按主键的读(单据 + 待办),不多不少",
|
||
len(full.statements), 2)
|
||
plain = _FakeDb(work=_running())
|
||
_moved_of(plain, _trip(task=""))
|
||
same("12 会话没带待办号时那一条待办语句根本不发", len(plain.statements), 1)
|
||
gone_db = _FakeDb()
|
||
_moved_of(gone_db, _trip())
|
||
same("12 单没了那一档不再追问待办(判据已定,何必多问一条)",
|
||
any("oa_task" in text for text in gone_db.statements), False)
|
||
|
||
|
||
def state_of(client, headers, prekey):
|
||
"""问一句,把 data 那一层原样交回来(HTTP 状态码塞进 _status 一起比)。"""
|
||
response = client.post("/api/v1/embed/state", headers=headers,
|
||
json={"code": SOURCE, "field": FIELD, "prekey": prekey})
|
||
body = dict((response.json() or {}).get("data") or {})
|
||
body["_status"] = response.status_code
|
||
return body
|
||
|
||
|
||
def counts(db):
|
||
"""这一趟专用的那本账:留痕条数与短码条数(与 check_embed_api.py 同一个口径)。"""
|
||
from sqlalchemy import func
|
||
|
||
logs = db.execute(select(func.count()).select_from(models.DataSourceLog)
|
||
.where(models.DataSourceLog.source == SOURCE)).scalar() or 0
|
||
tickets = db.execute(select(func.count()).select_from(models.EmbedTicket)
|
||
.where(models.EmbedTicket.source == SOURCE)).scalar() or 0
|
||
return int(logs), int(tickets)
|
||
|
||
|
||
def stamp_of(db, prekey):
|
||
"""这一趟自己的 update_time —— "有没有人动过这一行"最硬的一句证据。"""
|
||
return db.execute(select(models.EmbedSession.update_time)
|
||
.where(models.EmbedSession.prekey == prekey)).scalar()
|
||
|
||
|
||
def dml_during(call):
|
||
"""跑那一句的时候,引擎上到底发出去几条写语句(INSERT / UPDATE / DELETE)。
|
||
|
||
按语句数而不是按"台账里多没多一行"来算:留痕与短码那两张表只数得出一笔**已经 commit
|
||
的**写,而这一条要钉的是"轮询压根不该发写语句"——多一条没提交的 UPDATE 也一样把
|
||
oa_embed_session 那一行锁住,成串追问时正是它把提交那一头挡在锁外面。
|
||
|
||
只数这三张表的写:监听挂在共享 engine 上,同一进程里调度线程(发件箱投递、超时扫描)
|
||
随时可能在别的表上落一笔,把它们算进来会让这一句变成随机失败。这三张正是这一条接口
|
||
**有可能**动到的全部:会话行、打开留痕、免登短码。
|
||
"""
|
||
from sqlalchemy import event
|
||
|
||
from app.db import engine
|
||
|
||
tables = ("oa_embed_session", "oa_data_source_log", "oa_embed_ticket")
|
||
seen: list = []
|
||
|
||
def _note(_conn, _cursor, statement, _params, _context, _executemany):
|
||
text = str(statement)
|
||
head = text.lstrip()[:8].upper()
|
||
if head.startswith(("INSERT", "UPDATE", "DELETE")) and any(n in text for n in tables):
|
||
seen.append(text[:80])
|
||
|
||
event.listen(engine, "before_cursor_execute", _note)
|
||
try:
|
||
call()
|
||
finally:
|
||
event.remove(engine, "before_cursor_execute", _note)
|
||
return seen
|
||
|
||
|
||
class _NoRows:
|
||
"""一条什么都不查得到的库:每个口子都回 None,够把"认不出那一趟"那一路走到底。"""
|
||
|
||
def execute(self, statement):
|
||
return self
|
||
|
||
def scalars(self):
|
||
return self
|
||
|
||
def first(self):
|
||
return None
|
||
|
||
def scalar(self):
|
||
return None
|
||
|
||
|
||
class _Who:
|
||
"""够认趟用的一个人:接口那一路只读 person_id。"""
|
||
|
||
person_id = PERSON
|
||
is_admin = True
|
||
|
||
|
||
def route_checks() -> None:
|
||
"""第 9 句走真接口、**不碰库**:把 get_db 与 current_user 两个依赖换掉就够了。
|
||
|
||
生产上这一句是成串追问的轮询,预受理号过期、被人放弃、前端拿着上一趟的号重来一次,
|
||
都是"认不出那一趟"。那一路必须安静:200 加三句假话,不是一句异常——界面 catch 之后
|
||
只是"当没变",而 5xx 会把一次正常的轮询变成一次值得报警的失败。
|
||
"""
|
||
from app.db import get_db
|
||
from app.deps import current_user
|
||
|
||
# 安静一下:CSP 那位中间件自己开一条 SessionLocal 问可嵌入来源(不吃这里的依赖替换),
|
||
# 库不可达时它打一坨 traceback 才继续,看着像这一条挂了;httpx 那句访问日志同理
|
||
quiet = [logging.getLogger("app.service.embed"), logging.getLogger("httpx")]
|
||
saved_levels = [item.level for item in quiet]
|
||
for item in quiet:
|
||
item.setLevel(logging.CRITICAL)
|
||
|
||
saved = dict(app.dependency_overrides)
|
||
app.dependency_overrides[get_db] = lambda: _NoRows()
|
||
app.dependency_overrides[current_user] = lambda: _Who()
|
||
try:
|
||
client = TestClient(app, raise_server_exceptions=False)
|
||
# 令牌那一格只要过 current_user 那一道(已经换成假的),值本身不参与判定;写 ASCII
|
||
# 是因为 httpx 按 ASCII 编请求头,中文字在这里会当场炸
|
||
body = state_of(client, {"Authorization": "Bearer probe-token"}, "PRE-没这个号")
|
||
same("9 认不出那一趟(真路由、不碰库):200 + found=false + moved=false + state=null",
|
||
(body.get("_status"), body.get("found"), body.get("started"),
|
||
body.get("moved"), body.get("state")),
|
||
(200, False, None, False, None))
|
||
same("9 报文的键就是那四个,一个不多一个不少(started / found 一个都没动)",
|
||
sorted(body), ["_status", "found", "moved", "started", "state"])
|
||
finally:
|
||
for item, level in zip(quiet, saved_levels):
|
||
item.setLevel(level)
|
||
app.dependency_overrides.clear()
|
||
app.dependency_overrides.update(saved)
|
||
|
||
|
||
def db_checks(job):
|
||
"""要真表的那几条:走一次真接口,看报文,也看它是不是一行都没写。
|
||
|
||
这里不跑真流程 —— 这一条要钉的是"读出来的那份现场对不对、读的时候动没动手",与流转无
|
||
关,所以摆一张假单、一条真待办、一趟真会话就够,跑完连自己造的一起删干净。
|
||
"""
|
||
print("--- 真表(要一个连得上的库)")
|
||
db = SessionLocal()
|
||
try:
|
||
db.execute(select(models.User.id).limit(1))
|
||
except Exception as exc:
|
||
line = (str(exc).splitlines() or [type(exc).__name__])[0][:110]
|
||
print("[跳过] 库连不上(" + type(exc).__name__ + ":" + line + ")")
|
||
print(" 真表那九条本轮未跑;连上 MySQL 后原样再跑一次即可。判据那一段照算")
|
||
db.close()
|
||
return
|
||
try:
|
||
row = models.DataSource(code=SOURCE, name="嵌页面第二句校验源", kind="fetch",
|
||
provider="embed", url="https://erp.invalid/approve?no={arg.no}",
|
||
page_mode="ticket", auth_secret="check-embed-moved-key")
|
||
work = models.Work(job=job, serial=job, title="嵌页面第二句校验单 " + job,
|
||
process="p-check-embed-moved", process_name="嵌页面第二句校验",
|
||
status="running", activity="a-dept", activity_name="部门审批",
|
||
creator=PERSON, creator_person="校验", creator_identity="admin")
|
||
db.add_all([row, work])
|
||
db.flush()
|
||
task = models.Task(job=job, work=work.id, title=work.title, status="pending",
|
||
process=work.process, process_name=work.process_name,
|
||
activity="a-dept", activity_name="部门审批", person=PERSON,
|
||
identity="admin", identity_name="校验")
|
||
db.add(task)
|
||
db.flush()
|
||
session = embed_session.open_session(
|
||
db, row=row, field_key=FIELD,
|
||
field={"key": FIELD, "embed": {"actions": {"enabled": True, "allow": ["decide"]}}},
|
||
person=PERSON, work=work.id, job=job, activity="a-dept", task=task)[0]
|
||
db.commit()
|
||
prekey = str(session.prekey)
|
||
client = TestClient(app, raise_server_exceptions=False)
|
||
headers = {"Authorization": "Bearer " + create_access_token(PERSON)[0]}
|
||
|
||
# 会话就挂在这张单上:"成单了没"那一句问不出来(这正是改之前那一屏什么都没有的时
|
||
# 刻),而第二句答得出话。两句互不顶替 —— 这一条就是这次改动存在的全部理由
|
||
first = state_of(client, headers, prekey)
|
||
same("10 挂在单据上的那一趟:started 照旧是空的,moved 与 state 答得出话",
|
||
(first.get("_status"), first.get("found"), first.get("started"), first.get("moved")),
|
||
(200, True, None, False))
|
||
same("10 现场念的是真表里的此刻:环节、状态、那条待办都还在原地",
|
||
first.get("state"), {"job": job, "activity": "a-dept",
|
||
"status": "running", "task_open": True})
|
||
|
||
# 对面那一刀落下来:引擎把待办整行删掉(_complete_task),单还停在这一环。这正是生
|
||
# 产上等的那一秒 —— 第三方服务端替人办完,OA 这一屏当场听得见
|
||
db.execute(delete(models.Task).where(models.Task.id == task.id))
|
||
db.commit()
|
||
after = state_of(client, headers, prekey)
|
||
same("3 第三方服务端把这条待办办掉之后,这一句当场答得出动了",
|
||
(after.get("moved"), (after.get("state") or {}).get("task_open")), (True, False))
|
||
|
||
# 单整个没了:连行带号从运行表里抹掉(delete_unstarted 那一路)。快照还在,所以判据
|
||
# 该说动了;现场也念得出"这张单不在了",而不只是一个空串
|
||
db.execute(delete(models.Work).where(models.Work.id == work.id))
|
||
db.commit()
|
||
gone = state_of(client, headers, prekey)
|
||
same("5 那张单整个不在了:动了,现场念得出 gone",
|
||
(gone.get("moved"), (gone.get("state") or {}).get("status")), (True, "gone"))
|
||
|
||
# 回看那一屏:另一趟挂在一张不存在的单上,而会话上环节与待办都是空的 —— 没有可比的
|
||
# 东西就不许说动了,否则那一屏每切回来一次白刷一次整屏
|
||
back = embed_session.open_session(
|
||
db, row=row, field_key=FIELD, field={"key": FIELD, "embed": {}},
|
||
person=PERSON, work="w-没了", job=job, activity="", task=None)[0]
|
||
db.commit()
|
||
again = state_of(client, headers, str(back.prekey))
|
||
same("8 快照是空的(回看一屏)而单又没了 → 说没动,不许白刷",
|
||
(again.get("found"), again.get("moved")), (True, False))
|
||
|
||
# 认不出那一趟:found 与 moved 一起 false、state 留空,而且不抛异常(还是 200)
|
||
ghost = state_of(client, headers, "PRE-没这个号")
|
||
same("9 号认不出来:found=false、moved=false、state=null,200 不抛异常",
|
||
(ghost.get("_status"), ghost.get("found"), ghost.get("moved"), ghost.get("state")),
|
||
(200, False, False, None))
|
||
|
||
# 一行都不写:留痕、短码,连这一趟自己的 update_time 都不许挪
|
||
db.expire_all()
|
||
base, seen = counts(db), stamp_of(db, prekey)
|
||
writes = dml_during(lambda: [state_of(client, headers, prekey) for _ in range(5)])
|
||
db.expire_all()
|
||
same("12 连问五句:引擎上一条写语句都没发(INSERT/UPDATE/DELETE 全零)", writes, [])
|
||
same("12 连问五句:不发短码、不记打开留痕", counts(db), base)
|
||
same("12 连问五句:连这一趟自己的 update_time 都没挪(真的一行都不写)",
|
||
stamp_of(db, prekey), seen)
|
||
except OperationalError as exc:
|
||
line = (str(exc).splitlines() or ["库断了"])[0][:110]
|
||
print("[跳过] 跑到一半库断了(" + line + "),这一段以判据那半为准")
|
||
finally:
|
||
purge(db, job)
|
||
db.close()
|
||
|
||
|
||
def purge(db, job):
|
||
"""删掉自己造的那几张行:按这一趟专用的编码与单号删,别人的会话一条不碰。"""
|
||
for model in (models.Task, models.Work, models.WorkCompleted):
|
||
db.execute(delete(model).where(model.job == job))
|
||
db.execute(delete(models.EmbedSession).where(models.EmbedSession.source == SOURCE))
|
||
db.execute(delete(models.EmbedTicket).where(models.EmbedTicket.source == SOURCE))
|
||
db.execute(delete(models.DataSourceLog).where(models.DataSourceLog.source == SOURCE))
|
||
db.execute(delete(models.DataSource).where(models.DataSource.code == SOURCE))
|
||
db.commit()
|
||
|
||
|
||
def main() -> int:
|
||
pure_checks()
|
||
route_checks()
|
||
db_checks("MOVED" + datetime.now().strftime("%m%d%H%M%S"))
|
||
for line in FAILS:
|
||
print("[FAIL] " + line)
|
||
if FAILS:
|
||
print("共 " + str(len(FAILS)) + " 条不对")
|
||
return 1
|
||
print("通过:那一屏第二句判得准、读得便宜,问一句一行都不写(" + str(PASSED) + " 项)")
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|