Files
live-hub-py/tests/test_douyu_task_concurrency.py
T

1092 lines
32 KiB
Python

import inspect
from datetime import UTC, datetime, timedelta
import pytest
from fastapi import HTTPException
from pydantic import ValidationError
from sqlalchemy import text
from tests.support.db import make_test_session
from web.backend.database import engine as app_engine
from web.backend.main import health
from web.backend.models import Account, DouyuRoleApiLog, DouyuTask, User
from web.backend.routers import douyu as douyu_router
from web.backend.schemas import DouyuTaskBatchRequest
from web.backend.services import (
binding_poll_scheduler,
business_events,
douyu_batch_launcher,
douyu_concurrency,
douyu_service,
payment_poll_scheduler,
)
from web.backend.services.douyu_role_audit import record_role_api_candidates
from web.backend.services.douyu_runner import DouyuBatchRunner
from web.backend.services.douyu_runner_bind import bind_poll_interval_seconds
from web.backend.services.douyu_runner_core import (
DouyuBatchRunnerCore,
slim_douyu_task_result_for_storage,
)
from web.backend.services.task_runtime import (
_DEFAULT_WORKERS,
TaskLane,
douyu_lane_for_task,
)
def _fixtures(db, *, status: str = "planned") -> tuple[User, Account, DouyuTask]:
user = User(username="concurrency-user", password_hash="hash", role="operation")
db.add(user)
db.flush()
account = Account(
username="concurrency-account",
password="password",
email="concurrency@example.com",
email_password="mail-password",
cookie="acf_uid=1",
)
db.add(account)
db.flush()
task = DouyuTask(
batch_id="concurrency-batch",
account_id=account.id,
account_assigned_to=user.id,
task_type="get_bind_qr",
handbook_scope="elite",
status=status,
created_by=user.id,
)
db.add(task)
db.commit()
return user, account, task
def test_task_rows_commit_before_started_events(db, monkeypatch):
user = User(username="event-order", password_hash="hash", role="operation")
db.add(user)
db.flush()
account = Account(
username="event-order-account",
password="password",
email="event-order@example.com",
email_password="mail-password",
cookie="acf_uid=2",
)
db.add(account)
db.commit()
observed: list[int] = []
def fake_emit_bulk_read_committed(_db, events):
other = make_test_session()
try:
observed.append(
other.query(DouyuTask).filter(DouyuTask.status == "planned").count()
)
finally:
other.close()
return len(events)
monkeypatch.setattr(douyu_service, "emit_bulk", fake_emit_bulk_read_committed)
batch_id, count = douyu_service.create_douyu_planned_tasks(
db,
[account.id],
"query_points",
"elite",
user.id,
)
assert batch_id
assert count == 1
assert observed == [1]
def test_mark_task_commits_result_before_account_event(db, monkeypatch):
_, account, task = _fixtures(db, status="running")
task.account = account
runner = DouyuBatchRunnerCore(
db,
task.batch_id,
task.task_type,
close_db=False,
)
observed: list[tuple[str, object]] = []
def fake_record(_db, _account, **kwargs):
other = make_test_session()
try:
row = other.get(DouyuTask, task.id)
observed.append((row.status, row.result))
finally:
other.close()
return True
monkeypatch.setattr(business_events, "record_douyu_task_result", fake_record)
runner._mark_task(
db,
task,
"success",
"done",
{
"url": "https://example.test/qr",
"raw": {"large": "payload"},
"before_bind_info": {
"role_name": "role-a",
"raw": {"large": "nested"},
},
},
)
assert observed == [
(
"success",
{
"url": "https://example.test/qr",
"before_bind_info": {"role_name": "role-a"},
},
)
]
def test_cleanup_commits_stopped_status_before_account_event(db, monkeypatch):
_, _, task = _fixtures(db, status="running")
observed: list[str] = []
def fake_record(_db, _account, **kwargs):
other = make_test_session()
try:
observed.append(other.get(DouyuTask, task.id).status)
finally:
other.close()
return True
monkeypatch.setattr(business_events, "record_douyu_task_result", fake_record)
cleaned = douyu_service.cleanup_orphan_douyu_tasks(
db,
active_batch_ids=set(),
statuses=("running",),
)
assert cleaned == 1
assert observed == ["stopped"]
def test_cleanup_preserves_recoverable_binding_poll(db):
_, _, task = _fixtures(db, status="running")
task.queue_lane = "binding_poll"
task.next_run_at = datetime.now(UTC) + timedelta(seconds=5)
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
db.commit()
cleaned = douyu_service.cleanup_orphan_douyu_tasks(
db,
active_batch_ids=set(),
statuses=("running",),
)
db.refresh(task)
assert cleaned == 0
assert task.status == "running"
assert task.queue_lane == "binding_poll"
@pytest.mark.parametrize(
("elapsed", "expected"),
[
(0, 5),
(119, 5),
(120, 10),
(599, 10),
(600, 20),
(1200, 20),
],
)
def test_binding_poll_interval_backs_off_by_elapsed_time(elapsed, expected):
assert bind_poll_interval_seconds(elapsed) == expected
def test_role_api_audit_redacts_secrets_and_keeps_raw_role_payload(db):
_, account, task = _fixtures(db, status="running")
written = record_role_api_candidates(
db,
account_id=account.id,
task_id=task.id,
candidates=[
{
"act_alias": "bind-act",
"api_version": "v1",
"role_name": "new-role",
"is_bound_act": True,
"raw": {
"cookie": "should-not-be-stored",
"data": {
"bindAct": 1,
"gameRole": {"roleName": "new-role"},
},
},
}
],
scope="elite",
stage="test",
source="pytest",
)
db.commit()
row = db.query(DouyuRoleApiLog).one()
assert written == 1
assert row.account_id == account.id
assert row.task_id == task.id
assert row.role_name == "new-role"
assert row.is_bound_act is True
assert row.response_json["cookie"] == "<redacted>"
assert row.response_json["data"]["bindAct"] == 1
def test_cleanup_gives_binding_poll_a_final_poll_grace(db):
_, _, task = _fixtures(db, status="running")
task.queue_lane = "binding_poll"
task.next_run_at = datetime.now(UTC)
task.run_deadline_at = datetime.now(UTC) - timedelta(seconds=30)
db.commit()
cleaned = douyu_service.cleanup_orphan_douyu_tasks(
db,
active_batch_ids=set(),
statuses=("running",),
)
db.refresh(task)
assert cleaned == 0
assert task.status == "running"
def test_cleanup_preserves_recoverable_payment_poll(db):
_, _, task = _fixtures(db, status="running")
task.task_type = "create_gold_qr"
task.queue_lane = "payment_poll"
task.next_run_at = datetime.now(UTC) + timedelta(seconds=5)
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
db.commit()
cleaned = douyu_service.cleanup_orphan_douyu_tasks(
db,
active_batch_ids=set(),
statuses=("running",),
)
db.refresh(task)
assert cleaned == 0
assert task.status == "running"
assert task.queue_lane == "payment_poll"
def test_binding_poll_scheduler_claims_due_task_without_worker_wait(db):
_, _, task = _fixtures(db, status="running")
due_at = datetime.now(UTC) - timedelta(seconds=1)
task.queue_lane = "binding_poll"
task.next_run_at = due_at
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
db.commit()
try:
claimed = binding_poll_scheduler._claim_due_binding_tasks(10)
db.refresh(task)
assert claimed == [task.id]
assert task.next_run_at is not None
assert task.next_run_at > due_at
finally:
with binding_poll_scheduler._in_flight_lock:
binding_poll_scheduler._in_flight.discard(task.id)
def test_binding_poll_dispatch_skips_claim_when_lane_is_saturated(monkeypatch):
claimed_limits: list[int] = []
monkeypatch.setattr(
binding_poll_scheduler,
"available_slots",
lambda _lane: 0,
)
monkeypatch.setattr(
binding_poll_scheduler,
"_claim_due_binding_tasks",
lambda limit: claimed_limits.append(limit) or [],
)
submitted = binding_poll_scheduler.run_binding_poll_dispatch_once(20)
assert submitted == 0
assert claimed_limits == []
def test_batch_launcher_defers_database_session_to_worker(monkeypatch):
submitted: dict[str, object] = {}
def fake_submit(lane, fn, /, *args, **kwargs):
submitted.update(
{
"lane": lane,
"fn": fn,
"args": args,
"kwargs": kwargs,
}
)
return object()
monkeypatch.setattr(
douyu_batch_launcher,
"WorkerSessionLocal",
lambda: (_ for _ in ()).throw(
AssertionError("队列阶段不能创建数据库 Session")
),
)
monkeypatch.setattr(douyu_batch_launcher, "submit", fake_submit)
queued = douyu_batch_launcher.start_douyu_batch(
batch_id="deferred-session",
task_type="get_bind_qr",
payload={},
concurrency=1,
capture_event_loop=False,
)
assert queued is True
assert submitted["lane"] == TaskLane.BATCH_COORDINATOR
assert submitted["fn"] is douyu_batch_launcher._run_batch
def test_payment_poll_scheduler_claims_due_task_without_worker_wait(db):
_, _, task = _fixtures(db, status="running")
due_at = datetime.now(UTC) - timedelta(seconds=1)
task.task_type = "create_gold_qr"
task.queue_lane = "payment_poll"
task.next_run_at = due_at
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
task.result = {"pay_url": "https://example.test/pay"}
db.commit()
try:
claimed = payment_poll_scheduler._claim_due_payment_tasks(10)
db.refresh(task)
assert claimed == [task.id]
assert task.next_run_at is not None
assert task.next_run_at > due_at
assert task.attempt_count == 1
finally:
with payment_poll_scheduler._in_flight_lock:
payment_poll_scheduler._in_flight.discard(task.id)
def test_payment_poll_marks_expired_task_failed(db, monkeypatch):
_, _, task = _fixtures(db, status="running")
task.task_type = "create_elite_qr"
task.queue_lane = "payment_poll"
task.next_run_at = datetime.now(UTC) - timedelta(seconds=1)
task.run_deadline_at = datetime.now(UTC) - timedelta(seconds=1)
task.result = {"pay_url": "https://example.test/pay"}
db.commit()
monkeypatch.setattr(payment_poll_scheduler, "WorkerSessionLocal", make_test_session)
payment_poll_scheduler.poll_payment_task_once(task.id)
db.rollback()
db.refresh(task)
assert task.status == "failed"
assert task.queue_lane == ""
assert "超时" in task.message
def test_bind_qr_schedules_poll_and_releases_worker(db, monkeypatch):
_, account, task = _fixtures(db, status="running")
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
info = {
"act_alias": "bind-act",
"role_name": "old-role",
"is_bound_act": True,
}
snapshot = {
"role_name": "old-role",
"area_name": "",
"plat_name": "",
"game_id": "",
"game_name": "",
"game_channel": "",
"change_role_wait_time": None,
"can_change_time": None,
"can_change_role": True,
"is_bound_act": True,
"is_bound_role": True,
"is_bound_account": False,
"need_bind_act": False,
"need_bind_role": False,
}
client = type(
"Client",
(),
{"get_bind_qr": lambda self, _alias: {"url": "https://example.test/qr"}},
)()
monkeypatch.setattr(runner, "_client", lambda _cookie: client)
monkeypatch.setattr(runner, "_fetch_bind_info_candidates", lambda *_args: [info])
monkeypatch.setattr(runner, "_pick_baseline_bind_info", lambda *_args: info)
monkeypatch.setattr(runner, "_pick_change_wait_bind_info", lambda *_args: None)
monkeypatch.setattr(runner, "_pick_bind_info", lambda *_args, **_kwargs: info)
monkeypatch.setattr(runner, "_bind_snapshot", lambda _info: snapshot)
monkeypatch.setattr(
runner,
"_wait_bind_role_result",
lambda *_args, **_kwargs: (_ for _ in ()).throw(
AssertionError("scan wait must not block the worker")
),
)
runner._execute_get_bind_qr(
db,
task,
account,
"PHPSESSID=x",
{
"bind_act_alias": "bind-act",
"legacy_act_alias": "legacy-act",
},
)
db.refresh(task)
assert task.status == "running"
assert task.queue_lane == "binding_poll"
assert task.next_run_at is not None
assert task.run_deadline_at is not None
assert task.result["url"] == "https://example.test/qr"
def test_binding_poll_once_finishes_when_role_is_found(db, monkeypatch):
_, account, task = _fixtures(db, status="running")
task.queue_lane = "binding_poll"
task.next_run_at = datetime.now(UTC)
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
task.result = {
"url": "https://example.test/qr",
"query_act_aliases": ["bind-act"],
"baseline_role_name": "old-role",
"bind_polling": True,
}
db.commit()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
info = {"act_alias": "bind-act", "role_name": "new-role"}
snapshot = {
"role_name": "new-role",
"area_name": "微信",
"plat_name": "安卓",
"game_id": "",
"game_name": "",
"game_channel": "",
"change_role_wait_time": None,
"can_change_time": None,
"can_change_role": True,
"is_bound_act": False,
"is_bound_role": True,
"is_bound_account": False,
"need_bind_act": True,
"need_bind_role": True,
}
client = type("Client", (), {})()
monkeypatch.setattr(runner, "_client", lambda _cookie: client)
monkeypatch.setattr(runner, "_fetch_bind_info_candidates", lambda *_args: [info])
monkeypatch.setattr(runner, "_pick_bind_info", lambda *_args, **_kwargs: info)
monkeypatch.setattr(runner, "_bind_snapshot", lambda _info: snapshot)
monkeypatch.setattr(runner, "_is_pending_role", lambda *_args, **_kwargs: True)
monkeypatch.setattr(
runner,
"_format_bind_summary",
lambda *_args, **_kwargs: "role=new-role",
)
runner.poll_bind_role_once(
db,
task,
account,
{
"bind_act_alias": "bind-act",
"legacy_act_alias": "legacy-act",
},
)
db.refresh(task)
assert task.status == "success"
assert task.queue_lane == ""
assert task.next_run_at is None
assert task.result["role_name"] == "new-role"
assert task.result["bind_ready_for_confirm"] is True
def test_binding_poll_checks_action_alias_only_on_change_or_cadence(db, monkeypatch):
_, account, task = _fixtures(db, status="running")
task.queue_lane = "binding_poll"
task.next_run_at = datetime.now(UTC)
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
legacy = {
"act_alias": "cjm",
"role_name": "old-role",
"is_bound_act": True,
"is_bound_role": True,
"raw": {"data": {"bindAct": 1}},
}
activity = {
"act_alias": "20260120QYOOB",
"role_name": "old-role",
"is_bound_act": True,
"is_bound_role": True,
"raw": {"data": {"bindAct": 1}},
}
task.result = {
"url": "https://example.test/qr",
"query_act_aliases": ["cjm", "20260120QYOOB"],
"baseline_role_name": "old-role",
"baseline_is_bound_act": True,
"before_bind_info": activity,
"bind_poll_legacy_snapshot": {
"role_name": "old-role",
"area_name": "",
"plat_name": "",
"is_bound_act": True,
"is_bound_role": True,
"need_bind_act": False,
"need_bind_role": False,
},
"bind_polling": True,
"qr_generated_at": datetime.now(UTC).isoformat(),
"poll_count": 0,
}
db.commit()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
calls: list[list[str]] = []
def fake_fetch(_client, aliases):
calls.append(list(aliases))
return [legacy if alias == "cjm" else activity for alias in aliases]
monkeypatch.setattr(runner, "_client", lambda _cookie: object())
monkeypatch.setattr(runner, "_fetch_bind_info_candidates", fake_fetch)
runner.poll_bind_role_once(
db,
task,
account,
{
"bind_act_alias": "20260120QYOOB",
"confirm_act_alias": "20260120QYOOB",
"legacy_act_alias": "cjm",
},
)
runner.poll_bind_role_once(
db,
task,
account,
{
"bind_act_alias": "20260120QYOOB",
"confirm_act_alias": "20260120QYOOB",
"legacy_act_alias": "cjm",
},
)
runner.poll_bind_role_once(
db,
task,
account,
{
"bind_act_alias": "20260120QYOOB",
"confirm_act_alias": "20260120QYOOB",
"legacy_act_alias": "cjm",
},
)
assert calls == [
["cjm"],
["cjm"],
["cjm"],
["20260120QYOOB"],
]
assert db.query(DouyuRoleApiLog).count() == 1
assert db.query(DouyuRoleApiLog).one().stage == "binding_poll.action_alias"
def test_binding_poll_finishes_when_scan_directly_binds_new_role(db, monkeypatch):
"""扫码后官方直接返回 bindAct=1 时,也必须结束等待而不是继续轮询。"""
_, account, task = _fixtures(db, status="running")
task.queue_lane = "binding_poll"
task.next_run_at = datetime.now(UTC)
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
task.result = {
"url": "https://example.test/qr",
"query_act_aliases": ["bind-act"],
"baseline_role_name": "old-role",
"baseline_is_bound_act": True,
"before_bind_info": {
"act_alias": "bind-act",
"role_name": "old-role",
"is_bound_act": True,
},
"bind_polling": True,
}
db.commit()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
info = {
"act_alias": "bind-act",
"role_name": "new-role",
"is_bound_act": True,
"is_bound_role": True,
"need_bind_act": True,
}
snapshot = {
"role_name": "new-role",
"area_name": "微信",
"plat_name": "安卓",
"game_id": "",
"game_name": "",
"game_channel": "",
"change_role_wait_time": None,
"can_change_time": None,
"can_change_role": True,
"is_bound_act": True,
"is_bound_role": True,
"is_bound_account": True,
"need_bind_act": True,
"need_bind_role": True,
}
monkeypatch.setattr(runner, "_client", lambda _cookie: type("Client", (), {})())
monkeypatch.setattr(runner, "_fetch_bind_info_candidates", lambda *_args: [info])
monkeypatch.setattr(runner, "_pick_bind_info", lambda *_args, **_kwargs: info)
monkeypatch.setattr(runner, "_bind_snapshot", lambda _info: snapshot)
runner.poll_bind_role_once(
db,
task,
account,
{"bind_act_alias": "bind-act", "legacy_act_alias": "legacy-act"},
)
db.refresh(task)
assert task.status == "success"
assert task.queue_lane == ""
assert task.result["bind_confirmed"] is True
assert task.result["bind_phase"] == "confirmed"
assert task.result["role_name"] == "new-role"
assert task.result["bind_decision"]["reason"] == "directly_confirmed"
def test_deadline_poll_still_checks_role_once_before_timeout(db, monkeypatch):
"""到达截止时刻的最后一轮仍要先查角色,避免刚好扫上却被判超时。"""
_, account, task = _fixtures(db, status="running")
task.queue_lane = "binding_poll"
task.next_run_at = datetime.now(UTC)
task.run_deadline_at = datetime.now(UTC) - timedelta(seconds=1)
task.result = {
"url": "https://example.test/qr",
"query_act_aliases": ["bind-act"],
"baseline_role_name": "",
"baseline_is_bound_act": False,
"bind_polling": True,
}
db.commit()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
info = {"act_alias": "bind-act", "role_name": "new-role"}
snapshot = {
"role_name": "new-role",
"area_name": "微信",
"plat_name": "安卓",
"game_id": "",
"game_name": "",
"game_channel": "",
"change_role_wait_time": None,
"can_change_time": None,
"can_change_role": True,
"is_bound_act": False,
"is_bound_role": True,
"is_bound_account": True,
"need_bind_act": True,
"need_bind_role": True,
}
monkeypatch.setattr(runner, "_client", lambda _cookie: type("Client", (), {})())
monkeypatch.setattr(runner, "_fetch_bind_info_candidates", lambda *_args: [info])
monkeypatch.setattr(runner, "_pick_bind_info", lambda *_args, **_kwargs: info)
monkeypatch.setattr(runner, "_bind_snapshot", lambda _info: snapshot)
monkeypatch.setattr(runner, "_is_pending_role", lambda *_args, **_kwargs: True)
monkeypatch.setattr(
runner,
"_format_bind_summary",
lambda *_args, **_kwargs: "role=new-role",
)
runner.poll_bind_role_once(
db,
task,
account,
{"bind_act_alias": "bind-act", "legacy_act_alias": "legacy-act"},
)
db.refresh(task)
assert task.status == "success"
assert task.result["bind_ready_for_confirm"] is True
def test_qr_preflight_accepts_existing_action_alias_pending_same_role(
db, monkeypatch
):
_, account, task = _fixtures(db, status="running")
role = "忧郁情潇藏心中"
legacy = {
"act_alias": "cjm",
"role_name": role,
"area_name": "微信",
"plat_name": "安卓(android)",
"is_bound_account": True,
"is_bound_role": True,
"is_bound_act": False,
"need_bind_act": False,
"need_bind_role": True,
"change_role_wait_time": 0,
"can_change_time": 0,
"can_change_role": True,
}
activity = {
**legacy,
"act_alias": "20260120QYOOB",
"need_bind_act": True,
"change_role_wait_time": 2_592_000,
}
client = type(
"Client",
(),
{"get_bind_qr": lambda self, _alias: {"url": "https://example.test/qr"}},
)()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
monkeypatch.setattr(runner, "_client", lambda _cookie: client)
monkeypatch.setattr(
runner,
"_fetch_bind_info_candidates",
lambda *_args: [legacy, activity],
)
runner._execute_get_bind_qr(
db,
task,
account,
"PHPSESSID=x",
{
"bind_act_alias": "20260120QYOOB",
"confirm_act_alias": "20260120QYOOB",
"legacy_act_alias": "cjm",
},
)
db.refresh(task)
assert task.status == "success"
assert task.result["url"] == "https://example.test/qr"
assert task.result["pending_role_name"] == role
assert task.result["bind_ready_for_confirm"] is True
assert task.result["bind_decision"]["alias"] == "20260120QYOOB"
assert task.result["bind_decision"]["reason"] == "existing_actionable_pending"
def test_qr_preflight_accepts_same_bound_role_that_still_needs_binding(
db, monkeypatch
):
"""用户重新绑定同名角色时,bindAct=1 不应阻断可确认状态。"""
_, account, task = _fixtures(db, status="running")
role = "你哥奢皇"
legacy = {
"act_alias": "cjm",
"role_name": role,
"area_name": "微信",
"plat_name": "安卓(android)",
"is_bound_account": True,
"is_bound_role": True,
"is_bound_act": False,
"need_bind_act": False,
"need_bind_role": True,
"change_role_wait_time": 0,
"can_change_time": 0,
"can_change_role": True,
}
activity = {
**legacy,
"act_alias": "20260120QYOOB",
"is_bound_act": True,
"need_bind_act": True,
"can_change_time": 1_790_870_400,
}
client = type(
"Client",
(),
{"get_bind_qr": lambda self, _alias: {"url": "https://example.test/qr"}},
)()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
monkeypatch.setattr(runner, "_client", lambda _cookie: client)
monkeypatch.setattr(
runner,
"_fetch_bind_info_candidates",
lambda *_args: [legacy, activity],
)
runner._execute_get_bind_qr(
db,
task,
account,
"PHPSESSID=x",
{
"bind_act_alias": "20260120QYOOB",
"confirm_act_alias": "20260120QYOOB",
"legacy_act_alias": "cjm",
},
)
db.refresh(task)
assert task.status == "success"
assert task.result["url"] == "https://example.test/qr"
assert task.result["pending_role_name"] == role
assert task.result["bind_ready_for_confirm"] is True
assert task.result["bind_decision"]["alias"] == "20260120QYOOB"
assert (
task.result["bind_decision"]["reason"]
== "same_alias_after_bound_transition"
)
def test_binding_poll_accepts_existing_action_alias_pending_same_role(
db, monkeypatch
):
"""活动 alias 的同名待确认角色不能被 legacy(cjm) 的旧快照压掉。"""
_, account, task = _fixtures(db, status="running")
role = "忧郁情潇藏心中"
legacy = {
"act_alias": "cjm",
"role_name": role,
"area_name": "微信",
"plat_name": "安卓(android)",
"is_bound_account": True,
"is_bound_role": True,
"is_bound_act": False,
"need_bind_act": False,
"need_bind_role": True,
"change_role_wait_time": 0,
"can_change_time": 0,
"can_change_role": True,
}
activity = {
**legacy,
"act_alias": "20260120QYOOB",
"need_bind_act": True,
"change_role_wait_time": 2_592_000,
}
task.queue_lane = "binding_poll"
task.next_run_at = datetime.now(UTC)
task.run_deadline_at = datetime.now(UTC) + timedelta(minutes=10)
task.result = {
"url": "https://example.test/qr",
"query_act_aliases": ["cjm", "20260120QYOOB"],
"baseline_role_name": role,
"baseline_is_bound_act": False,
"before_bind_info": activity,
"bind_polling": True,
}
db.commit()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
client = type("Client", (), {})()
monkeypatch.setattr(runner, "_client", lambda _cookie: client)
monkeypatch.setattr(
runner,
"_fetch_bind_info_candidates",
lambda *_args: [legacy, activity],
)
runner.poll_bind_role_once(
db,
task,
account,
{
"bind_act_alias": "20260120QYOOB",
"confirm_act_alias": "20260120QYOOB",
"legacy_act_alias": "cjm",
},
)
db.refresh(task)
assert task.status == "success"
assert task.result["role_name"] == role
assert task.result["bind_ready_for_confirm"] is True
assert task.result["bind_decision"]["alias"] == "20260120QYOOB"
assert task.result["bind_decision"]["reason"] == "existing_actionable_pending"
assert {
row["alias"]: row["reason"]
for row in task.result["bind_candidate_decisions"]
} == {
"cjm": "same_role_stale",
"20260120QYOOB": "existing_actionable_pending",
}
def test_active_task_budget_rejects_new_batch(db, monkeypatch):
user = User(username="budget-user", password_hash="hash", role="operation")
db.add(user)
db.flush()
account = Account(
username="budget-account",
password="password",
email="budget@example.com",
email_password="mail-password",
cookie="acf_uid=3",
)
db.add(account)
db.commit()
monkeypatch.setattr(douyu_service, "DOUYU_MAX_ACTIVE_TASKS", 1)
douyu_service.create_douyu_planned_tasks(
db,
[account.id],
"query_points",
"elite",
user.id,
)
with pytest.raises(douyu_service.DouyuTaskBackpressureError, match="上限 1"):
douyu_service.create_douyu_planned_tasks(
db,
[account.id],
"query_game_name",
"elite",
user.id,
)
def test_active_batch_budget_returns_429(monkeypatch):
monkeypatch.setattr(douyu_router, "DOUYU_MAX_ACTIVE_BATCHES", 1)
with pytest.raises(HTTPException) as exc_info:
douyu_router._ensure_active_batch_budget(1)
assert exc_info.value.status_code == 429
def test_douyu_batch_request_allows_ten_workers_for_payment_qr():
req = DouyuTaskBatchRequest(
account_ids=[1],
task_type="create_gold_qr",
handbook_scope="elite",
concurrency=10,
)
assert req.concurrency == 10
with pytest.raises(ValidationError):
DouyuTaskBatchRequest(
account_ids=[1],
task_type="create_gold_qr",
handbook_scope="elite",
concurrency=11,
)
def test_batch_task_concurrency_is_capped_at_five():
assert douyu_concurrency.clamp_batch_task_concurrency(20) == 5
assert douyu_concurrency.clamp_douyu_task_concurrency("query_points", 20) == 5
assert douyu_concurrency.clamp_douyu_task_concurrency("create_gold_qr", 20) == 10
def test_runner_applies_task_specific_concurrency(db):
payment = DouyuBatchRunner(
db,
"payment-batch",
"create_gold_qr",
concurrency=10,
close_db=False,
)
overview = DouyuBatchRunner(
db,
"overview-batch",
"query_account_overview",
concurrency=10,
close_db=False,
)
assert payment.concurrency == 10
assert overview.concurrency == 5
def test_douyu_lanes_separate_interactive_query_payment_and_writes():
assert douyu_lane_for_task("get_bind_qr") == TaskLane.INTERACTIVE_BINDING
assert douyu_lane_for_task("query_account_overview") == TaskLane.OVERVIEW_QUERY
assert douyu_lane_for_task("create_gold_qr") == TaskLane.PAYMENT_QR
assert douyu_lane_for_task("exchange_goods") == TaskLane.OPS_WRITE
assert _DEFAULT_WORKERS[TaskLane.PAYMENT_QR] == 10
assert _DEFAULT_WORKERS[TaskLane.PAYMENT_POLL] == 3
assert _DEFAULT_WORKERS[TaskLane.OVERVIEW_QUERY] == 5
assert _DEFAULT_WORKERS[TaskLane.BINDING_POLL] == 6
def test_slim_task_result_removes_debug_payloads():
result = slim_douyu_task_result_for_storage(
{
"url": "https://example.test/qr",
"raw": {"debug": True},
"query_params": {"token": "secret"},
"before_bind_info": {
"role_name": "role-a",
"raw": {"debug": True},
},
"items": [{"name": "kept", "raw": {"debug": True}}],
}
)
assert result == {
"url": "https://example.test/qr",
"before_bind_info": {"role_name": "role-a"},
"items": [{"name": "kept"}],
}
def test_health_endpoint_does_not_use_db_threadpool():
assert inspect.iscoroutinefunction(health)
def test_mysql_lock_wait_timeout_is_bounded():
with app_engine.connect() as connection:
value = connection.execute(
text("SELECT @@SESSION.innodb_lock_wait_timeout")
).scalar()
assert value is not None
assert int(value) <= 10