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

2034 lines
70 KiB
Python

"""直播账号履约:订单同步、映射、选号、绑码状态和人工完成。"""
from __future__ import annotations
import asyncio
from datetime import UTC, datetime, timedelta
from unittest.mock import patch
import pytest
from fastapi import HTTPException
from tests.support.db import get_test_engine, make_test_session
from web.backend.deps import require_permission
from web.backend.models import (
Account,
AccountCommodityState,
AccountEvent,
AccountLease,
AutomationJob,
DouyuExternalOrder,
DouyuGoodsSnapshot,
DouyuTask,
IntegrationOutbox,
PlatformCommodityMapping,
PlatformFulfillmentEvent,
PlatformFulfillmentSetting,
PlatformFulfillmentTask,
User,
)
from web.backend.permissions import ROLE_PERMISSIONS
from web.backend.schemas import DouyuCollabOrderOut
from web.backend.services import douyu_collab_service as collab
from web.backend.services.automation.jobs import (
platform_fulfillment_lease_reaper as reaper,
)
from web.backend.services.douyu_account_state import DouyuLiveAccountState
from web.backend.services.douyu_activity_query import DouyuEligibilityResult
from web.backend.services.platform_fulfillment import account_selector, service
NOW = datetime.now(UTC).replace(microsecond=0)
COMMODITY = "20260120QYOOB_bag10"
INTERNAL_SKU = "套装-兔兔白日梦"
class _Base:
def setup_method(self):
self.engine = get_test_engine()
self.session = make_test_session(self.engine)
self.admin = User(
username="pf-admin",
password_hash="h",
role="super_admin",
)
self.session.add(self.admin)
self.session.commit()
self.admin_id = self.admin.id
self.session.add(
PlatformFulfillmentSetting(
id=1,
lease_duration_minutes=None,
order_match_started_at=NOW - timedelta(days=1),
)
)
self.session.commit()
self.refresh_patch = patch.object(
service,
"refresh_douyu_account_state",
side_effect=self._live_state,
)
self.refresh_mock = self.refresh_patch.start()
def teardown_method(self):
self.refresh_patch.stop()
self.session.close()
@staticmethod
def _live_state(_db, account, **_kwargs):
return DouyuLiveAccountState(
account_id=account.id,
account_name=account.username,
checked_at=NOW,
ck_verdict="valid",
ck_message="有效",
elite_opened=True,
points=account.points or 2000,
limited_ids=frozenset(),
role_change_available_at=account.role_change_available_at,
)
def account(
self,
name: str,
*,
points: int = 2000,
opened: bool = True,
role_available_at: datetime | None = None,
) -> Account:
row = Account(
username=name,
password="p",
email=f"{name}@example.com",
email_password="ep",
status="active",
ck_check_status="valid",
cookie="PHPSESSID=x",
elite_opened=opened,
points=points,
gold_balance=100,
auto_managed=True,
role_change_available_at=role_available_at,
)
self.session.add(row)
self.session.commit()
return row
def mapping(self, enabled: bool = True) -> PlatformCommodityMapping:
row = PlatformCommodityMapping(
target_platform="douyu",
internal_sku_key=INTERNAL_SKU,
commodity_id=COMMODITY,
goods_name=INTERNAL_SKU,
required_points=1280,
scope="elite",
enabled=enabled,
created_by=self.admin_id,
created_at=NOW,
updated_at=NOW,
)
self.session.add(row)
self.session.commit()
return row
def task(self, *, mapped: bool = True) -> PlatformFulfillmentTask:
mapping = self.mapping() if mapped else None
row = PlatformFulfillmentTask(
source_system="order_site",
source_order_id="100",
source_order_item_id="101",
source_fulfillment_id="201",
platform_order_id="ORDER-101",
provider="91kaquan",
shop_id="shop-1",
shop_name="测试店",
sku_code=INTERNAL_SKU,
sku_name=INTERNAL_SKU,
internal_sku_key=INTERNAL_SKU,
quantity=1,
order_amount_fen=9900,
target_platform="douyu",
scope="elite",
commodity_mapping_id=mapping.id if mapping else None,
commodity_id=COMMODITY if mapping else "",
required_points=1280 if mapping else None,
binding_status="not_started",
execution_status="ready" if mapping else "pending_mapping",
exchange_status="not_started",
source_snapshot_json={"order_no": "ORDER-101"},
paid_at=NOW,
created_at=NOW,
updated_at=NOW,
)
self.session.add(row)
self.session.commit()
return row
class TestSyncAndMapping(_Base):
def test_sync_skips_external_orders_when_no_mapping_is_configured(
self, monkeypatch
):
monkeypatch.setattr(
service,
"list_pending_manual_fulfillments",
lambda **_kwargs: (_ for _ in ()).throw(
AssertionError("没有映射时不应查询 order_site")
),
)
result = service.sync_pending_tasks(self.session, limit=10)
assert result["fetched"] == 0
assert result["created"] == 0
assert result["configuredSkuCount"] == 0
assert self.session.query(PlatformFulfillmentTask).count() == 0
def test_sync_is_idempotent_and_applies_mapping(self, monkeypatch):
self.mapping()
cutoff = NOW - timedelta(days=1)
captured_keys: list[str] = []
captured_cutoff: list[datetime | None] = []
def _rows(
*,
limit: int,
internal_sku_keys: list[str],
paid_at_from: datetime | None,
):
del limit
captured_keys.extend(internal_sku_keys)
captured_cutoff.append(paid_at_from)
return [
{
"source_order_id": "100",
"source_order_item_id": "101",
"source_fulfillment_id": "201",
"platform_order_id": "ORDER-101",
"provider": "91kaquan",
"shop_id": "shop-1",
"shop_name": "测试店",
"sku_code": INTERNAL_SKU,
"sku_name": INTERNAL_SKU,
"internal_sku_key": INTERNAL_SKU,
"quantity": 1,
"revenue_amount_fen": 9900,
"total_amount": 9900,
"paid_at": NOW,
"item_updated_at": NOW,
}
]
monkeypatch.setattr(
service,
"list_pending_manual_fulfillments",
_rows,
)
first = service.sync_pending_tasks(self.session, limit=10)
second = service.sync_pending_tasks(self.session, limit=10)
assert first["created"] == 1
assert second["created"] == 0
assert captured_keys == [INTERNAL_SKU, INTERNAL_SKU]
assert captured_cutoff == [cutoff, cutoff]
assert self.session.query(PlatformFulfillmentTask).count() == 1
task = self.session.query(PlatformFulfillmentTask).one()
assert task.execution_status == "ready"
assert task.commodity_id == COMMODITY
assert task.paid_at == NOW
def test_list_only_returns_tasks_that_have_a_commodity_mapping(self):
legacy = self.task(mapped=False)
mapping = self.mapping()
mapped = PlatformFulfillmentTask(
source_system="order_site",
source_order_id="102",
source_order_item_id="103",
source_fulfillment_id="203",
platform_order_id="ORDER-103",
provider="91kaquan",
shop_id="shop-1",
shop_name="测试店",
sku_code=INTERNAL_SKU,
sku_name=INTERNAL_SKU,
internal_sku_key=INTERNAL_SKU,
quantity=1,
order_amount_fen=9900,
target_platform="douyu",
scope="elite",
commodity_mapping_id=mapping.id,
commodity_id=COMMODITY,
required_points=1280,
binding_status="not_started",
execution_status="ready",
exchange_status="not_started",
source_snapshot_json={"order_no": "ORDER-103"},
paid_at=NOW,
created_at=NOW,
updated_at=NOW,
)
self.session.add(mapped)
self.session.commit()
listed = service.list_tasks(self.session)
assert [item["id"] for item in listed["items"]] == [mapped.id]
assert listed["pagination"]["total"] == 1
assert legacy.id != mapped.id
def test_list_hides_tasks_paid_before_order_match_cutoff(self):
mapping = self.mapping()
task = PlatformFulfillmentTask(
source_system="order_site",
source_order_id="104",
source_order_item_id="105",
source_fulfillment_id="205",
platform_order_id="ORDER-105",
sku_code=INTERNAL_SKU,
sku_name=INTERNAL_SKU,
internal_sku_key=INTERNAL_SKU,
quantity=1,
target_platform="douyu",
scope="elite",
commodity_mapping_id=mapping.id,
commodity_id=COMMODITY,
required_points=1280,
binding_status="not_started",
execution_status="ready",
exchange_status="not_started",
paid_at=NOW - timedelta(hours=2),
created_at=NOW,
updated_at=NOW,
)
self.session.add(task)
self.session.commit()
service.update_settings(
self.session,
lease_duration_minutes=None,
order_match_started_at=NOW - timedelta(hours=1),
current=self.admin,
)
listed = service.list_tasks(self.session)
assert listed["pagination"]["total"] == 0
def test_list_order_is_stable_by_paid_time_not_updated_at(self):
first = self.task()
second = PlatformFulfillmentTask(
source_system="order_site",
source_order_id="108",
source_order_item_id="109",
source_fulfillment_id="209",
platform_order_id="ORDER-109",
provider="91kaquan",
shop_id="shop-1",
shop_name="测试店",
sku_code=INTERNAL_SKU,
sku_name=INTERNAL_SKU,
internal_sku_key=INTERNAL_SKU,
quantity=1,
order_amount_fen=9900,
target_platform="douyu",
scope="elite",
commodity_mapping_id=first.commodity_mapping_id,
commodity_id=COMMODITY,
required_points=1280,
binding_status="not_started",
execution_status="ready",
exchange_status="not_started",
paid_at=NOW + timedelta(minutes=1),
created_at=NOW,
updated_at=NOW,
)
self.session.add(second)
self.session.commit()
# 模拟 worker 重试:旧订单的 updated_at 变得更新,但列表顺序不能跳。
first.updated_at = NOW + timedelta(minutes=10)
self.session.commit()
listed = service.list_tasks(self.session)
assert [item["id"] for item in listed["items"]] == [second.id, first.id]
def test_list_includes_recent_paid_task_created_before_order_match_cutoff(self):
mapping = self.mapping()
task = PlatformFulfillmentTask(
source_system="order_site",
source_order_id="106",
source_order_item_id="107",
source_fulfillment_id="207",
platform_order_id="ORDER-107",
sku_code=INTERNAL_SKU,
sku_name=INTERNAL_SKU,
internal_sku_key=INTERNAL_SKU,
quantity=1,
target_platform="douyu",
scope="elite",
commodity_mapping_id=mapping.id,
commodity_id=COMMODITY,
required_points=1280,
binding_status="not_started",
execution_status="ready",
exchange_status="not_started",
paid_at=NOW,
created_at=NOW - timedelta(hours=2),
updated_at=NOW,
)
self.session.add(task)
self.session.commit()
service.update_settings(
self.session,
lease_duration_minutes=None,
order_match_started_at=NOW - timedelta(hours=1),
current=self.admin,
)
listed = service.list_tasks(self.session)
assert [item["id"] for item in listed["items"]] == [task.id]
def test_customer_session_ignores_task_before_order_match_cutoff(
self,
monkeypatch,
):
task = self.task()
assert task.paid_at is not None
service.update_settings(
self.session,
lease_duration_minutes=None,
order_match_started_at=task.paid_at + timedelta(minutes=1),
current=self.admin,
)
monkeypatch.setattr(
service,
"lookup_pending_manual_fulfillment",
lambda *_args, **_kwargs: None,
)
with pytest.raises(HTTPException) as exc_info:
service.ensure_customer_session(
self.session,
source_order_item_id=task.source_order_item_id,
platform_order_id=task.platform_order_id,
)
assert exc_info.value.status_code == 404
def test_upsert_mapping_advances_existing_task(self):
task = self.task(mapped=False)
self.session.add(
DouyuGoodsSnapshot(
commodity_id=COMMODITY,
name=INTERNAL_SKU,
score=1280,
)
)
self.session.commit()
service.upsert_mapping(
self.session,
internal_sku_key=INTERNAL_SKU,
commodity_id=COMMODITY,
goods_name="",
required_points=None,
enabled=True,
current=self.admin,
)
self.session.refresh(task)
assert task.execution_status == "ready"
assert task.commodity_id == COMMODITY
assert task.required_points == 1280
class TestFulfillmentCollabSync(_Base):
def _task_with_account(
self,
*,
execution_status: str = "ready",
) -> PlatformFulfillmentTask:
task = self.task()
account = self.account("collab-sync-account")
task.account_id = account.id
task.execution_status = execution_status
self.session.commit()
return task
def test_manual_sync_creates_projected_collab_order(self):
task = self._task_with_account()
mapping = self.session.query(PlatformCommodityMapping).one()
mapping.goods_name = "套装-兔兔白日梦(斗鱼)"
self.session.add(
DouyuGoodsSnapshot(
commodity_id=COMMODITY,
name="不应覆盖显式映射",
score=999,
)
)
bind_task = DouyuTask(
batch_id="collab-sync-bind",
account_id=task.account_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="success",
result={
"role_name": "已确认角色",
"bind_confirmed": True,
"area_name": "微信",
"plat_name": "苹果(iOS)",
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
self.session.commit()
order, action = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
assert action == "created"
assert order.order_no == task.platform_order_id
assert order.source_type == "platform_fulfillment"
assert order.source_task_id == task.id
assert order.source_order_id == task.source_order_id
assert order.source_order_item_id == task.source_order_item_id
assert order.source_platform_order_id == task.platform_order_id
assert order.last_synced_at is not None
assert order.shop == task.shop_name
assert order.gift_name == "套装-兔兔白日梦(斗鱼)"
assert order.commodity_id == COMMODITY
assert order.required_points == 1280
assert order.account_id == task.account_id
assert order.account_username == "collab-sync-account"
assert order.bind_game_role == "已确认角色"
assert order.bind_game_channel == "微信 / 苹果(iOS)"
assert order.status == collab.STATUS_INCOMPLETE
payload = DouyuCollabOrderOut.model_validate(
collab.serialize_one(self.session, order)
).model_dump()
assert payload["source_task_id"] == task.id
assert payload["source_platform_order_id"] == task.platform_order_id
assert (
self.session.query(AccountEvent)
.filter(AccountEvent.event_type == "collab_synced")
.count()
== 1
)
def test_manual_sync_does_not_clear_account_added_in_collab(self):
task = self.task()
order, _ = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
account = self.account("manual-collab-account")
order.account_id = account.id
order.account_username = account.username
self.session.commit()
synced, _ = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
assert synced.account_id == account.id
assert synced.account_username == account.username
def test_manual_sync_is_idempotent_and_preserves_human_fields(self):
task = self._task_with_account()
order, _ = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
other_owner = User(
username="collab-owner",
password_hash="h",
role="operator",
)
self.session.add(other_owner)
self.session.commit()
order.owner_id = other_owner.id
order.fish_fin_balance = 321
order.points_balance = 654
order.points_check_message = "人工核账快照"
order.remark = "客服人工备注"
order.order_no = f"PF{task.id}"
self.session.commit()
synced, action = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
assert action == "updated"
assert self.session.query(DouyuExternalOrder).count() == 1
assert synced.id == order.id
assert synced.order_no == task.platform_order_id
assert synced.owner_id == other_owner.id
assert synced.fish_fin_balance == 321
assert synced.points_balance == 654
assert synced.points_check_message == "人工核账快照"
assert synced.remark == "客服人工备注"
def test_manual_sync_links_existing_collab_order_with_real_order_no(self):
task = self.task()
manual = DouyuExternalOrder(
order_no=task.platform_order_id,
shop="人工先建单",
owner_id=self.admin.id,
remark="人工备注保留",
status="to_recharge",
created_by=self.admin.id,
updated_by=self.admin.id,
)
self.session.add(manual)
self.session.commit()
synced, action = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
assert action == "updated"
assert synced.id == manual.id
assert synced.order_no == task.platform_order_id
assert synced.source_type == "platform_fulfillment"
assert synced.source_task_id == task.id
assert synced.remark == "人工备注保留"
def test_manual_sync_preserves_existing_collab_account_and_role(self):
task = self.task()
task_account = self.account("task-account")
manual_account = self.account("manual-account")
task.account_id = task_account.id
manual = DouyuExternalOrder(
order_no=task.platform_order_id,
account_id=manual_account.id,
account_username=manual_account.username,
bind_game_role="人工绑定角色",
bind_game_channel="手工渠道",
status="to_recharge",
)
self.session.add(manual)
self.session.commit()
synced, action = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
assert action == "updated"
assert synced.id == manual.id
assert synced.account_id == manual_account.id
assert synced.account_username == manual_account.username
assert synced.bind_game_role == "人工绑定角色"
assert synced.bind_game_channel == "手工渠道"
assert synced.status == "to_recharge"
def test_manual_sync_maps_only_safe_terminal_statuses(self):
task = self._task_with_account()
order, _ = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
order.status = collab.STATUS_TO_RECHARGE
self.session.commit()
task.execution_status = "completed"
task.completed_at = NOW
self.session.commit()
order, _ = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
assert order.status == collab.STATUS_DONE
assert order.done_at == NOW
cancelled = PlatformFulfillmentTask(
source_system="order_site",
source_order_id="200",
source_order_item_id="201",
source_fulfillment_id="301",
platform_order_id="ORDER-201",
sku_code=INTERNAL_SKU,
sku_name=INTERNAL_SKU,
internal_sku_key=INTERNAL_SKU,
commodity_mapping_id=task.commodity_mapping_id,
commodity_id=COMMODITY,
required_points=1280,
execution_status="cancelled",
paid_at=NOW,
created_at=NOW,
updated_at=NOW,
)
self.session.add(cancelled)
self.session.commit()
cancelled_order, action = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
cancelled,
)
assert action == "created"
assert cancelled_order.status == collab.STATUS_VOID
assert cancelled_order.void_reason == "直播履约任务已取消"
def test_manual_sync_batch_reports_created_and_missing(self):
first = self.task()
second = PlatformFulfillmentTask(
source_system="order_site",
source_order_id="300",
source_order_item_id="301",
source_fulfillment_id="401",
platform_order_id="ORDER-301",
sku_code=INTERNAL_SKU,
sku_name=INTERNAL_SKU,
internal_sku_key=INTERNAL_SKU,
commodity_mapping_id=first.commodity_mapping_id,
commodity_id=COMMODITY,
required_points=1280,
execution_status="ready",
paid_at=NOW,
created_at=NOW,
updated_at=NOW,
)
self.session.add(second)
self.session.commit()
result = collab.sync_platform_fulfillment_orders(
self.session,
self.admin,
task_ids=[first.id, second.id, 99999999],
)
assert result["requested"] == 3
assert result["created"] == 2
assert result["updated"] == 0
assert result["skipped"] == 1
assert result["failed"] == 0
assert [item["action"] for item in result["items"]] == [
"created",
"created",
"skipped",
]
def test_task_list_exposes_linked_collab_order(self):
task = self._task_with_account()
order, _ = collab.sync_platform_fulfillment_order(
self.session,
self.admin,
task,
)
listed = service.list_tasks(self.session)
assert listed["items"][0]["collabOrder"] == {
"id": order.id,
"orderNo": order.order_no,
"status": collab.STATUS_INCOMPLETE,
"lastSyncedAt": order.last_synced_at,
}
class TestSnapshotSync(_Base):
def snapshot(self, **overrides):
payload = {
"sourceOrderId": "100",
"sourceOrderItemId": "101",
"sourceFulfillmentId": "201",
"platformOrderId": "ORDER-101",
"provider": "91kaquan",
"shopId": "shop-1",
"shopName": "测试店",
"orderStatus": "paid",
"payStatus": "paid",
"skuCode": INTERNAL_SKU,
"skuName": INTERNAL_SKU,
"internalSkuKey": INTERNAL_SKU,
"quantity": 1,
"revenueAmountFen": 9900,
"orderCreatedAt": NOW.isoformat(),
"paidAt": NOW.isoformat(),
"fulfillmentStatus": "assigned",
"fulfillmentChannel": "manual",
"configEnabled": True,
"douyuFulfillmentEnabled": True,
}
payload.update(overrides)
return payload
def test_order_snapshot_creates_task_without_external_database_read(
self, monkeypatch
):
self.mapping()
monkeypatch.setattr(
service,
"lookup_pending_manual_fulfillment",
lambda *_args, **_kwargs: (_ for _ in ()).throw(
AssertionError("新快照契约不应回查 order_site")
),
)
result = service.sync_order_snapshot(
self.session,
{
"eventType": "platform_fulfillment.order_snapshot",
"contractVersion": 2,
"data": self.snapshot(),
},
)
task = self.session.query(PlatformFulfillmentTask).one()
assert result["created"] == 1
assert task.execution_status == "ready"
assert task.next_allocate_at is not None
assert task.state_version == 1
outbox = self.session.query(IntegrationOutbox).one()
assert outbox.payload_json["items"][0]["stateVersion"] == 1
def test_duplicate_snapshot_keeps_allocated_task_state(self):
self.mapping()
account = self.account("snapshot-allocated")
service.sync_order_snapshot(self.session, {"data": self.snapshot()})
task = self.session.query(PlatformFulfillmentTask).one()
service.allocate_task(
self.session,
task_id=task.id,
current=self.admin,
)
service.sync_order_snapshot(self.session, {"data": self.snapshot()})
self.session.refresh(task)
assert task.execution_status == "allocated"
assert task.account_id == account.id
assert task.lease_id is not None
assert task.next_allocate_at is None
assert task.exchange_status == "eligible"
assert task.issue_code == ""
def test_duplicate_snapshot_preserves_allocation_retry(self):
self.mapping()
service.sync_order_snapshot(self.session, {"data": self.snapshot()})
task = self.session.query(PlatformFulfillmentTask).one()
retry_at = NOW + timedelta(seconds=45)
task.issue_code = "no_eligible_account"
task.last_error = "当前没有可用账号"
task.next_allocate_at = retry_at
self.session.commit()
service.sync_order_snapshot(self.session, {"data": self.snapshot()})
self.session.refresh(task)
assert task.execution_status == "ready"
assert task.issue_code == "no_eligible_account"
assert task.last_error == "当前没有可用账号"
assert task.next_allocate_at == retry_at
def test_legacy_event_only_reads_the_specified_order_item(self, monkeypatch):
self.mapping()
requested: list[str] = []
def lookup(item_id: str):
requested.append(item_id)
return self.snapshot()
monkeypatch.setattr(service, "lookup_pending_manual_fulfillment", lookup)
result = service.sync_order_item_ids(self.session, ["101"])
assert requested == ["101"]
assert result["created"] == 1
assert self.session.query(PlatformFulfillmentTask).count() == 1
def test_terminal_snapshot_cancels_task_and_increments_state_version(self):
self.mapping()
service.sync_order_snapshot(self.session, {"data": self.snapshot()})
service.sync_order_snapshot(
self.session,
{"data": self.snapshot(orderStatus="refunded")},
)
task = self.session.query(PlatformFulfillmentTask).one()
assert task.execution_status == "cancelled"
assert task.state_version == 2
assert task.next_allocate_at is None
def test_unpaid_snapshot_does_not_enter_live_fulfillment(self):
self.mapping()
result = service.sync_order_snapshot(
self.session,
{"data": self.snapshot(payStatus="unpaid")},
)
assert result["created"] == 0
assert result["ignored"] == 1
assert self.session.query(PlatformFulfillmentTask).count() == 0
class TestAccountSelection(_Base):
def test_capability_match_checks_only_selected_candidate(self, monkeypatch):
account = self.account("capability-fast")
task = self.task()
self.session.add(
AccountCommodityState(
account_id=account.id,
platform="douyu",
scope="elite",
commodity_id=COMMODITY,
commodity_name=INTERNAL_SKU,
availability="available",
observed_at=NOW,
valid_until=NOW + timedelta(minutes=15),
source="overview",
)
)
self.session.commit()
monkeypatch.setenv("PLATFORM_FULFILLMENT_MATCH_MODE", "capability")
detail = service.allocate_task(
self.session,
task_id=task.id,
current=self.admin,
)
assert detail["task"]["account"]["id"] == account.id
assert detail["task"]["executionStatus"] == "allocated"
self.refresh_mock.assert_called_once()
def test_hybrid_falls_back_to_live_scan_when_capability_candidate_fails(
self,
monkeypatch,
):
capability_account = self.account("capability-stale")
live_account = self.account("live-fallback")
task = self.task()
self.session.add(
AccountCommodityState(
account_id=capability_account.id,
platform="douyu",
scope="elite",
commodity_id=COMMODITY,
availability="available",
observed_at=NOW,
valid_until=NOW + timedelta(minutes=15),
source="overview",
)
)
self.session.commit()
def live_state(_db, account, **_kwargs):
return DouyuLiveAccountState(
account_id=account.id,
account_name=account.username,
checked_at=NOW,
ck_verdict="valid",
ck_message="有效",
elite_opened=True,
points=2000,
limited_ids=(
frozenset({COMMODITY})
if account.id == capability_account.id
else frozenset()
),
role_change_available_at=None,
)
self.refresh_mock.side_effect = live_state
monkeypatch.setenv("PLATFORM_FULFILLMENT_MATCH_MODE", "hybrid")
detail = service.allocate_task(
self.session,
task_id=task.id,
current=self.admin,
)
assert detail["task"]["account"]["id"] == live_account.id
assert self.refresh_mock.call_count == 2
def test_allocation_refreshes_live_state_instead_of_cached_filters(self):
account = Account(
username="live-refresh-account",
password="p",
email="live@example.com",
email_password="ep",
status="imported",
ck_check_status="",
cookie="PHPSESSID=live",
elite_opened=None,
points=None,
gold_balance=100,
auto_managed=True,
)
self.session.add(account)
self.session.commit()
task = self.task()
detail = service.allocate_task(
self.session,
task_id=task.id,
current=self.admin,
)
assert detail["task"]["account"]["id"] == account.id
assert detail["task"]["executionStatus"] == "allocated"
self.refresh_mock.assert_called()
def test_live_candidates_include_support_accounts_and_prefer_valid_cache(self):
support = User(
username="pool-support",
password_hash="h",
role="support",
is_active=True,
)
self.session.add(support)
self.session.flush()
invalid = Account(
username="old-invalid",
password="p",
email="invalid@example.com",
email_password="ep",
status="invalid",
ck_check_status="invalid",
ck_checked_at=NOW - timedelta(days=2),
cookie="PHPSESSID=invalid",
auto_managed=True,
)
valid = Account(
username="support-valid",
password="p",
email="valid@example.com",
email_password="ep",
status="active",
ck_check_status="valid",
ck_checked_at=NOW - timedelta(days=1),
cookie="PHPSESSID=valid",
elite_opened=True,
points=2000,
auto_managed=True,
assigned_to=support.id,
)
self.session.add_all([invalid, valid])
self.session.commit()
rows = account_selector.live_candidate_accounts(
self.session,
required_points=1680,
)
assert [row.id for row in rows] == [valid.id, invalid.id]
def test_points_short_is_soft_and_does_not_block_allocation(self):
account = self.account("points-short", points=100)
task = self.task()
detail = service.allocate_task(
self.session,
task_id=task.id,
current=self.admin,
)
assert detail["task"]["account"]["id"] == account.id
assert detail["task"]["executionStatus"] == "allocated"
assert detail["task"]["exchangeStatus"] == "points_short"
assert detail["task"]["issueCode"] == "points_short"
def test_elite_not_opened_is_soft_and_does_not_block_allocation(self):
account = self.account("elite-closed", opened=False)
self.refresh_mock.side_effect = lambda _db, row, **_kwargs: (
DouyuLiveAccountState(
account_id=row.id,
account_name=row.username,
checked_at=NOW,
ck_verdict="valid",
ck_message="有效",
elite_opened=False,
points=2000,
limited_ids=frozenset(),
role_change_available_at=None,
)
)
task = self.task()
detail = service.allocate_task(
self.session,
task_id=task.id,
current=self.admin,
)
assert detail["task"]["account"]["id"] == account.id
assert detail["task"]["executionStatus"] == "allocated"
assert detail["task"]["exchangeStatus"] == "not_opened"
assert detail["task"]["issueCode"] == "elite_not_opened"
def test_eligible_account_excludes_cooldown_and_uses_least_points(self):
self.account("small", points=1300)
self.account("large", points=9000)
self.account(
"cooldown",
points=1400,
role_available_at=NOW + timedelta(days=1),
)
candidates = account_selector.eligible_accounts(
self.session,
commodity_id=COMMODITY,
required_points=1280,
now=NOW,
)
assert [row.username for row in candidates] == ["small", "large"]
def test_lease_is_unique_per_account(self):
account = self.account("leased")
candidate = account_selector.eligible_accounts(
self.session,
commodity_id=COMMODITY,
required_points=1280,
now=NOW,
)[0]
first = account_selector.lease_account(
self.session,
candidate=candidate,
holder_user_id=self.admin_id,
task_id=1,
commodity_id=COMMODITY,
now=NOW,
)
second = account_selector.lease_account(
self.session,
candidate=candidate,
holder_user_id=self.admin_id,
task_id=2,
commodity_id=COMMODITY,
now=NOW,
)
assert first is not None
assert second is None
assert (
self.session.query(AccountLease).filter_by(account_id=account.id).count()
== 1
)
def test_allocate_and_release_task(self):
account = self.account("allocated")
task = self.task()
detail = service.allocate_task(
self.session,
task_id=task.id,
current=self.admin,
)
assert detail["task"]["account"]["id"] == account.id
assert detail["task"]["executionStatus"] == "allocated"
lease = self.session.query(AccountLease).one()
assert lease.purpose == "platform_fulfillment"
assert lease.status == "active"
assert lease.expires_at is None
acquired = (
self.session.query(AccountEvent)
.filter(
AccountEvent.account_id == account.id,
AccountEvent.event_type == "lease_acquired",
)
.one()
)
assert acquired.detail["task_id"] == task.id
released = service.release_task_account(
self.session,
task_id=task.id,
current=self.admin,
)
assert released["task"]["executionStatus"] == "ready"
self.session.refresh(lease)
assert lease.status == "released"
released_event = (
self.session.query(AccountEvent)
.filter(
AccountEvent.account_id == account.id,
AccountEvent.event_type == "lease_released",
)
.one()
)
assert released_event.detail["lease_id"] == lease.id
def test_lease_settings_support_unlimited_and_finite_duration(self):
self.account("settings-account")
task = self.task()
service.allocate_task(self.session, task_id=task.id, current=self.admin)
lease = self.session.query(AccountLease).one()
assert lease.expires_at is None
finite = service.update_settings(
self.session,
lease_duration_minutes=90,
order_match_started_at=NOW - timedelta(days=1),
current=self.admin,
)
self.session.refresh(lease)
assert finite["leaseDurationMinutes"] == 90
assert finite["orderMatchStartedAt"] is not None
assert lease.expires_at is not None
unlimited = service.update_settings(
self.session,
lease_duration_minutes=None,
order_match_started_at=NOW - timedelta(days=1),
current=self.admin,
)
self.session.refresh(lease)
assert unlimited["leaseDurationMinutes"] is None
assert lease.expires_at is None
class TestBindingAndCompletion(_Base):
def _allocated(self):
self.account("bind-account")
task = self.task()
service.allocate_task(self.session, task_id=task.id, current=self.admin)
self.session.refresh(task)
return task
def test_start_binding_clears_stale_binding_failure(self, monkeypatch):
task = self._allocated()
failed_bind_task = DouyuTask(
batch_id="bind-failed",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="failed",
message="绑定任务失败",
result={},
created_by=self.admin_id,
)
self.session.add(failed_bind_task)
self.session.flush()
task.bind_task_id = failed_bind_task.id
task.binding_status = "failed"
task.execution_status = "manual_required"
task.issue_code = "binding_failed"
task.last_error = "绑定失败,请刷新二维码后重试"
self.session.commit()
monkeypatch.setattr(service, "start_douyu_batch", lambda **_kwargs: None)
asyncio.run(
service.start_binding(
self.session,
task_id=task.id,
current=self.admin,
force_refresh=True,
)
)
self.session.refresh(task)
assert task.binding_status == "preparing"
assert task.execution_status == "waiting_bind"
assert task.issue_code == ""
assert task.last_error == ""
def test_confirm_binding_pins_expected_role_for_two_role_snapshot(
self, monkeypatch
):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-two-roles",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="success",
message="已识别待确认角色",
result={
"role_name": "我是火星人2222",
"current_role_name": "狗鼻子弗尼亚bd",
"bind_ready_for_confirm": True,
"bind_confirmed": False,
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "role_ready"
task.execution_status = "role_ready"
self.session.commit()
monkeypatch.setattr(service, "start_douyu_batch", lambda **_kwargs: None)
asyncio.run(
service.confirm_binding(
self.session,
task_id=task.id,
current=self.admin,
)
)
confirm_task = (
self.session.query(DouyuTask)
.filter(DouyuTask.task_type == "confirm_bind")
.order_by(DouyuTask.id.desc())
.first()
)
assert confirm_task is not None
assert confirm_task.result["expected_role_name"] == "我是火星人2222"
assert confirm_task.result["baseline_role_name"] == "狗鼻子弗尼亚bd"
def test_reset_binding_clears_failed_state_and_keeps_account(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-reset",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="failed",
message="该游戏角色仍在换绑冷却期",
result={"bind_phase": "confirm_failed"},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "failed"
task.execution_status = "manual_required"
task.exchange_status = "not_started"
task.issue_code = "customer_role_cooldown"
task.last_error = "该游戏角色仍在换绑冷却期"
self.session.commit()
account_id = task.account_id
lease_id = task.lease_id
detail = service.reset_task_binding(
self.session,
task_id=task.id,
current=self.admin,
reason="客服核对后重置角色资料",
)
self.session.refresh(task)
assert detail["task"]["executionStatus"] == "allocated"
assert task.account_id == account_id
assert task.lease_id == lease_id
assert task.bind_task_id is None
assert task.binding_status == "not_started"
assert task.issue_code == ""
assert task.last_error == ""
event = (
self.session.query(PlatformFulfillmentEvent)
.filter_by(task_id=task.id, event_type="binding_reset")
.one()
)
assert event.detail_json["customerProfileReset"] is True
outbox = (
self.session.query(IntegrationOutbox)
.order_by(IntegrationOutbox.id.desc())
.first()
)
assert outbox is not None
assert outbox.payload_json["items"][0]["customerProfileReset"] is True
def test_reset_binding_rejects_running_bind_task(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-running",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="running",
message="等待客户扫码",
result={"url": "https://example.com/qr"},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "failed"
task.execution_status = "waiting_bind"
self.session.commit()
with pytest.raises(HTTPException) as exc_info:
service.reset_task_binding(
self.session,
task_id=task.id,
current=self.admin,
)
assert exc_info.value.status_code == 409
assert "仍在执行" in str(exc_info.value.detail)
def test_cancel_permission_excludes_support(self):
assert "platform_fulfillment:cancel" in ROLE_PERMISSIONS["operation"]
assert "platform_fulfillment:cancel" in ROLE_PERMISSIONS["super_admin"]
assert "platform_fulfillment:cancel" not in ROLE_PERMISSIONS["support"]
assert "platform_fulfillment:view" in ROLE_PERMISSIONS["support"]
assert "platform_fulfillment:use" in ROLE_PERMISSIONS["support"]
checker = require_permission("platform_fulfillment:cancel")
support = User(
username="cancel-support",
password_hash="h",
role="support",
is_active=True,
)
operator = User(
username="cancel-operator",
password_hash="h",
role="operation",
is_active=True,
)
with pytest.raises(HTTPException) as exc_info:
checker(current_user=support)
assert exc_info.value.status_code == 403
assert checker(current_user=operator) is operator
def test_restore_permission_is_super_admin_only(self):
assert "platform_fulfillment:restore" in ROLE_PERMISSIONS["super_admin"]
assert "platform_fulfillment:restore" not in ROLE_PERMISSIONS["operation"]
assert "platform_fulfillment:restore" not in ROLE_PERMISSIONS["support"]
checker = require_permission("platform_fulfillment:restore")
operator = User(
username="restore-operator",
password_hash="h",
role="operation",
is_active=True,
)
admin = User(
username="restore-admin",
password_hash="h",
role="super_admin",
is_active=True,
)
with pytest.raises(HTTPException) as exc_info:
checker(current_user=operator)
assert exc_info.value.status_code == 403
assert checker(current_user=admin) is admin
def test_restore_manual_cancel_requeues_task_and_restores_collab(
self, monkeypatch
):
task = self.task()
service.cancel_task(
self.session,
task_id=task.id,
current=self.admin,
reason="客服误点取消",
)
collab_order = DouyuExternalOrder(
order_no=task.platform_order_id,
source_type="platform_fulfillment",
source_task_id=task.id,
status="void",
void_reason="直播履约任务已取消",
)
self.session.add(collab_order)
self.session.commit()
monkeypatch.setattr(
service,
"lookup_pending_manual_fulfillment",
lambda _item_id: {
"order_status": "paid",
"pay_status": "paid",
"fulfillment_issue_code": "",
},
)
detail = service.restore_cancelled_task(
self.session,
task_id=task.id,
current=self.admin,
reason="核对订单仍有效,恢复误取消任务",
)
self.session.refresh(task)
self.session.refresh(collab_order)
assert detail["task"]["executionStatus"] == "ready"
assert task.account_id is None
assert task.lease_id is None
assert task.next_allocate_at is not None
assert collab_order.status == "incomplete"
assert collab_order.void_reason == ""
restored = next(
event for event in detail["events"] if event["eventType"] == "task_restored"
)
assert restored["actorName"] == "pf-admin"
assert restored["detail"]["reason"] == "核对订单仍有效,恢复误取消任务"
def test_restore_rejects_source_cancelled_task(self):
task = self.task()
task.execution_status = "cancelled"
task.issue_code = "source_cancelled"
self.session.commit()
with pytest.raises(HTTPException) as exc_info:
service.restore_cancelled_task(
self.session,
task_id=task.id,
current=self.admin,
reason="尝试恢复来源取消任务",
)
assert exc_info.value.status_code == 409
assert "来源订单已取消" in str(exc_info.value.detail)
def test_restore_rejects_active_external_collab(self, monkeypatch):
task = self.task()
service.cancel_task(
self.session,
task_id=task.id,
current=self.admin,
reason="客服误点取消",
)
account = self.account("active-collab-account")
self.session.add(
DouyuExternalOrder(
order_no=task.platform_order_id,
source_type="platform_fulfillment",
source_task_id=task.id,
account_id=account.id,
account_username=account.username,
bind_game_role="人工已绑定",
status="to_recharge",
)
)
self.session.commit()
monkeypatch.setattr(
service,
"lookup_pending_manual_fulfillment",
lambda _item_id: {
"order_status": "paid",
"pay_status": "paid",
"fulfillment_issue_code": "",
},
)
with pytest.raises(HTTPException) as exc_info:
service.restore_cancelled_task(
self.session,
task_id=task.id,
current=self.admin,
reason="尝试恢复已人工处理订单",
)
assert exc_info.value.status_code == 409
assert "外部协作单已在人工处理" in str(exc_info.value.detail)
def test_restore_rejects_terminal_source_order(self, monkeypatch):
task = self.task()
service.cancel_task(
self.session,
task_id=task.id,
current=self.admin,
reason="客服误点取消",
)
monkeypatch.setattr(
service,
"lookup_pending_manual_fulfillment",
lambda _item_id: {
"order_status": "refunded",
"pay_status": "paid",
"fulfillment_issue_code": "",
},
)
with pytest.raises(HTTPException) as exc_info:
service.restore_cancelled_task(
self.session,
task_id=task.id,
current=self.admin,
reason="核对订单是否可恢复",
)
assert exc_info.value.status_code == 409
assert "不能恢复" in str(exc_info.value.detail)
def test_cancel_releases_account_and_terminal_state_cannot_be_refreshed_back(
self, monkeypatch
):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-cancel",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="running",
message="等待客户扫码",
result={"url": "https://example.com/qr"},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "qr_pending"
task.execution_status = "waiting_bind"
self.session.commit()
account_id = task.account_id
lease_id = task.lease_id
stopped: list[str] = []
monkeypatch.setattr(
service,
"stop_douyu_batches",
lambda batch_ids: stopped.extend(batch_ids) or len(batch_ids),
)
detail = service.cancel_task(
self.session,
task_id=task.id,
current=self.admin,
reason="运营取消并释放账号",
)
self.session.refresh(task)
self.session.refresh(bind_task)
lease = self.session.query(AccountLease).filter_by(id=lease_id).one()
assert detail["task"]["executionStatus"] == "cancelled"
cancel_event = next(
event
for event in detail["events"]
if event["eventType"] == "task_cancelled"
)
assert cancel_event["actorName"] == "pf-admin"
assert cancel_event["actorRole"] == "super_admin"
assert cancel_event["actorRoleLabel"] == "超级管理员"
assert task.account_id is None
assert task.lease_id is None
assert task.bind_task_id is None
assert task.binding_status == "not_started"
assert task.exchange_status == "not_started"
assert account_id is not None
assert lease.status == "released"
assert bind_task.status == "stopped"
assert stopped == ["bind-cancel"]
refreshed = service.refresh_binding(self.session, task_id=task.id)
assert refreshed["task"]["executionStatus"] == "cancelled"
self.session.refresh(task)
assert task.execution_status == "cancelled"
def test_release_to_manual_releases_lease_without_reallocating(self):
task = self._allocated()
account_id = task.account_id
lease_id = task.lease_id
detail = service.release_task_to_manual(
self.session,
task_id=task.id,
current=self.admin,
reason="以外部单协作人工处理为准",
)
self.session.refresh(task)
lease = self.session.query(AccountLease).filter_by(id=lease_id).one()
assert detail["task"]["executionStatus"] == "manual_required"
assert task.account_id is None
assert task.lease_id is None
assert task.next_allocate_at is None
assert task.issue_code == "manual_required"
assert task.last_error == "以外部单协作人工处理为准"
assert lease.status == "released"
assert lease.release_reason == "platform_fulfillment_manual"
event = (
self.session.query(PlatformFulfillmentEvent)
.filter_by(task_id=task.id, event_type="released_to_manual")
.one()
)
assert event.detail_json["releasedAccountId"] == account_id
assert event.detail_json["releasedLeaseId"] == lease_id
def test_refresh_binding_maps_role_ready(self, monkeypatch):
notified: list[int] = []
monkeypatch.setattr(
service,
"_emit_order_site_binding_state",
lambda _db, task_id: notified.append(task_id) or True,
)
task = self._allocated()
notified.clear()
bind_task = DouyuTask(
batch_id="bind-1",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="success",
result={
"url": "https://example.com/qr",
"role_name": "测试角色",
"need_bind_act": True,
"bind_ready_for_confirm": True,
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "preparing"
task.execution_status = "waiting_bind"
self.session.commit()
detail = service.refresh_binding(self.session, task_id=task.id)
assert detail["task"]["bindingStatus"] == "role_ready"
assert detail["task"]["bindTask"]["roleName"] == "测试角色"
assert notified == [task.id]
def test_refresh_binding_ignores_legacy_same_role_pending(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-stale-same-role",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="success",
result={
"url": "https://example.com/old-qr",
"role_name": "少和我较劲",
"current_role_name": "少和我较劲",
"baseline_role_name": "少和我较劲",
"need_bind_act": False,
"is_bound_act": False,
"bind_ready_for_confirm": True,
"bind_confirmed": False,
"bind_phase": "role_ready",
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "role_ready"
task.execution_status = "role_ready"
self.session.commit()
detail = service.refresh_binding(self.session, task_id=task.id)
self.session.refresh(task)
assert task.bind_task_id is None
assert task.binding_status == "not_started"
assert task.execution_status == "allocated"
assert detail["task"]["bindTask"] is None
event = (
self.session.query(PlatformFulfillmentEvent)
.filter_by(task_id=task.id, event_type="binding_stale_role_ignored")
.one()
)
assert event.detail_json["roleName"] == "少和我较劲"
def test_refresh_binding_keeps_same_role_after_pending_transition(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-new-same-role",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="success",
result={
"url": "https://example.com/new-qr",
"act_alias": "20260120QYOOB",
"role_name": "少和我较劲",
"current_role_name": "少和我较劲",
"baseline_role_name": "少和我较劲",
"before_bind_info": {
"act_alias": "20260120QYOOB",
"role_name": "少和我较劲",
"is_bound_act": True,
},
"need_bind_act": True,
"is_bound_act": False,
"bind_ready_for_confirm": True,
"bind_confirmed": False,
"bind_phase": "role_ready",
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "waiting_bind"
task.execution_status = "waiting_bind"
self.session.commit()
detail = service.refresh_binding(self.session, task_id=task.id)
assert detail["task"]["bindingStatus"] == "role_ready"
assert detail["task"]["bindTask"]["roleName"] == "少和我较劲"
assert detail["task"]["bindTask"]["bindReadyForConfirm"] is True
def test_confirmed_binding_is_not_reported_as_waiting_for_confirmation(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-confirmed",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="confirm_bind",
handbook_scope="elite",
status="success",
result={
"role_name": "洋崽想要躺鸡",
"need_bind_act": True,
"is_bound_act": True,
"bind_ready_for_confirm": True,
"bind_confirmed": True,
"bind_phase": "confirmed",
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "bound"
task.execution_status = "bound"
self.session.commit()
live = service.customer_binding_out(self.session, task.id)
detail = service.get_task_detail(self.session, task.id)
assert live["roleName"] == "洋崽想要躺鸡"
assert live["bindConfirmed"] is True
assert live["bindReadyForConfirm"] is False
assert detail["task"]["bindTask"]["bindReadyForConfirm"] is False
def test_refresh_binding_clears_stale_failure_when_qr_is_pending(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-qr-after-failure",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="running",
result={"url": "https://example.com/new-qr"},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "failed"
task.execution_status = "manual_required"
task.issue_code = "binding_failed"
task.last_error = "绑定失败,请刷新二维码后重试"
self.session.commit()
detail = service.refresh_binding(self.session, task_id=task.id)
assert detail["task"]["bindingStatus"] == "qr_pending"
assert detail["task"]["executionStatus"] == "waiting_bind"
assert detail["task"]["issueCode"] == ""
assert detail["task"]["lastError"] == ""
def test_refresh_binding_classifies_customer_role_cooldown(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-customer-cooldown",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="confirm_bind",
handbook_scope="elite",
status="failed",
message="待绑定游戏账号(测试角色)未到换绑时间,请重新换账号扫码绑定",
result={
"bind_phase": "confirm_failed",
"role_name": "测试角色",
"bind_ready_for_confirm": True,
"bind_confirmed": False,
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "role_ready"
task.execution_status = "role_ready"
self.session.commit()
detail = service.refresh_binding(self.session, task_id=task.id)
assert detail["task"]["issueCode"] == "customer_role_cooldown"
assert detail["task"]["bindingStatus"] == "failed"
assert detail["task"]["executionStatus"] == "manual_required"
assert "截图" in detail["task"]["lastError"]
assert "联系客服" in detail["task"]["lastError"]
live = service.customer_binding_out(self.session, task.id)
assert live["bindingStatus"] == "failed"
assert live["executionStatus"] == "manual_required"
assert live["bindReadyForConfirm"] is False
assert live["bindConfirmed"] is False
def test_refresh_binding_classifies_account_role_cooldown(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-account-cooldown",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="failed",
message="当前角色 暂不能换绑,剩余 3天",
result={
"bind_phase": "change_waiting",
"change_role_wait_time": 259200,
},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "preparing"
task.execution_status = "waiting_bind"
self.session.commit()
detail = service.refresh_binding(self.session, task_id=task.id)
assert detail["task"]["issueCode"] == "account_role_cooldown"
assert detail["task"]["executionStatus"] == "manual_required"
assert "截图" in detail["task"]["lastError"]
live = service.customer_binding_out(self.session, task.id)
assert live["bindReadyForConfirm"] is False
def test_list_hides_qr_but_detail_returns_it(self):
task = self._allocated()
bind_task = DouyuTask(
batch_id="bind-qr",
account_id=task.account_id,
account_assigned_to=self.admin_id,
task_type="get_bind_qr",
handbook_scope="elite",
status="running",
result={"url": "https://example.com/private-qr"},
created_by=self.admin_id,
)
self.session.add(bind_task)
self.session.flush()
task.bind_task_id = bind_task.id
task.binding_status = "qr_pending"
task.execution_status = "waiting_bind"
self.session.commit()
listed = service.list_tasks(self.session)
detail = service.get_task_detail(self.session, task.id)
assert listed["items"][0]["bindTask"]["qrUrl"] == ""
assert detail["task"]["bindTask"]["qrUrl"] == "https://example.com/private-qr"
def test_manual_completion_requires_bound_and_releases_lease(self):
task = self._allocated()
task.binding_status = "bound"
task.execution_status = "bound"
task.exchange_status = "eligible"
self.session.commit()
detail = service.complete_manual_exchange(
self.session,
task_id=task.id,
current=self.admin,
note="人工兑换完成",
)
assert detail["task"]["executionStatus"] == "completed"
assert detail["task"]["exchangeStatus"] == "manual_done"
lease = self.session.query(AccountLease).one()
assert lease.status == "released"
def test_points_short_after_binding_keeps_account_and_stays_bound(
self, monkeypatch
):
task = self._allocated()
account = (
self.session.query(Account).filter(Account.id == task.account_id).one()
)
task.binding_status = "bound"
task.execution_status = "bound"
self.session.commit()
monkeypatch.setattr(
service,
"query_exchange_eligibility",
lambda *_args, **_kwargs: DouyuEligibilityResult(
elite_user_info={"manual_type": 1},
points=100,
points_response={"points": 100},
limited_goods=[],
limited_ids=frozenset(),
),
)
detail = service.refresh_exchange_eligibility(
self.session,
task_id=task.id,
current=self.admin,
)
assert detail["task"]["executionStatus"] == "bound"
assert detail["task"]["exchangeStatus"] == "points_short"
assert detail["task"]["account"]["id"] == account.id
def test_expired_lease_moves_unfinished_task_to_manual(self):
task = self._allocated()
lease = self.session.query(AccountLease).one()
lease.expires_at = NOW - timedelta(minutes=1)
self.session.commit()
job = AutomationJob(key=reaper.JOB_KEY, batch_size=100)
result = reaper.run_platform_fulfillment_lease_reaper(
self.session,
job,
now=NOW,
)
self.session.refresh(task)
assert result["expired"] == 1
assert task.execution_status == "manual_required"
assert task.issue_code == "lease_expired"
def test_unlimited_lease_is_ignored_by_reaper(self):
task = self._allocated()
lease = self.session.query(AccountLease).one()
lease.expires_at = None
self.session.commit()
job = AutomationJob(key=reaper.JOB_KEY, batch_size=100)
result = reaper.run_platform_fulfillment_lease_reaper(
self.session,
job,
now=NOW + timedelta(days=365),
)
self.session.refresh(task)
assert result["expired"] == 0
assert task.execution_status == "allocated"
def test_completion_rejects_limited_exchange(self):
task = self._allocated()
task.binding_status = "bound"
task.execution_status = "manual_required"
task.exchange_status = "limited"
self.session.commit()
with pytest.raises(HTTPException):
service.complete_manual_exchange(
self.session,
task_id=task.id,
current=self.admin,
)