"""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()