938 lines
32 KiB
Python
938 lines
32 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.models import (
|
|
Account,
|
|
AccountLease,
|
|
AutomationJob,
|
|
DouyuGoodsSnapshot,
|
|
DouyuTask,
|
|
IntegrationOutbox,
|
|
PlatformCommodityMapping,
|
|
PlatformFulfillmentEvent,
|
|
PlatformFulfillmentTask,
|
|
User,
|
|
)
|
|
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.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"},
|
|
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()
|
|
captured_keys: list[str] = []
|
|
|
|
def _rows(*, limit: int, internal_sku_keys: list[str]):
|
|
del limit
|
|
captured_keys.extend(internal_sku_keys)
|
|
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 self.session.query(PlatformFulfillmentTask).count() == 1
|
|
task = self.session.query(PlatformFulfillmentTask).one()
|
|
assert task.execution_status == "ready"
|
|
assert task.commodity_id == COMMODITY
|
|
|
|
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"},
|
|
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_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 TestAccountSelection(_Base):
|
|
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_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
|
|
|
|
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"
|
|
|
|
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,
|
|
current=self.admin,
|
|
)
|
|
self.session.refresh(lease)
|
|
assert finite["leaseDurationMinutes"] == 90
|
|
assert lease.expires_at is not None
|
|
|
|
unlimited = service.update_settings(
|
|
self.session,
|
|
lease_duration_minutes=None,
|
|
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_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"
|
|
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_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": "测试角色"},
|
|
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_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,
|
|
)
|