Files
myrzx_bot/ranch_web/tests/test_battle_recovery_contract.py

248 lines
15 KiB
Python

"""Web authorization of Engine-classified recovery, using offline clients only."""
from copy import deepcopy
import math
import time
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Snapshot
from ranch_web.service import AccountWorker
from ranch_web.tests import test_lifecycle_recovery as lifecycle
from ranch_web.tests import test_service as fixtures
from ranch_web.views import build_view
class RecoveryGuardContractTests(unittest.TestCase):
def worker(self, runtime):
worker = AccountWorker.__new__(AccountWorker)
worker.active_identity, worker._legacy_pending = None, {}
record = {"kind": "stage_battle", "stage_id": "0102", "phase": "unknown",
"execution_status": "timed_out", "terminal_reason": "worker_wall_clock_limit",
"path": "stageService/stageStart"}
worker.engine = SimpleNamespace(snapshot=object(), battles=runtime,
battle_journal=SimpleNamespace(pending=lambda snapshot: record),
_progression_pending=lambda: record, sweeper=SimpleNamespace(state={}),
explore_planner=SimpleNamespace(pending=lambda snapshot: None), _breakthrough_pending=None)
return worker, record
def test_engine_recovery_contract_overrides_old_clock_predicate(self):
for allowed in (False, True):
with self.subTest(allowed=allowed):
runtime = SimpleNamespace(recovery_status=Mock(return_value={
"state": "abandon_stage" if allowed else "blocked", "resumable": allowed,
"message": "已确认开战,按原客户端协议退出"}),
resumable_task_clock=Mock(return_value=not allowed))
worker, record = self.worker(runtime)
worker.engine.pending_battle_recovery = Mock(return_value=runtime.recovery_status.return_value)
self.assertEqual(worker._pending_execution_reason() == "", allowed)
worker.engine.pending_battle_recovery.assert_called_once_with()
runtime.recovery_status.assert_not_called()
runtime.resumable_task_clock.assert_not_called()
def test_truthy_recovery_flag_does_not_grant_write_permission(self):
for flag in (1, "true", None):
with self.subTest(flag=flag):
worker, _ = self.worker(SimpleNamespace(recovery_status=lambda *args, **kwargs: {
"state": "abandon_stage", "resumable": flag, "message": ""},
resumable_task_clock=lambda record: True))
worker.engine.pending_battle_recovery = lambda: {"state": "abandon_stage", "resumable": flag, "message": ""}
self.assertTrue(worker._pending_execution_reason())
def test_runtime_without_recovery_helper_keeps_old_clock_fallback(self):
for allowed in (False, True):
with self.subTest(allowed=allowed):
worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: allowed))
self.assertEqual(worker._pending_execution_reason() == "", allowed)
def test_disabled_origin_uses_specific_engine_policy_message(self):
worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: True))
message = "对应委托策略已关闭,等待启用委托策略后恢复原战斗"
worker.engine.pending_battle_recovery = lambda: {
"state": "blocked_policy", "resumable": False, "message": message}
self.assertEqual(worker._pending_execution_reason(), message)
class LegacyBattleRecoveryTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
connected = lifecycle.LifecycleRecoveryTests.connected
tick = lifecycle.LifecycleRecoveryTests.tick
paths = lifecycle.LifecycleRecoveryTests.paths
def login(self, identifier):
return fixtures.ServiceTests.login(self, identifier, account="recovery-" + identifier)
def legacy_timeout(self, *, unaccepted=False):
identifier, worker = self.connected()
engine = worker.engine
source_id, source_type, source_step = (0, "4001004", 0) if unaccepted else (51, "1002013", 1)
engine.client.raw["currentTasks"] = ([] if unaccepted else [
{"id": source_id, "typeId": source_type, "curStep": source_step, "stepValue": 0}])
engine.snapshot = Snapshot(deepcopy(engine.client.raw))
engine.game_data = ProgressionData({"task_info": {source_type: {"type": 4, "name": "离线材料委托",
"steps": [{"statusType": "none", "statusValue": {}}]}}})
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = True
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
journal = engine.battle_journal
record = journal.begin(engine.snapshot, {"kind": "stage_battle", "stage_id": "0102", "difficulty": 1,
"battle_kind": "ordinary_stage", "description": "离线委托材料关卡", "task_id": None,
"task_type_id": None, "source_task_id": source_id,
"source_task_type_id": source_type, "source_step_number": source_step})
journal.update(record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart",
start_response={"resCode": 0, "triggerEvent": False, "stageEvent": None},
battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False,
terminal_reason="worker_wall_clock_limit", message="战斗已取消、超时或结果不确定,等待核对")
self.assertEqual(engine.battles.recovery_status(record, snapshot=engine.snapshot)["state"], "abandon_stage")
engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
return identifier, worker
def test_legacy_timeout_blocked_by_default_when_engine_denies_recovery(self):
identifier, worker = self.legacy_timeout()
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
before = len(fixtures.FakeClient.calls)
with patch.object(worker.engine, "pending_battle_recovery", return_value={
"state": "blocked", "resumable": False, "message": "尚无可验证的安全恢复证据"}):
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
def test_strict_safe_legacy_timeout_starts_then_exits_on_reconcile_without_reentry(self):
identifier, worker = self.legacy_timeout()
self.assert_failure_exit(identifier, worker)
def test_unaccepted_commission_legacy_timeout_exits_without_reentry_or_reward(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
self.assert_failure_exit(identifier, worker)
def assert_failure_exit(self, identifier, worker):
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto, "Start must not dispatch recovery inline")
self.assertEqual(len(fixtures.FakeClient.calls), before)
state = self.manager.status(identifier)
self.assertEqual(state["strategy_state"], "recovering")
self.assertIn("退出", state["strategy_message"])
self.assertNotIn("战果已保存", state["strategy_message"])
worker.schedule.next_poll = math.inf
after = self.manager.logs(identifier)["next"]
poll = worker.engine.poll
def recovery_poll(**kwargs):
self.assertFalse(worker.engine.auto, "Recovery must not enable other strategies")
self.assertIs(kwargs.get("resume_pending"), True)
return poll(**kwargs)
with patch.object(worker.engine, "poll", side_effect=recovery_poll):
self.assertEqual(self.tick(identifier, worker)["result"]["kind"], "reconcile")
writes = [("/".join(url.rsplit("/", 2)[-2:]),
{key: value for key, value in payload.items() if key not in {"token", "reqid", "reqsid"}})
for _, url, payload in fixtures.FakeClient.calls[before:]
if not url.endswith("masterService/masterQueryDetail")]
self.assertEqual(writes, [("battleService/recordBattleResult", {"stageId": "0102", "cityId": "1", "result": 0})])
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
record = worker.engine.battle_journal.records(worker.engine.snapshot)[0]
self.assertEqual(record["outcome"], "abandoned")
self.assertNotIn("battle_data", record)
rows = build_view(worker.engine, "battles", worker.config)["rows"]
row = next(row for row in rows if row["outcome"] == "abandoned")
self.assertIn("已放弃(本地计算失败)", row["outcome_label"])
self.assertNotIn("打不过", row["outcome_label"])
logs = self.manager.logs(identifier, after=after)["entries"]
self.assertTrue(any("退出" in row["message"] for row in logs))
self.assertFalse(any("打不过" in row["message"] for row in logs))
def test_manual_refresh_never_authorizes_safe_source_zero_recovery(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
self.job(identifier, self.manager.submit(identifier, "start"))
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
def test_manual_stop_prevents_safe_legacy_failure_exit(self):
identifier, worker = self.legacy_timeout()
self.manager.submit(identifier, "stop")
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.tick(identifier, worker)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertFalse(worker.running)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
def test_disabled_source_policy_prevents_safe_legacy_failure_exit(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = False
config["config"]["daily_policy"].update(enabled=True, selected=["gift"])
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
worker.schedule.next_poll = math.inf
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
state = self.manager.status(identifier)
self.assertFalse(state["running"])
self.assertEqual(state["strategy_state"], "blocked")
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
recovery = worker.engine.pending_battle_recovery()
self.assertEqual(recovery["state"], "blocked_policy")
self.assertEqual(state["strategy_message"], recovery["message"])
self.assertIn("委托", state["strategy_message"])
self.assertIn("启用", state["strategy_message"])
self.assertFalse(worker.engine.quest_policy.enabled)
self.assertTrue(worker.engine.daily_policy.enabled)
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = True
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
self.tick(identifier, worker)
writes = [("/".join(url.rsplit("/", 2)[-2:]), payload.get("result"))
for _, url, payload in fixtures.FakeClient.calls[before:]
if not url.endswith("masterService/masterQueryDetail")]
self.assertEqual(writes, [("battleService/recordBattleResult", 0)])
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
def test_unknown_start_settlement_or_failure_reply_never_grants_recovery(self):
for changes in ({"start_response": None}, {"settlement_dispatched": True, "path": "battleService/battleEnd"},
{"record_dispatched": True}):
with self.subTest(changes=changes):
identifier, worker = self.legacy_timeout()
journal = worker.engine.battle_journal
journal.update(journal.pending(worker.engine.snapshot), "unknown", **changes)
evidence = deepcopy(journal.pending(worker.engine.snapshot))
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
self.assertEqual(journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
if __name__ == "__main__":
unittest.main()