1505 lines
52 KiB
Python
1505 lines
52 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,
|
|
AccountCommodityState,
|
|
AccountEvent,
|
|
AccountLease,
|
|
AutomationJob,
|
|
DouyuGoodsSnapshot,
|
|
DouyuTask,
|
|
IntegrationOutbox,
|
|
PlatformCommodityMapping,
|
|
PlatformFulfillmentEvent,
|
|
PlatformFulfillmentSetting,
|
|
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.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 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_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": "测试角色",
|
|
"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,
|
|
)
|