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

1375 lines
41 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import inspect
from datetime import UTC, datetime, timedelta
import pytest
from fastapi import HTTPException
from pydantic import ValidationError
from sqlalchemy import text
from core.douyu import DouyuActivityError
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"
def test_force_cleanup_stops_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,
batch_id=task.batch_id,
statuses=("running",),
include_durable=True,
message="任务已停止(批次不存在)",
)
db.refresh(task)
assert cleaned == 1
assert task.status == "stopped"
assert task.queue_lane == ""
assert task.next_run_at is None
@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": "old-role",
"baseline_is_bound_act": True,
"before_bind_info": {
"act_alias": "bind-act",
"role_name": "old-role",
"is_bound_act": True,
"is_bound_role": True,
"need_bind_act": True,
"need_bind_role": 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": False,
"is_bound_role": True,
"need_bind_act": True,
"need_bind_role": 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": 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,
"_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_confirm_bind_maps_platform_cooldown_and_keeps_old_role(
db, monkeypatch
):
"""2026-11-22 失败 HAR:-200001 是斗鱼账号冷却,旧绑定不能被新角色覆盖。"""
_, account, task = _fixtures(db, status="running")
old_role = "狗鼻子弗尼亚bd"
new_role = "巫师基尔斯84"
task.task_type = "confirm_bind"
task.result = {
"expected_role_name": new_role,
"baseline_role_name": old_role,
}
account.game_name = old_role
account.role_bind_status = "bound"
db.commit()
can_change_time = int(
(datetime.now(UTC) + timedelta(days=2)).timestamp()
)
old_bound = {
"act_alias": "20260120QYOOB",
"role_name": old_role,
"area_name": "微信",
"plat_name": "安卓(android)",
"is_bound_account": True,
"is_bound_role": True,
"is_bound_act": True,
"need_bind_act": True,
"need_bind_role": True,
"change_role_wait_time": 172_800,
"can_change_time": can_change_time,
"can_change_role": False,
}
new_pending = {
**old_bound,
"act_alias": "cjm",
"role_name": new_role,
"area_name": "微信",
"plat_name": "苹果(iOS)",
"is_bound_act": False,
"change_role_wait_time": 0,
"can_change_time": 0,
"can_change_role": True,
}
payload = {
"error": -200001,
"msg": "该平台账号未到可换绑时间,请使用其他平台账号",
"data": None,
}
class Client:
@staticmethod
def confirm_bind(_alias):
raise DouyuActivityError(
payload["msg"],
code=payload["error"],
payload=payload,
)
runner = DouyuBatchRunner(
db,
task.batch_id,
"confirm_bind",
close_db=False,
)
monkeypatch.setattr(runner, "_client", lambda _cookie: Client())
monkeypatch.setattr(
runner,
"_fetch_bind_info_candidates",
lambda *_args: [old_bound, new_pending],
)
runner._execute_confirm_bind(
db,
task,
account,
"PHPSESSID=x",
{
"bind_act_alias": "20260120QYOOB",
"confirm_act_alias": "20260120QYOOB",
"legacy_act_alias": "cjm",
},
)
db.refresh(task)
db.refresh(account)
assert task.status == "failed"
assert task.result["issue_code"] == "account_role_cooldown"
assert task.result["confirm_error_code"] == -200001
assert task.result["before_bound_bind_info"]["role_name"] == old_role
assert task.result["role_name"] == new_role
assert task.result["bind_ready_for_confirm"] is False
assert "斗鱼账号" in task.message
assert "更换斗鱼账号" in task.message
assert account.game_name == old_role
assert account.role_bind_status == "bound"
def test_qr_preflight_accepts_existing_action_alias_pending_from_har(
db, monkeypatch
):
"""2026-11-22 成功 HAR:已有 bindAct=0 角色无需等新一轮状态变化。"""
_, 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["bind_phase"] == "role_ready"
assert task.result["bind_ready_for_confirm"] is True
assert task.result["pending_role_name"] == role
assert task.result["bind_decision"]["alias"] == "20260120QYOOB"
assert task.result["bind_decision"]["reason"] == "existing_actionable_pending"
def test_qr_preflight_keeps_bound_role_waiting_for_new_scan_transition(
db, monkeypatch
):
"""历史 bindAct=1 + needBindAct=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 == "running"
assert task.result["url"] == "https://example.test/qr"
assert task.result["bind_phase"] == "waiting_scan"
assert task.result["bind_ready_for_confirm"] is False
assert "pending_role_name" not in task.result
action_decision = next(
item
for item in task.result["bind_candidate_decisions"]
if item["alias"] == "20260120QYOOB"
)
assert action_decision["reason"] == "already_bound"
def test_qr_preflight_blocks_platform_account_change_cooldown_from_har(
db, monkeypatch
):
"""2026-11-22 失败 HAR:canChangeTime 限制当前斗鱼号,发码前就必须拦截。"""
_, account, task = _fixtures(db, status="running")
role = "狗鼻子弗尼亚bd"
can_change_time = int(
(datetime.now(UTC) + timedelta(days=2)).timestamp()
)
activity = {
"act_alias": "20260120QYOOB",
"role_name": role,
"area_name": "微信",
"plat_name": "安卓(android)",
"is_bound_account": True,
"is_bound_role": True,
"is_bound_act": True,
"need_bind_act": True,
"need_bind_role": True,
"change_role_wait_time": 172_800,
"can_change_time": can_change_time,
"can_change_role": False,
}
account.game_name = role
account.role_bind_status = "bound"
db.commit()
client = type(
"Client",
(),
{
"get_bind_qr": lambda *_args: (_ for _ in ()).throw(
AssertionError("斗鱼账号冷却时不能生成二维码")
)
},
)()
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: [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)
db.refresh(account)
assert task.status == "failed"
assert task.result["bind_phase"] == "change_waiting"
assert task.result["issue_code"] == "account_role_cooldown"
assert "url" not in task.result
assert "斗鱼账号" in task.message
assert account.game_name == role
assert account.role_bind_status == "bound"
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": True,
"before_bind_info": {**activity, "is_bound_act": True},
"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"] == "same_alias_after_bound_transition"
assert {
row["alias"]: row["reason"]
for row in task.result["bind_candidate_decisions"]
} == {
"cjm": "same_role_stale",
"20260120QYOOB": "same_alias_after_bound_transition",
}
def test_binding_poll_accepts_unchanged_existing_action_alias_pending(
db, monkeypatch
):
"""2026-11-22 成功 HAR:已有动作 alias pending 不要求本轮状态变化。"""
_, account, task = _fixtures(db, status="running")
role = "只为爱杰宝"
legacy = {
"act_alias": "cjm",
"role_name": role,
"area_name": "手Q",
"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,
"qr_generated_at": datetime.now(UTC).isoformat(),
"poll_count": 2,
}
db.commit()
runner = DouyuBatchRunner(
db,
task.batch_id,
"get_bind_qr",
close_db=False,
)
monkeypatch.setattr(runner, "_client", lambda _cookie: object())
monkeypatch.setattr(
runner,
"_fetch_bind_info_candidates",
lambda _client, aliases: [
legacy if alias == "cjm" else activity for alias in aliases
],
)
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["bind_phase"] == "role_ready"
assert task.result["role_name"] == role
assert task.result["bind_decision"]["alias"] == "20260120QYOOB"
assert task.result["bind_decision"]["reason"] == "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