dachui/live-hub-py
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(account): S2 读写一次切换 —— CK/健康/重登彻底搬到账号，登录记录退化为历史

Browse Source 
S1 加好了列，本提交把**读与写一起切**过去。这是设计里「同一份数据的读与写必须
在同一个提交里切」的要求：先切读或先切写都会出现「写账号、读记录」的中间态，
跑起来不报错，只是默默用错数据。

## 核心改动

**判定「谁有 CK」不再借道登录记录**
- `cookie_holding_filter()` / `cookie_operable_filter()` / `cookie_holding_account_ids_query()`
  / `visible_douyu_task_accounts()` 全部改为作用于 `Account`；
- `cookie_operable_filter()` 的「在途排除」仍查 `login_tasks`（那是**某次尝试**的属性），
  用 `NOT EXISTS` 子查询 + 迁移 0042 新增的 `(account_id, attempt_status)` 索引；
- 删除死代码 `latest_cookie_login_task()`；`latest_cookie()` 改为直接读账号。

**CK 写入**
- `_write_login_success()` 写 `Account.cookie / cookie_updated_at / cookie_source`；
- `_mark_attempt_failed()` 改看**账号**有没有 CK（决定是否沿用旧的失败语义）；
- 检测模式的 `task.cookie = ""` **不再清空账号的 CK**（见下「行为变更」）。

**自动化作业按账号调度**
- `ck_health`：`_select_tasks` → `_select_accounts`，`db.query(Account)`；新增
  `count_remaining()`（刻意不带 LIMIT，否则积压数恒等于批次上限）；
- `ck_relogin`：同样按账号选行；结算改为「账号 + 本轮尝试记录」，
  退避进度写账号；`settle_fresh_results(batch_id)` 按 `attempt_batch_id` 配对，
  `run_ck_relogin` 把 **account_ids** 交给 runner；
- 顺带让**没有任何登录历史的账号**也能被巡检/重登（以前它们永远进不了队列）。

**登录批次**
- `LoginBatchRunner` 去掉 `relogin_task_ids`，重登与登录统一走 `account_ids`；
- 批次行复用逻辑重写：只保证「同一账号不并发两行」，不再关心「哪一行持有 CK」。
  失败行复用同时看 `attempt_status`（账号有 CK 时 `_mark_attempt_failed` 刻意不动
  `status`，只看 status 会永远命不中 → 每次失败刷一行）。

**删除护栏语义变更（用户可感知）**
- 去掉「持有 CK 的记录不可删」——CK 在账号上，删历史不再影响登录态，历史终于可清理；
- **保留**「在途尝试不可删」（批次线程正拿着那条记录）。

## 行为变更（需评审）

1. **账号检测不再清空 CK**。旧代码在 check 模式写 `task.cookie = ""`，而那时记录的
   cookie 就是账号唯一凭证 —— 一次「批量检测」会把账号登录态删掉。解耦后
   「检测账号凭据」与「CK 是否有效」本就是两件事（后者归 `ck_health` 判），
   继续清空等于凭空制造不可逆的数据丢失（重登当前成功率极低）。
2. **Cookie 页的记录单位从「登录记录」变成「账号」**，所有接口的 id 入参/出参
   变成 `account_id`；`DELETE /cookies/{id}` 清的是该账号的 CK，**必写审计**。
3. 重复检测从「同一账号多行持 CK」改为「**同一个 CK 出现在多个账号上**」——
   后者才是真风险（两个账号共用一个登录态）。用 sha256 指纹分组：
   CK 是 AES-GCM + 随机 nonce 加密，**同一明文每次密文都不同**，比密文永远比不出重复。

## 修掉一个真实并发缺陷

`_write_login_success` 原先被传入 `self.db`（runner 主会话），而它是在**工作线程**里
用 `worker_db` 执行的。`emit()` 会往 `account_events` 插一行，其 `account_id` 外键对
`accounts` 那一行加**共享锁**；这把锁加在另一个会话上，紧接着本会话的
`UPDATE accounts SET cookie=...` 就被自己人挡住 —— 实测 **50 秒后
`Lock wait timeout exceeded`，登录明明成功却写不回 CK**（改造前 UPDATE 打在
`login_tasks` 上所以没撞上）。改为传 `worker_db`：事件本就该和状态变更同事务提交，
顺带修掉跨线程共用一个 Session 的隐患。

## 验证

- 全量 pytest **368 passed / 6 skipped**；迁移链 3 passed；
- 前端 `tsc -b && vite build` 通过；
- `ruff check` / `ruff format --check` 全绿（顺带修掉 main 上遗留的 F821）；
- 新增/改写的关键回归：**删掉全部登录历史后账号的 CK 与健康状态仍在**、
  **无登录历史的账号也能进巡检队列**、结算不碰 CK、删除护栏改为在途语义。

仍未做（设计里排期的后续阶段）：`account_lifecycle` 状态收口（S3）、事件发射点补齐（S4）、
业务事实直发事件（S5）、账号页重构（S6）。注意 `status` 目前只有模型默认值与迁移回填，
所以 `disabled/archived` 还没有任何写入方——S3 落地时要把自动化选行的状态过滤一起补上。
This commit is contained in:
yml2213
2026-10-04 14:10:13 +08:00
parent e916a7015d
commit 00125fbfc4
26 changed files with 1380 additions and 1068 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_automation_ck_health.py
+160 -58
View File
@@ -5,9 +5,15 @@
1. **调度器行为**：只跑到点的、打开开关的作业；作业抛异常只记 failed，不能
把调度线程带崩；跑完排下一轮时间；已有配置不能被重启重置。
2. **本作业绝不改 CK**：P1a 的定位是「只检测、只标记」，所以巡检后
``cookie`` / ``status`` / ``message`` / ``attempt_*`` 必须一字未动 ——
**账号的** ``cookie`` / ``status`` / ``relogin_*`` 以及登录尝试历史的
``status`` / ``message`` / ``attempt_*`` 必须一字未动 ——
线上全靠这条保证「自动化上线了但人工流程照旧」，回归时一旦有人顺手写了
``status``，这里要立刻红。
``cookie`` 或 ``status``，这里要立刻红。
> CK 与健康/重登状态自 2026-10-04 起是 **``accounts`` 的列**
> （见 ``docs/设计-账号全生命周期.md`` §3.3）；``login_tasks`` 退化为纯登录
> 尝试历史，它的 ``cookie`` / ``ck_check_*`` / ``relogin_*`` 旧列留作回退、
> 新代码不再读写，测试也不许再往上面写值。
"""
from datetime import UTC, datetime, timedelta
@@ -48,7 +54,28 @@ class _Base:
def teardown_method(self):
self.session.close()
def make_account(self, name="acc", *, auto_managed=True, assigned_to=None):
def make_account(
self,
name="acc",
*,
cookie="acf_uid=1",
status="active",
auto_managed=True,
assigned_to=None,
ck_check_status="",
ck_check_result=None,
ck_checked_at=None,
relogin_attempts=0,
relogin_next_at=None,
relogin_last_error="",
relogin_failure_kind="",
):
"""建一个账号。**CK 与健康/重登状态都是账号自己的列。**
默认 ``cookie="acf_uid=1"``（与迁移前 ``make_task`` 的默认一致）：
巡检的候选口径是「账号有 CK」，所以不显式给 cookie
的账号本来就不该进队列 —— 要造这种账号就传 ``cookie=""``。
"""
account = Account(
username=name,
password="p",
@@ -56,71 +83,98 @@ class _Base:
email_password="ep",
assigned_to=assigned_to,
auto_managed=auto_managed,
cookie=cookie,
status=status,
ck_check_status=ck_check_status,
ck_check_result=ck_check_result,
ck_checked_at=ck_checked_at,
relogin_attempts=relogin_attempts,
relogin_next_at=relogin_next_at,
relogin_last_error=relogin_last_error,
relogin_failure_kind=relogin_failure_kind,
)
self.session.add(account)
self.session.commit()
return account
def make_task(
def make_attempt(
self,
account,
*,
cookie="acf_uid=1",
status="success",
message="",
attempt_status="",
ck_checked_at=None,
ck_check_status="",
attempt_message="",
attempt_batch_id="",
attempt_at=None,
):
task = LoginTask(
"""建一条登录尝试历史（``LoginTask`` 已退化为纯尝试流水）。
只写它保留下来的字段：``cookie`` / ``ck_check_*`` / ``relogin_*``
下一次发版就要 drop，测试再往上写值只会掩盖解耦没做干净。
"""
attempt = LoginTask(
batch_id="b1",
account_id=account.id,
created_by=self.admin.id,
status=status,
cookie=cookie,
message=message,
attempt_status=attempt_status,
ck_checked_at=ck_checked_at,
ck_check_status=ck_check_status,
attempt_message=attempt_message,
attempt_batch_id=attempt_batch_id,
attempt_at=attempt_at,
)
self.session.add(task)
self.session.add(attempt)
self.session.commit()
return task
return attempt
class TestCkHealthSelection(_Base):
def _selected_ids(self, job):
"""返回被选中**账号**的 id（解耦后按账号选行，不再按登录记录选）。"""
return [
t.id for t in ck_health._select_tasks(self.session, job, datetime.now(UTC))
a.id
for a in ck_health._select_accounts(self.session, job, datetime.now(UTC))
]
def test_picks_only_rows_that_still_hold_cookie(self):
def test_picks_only_accounts_that_still_hold_cookie(self):
job = self._job()
with_cookie = self.make_task(self.make_account("a"))
self.make_task(self.make_account("b"), cookie="")
with_cookie = self.make_account("a")
self.make_account("b", cookie="")
assert self._selected_ids(job) == [with_cookie.id]
def test_skips_accounts_with_inflight_attempt(self):
job = self._job()
idle = self.make_task(self.make_account("a"))
self.make_task(self.make_account("b"), attempt_status="running")
self.make_task(self.make_account("c"), attempt_status="pending")
idle = self.make_account("a")
running = self.make_account("b")
self.make_attempt(running, attempt_status="running")
pending = self.make_account("c")
self.make_attempt(pending, attempt_status="pending")
assert self._selected_ids(job) == [idle.id]
def test_skips_accounts_opted_out_of_automation(self):
job = self._job()
managed = self.make_task(self.make_account("a"))
self.make_task(self.make_account("b", auto_managed=False))
managed = self.make_account("a")
self.make_account("b", auto_managed=False)
assert self._selected_ids(job) == [managed.id]
def test_account_without_login_history_is_selectable(self):
"""回归：解耦前选行是 ``LoginTask JOIN Account``，从没登录过的账号永远进不了队列。
CK 现在挂在账号上，选行只按账号判定 —— 没有尝试历史的账号也必须被巡检。
"""
job = self._job()
account = self.make_account("only-account")
assert self.session.query(LoginTask).count() == 0
assert self._selected_ids(job) == [account.id]
def test_respects_interval_and_prefers_stalest(self):
job = self._job()
fresh = self.make_task(
self.make_account("fresh"), ck_checked_at=datetime.now(UTC)
fresh = self.make_account("fresh", ck_checked_at=datetime.now(UTC))
stale = self.make_account(
"stale", ck_checked_at=datetime.now(UTC) - timedelta(hours=30)
)
stale = self.make_task(
self.make_account("stale"),
ck_checked_at=datetime.now(UTC) - timedelta(hours=30),
)
never = self.make_task(self.make_account("never"), ck_checked_at=None)
never = self.make_account("never", ck_checked_at=None)
ids = self._selected_ids(job)
assert fresh.id not in ids
# 从没检测过的排最前，其次是久未检测的
@@ -147,7 +201,7 @@ class TestCkHealthSelection(_Base):
job = self._job()
job.batch_size = 2
for index in range(5):
self.make_task(self.make_account(f"a{index}"))
self.make_account(f"a{index}")
assert len(self._selected_ids(job)) == 2
def _job(self):
@@ -159,9 +213,40 @@ class TestCkHealthSelection(_Base):
class TestCkHealthNeverTouchesCookie(_Base):
def test_patrol_only_writes_check_fields(self):
job = self._job()
account = self.make_account("acc")
task = self.make_task(account, attempt_status="failed", ck_check_status="")
before = (task.cookie, task.status, task.message, task.attempt_status)
# 账号自带 CK、生命周期状态与重登进度；巡检只许动 ck_check_* 三件套。
account = self.make_account(
"acc",
cookie="acf_uid=1",
status="active",
relogin_attempts=2,
relogin_next_at=datetime.now(UTC) + timedelta(hours=1),
relogin_last_error="上次登录失败",
relogin_failure_kind="network",
)
attempt = self.make_attempt(
account,
status="success",
message="历史登录结果",
attempt_status="failed",
attempt_message="历史失败",
attempt_batch_id="b0",
)
before = (
account.cookie,
account.status,
account.relogin_attempts,
account.relogin_next_at,
account.relogin_last_error,
account.relogin_failure_kind,
)
before_attempt = (
attempt.status,
attempt.message,
attempt.attempt_status,
attempt.attempt_message,
attempt.attempt_batch_id,
attempt.attempt_at,
)
ck_health.check_douyu_cookie = _fake_check(valid=True)
try:
@@ -169,17 +254,34 @@ class TestCkHealthNeverTouchesCookie(_Base):
finally:
ck_health.check_douyu_cookie = _REAL_CHECK
self.session.refresh(task)
self.session.refresh(account)
self.session.refresh(attempt)
assert counters["scanned"] == 1 and counters["valid"] == 1
assert task.ck_check_status == "valid"
assert task.ck_checked_at is not None
assert task.ck_check_result["nickname"] == "测试"
# 核心断言：CK 本体与尝试状态一字未动
assert (task.cookie, task.status, task.message, task.attempt_status) == before
assert account.ck_check_status == "valid"
assert account.ck_checked_at is not None
assert account.ck_check_result["nickname"] == "测试"
# 核心断言：账号的 CK 本体、生命周期状态、重登进度一字未动
assert (
account.cookie,
account.status,
account.relogin_attempts,
account.relogin_next_at,
account.relogin_last_error,
account.relogin_failure_kind,
) == before
# 登录尝试历史同样不是巡检该碰的东西
assert (
attempt.status,
attempt.message,
attempt.attempt_status,
attempt.attempt_message,
attempt.attempt_batch_id,
attempt.attempt_at,
) == before_attempt
def test_invalid_result_marks_invalid_but_keeps_cookie(self):
job = self._job()
task = self.make_task(self.make_account("acc"))
account = self.make_account("acc", cookie="acf_uid=1")
# 必须是鉴权类失败（斗鱼说未登录）才会被标成 invalid
ck_health.check_douyu_cookie = _fake_check(
valid=False,
@@ -189,29 +291,29 @@ class TestCkHealthNeverTouchesCookie(_Base):
counters = ck_health.run_ck_health(self.session, job)
finally:
ck_health.check_douyu_cookie = _REAL_CHECK
self.session.refresh(task)
self.session.refresh(account)
assert counters["invalid"] == 1
assert task.ck_check_status == "invalid"
assert task.cookie == "acf_uid=1"
assert account.ck_check_status == "invalid"
assert account.cookie == "acf_uid=1"
def test_detection_exception_does_not_abort_round(self):
"""单个账号检测抛异常不影响整轮，但也不能把它标成失效。"""
job = self._job()
first = self.make_task(self.make_account("a"), ck_check_status="valid")
second = self.make_task(self.make_account("b"), ck_check_status="valid")
first = self.make_account("a", ck_check_status="valid")
second = self.make_account("b", ck_check_status="valid")
ck_health.check_douyu_cookie = _fake_check(raises=True)
try:
counters = ck_health.run_ck_health(self.session, job)
finally:
ck_health.check_douyu_cookie = _REAL_CHECK
assert counters["scanned"] == 2
# 查不到不等于失效：两行都保留原结论，只记录这次异常
# 查不到不等于失效：两个账号都保留原结论，只记录这次异常
assert counters["invalid"] == 0
assert counters["skipped"] == 2
for task in (first, second):
self.session.refresh(task)
assert task.ck_check_status == "valid"
assert task.ck_check_result["verdict"] == "error"
for account in (first, second):
self.session.refresh(account)
assert account.ck_check_status == "valid"
assert account.ck_check_result["verdict"] == "error"
def _job(self):
return AutomationJob(
@@ -448,7 +550,7 @@ class TestAutomationApi(_Base):
def test_run_endpoint_records_run_and_audit(self):
api = self._api()
self.make_task(self.make_account("a"))
self.make_account("a")
ck_health.check_douyu_cookie = _fake_check(valid=True)
try:
outcome = api.run_job(
@@ -528,7 +630,7 @@ class TestFailureClassification(_Base):
def test_error_keeps_previous_verdict_but_marks_checked(self):
job = self._job()
task = self.make_task(self.make_account("acc"), ck_check_status="valid")
account = self.make_account("acc", ck_check_status="valid")
ck_health.check_douyu_cookie = _fake_check(
valid=False, message="请求失败: timeout"
)
@@ -536,19 +638,19 @@ class TestFailureClassification(_Base):
counters = ck_health.run_ck_health(self.session, job)
finally:
ck_health.check_douyu_cookie = _REAL_CHECK
self.session.refresh(task)
self.session.refresh(account)
assert counters["valid"] == 0 and counters["invalid"] == 0
assert counters["skipped"] == 1 # error 计入 skipped
assert task.ck_check_status == "valid" # 原结论保留
assert task.ck_check_result["verdict"] == "error" # 但记录了这次查不到
assert task.ck_checked_at is not None
assert account.ck_check_status == "valid" # 原结论保留
assert account.ck_check_result["verdict"] == "error" # 但记录了这次查不到
assert account.ck_checked_at is not None
def test_mass_network_failure_pauses_the_job(self):
job = self._job()
job.enabled = True
job.batch_size = 40
for index in range(40):
self.make_task(self.make_account(f"a{index}"))
self.make_account(f"a{index}")
ck_health.check_douyu_cookie = _fake_check(
valid=False, message="请求失败: Connection refused"
)
@@ -567,7 +669,7 @@ class TestFailureClassification(_Base):
job.enabled = True
job.batch_size = 40
for index in range(40):
self.make_task(self.make_account(f"a{index}"))
self.make_account(f"a{index}")
ck_health.check_douyu_cookie = _fake_check(
valid=False,
message="鱼丸接口: 账户登陆异常，请重新登陆；等级接口: 用户未登录",
tests/test_automation_ck_relogin.py
+195 -102
View File
@@ -10,6 +10,11 @@
结算逻辑（``settle_results``）与选行查询（``build_select_query``）都刻意抽成了
纯函数/可编译对象，这里不碰真实登录链路。
CK 解耦（2026-10-04）后，**选行与退避进度的单位是账号**：``ck_check_status`` 与
``relogin_*`` 都落到了 ``accounts`` 上，``login_tasks`` 退化为纯登录尝试历史
（本轮只读它的 ``attempt_status`` / ``attempt_message`` / ``attempt_batch_id``）。
所以这里建的是 Account；只有「在途」这类**某次尝试**的属性才补一条 LoginTask。
"""
from datetime import UTC, datetime, timedelta
@@ -37,43 +42,59 @@ class _Base:
def teardown_method(self):
self.session.close()
def make_task(
def make_account(
self,
name="acc",
*,
ck_check_status="invalid",
cookie="acf_uid=1",
attempt_status="",
attempt_message="",
relogin_attempts=0,
relogin_next_at=None,
relogin_failure_kind="",
relogin_last_error="",
auto_managed=True,
):
"""建一个账号 —— CK 与重登进度都是账号自己的属性。
``login_tasks`` 的 ``cookie`` / ``ck_check_*`` / ``relogin_*`` 旧列已不再被
新代码读写，这里也不往里写值：留作回退的列不该继续被测试固化。
"""
account = Account(
username=name,
password="p",
email=f"{name}@e.com",
email_password="ep",
auto_managed=auto_managed,
)
self.session.add(account)
self.session.commit()
task = LoginTask(
batch_id="b",
account_id=account.id,
created_by=self.admin.id,
status="success",
cookie=cookie,
ck_check_status=ck_check_status,
attempt_status=attempt_status,
attempt_message=attempt_message,
relogin_attempts=relogin_attempts,
relogin_next_at=relogin_next_at,
relogin_failure_kind=relogin_failure_kind,
relogin_last_error=relogin_last_error,
)
self.session.add(account)
self.session.commit()
return account
def make_attempt(
self,
account,
*,
attempt_status="",
attempt_message="",
attempt_batch_id="",
status="success",
):
"""建一条登录尝试历史（本轮重登的那条记录）。"""
task = LoginTask(
batch_id="b",
account_id=account.id,
created_by=self.admin.id,
status=status,
attempt_status=attempt_status,
attempt_message=attempt_message,
attempt_batch_id=attempt_batch_id,
)
self.session.add(task)
self.session.commit()
return task
@@ -155,61 +176,68 @@ class TestBackoff(_Base):
class TestSelection(_Base):
"""选行：``build_select_query`` 现在按**账号**返回，断言取 ``account.id``。"""
def _ids(self, job):
now = datetime.now(UTC)
return [
t.id
for t in ck_relogin.build_select_query(
account.id
for account in ck_relogin.build_select_query(
self.session, job, now, max_attempts=2
).all()
]
def test_picks_invalid_with_expired_backoff(self):
job = self.job()
ready = self.make_task("ready")
ready = self.make_account("ready")
assert self._ids(job) == [ready.id]
def test_skips_valid_and_empty_cookie_and_opted_out(self):
job = self.job()
keep = self.make_task("keep")
self.make_task("valid", ck_check_status="valid")
self.make_task("nocookie", cookie="")
self.make_task("optedout", auto_managed=False)
keep = self.make_account("keep")
self.make_account("valid", ck_check_status="valid")
self.make_account("nocookie", cookie="")
self.make_account("optedout", auto_managed=False)
assert self._ids(job) == [keep.id]
def test_skips_inflight_attempt(self):
"""「在途」是某次尝试的属性，仍然要靠 login_tasks 表达。"""
job = self.job()
keep = self.make_task("keep")
self.make_task("running", attempt_status="running")
self.make_task("pending", attempt_status="pending")
keep = self.make_account("keep")
running = self.make_account("running")
self.make_attempt(running, attempt_status="running")
pending = self.make_account("pending")
self.make_attempt(pending, attempt_status="pending")
assert self._ids(job) == [keep.id]
def test_respects_backoff_window(self):
job = self.job()
due = self.make_task(
due = self.make_account(
"due", relogin_next_at=datetime.now(UTC) - timedelta(minutes=1)
)
self.make_task("later", relogin_next_at=datetime.now(UTC) + timedelta(hours=3))
self.make_account(
"later", relogin_next_at=datetime.now(UTC) + timedelta(hours=3)
)
assert self._ids(job) == [due.id]
def test_skips_when_attempts_exhausted(self):
job = self.job()
keep = self.make_task("keep")
self.make_task("exhausted", relogin_attempts=2)
keep = self.make_account("keep")
self.make_account("exhausted", relogin_attempts=2)
assert self._ids(job) == [keep.id]
def test_never_retries_manual_kinds(self):
"""已判定极验/凭证问题的账号，绝不能再次自动重登。"""
job = self.job()
keep = self.make_task("keep")
self.make_task("captcha", relogin_failure_kind="captcha")
self.make_task("credential", relogin_failure_kind="credential")
keep = self.make_account("keep")
self.make_account("captcha", relogin_failure_kind="captcha")
self.make_account("credential", relogin_failure_kind="credential")
assert self._ids(job) == [keep.id]
def test_retryable_kinds_stay_eligible(self):
job = self.job()
code = self.make_task("code", relogin_failure_kind="email_code")
net = self.make_task("net", relogin_failure_kind="network")
code = self.make_account("code", relogin_failure_kind="email_code")
net = self.make_account("net", relogin_failure_kind="network")
assert sorted(self._ids(job)) == sorted([code.id, net.id])
def test_generated_sql_is_mysql_compatible(self):
@@ -224,20 +252,24 @@ class TestSelection(_Base):
def test_batch_size_caps_the_round(self):
job = self.job(batch_size=3)
for index in range(6):
self.make_task(f"a{index}")
self.make_account(f"a{index}")
assert len(self._ids(job)) == 3
class TestSettlement(_Base):
"""结算：成功清零；失败按分型决定重试还是转人工。"""
"""结算：成功清零；失败按分型决定重试还是转人工。
def _settle(self, tasks, *, max_attempts=2):
解耦后决策看「账号 + 本轮的尝试记录」：成败读 ``LoginTask.attempt_status``，
退避进度写**账号**的 ``relogin_*``。
"""
def _settle(self, pairs, *, max_attempts=2):
now = datetime.now(UTC)
fresh = {t.id: t for t in tasks}
fresh = {account.id: (account, task) for account, task in pairs}
counters = ck_relogin.settle_results(
self.session,
fresh,
[t.id for t in tasks],
[account.id for account, _ in pairs],
now=now,
max_attempts=max_attempts,
)
@@ -245,77 +277,85 @@ class TestSettlement(_Base):
return counters, now
def test_success_resets_state(self):
task = self.make_task(
account = self.make_account(
"ok",
attempt_status="success",
relogin_attempts=1,
relogin_failure_kind="email_code",
relogin_last_error="旧的报错",
relogin_next_at=datetime.now(UTC) + timedelta(hours=1),
)
counters, _ = self._settle([task])
self.session.refresh(task)
task = self.make_attempt(account, attempt_status="success")
counters, _ = self._settle([(account, task)])
self.session.refresh(account)
assert counters["valid"] == 1 and counters["invalid"] == 0
assert task.relogin_attempts == 0
assert task.relogin_next_at is None
assert task.relogin_failure_kind == ""
assert task.relogin_last_error == ""
assert account.relogin_attempts == 0
assert account.relogin_next_at is None
assert account.relogin_failure_kind == ""
assert account.relogin_last_error == ""
def test_retryable_failure_schedules_next_attempt(self):
task = self.make_task(
"retry",
account = self.make_account("retry")
task = self.make_attempt(
account,
attempt_status="failed",
attempt_message="等待验证码超时（旧 Cookie 已保留）",
)
counters, now = self._settle([task])
self.session.refresh(task)
counters, now = self._settle([(account, task)])
self.session.refresh(account)
assert counters["invalid"] == 1 and counters["retry"] == 1
assert task.relogin_failure_kind == "email_code"
assert task.relogin_attempts == 1
assert task.relogin_next_at is not None and task.relogin_next_at > now
assert "旧 Cookie" in task.relogin_last_error
assert account.relogin_failure_kind == "email_code"
assert account.relogin_attempts == 1
assert account.relogin_next_at is not None and account.relogin_next_at > now
assert "旧 Cookie" in account.relogin_last_error
def test_captcha_goes_to_manual_without_schedule(self):
task = self.make_task(
"cap", attempt_status="failed", attempt_message="极验验证失败: slide"
account = self.make_account("cap")
task = self.make_attempt(
account, attempt_status="failed", attempt_message="极验验证失败: slide"
)
counters, _ = self._settle([task])
self.session.refresh(task)
counters, _ = self._settle([(account, task)])
self.session.refresh(account)
assert counters["manual"] == 1 and counters["retry"] == 0
assert task.relogin_failure_kind == "captcha"
assert task.relogin_next_at is None # 不再自动排期
assert account.relogin_failure_kind == "captcha"
assert account.relogin_next_at is None # 不再自动排期
def test_quota_backs_off_to_next_day(self):
task = self.make_task(
"quota",
account = self.make_account("quota")
task = self.make_attempt(
account,
attempt_status="failed",
attempt_message="您的邮箱验证码发送次数已达上限，请改天再试！",
)
counters, now = self._settle([task])
self.session.refresh(task)
counters, now = self._settle([(account, task)])
self.session.refresh(account)
assert counters["email_quota"] == 1 and counters["retry"] == 1
assert task.relogin_next_at.date() == (now + timedelta(days=1)).date()
assert account.relogin_next_at.date() == (now + timedelta(days=1)).date()
def test_attempts_exhausted_stops_retrying(self):
task = self.make_task(
"used",
account = self.make_account("used", relogin_attempts=1)
task = self.make_attempt(
account,
attempt_status="failed",
attempt_message="等待验证码超时",
relogin_attempts=1,
)
counters, _ = self._settle([task], max_attempts=2)
self.session.refresh(task)
counters, _ = self._settle([(account, task)], max_attempts=2)
self.session.refresh(account)
assert counters["manual"] == 1 and counters["retry"] == 0
assert task.relogin_next_at is None
assert account.relogin_next_at is None
def test_settlement_never_touches_cookie(self):
task = self.make_task(
"keepck", attempt_status="failed", attempt_message="极验验证失败: slide"
"""结算只改账号的 ``relogin_*``，绝不碰账号持有的 CK。"""
account = self.make_account("keepck", cookie="acf_uid=1")
task = self.make_attempt(
account, attempt_status="failed", attempt_message="极验验证失败: slide"
)
before = (task.cookie, task.status)
self._settle([task])
self.session.refresh(task)
assert (task.cookie, task.status) == before
before = (account.cookie, account.status)
self._settle([(account, task)])
self.session.refresh(account)
assert (account.cookie, account.status) == before
assert account.cookie == "acf_uid=1"
# 顺带确认结算确实跑了：分型写上了，而 CK 仍原封不动。
assert account.relogin_failure_kind == "captcha"
class TestManualQueueApi(_Base):
@@ -327,56 +367,79 @@ class TestManualQueueApi(_Base):
return api.manual_queue(limit=20, db=self.session, current=self.admin)
def test_groups_manual_kinds_only(self):
captcha = self.make_task(
captcha = self.make_account(
"cap",
attempt_status="failed",
attempt_message="极验验证失败: slide",
relogin_failure_kind="captcha",
relogin_attempts=1,
relogin_last_error="极验验证失败: slide",
)
self.make_task(
self.make_attempt(
captcha, attempt_status="failed", attempt_message="极验验证失败: slide"
)
cred = self.make_account(
"cred",
attempt_status="failed",
attempt_message="账号缺少密码或邮箱",
relogin_failure_kind="credential",
relogin_attempts=1,
relogin_last_error="账号缺少密码或邮箱",
)
self.make_attempt(
cred, attempt_status="failed", attempt_message="账号缺少密码或邮箱"
)
# 可自动重试的不该出现在人工队列里
self.make_task(
retryable = self.make_account(
"retryable",
attempt_status="failed",
attempt_message="等待验证码超时",
relogin_failure_kind="email_code",
relogin_attempts=1,
relogin_next_at=datetime.now(UTC) + timedelta(hours=1),
relogin_last_error="等待验证码超时",
)
self.make_attempt(
retryable, attempt_status="failed", attempt_message="等待验证码超时"
)
payload = self._queue()
kinds = [group["kind"] for group in payload["groups"]]
assert sorted(kinds) == ["captcha", "credential"]
assert payload["total"] == 2
captcha_group = next(g for g in payload["groups"] if g["kind"] == "captcha")
assert captcha_group["count"] == 1
assert captcha_group["samples"][0]["task_id"] == captcha.id
assert captcha_group["samples"][0]["account_id"] == captcha.id
assert "极验" in captcha_group["label"]
def test_exhausted_retries_show_up_as_manual(self):
"""次数用尽的（next_run_at 已清空）也要冒出来，否则会静默卡住。"""
self.make_task(
used = self.make_account(
"used",
attempt_status="failed",
attempt_message="等待验证码超时",
relogin_failure_kind="email_code",
relogin_attempts=2,
relogin_next_at=None,
relogin_last_error="等待验证码超时",
)
self.make_attempt(
used, attempt_status="failed", attempt_message="等待验证码超时"
)
payload = self._queue()
assert payload["total"] == 1
assert "重试次数用尽" in payload["groups"][0]["label"]
def test_sample_last_error_comes_from_account(self):
"""样本里的 last_error 取账号的 ``relogin_last_error``，不回退到尝试文案。"""
account = self.make_account(
"cap",
relogin_failure_kind="captcha",
relogin_attempts=1,
relogin_last_error="账号侧记录的失败原因",
)
self.make_attempt(
account,
attempt_status="failed",
attempt_message="这是尝试记录里的文案，不该被当成账号的最后错误",
)
payload = self._queue()
assert payload["total"] == 1
assert (
payload["groups"][0]["samples"][0]["last_error"] == "账号侧记录的失败原因"
)
def test_empty_queue(self):
payload = self._queue()
assert payload["total"] == 0 and payload["groups"] == []
@@ -386,15 +449,16 @@ class TestLinkageWithHealthJob(_Base):
"""两个作业是上下游：jobs 接口要暴露「当前有多少条等着自动重登」。
页面靠这个数字把巡检 → 重登的关系显性化；没有它，两个开关看起来像互不相干。
解耦后 ``count_pending_relogin`` 按**账号**计数。
"""
def test_pending_relogin_counts_only_actionable_invalid(self):
from web.backend.routers import automation as api
ready = self.make_task("ready")
self.make_task("valid", ck_check_status="valid")
self.make_task("nocookie", cookie="")
self.make_task("optedout", auto_managed=False)
ready = self.make_account("ready")
self.make_account("valid", ck_check_status="valid")
self.make_account("nocookie", cookie="")
self.make_account("optedout", auto_managed=False)
payload = api.list_jobs(db=self.session, current=self.admin)
# 只有 ready 同时满足：invalid + 有 CK + 允许自动管理
@@ -412,7 +476,7 @@ class TestLinkageWithHealthJob(_Base):
from web.backend.routers import automation as api
for index in range(25):
self.make_task(f"acc{index}")
self.make_account(f"acc{index}")
payload = api.list_jobs(db=self.session, current=self.admin)
relogin = next(j for j in payload["jobs"] if j["key"] == ck_relogin.JOB_KEY)
assert relogin["batch_size"] == 10
@@ -428,10 +492,21 @@ class TestSettlementVisibility(_Base):
SQLite 的读一致性不同，这条在 SQLite 上复现不出来 —— 属于「测试跑在 SQLite
就漏掉」的典型，现在测试跑在 MySQL 上才守得住。
解耦后本轮记录靠 ``LoginTask.attempt_batch_id`` 找回，退避进度落在账号上。
"""
def test_settlement_sees_other_session_commit(self):
task = self.make_task("acc", attempt_status="pending")
account = self.make_account(
"acc",
relogin_attempts=1,
relogin_failure_kind="email_code",
relogin_last_error="上一次的失败",
relogin_next_at=datetime.now(UTC) + timedelta(hours=1),
)
task = self.make_attempt(
account, attempt_status="pending", attempt_batch_id="batch-visibility"
)
# 调用方会话先开事务（模拟调度器挑完候选后的状态）。
stale = make_test_session(self.engine)
@@ -455,20 +530,38 @@ class TestSettlementVisibility(_Base):
), "REPEATABLE READ 下同一事务读不到别人的提交，这正是当初踩的坑"
counters = ck_relogin.settle_fresh_results(
[task.id], now=datetime.now(UTC), max_attempts=2
"batch-visibility", now=datetime.now(UTC), max_attempts=2
)
self.session.expire_all()
assert counters["valid"] == 1 and counters["invalid"] == 0
assert self.session.get(LoginTask, task.id).relogin_failure_kind == ""
# 结算写在自己的事务里。这里必须再用**一个全新会话**读回：当前测试会话的
# 事务快照在上面读 ``task.id``（commit 后属性已过期，取用即触发刷新）时
# 就已经开了，复用它会看到结算前的旧值 —— 正是这条用例要守的坑。
checker = make_test_session(self.engine)
settled = checker.get(Account, account.id)
assert settled.relogin_failure_kind == ""
assert settled.relogin_attempts == 0
assert settled.relogin_next_at is None
checker.close()
stale.close()
def test_settlement_marks_real_success_as_valid(self):
"""结算看到 success 就必须清零退避，不能写成失败。"""
task = self.make_task("acc", attempt_status="success", relogin_attempts=1)
account = self.make_account(
"acc",
relogin_attempts=1,
relogin_failure_kind="email_code",
relogin_last_error="上一次的失败",
relogin_next_at=datetime.now(UTC) + timedelta(hours=1),
)
task = self.make_attempt(account, attempt_status="success")
now = datetime.now(UTC)
counters = ck_relogin.settle_results(
self.session, {task.id: task}, [task.id], now=now, max_attempts=2
self.session,
{account.id: (account, task)},
[account.id],
now=now,
max_attempts=2,
)
assert counters["valid"] == 1 and counters["invalid"] == 0
assert task.relogin_failure_kind == ""
assert task.relogin_next_at is None
assert account.relogin_failure_kind == ""
assert account.relogin_next_at is None
tests/test_cookie_custom_order.py
+31 -26
View File
@@ -1,8 +1,14 @@
"""回归：CK 列表按用户粘贴的账号名顺序排序，而不是按「最近拿到 CK 的时间」。
2026-10-04 CK 解耦后，列表单位从「登录记录」变成「账号」，排序键也跟着从
``login_tasks.finished_at`` 换成 ``accounts.cookie_updated_at``。
"""
from datetime import UTC, datetime, timedelta
from tests.support.db import get_test_engine, make_test_session
from web.backend.models import Account, LoginTask, User
from web.backend.routers.cookies import _order_cookie_tasks
from web.backend.models import Account, User
from web.backend.routers.cookies import _order_cookie_accounts
class TestCustomCookieOrder:
@@ -14,38 +20,37 @@ class TestCustomCookieOrder:
self.db.flush()
now = datetime.now(UTC)
accounts = {
name: Account(username=name, password="p", email="e", email_password="ep")
for name in ("account-a", "account-b", "account-c")
}
self.db.add_all(accounts.values())
self.db.flush()
# 完成时间特意与用户输入顺序相反。
self.accounts = {}
for index, name in enumerate(("account-a", "account-b", "account-c")):
self.db.add(
LoginTask(
batch_id=f"batch-{name}",
account_id=accounts[name].id,
status="success",
created_by=self.user.id,
finished_at=now + timedelta(minutes=index),
)
account = Account(
username=name,
password="p",
email="e",
email_password="ep",
cookie=f"ck-{name}",
# 拿到 CK 的时间特意与用户输入顺序相反。
cookie_updated_at=now + timedelta(minutes=index),
)
self.accounts[name] = account
self.db.add(account)
self.db.commit()
def teardown_method(self):
self.db.close()
def test_custom_cookie_order_follows_input_not_finished_time(self):
def test_custom_cookie_order_follows_input_not_updated_time(self):
selected_names = ["account-c", "account-a", "account-b"]
tasks = _order_cookie_tasks(
self.db.query(LoginTask)
.join(Account, LoginTask.account_id == Account.id)
.filter(Account.username.in_(selected_names)),
accounts = _order_cookie_accounts(
self.db.query(Account).filter(Account.username.in_(selected_names)),
selected_names,
).all()
account_names = {
account.id: account.username for account in self.db.query(Account).all()
}
assert [account_names[task.account_id] for task in tasks] == selected_names
assert [account.username for account in accounts] == selected_names
def test_default_order_is_most_recent_cookie_first(self):
accounts = _order_cookie_accounts(self.db.query(Account), []).all()
assert [account.username for account in accounts] == [
"account-c",
"account-b",
"account-a",
]
tests/test_cookie_operations.py
+97 -88
View File
@@ -1,3 +1,9 @@
"""CK 操作页的权限隔离、脱敏与重登入口。
2026-10-04 CK 解耦后本页面的**记录单位从「登录记录」变成「账号」**：
CK 与健康/重登进度都挂在 `accounts` 上，所有接口的 id 都是 account_id。
"""
from types import SimpleNamespace
from typing import cast
from unittest.mock import patch
@@ -34,47 +40,25 @@ class TestCookieOperation:
self.session.add_all([self.support, self.other_support])
self.session.commit()
owned = Account(
# CK 挂在账号上（2026-10-04 CK 解耦），所以「CK 记录」就是账号本身。
self.owned_account = Account(
username="owned-account",
password="owned-password",
email="owned@example.com",
email_password="mail-password",
assigned_to=self.support.id,
cookie="owned-secret",
)
other = Account(
self.other_account = Account(
username="other-account",
password="other-password",
email="other@example.com",
email_password="mail-password",
assigned_to=self.other_support.id,
cookie="other-secret",
)
self.session.add_all([owned, other])
self.session.add_all([self.owned_account, self.other_account])
self.session.commit()
self.session.add_all(
[
LoginTask(
batch_id="owned",
account_id=owned.id,
created_by=self.support.id,
status="success",
cookie="owned-secret",
),
LoginTask(
batch_id="other",
account_id=other.id,
created_by=self.other_support.id,
status="success",
cookie="other-secret",
),
]
)
self.session.commit()
self.owned_task = (
self.session.query(LoginTask).filter(LoginTask.batch_id == "owned").one()
)
self.other_task = (
self.session.query(LoginTask).filter(LoginTask.batch_id == "other").one()
)
def teardown_method(self):
self.session.close()
@@ -92,7 +76,7 @@ class TestCookieOperation:
assert result["total"] == 1
assert result["items"] == [
{
"id": self.owned_task.id,
"id": self.owned_account.id,
"account_username": "owned-account",
"tag": "",
"ck_check_status": "",
@@ -110,17 +94,13 @@ class TestCookieOperation:
with pytest.raises(Exception, match="cookie:view"):
list_cookies(db=self.session, current=self.support)
with pytest.raises(Exception, match="cookie:view"):
get_cookie(self.owned_task.id, db=self.session, current=self.support)
get_cookie(self.owned_account.id, db=self.session, current=self.support)
def test_cookie_list_filters_by_account_tag(self):
admin = User(username="admin", password_hash="hash", role="super_admin")
self.session.add(admin)
self.session.query(Account).filter(
Account.id == self.owned_task.account_id
).update({"tag": "A组"})
self.session.query(Account).filter(
Account.id == self.other_task.account_id
).update({"tag": "B组"})
self.owned_account.tag = "A组"
self.other_account.tag = "B组"
self.session.commit()
result = list_cookies(
@@ -136,15 +116,11 @@ class TestCookieOperation:
assert isinstance(result, dict)
assert result["total"] == 1
assert [item["id"] for item in result["items"]] == [self.owned_task.id]
assert [item["id"] for item in result["items"]] == [self.owned_account.id]
def test_support_operation_tag_filter_and_list_stay_scoped(self):
self.session.query(Account).filter(
Account.id == self.owned_task.account_id
).update({"tag": "我的标签"})
self.session.query(Account).filter(
Account.id == self.other_task.account_id
).update({"tag": "别人的标签"})
self.owned_account.tag = "我的标签"
self.other_account.tag = "别人的标签"
self.session.commit()
tags = list_cookie_operation_tags(db=self.session, current=self.support)
@@ -163,7 +139,7 @@ class TestCookieOperation:
@patch("web.backend.routers.cookies._check_one_cookie")
def test_support_can_check_only_assigned_cookie(self, check_one_cookie):
check_one_cookie.return_value = {
"id": self.owned_task.id,
"id": self.owned_account.id,
"valid": True,
"message": "有效",
"fish_ball": 9,
@@ -173,16 +149,17 @@ class TestCookieOperation:
}
result = check_cookie_operations(
ids=f"{self.owned_task.id},{self.other_task.id}",
ids=f"{self.owned_account.id},{self.other_account.id}",
db=self.session,
current=self.support,
)
assert [item["id"] for item in result["results"]] == [self.owned_task.id]
self.session.refresh(self.owned_task)
self.session.refresh(self.other_task)
assert self.owned_task.ck_check_status == "valid"
assert self.other_task.ck_check_status == ""
assert [item["id"] for item in result["results"]] == [self.owned_account.id]
self.session.refresh(self.owned_account)
self.session.refresh(self.other_account)
# 检测结论写在账号上，且只写了被授权的那一个
assert self.owned_account.ck_check_status == "valid"
assert self.other_account.ck_check_status == ""
def test_operation_permission_does_not_allow_unrelated_users(self):
no_permission_user = SimpleNamespace(
@@ -201,9 +178,10 @@ class TestCookieOperation:
current=cast(User, no_permission_user),
)
def test_relogin_failed_record_stays_visible_and_can_be_checked(self):
self.owned_task.attempt_status = "failed"
self.owned_task.attempt_message = "重新登录失败: 密码错误（旧 Cookie 已保留）"
def test_relogin_failed_account_stays_visible_and_can_be_checked(self):
# 重登进度就写在账号上：判失效 + 有待重试时间 = 排队中
self.owned_account.ck_check_status = "invalid"
self.owned_account.relogin_last_error = "重新登录失败: 密码错误"
self.session.commit()
result = list_cookie_operations(
@@ -217,58 +195,89 @@ class TestCookieOperation:
assert result["total"] == 1
assert result["items"][0]["relogin_status"] == "relogin_failed"
assert "旧 Cookie 已保留" in result["items"][0]["relogin_message"]
# 失败的重登尝试不影响记录持有的 CK
assert self.owned_task.cookie == "owned-secret"
assert self.owned_task.status == "success"
assert "重新登录失败" in result["items"][0]["relogin_message"]
# 重登失败不影响账号持有的 CK
assert self.owned_account.cookie == "owned-secret"
def test_relogin_pending_account_is_reported_as_pending(self):
self.owned_account.ck_check_status = "invalid"
from datetime import UTC, datetime, timedelta
self.owned_account.relogin_next_at = datetime.now(UTC) + timedelta(hours=1)
self.session.commit()
result = list_cookie_operations(
search="",
tag="",
page=1,
page_size=20,
db=self.session,
current=self.support,
)
assert result["items"][0]["relogin_status"] == "relogin_pending"
def test_service_restart_cleans_orphan_relogin_tasks(self):
self.owned_task.attempt_status = "running"
self.owned_task.attempt_message = "正在重新登录，旧 Cookie 保留中"
attempt = LoginTask(
batch_id="orphan-relogin",
account_id=self.owned_account.id,
created_by=self.support.id,
status="success",
attempt_status="running",
attempt_message="正在重新登录，旧 Cookie 保留中",
)
self.session.add(attempt)
self.session.commit()
cleaned = cleanup_orphan_relogin_tasks(self.session)
assert cleaned == 1
self.session.refresh(self.owned_task)
self.session.refresh(self.other_task)
# 只收敛尝试状态，已有 CK 与成功状态原封不动
assert self.owned_task.attempt_status == "failed"
assert "服务重启" in self.owned_task.attempt_message
assert self.owned_task.status == "success"
assert self.owned_task.cookie == "owned-secret"
assert self.other_task.attempt_status == ""
assert self.other_task.status == "success"
self.session.refresh(attempt)
self.session.refresh(self.owned_account)
# 只收敛尝试状态，账号的 CK 原封不动
assert attempt.attempt_status == "failed"
assert "服务重启" in attempt.attempt_message
assert self.owned_account.cookie == "owned-secret"
def test_service_restart_cleans_orphan_login_tasks(self):
"""普通登录批次遗留的在途尝试必须收敛，且保留旧 CK。"""
self.owned_task.attempt_status = "pending"
self.owned_task.cookie = "acf_uid=owned"
"""普通登录批次遗留的在途尝试必须收敛，且不动账号的旧 CK。"""
attempt = LoginTask(
batch_id="orphan-login",
account_id=self.owned_account.id,
created_by=self.support.id,
status="success",
attempt_status="pending",
)
self.session.add(attempt)
self.session.commit()
cleaned = cleanup_orphan_login_tasks(self.session)
assert cleaned == 1
self.session.refresh(self.owned_task)
self.session.refresh(self.other_task)
assert self.owned_task.attempt_status == "failed"
assert self.owned_task.cookie == "acf_uid=owned"
assert self.owned_task.status == "success"
assert "服务重启" in self.owned_task.attempt_message
assert self.other_task.status == "success"
self.session.refresh(attempt)
self.session.refresh(self.owned_account)
assert attempt.attempt_status == "failed"
assert "服务重启" in attempt.attempt_message
assert self.owned_account.cookie == "owned-secret"
def test_service_restart_cleans_legacy_in_flight_status(self):
"""升级前直接把状态写在 status 上的在途记录也要能收敛。"""
self.owned_task.status = "relogin_running"
self.owned_task.attempt_status = ""
attempt = LoginTask(
batch_id="legacy-inflight",
account_id=self.owned_account.id,
created_by=self.support.id,
status="relogin_running",
attempt_status="",
)
self.session.add(attempt)
self.session.commit()
cleaned = cleanup_orphan_login_tasks(self.session)
assert cleaned == 1
self.session.refresh(self.owned_task)
assert self.owned_task.attempt_status == "failed"
assert self.owned_task.cookie == "owned-secret"
self.session.refresh(attempt)
assert attempt.attempt_status == "failed"
assert self.owned_account.cookie == "owned-secret"
def test_runner_copies_proxy_config_before_background_execution(self):
proxy = ProxyConfig(
@@ -314,10 +323,10 @@ class TestCookieOperation:
assert result["nickname"] == "new-name"
assert result["level"] == 12
@patch("web.backend.routers.cookies._start_relogin_tasks")
@patch("web.backend.routers.cookies._start_relogin_accounts")
def test_relogin_invalid_only_targets_support_visible_accounts(self, start_relogin):
self.owned_task.ck_check_status = "invalid"
self.other_task.ck_check_status = "invalid"
self.owned_account.ck_check_status = "invalid"
self.other_account.ck_check_status = "invalid"
self.session.commit()
start_relogin.return_value = {
"batch_id": "batch",
@@ -334,5 +343,5 @@ class TestCookieOperation:
)
assert result["success"]
selected_tasks = start_relogin.call_args.args[0]
assert [task.id for task in selected_tasks] == [self.owned_task.id]
selected_accounts = start_relogin.call_args.args[0]
assert [account.id for account in selected_accounts] == [self.owned_account.id]
tests/test_douyu_account_name_filter.py
+3 -10
View File
@@ -1,5 +1,5 @@
from tests.support.db import get_test_engine, make_test_session
from web.backend.models import Account, LoginTask, User
from web.backend.models import Account, User
from web.backend.routers.douyu import (
_parse_account_names,
list_task_account_ids,
@@ -22,18 +22,11 @@ class TestDouyuAccountNameFilter:
password="password",
email=f"{name}@example.com",
email_password="mail-password",
# CK 挂在账号上（2026-10-04 CK 解耦）
cookie="acf_uid=1",
)
self.session.add(account)
self.session.flush()
self.session.add(
LoginTask(
batch_id=f"login-{name}",
account_id=account.id,
created_by=self.user.id,
status="success",
cookie="acf_uid=1",
)
)
self.accounts[name] = account
self.session.commit()
tests/test_douyu_cookie_visibility.py
+36 -20
View File
@@ -1,10 +1,13 @@
"""回归：只要账号还留着 CK，就不得因为登录批次状态而从工作台消失。
"""回归：账号只要自己有 CK 就可见，**与任何登录记录的状态无关**。
线上事故（2026-10-01）：账号「远行者103」被分配给客服后，客服与管理员在
斗鱼工作台都看不到它，只有账号管理里还能搜到。原因是可见性判定写成了
``LoginTask.status == "success"``，而普通登录批次启动时会把复用的成功记录
置为 ``pending``，CK 重登失败会置为 ``relogin_failed`` —— 两种状态都保留旧
Cookie，却让账号从工作台与 CK 列表里凭空消失。
这一条是 2026-10-04 CK 解耦的核心验收点。
解耦前：CK 存在 `login_tasks.cookie` 上，于是「记录被复用置为 pending」「重登失败」
都会让账号看起来「没有 CK」；线上出过事故（账号「远行者103」被分配后，
客服与管理员在工作台都看不到它）。
解耦后：CK 在账号上，登录记录只是一次尝试的历史 —— 删历史、批次排队、
重登失败都不可能让账号失去可见性。所以这个用例从「绕开记录状态」变成了
「根本不看记录」。
"""
import pytest
@@ -16,7 +19,6 @@ from web.backend.routers.douyu import list_task_account_ids, list_task_accounts
from web.backend.services.account_service import cookie_account_ids_query
from web.backend.services.douyu_service import (
create_douyu_planned_tasks,
latest_cookie_login_task,
visible_douyu_task_accounts,
)
@@ -31,30 +33,30 @@ class TestDouyuCookieVisibility:
self.session.add_all([self.admin, self.support])
self.session.commit()
# relogin_failed：重登失败但旧 CK 已按设计保留
# 有 CK 的账号：即使历史记录是「重登失败」，也必须可见。
self.relogin_account = self._make_account("远行者103", self.support.id)
self.relogin_account.cookie = "acf_uid=481802039"
self.relogin_account.ck_check_status = "valid"
self.session.add(
LoginTask(
batch_id="relogin-failed",
account_id=self.relogin_account.id,
created_by=self.support.id,
status="relogin_failed",
cookie="acf_uid=481802039",
ck_check_status="valid",
)
)
# pending：普通登录批次排队中，复用了成功记录，旧 CK 仍在
# 有 CK 的账号：即使历史记录停在 pending（批次排队中），也必须可见。
self.pending_account = self._make_account("排队中账号", self.support.id)
self.pending_account.cookie = "acf_uid=2"
self.session.add(
LoginTask(
batch_id="queued",
account_id=self.pending_account.id,
created_by=self.admin.id,
status="pending",
cookie="acf_uid=2",
)
)
# 从未登录成功：没有 CK，必须继续隐藏
# 从未登录成功：没有 CK，必须继续隐藏。
self.empty_account = self._make_account("无CK账号", self.support.id)
self.session.add(
LoginTask(
@@ -62,7 +64,6 @@ class TestDouyuCookieVisibility:
account_id=self.empty_account.id,
created_by=self.admin.id,
status="failed",
cookie="",
)
)
self.session.commit()
@@ -115,11 +116,6 @@ class TestDouyuCookieVisibility:
self.pending_account.id,
}
def test_latest_cookie_login_task_ignores_batch_status(self):
task = latest_cookie_login_task(self.session, self.relogin_account.id)
assert task is not None
assert task.cookie == "acf_uid=481802039"
def test_visible_task_accounts_include_retained_cookie(self):
accounts = visible_douyu_task_accounts(
self.session,
@@ -133,7 +129,7 @@ class TestDouyuCookieVisibility:
}
assert ids == {self.relogin_account.id, self.pending_account.id}
def test_cookie_management_page_lists_retained_cookie(self):
def test_cookie_management_page_lists_accounts_with_cookie(self):
items = list_cookies(
search="",
tag="",
@@ -148,6 +144,11 @@ class TestDouyuCookieVisibility:
"远行者103",
"排队中账号",
}
# 解耦后 id 就是账号 id（以前是「持有 CK 的登录记录 id」）。
assert {item["id"] for item in items} == {
self.relogin_account.id,
self.pending_account.id,
}
def test_retained_cookie_account_can_still_create_task(self):
batch_id, created = create_douyu_planned_tasks(
@@ -159,3 +160,18 @@ class TestDouyuCookieVisibility:
)
assert batch_id
assert created == 1
def test_deleting_login_history_does_not_touch_cookie(self):
"""本次改造的验收核心：删掉全部登录历史，账号的 CK 与健康状态仍在。"""
self.session.query(LoginTask).delete(synchronize_session=False)
self.session.commit()
self.session.expire_all()
fresh = (
self.session.query(Account)
.filter(Account.id == self.relogin_account.id)
.one()
)
assert fresh.cookie == "acf_uid=481802039"
assert fresh.ck_check_status == "valid"
assert self._task_account_names(self.admin) == {"远行者103", "排队中账号"}
tests/test_douyu_gold_recharge_channel.py
+10 -14
View File
@@ -6,7 +6,7 @@ from unittest.mock import ANY, AsyncMock, Mock, patch
from core.douyu import FishFinRechargeClient, FishFinRechargeConfig
from tests.support.db import get_test_engine, make_test_session
from web.backend.models import Account, AuditLog, DouyuTask, LoginTask, User
from web.backend.models import Account, AuditLog, DouyuTask, User
from web.backend.routers.douyu import get_recharge_channel, supplier_recharge_callback
from web.backend.services.audit_service import record_audit
from web.backend.services.douyu_runner import DouyuBatchRunner
@@ -192,18 +192,12 @@ class TestDouyuGoldRechargeChannel:
def test_invalid_cookie_skips_activity_and_marks_relogin_required(
self, session_local, check_cookie
):
login_task = LoginTask(
batch_id="login-batch",
account_id=self.account.id,
created_by=self.task.created_by,
status="success",
cookie="acf_uid=10001",
)
# CK 挂在账号上（2026-10-04 CK 解耦）
self.account.cookie = "acf_uid=10001"
self.task.status = "planned"
self.session.add(login_task)
self.session.commit()
task_id = self.task.id
login_task_id = login_task.id
account_id = self.account.id
session_local.return_value = self.session
check_cookie.return_value = {
"valid": False,
@@ -221,15 +215,17 @@ class TestDouyuGoldRechargeChannel:
verify_session = make_test_session(self.engine)
try:
task = verify_session.get(DouyuTask, task_id)
checked_login = verify_session.get(LoginTask, login_task_id)
checked_account = verify_session.get(Account, account_id)
assert task is not None
assert checked_login is not None
assert checked_account is not None
assert task.status == "failed"
assert "Cookie 已失效，请重新登录" in task.message
assert checked_login.ck_check_status == "invalid"
check_result = checked_login.ck_check_result
# 检测结论写在**账号**上，CK 本体不动
assert checked_account.ck_check_status == "invalid"
check_result = checked_account.ck_check_result
assert isinstance(check_result, dict)
assert check_result["message"] == "鱼丸接口: 未登录；等级接口: 未登录"
assert checked_account.cookie == "acf_uid=10001"
finally:
verify_session.close()
tests/test_douyu_task_assigned_optimization.py
+5 -19
View File
@@ -1,5 +1,7 @@
"""验证 DouyuTask 的 account_assigned_to 字段与任务查询优化。"""
from sqlalchemy.orm import Session
from tests.support.db import init_test_schema, make_test_session
from web.backend.models import Account, DouyuTask, User
from web.backend.routers.douyu import _visible_tasks_query
@@ -38,6 +40,8 @@ def test_douyu_task_assigned_to_flow():
email="em1@test.com",
email_password="pwd",
assigned_to=user_a.id,
# CK 挂在账号上（2026-10-04 CK 解耦）
cookie="acf_uid=101; acf_auth=fake",
)
acc_2 = Account(
username="dy_user_2",
@@ -45,29 +49,11 @@ def test_douyu_task_assigned_to_flow():
email="em2@test.com",
email_password="pwd",
assigned_to=user_b.id,
cookie="acf_uid=102; acf_auth=fake",
)
db.add_all([acc_1, acc_2])
db.flush()
from web.backend.models import LoginTask
lt_1 = LoginTask(
account_id=acc_1.id,
batch_id="b1",
status="success",
cookie="acf_uid=101; acf_auth=fake",
created_by=user_a.id,
)
lt_2 = LoginTask(
account_id=acc_2.id,
batch_id="b2",
status="success",
cookie="acf_uid=102; acf_auth=fake",
created_by=user_b.id,
)
db.add_all([lt_1, lt_2])
db.flush()
# 1. 验证创建任务时，自动继承 account.assigned_to
batch_id, count = create_douyu_planned_tasks(
db=db,
tests/test_douyu_workbench_scopes.py
+2 -11
View File
@@ -6,7 +6,6 @@ from web.backend.models import (
DouyuTask,
DouyuWorkbench,
DouyuWorkbenchAccount,
LoginTask,
User,
)
from web.backend.routers.accounts import delete_account
@@ -31,19 +30,11 @@ class TestDouyuWorkbenchScope:
password="password",
email="mail@example.com",
email_password="mail-password",
# CK 挂在账号上（2026-10-04 CK 解耦），不再需要造一条登录记录
cookie="acf_uid=1",
)
self.session.add(self.account)
self.session.commit()
self.session.add(
LoginTask(
batch_id="login",
account_id=self.account.id,
created_by=self.user.id,
status="success",
cookie="acf_uid=1",
)
)
self.session.commit()
def teardown_method(self):
self.session.close()
tests/test_login_attempt_isolation.py
+37 -12
View File
@@ -1,9 +1,10 @@
"""回归：替换 CK 必须是最后一步，只有登录成功才会写回记录。
"""回归：替换 CK 必须是最后一步，只有登录成功才会写回**账号**。
事故背景：批次启动时会把复用的成功记录直接改成 pending（旧 CK 仍保留），
批次被停止或失败后没有任何地方把它改回成功，账号于是从工作台消失。
现在尝试状态独立存放在 attempt_*，status/cookie/message 只在登录成功时
更新，所以停止、失败、进程重启都不可能破坏账号已有的 CK。
现在尝试状态独立存放在 attempt_*，而 CK 自 2026-10-04 起挂在**账号**上
（`accounts.cookie`），登录记录只是一次尝试的历史 ——
停止、失败、进程重启都不可能破坏账号已有的 CK。
"""
from types import SimpleNamespace
@@ -56,6 +57,8 @@ class TestLoginAttemptIsolation:
password="password",
email="yuanxingzhe@example.com",
email_password="mail-password",
# CK 是账号的属性（解耦前它挂在 login_tasks.cookie 上）
cookie="old-cookie",
)
self.session.add(self.account)
self.session.flush()
@@ -64,8 +67,11 @@ class TestLoginAttemptIsolation:
account_id=self.account.id,
created_by=self.user.id,
status="success",
cookie="old-cookie",
message="登录成功",
# 上一次尝试失败过 —— 解耦后「复用行为」按 attempt_status 判定，
# 批次会复用这一行继续重试（而不是每次失败都新建一行）。
attempt_status="failed",
attempt_message="上一次登录失败",
)
self.session.add(self.task)
self.session.commit()
@@ -104,6 +110,14 @@ class TestLoginAttemptIsolation:
finally:
session.close()
def _fresh_account(self) -> Account:
"""重新读账号 —— CK 现在挂在它身上，断言要跨会话读才作数。"""
session = sessionmaker(bind=self.engine)()
try:
return session.query(Account).filter(Account.id == self.account.id).one()
finally:
session.close()
def _fresh_user(self, session) -> User:
return session.query(User).filter(User.id == self.user.id).one()
@@ -114,17 +128,18 @@ class TestLoginAttemptIsolation:
self._run_batch(monkeypatch)
task = self._fresh(self.task_id)
# 记录持有 CK 的字段完全没被碰过
# 登录记录只是历史，它的状态字段没被碰过
assert task.status == "success"
assert task.cookie == "old-cookie"
assert task.message == "登录成功"
assert task.batch_id == "old-batch"
# 失败只体现在尝试字段上
assert task.attempt_status == "failed"
assert task.attempt_message == "账号密码错误"
assert task.attempt_at is not None
# 账号的 CK 完全没被碰过
assert self._fresh_account().cookie == "old-cookie"
def test_failed_attempt_reuses_the_cookie_row(self, monkeypatch):
def test_failed_attempt_reuses_the_failed_row(self, monkeypatch):
_FakeLogin.success = False
_FakeLogin.message = "账号密码错误"
@@ -145,19 +160,23 @@ class TestLoginAttemptIsolation:
self._run_batch(monkeypatch)
task = self._fresh(self.task_id)
account = self._fresh_account()
assert task.status == "success"
assert task.cookie == "new-cookie"
assert task.message == "登录成功"
assert task.attempt_status == "success"
assert task.attempt_at is not None
assert task.batch_id != "old-batch"
# 唯一替换 CK 的入口：写的是**账号**
assert account.cookie == "new-cookie"
assert account.cookie_updated_at is not None
assert account.cookie_source == "web"
def test_stopped_batch_keeps_existing_cookie(self, monkeypatch):
self._run_batch(monkeypatch, stop=True)
task = self._fresh(self.task_id)
assert _FakeLogin.calls == 0
assert task.cookie == "old-cookie"
assert self._fresh_account().cookie == "old-cookie"
assert task.status == "success"
assert task.attempt_status == "failed"
assert "旧 Cookie 已保留" in task.attempt_message
@@ -177,11 +196,11 @@ class TestLoginAttemptIsolation:
read_db.close()
assert len(rows) == 1
row = rows[0]
# 页面看到的是「这次尝试怎么样了」，而记录仍然持有 CK
# 页面看到的是「这次尝试怎么样了」，而账号仍然持有 CK
assert row.status == "failed"
assert row.message == "账号密码错误"
assert row.batch_id == runner.batch_id
assert self._fresh(self.task_id).cookie == "old-cookie"
assert self._fresh_account().cookie == "old-cookie"
def test_account_without_cookie_still_reports_failure(self, monkeypatch):
"""首次登录失败的账号没有 CK 需要保护，保持原来的失败语义。"""
@@ -208,6 +227,12 @@ class TestLoginAttemptIsolation:
assert task.status == "failed"
assert task.message == "账号密码错误"
assert task.attempt_status == "failed"
assert task.cookie == ""
assert (
session.query(Account)
.filter(Account.id == fresh_account.id)
.one()
.cookie
== ""
)
finally:
session.close()
tests/test_login_tasks_pagination.py
+64 -58
View File
@@ -231,16 +231,15 @@ class TestBulkDelete:
assert "无效的任务ID" in str(exc.value)
class TestCkProtection:
"""⚠️ 最重要的护栏：删除不能丢 CK。
class TestDeleteGuard:
"""⚠️ 护栏语义已随 CK 解耦改变（2026-10-04）。
事故背景（2026-10-03）：斗鱼账号的 CK **只存在 `login_tasks.cookie`**，
`accounts` 表没有 cookie 列。列表显示的「状态」是最近一次尝试
（``attempt_status``），于是一条**显示「失败」但实际持有有效 CK** 的记录
（``status='success'`` + cookie + 上次尝试失败）会被「清空失败」当成垃圾删掉，
账号的登录态随之永久丢失。
旧护栏：「持有 CK 的记录不可删」—— 因为那时 CK 只存在 `login_tasks.cookie`，
删历史就是删账号的登录态（2026-10-03 事故）。
所以判定必须看 ``cookie``，不能看显示状态。
新护栏：CK 已迁到 `accounts.cookie`，**删除历史不再影响任何账号的登录态**，
所以 CK 不再是护栏理由（历史终于可以自由清理）。保留的是**在途护栏**：
批次线程正拿着那条记录，删掉会让它找不到目标。
"""
def setup_method(self):
@@ -252,51 +251,48 @@ class TestCkProtection:
self.session.add(self.user)
self.session.flush()
self.account = Account(
username="CK保护账号",
username="CK账号",
password="p",
email="ck@example.com",
email_password="ep",
cookie="valid-ck-1",
)
self.session.add(self.account)
self.session.flush()
# ① 显示失败、但持有有效 CK —— 生产事故就是删到了这种
self.holds_ck_shows_failed = self._add(
status="success", attempt_status="failed", cookie="valid-ck-1"
# ① 历史：显示失败、但账号仍持有有效 CK（本次改造前会被当成垃圾删掉）
self.failed_history = self._add(status="failed", attempt_status="failed")
# ② 历史：成功
self.success_history = self._add(status="success", attempt_status="success")
# ③ 在途：批次正拿着它，不可删
self.in_flight = self._add(
status="pending", attempt_status="running", attempt_batch_id="live-batch"
)
# ② 成功且持有 CK
self.holds_ck_shows_success = self._add(
status="success", attempt_status="success", cookie="valid-ck-2"
)
# ③ 真垃圾：没有任何 CK
self.no_ck = self._add(status="failed", attempt_status="failed", cookie="")
# 用两个账号，避免同一账号多条记录干扰「账号是否还有 CK」的判断
self.other = Account(
username="CK保护账号2",
username="CK账号2",
password="p",
email="ck2@example.com",
email_password="ep",
cookie="valid-ck-2",
)
self.session.add(self.other)
self.session.flush()
self.holds_ck_other = self._add(
status="success",
attempt_status="failed",
cookie="valid-ck-3",
account_id=self.other.id,
self.other_history = self._add(
status="success", attempt_status="failed", account_id=self.other.id
)
self.session.commit()
def _add(self, *, status, attempt_status, cookie, account_id=None):
def _add(
self, *, status, attempt_status, account_id=None, attempt_batch_id="ck-batch"
):
task = LoginTask(
batch_id="ck-batch",
account_id=account_id or self.account.id,
created_by=self.user.id,
status=status,
cookie=cookie,
attempt_status=attempt_status,
attempt_batch_id="ck-batch",
attempt_batch_id=attempt_batch_id,
message="x",
)
self.session.add(task)
@@ -318,65 +314,75 @@ class TestCkProtection:
finally:
db.close()
def test_bulk_delete_skips_ck_holding_records(self):
"""「清空失败」绝不能删掉持有 CK 的记录，哪怕它显示为失败。"""
def _account_cookie(self, account_id: int) -> str:
db = self._fresh()
try:
res = delete_tasks(
status="failed", all_matching=True, db=db, current=self.user
)
return db.query(Account).filter(Account.id == account_id).one().cookie
finally:
db.close()
assert self._exists(self.holds_ck_shows_failed), (
"显示失败但持有 CK 的记录被删了！"
)
assert self._exists(self.holds_ck_other), "另一个账号的 CK 记录被删了！"
assert not self._exists(self.no_ck), "无 CK 的历史记录应被删除"
assert res["deleted"] == 1
assert res["skipped"] >= 2
def test_bulk_delete_reports_skipped_count(self):
def test_bulk_delete_removes_history_even_when_account_holds_cookie(self):
"""核心验收：删掉全部历史，账号的 CK 一点不受影响。"""
db = self._fresh()
try:
res = delete_tasks(all_matching=True, db=db, current=self.user)
finally:
db.close()
# 3 条持有 CK（含另一个账号）、1 条无 CK
assert res["deleted"] == 1
assert res["skipped"] == 3
assert "持有 CK" in res["message"]
def test_explicit_ids_cannot_delete_ck_holder(self):
"""即使用户手动勾选，持有 CK 的也不能删。"""
assert not self._exists(self.failed_history)
assert not self._exists(self.success_history)
assert not self._exists(self.other_history)
# 在途那条被跳过
assert self._exists(self.in_flight)
assert res["deleted"] == 3
assert res["skipped"] == 1
# 账号的 CK 仍在 —— 这就是解耦要的效果
assert self._account_cookie(self.account.id) == "valid-ck-1"
assert self._account_cookie(self.other.id) == "valid-ck-2"
def test_bulk_delete_reports_in_flight_skipped_count(self):
db = self._fresh()
try:
res = delete_tasks(all_matching=True, db=db, current=self.user)
finally:
db.close()
assert res["deleted"] == 3
assert res["skipped"] == 1
assert "在途" in res["message"]
def test_explicit_ids_can_delete_cookie_history_but_not_in_flight(self):
"""用户手动勾选时，历史可删，在途仍不可删。"""
db = self._fresh()
try:
res = delete_tasks(
task_ids=f"{self.holds_ck_shows_failed},{self.no_ck}",
task_ids=f"{self.failed_history},{self.in_flight}",
db=db,
current=self.user,
)
finally:
db.close()
assert self._exists(self.holds_ck_shows_failed)
assert not self._exists(self.no_ck)
assert not self._exists(self.failed_history)
assert self._exists(self.in_flight)
assert res["deleted"] == 1
assert res["skipped"] == 1
assert self._account_cookie(self.account.id) == "valid-ck-1"
def test_single_delete_refuses_ck_holder(self):
def test_single_delete_refuses_in_flight_record(self):
db = self._fresh()
try:
with pytest.raises(Exception) as exc:
delete_task(self.holds_ck_shows_success, db=db, current=self.user)
delete_task(self.in_flight, db=db, current=self.user)
finally:
db.close()
assert "持有 CK" in str(exc.value)
assert self._exists(self.holds_ck_shows_success)
assert "正在被批次处理" in str(exc.value)
assert self._exists(self.in_flight)
def test_single_delete_allows_empty_cookie(self):
def test_single_delete_allows_cookie_history(self):
db = self._fresh()
try:
res = delete_task(self.no_ck, db=db, current=self.user)
res = delete_task(self.success_history, db=db, current=self.user)
finally:
db.close()
assert res["success"] is True
assert not self._exists(self.no_ck)
assert not self._exists(self.success_history)
assert self._account_cookie(self.account.id) == "valid-ck-1"