"""Interrupted combat recovery; all server calls and worker results are offline fakes.""" from copy import deepcopy import json import threading import unittest from unittest.mock import Mock, patch from ranch_assistant.battles import BattleJournal, BattleOrchestrator from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime, fixture, intent, policy from ranch_assistant.tests.test_core import workspace_temp class BattleRecoveryTests(unittest.TestCase): def setUp(self): self.folder = self.enterContext(workspace_temp()) self.path = self.folder / "journal.json" self.catalog, self.snapshot = fixture() self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "1002013", "curStep": 1}] self.runtime = ExperimentalRuntime() self.client = Mock() self.client.call.side_effect = lambda path, payload: {"resCode": 0, "triggerEvent": False, "reward": {}} self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime) self.action = intent(kind="stage_battle", source_task_id=51, source_task_type_id="1002013", source_step_number=1) self.policy = policy(battle_mode="experimental") def paths(self): return [call.args[0] for call in self.client.call.call_args_list] def restart(self): self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime) def test_generation_cancel_inside_worker_retries_saved_combat_without_second_entry(self): cancel = threading.Event() original = self.runtime._run captured = [] def interrupted(request, *, cancel_event): captured.append(deepcopy(request)) cancel_event.set() return {"outcome": "cancelled", "execution_mode": "experimental", "execution_status": "cancelled", "faithful": False, "approximate": True, "terminal": False, "terminal_reason": "worker_cancelled"} self.runtime.run.side_effect = interrupted self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) self.assertEqual(self.paths(), ["stageService/stageStart"]) self.restart() record = self.runner.pending(self.snapshot) self.assertEqual(self.runner.recovery_status(record)["state"], "retry_local_runtime") self.snapshot.raw["monsters"][0]["level"] = 999 retried = [] def complete(request, *, cancel_event): retried.append(deepcopy(request)) return original(request, cancel_event=cancel_event) self.runtime.run.side_effect = complete self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(retried[0], record["combat_request"]) self.assertNotIn("level", retried[0]["roster"]["monsters"][0]) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) self.assertIsNone(self.runner.pending(self.snapshot)) self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(len(self.paths()), 3) def test_cancel_at_completed_result_preserves_it_without_resimulation(self): cancel = threading.Event() def complete(request, *, cancel_event): result = self.runtime._run(request, cancel_event=cancel_event) cancel_event.set() return result self.runtime.run.side_effect = complete self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) self.restart() record = self.runner.pending(self.snapshot) self.assertTrue(record["battle_data"]["win"]) self.assertTrue(self.runner.resumable_task_clock(record)) self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.runtime.run.call_count, 1) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) def test_cancel_during_wait_resumes_saved_stage_battle_without_new_worker(self): self.runner.clock = lambda: 0 cancel = threading.Event() cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True) self.runtime.run.side_effect = lambda request, cancel_event: self.runtime._run(request, cancel_event=cancel_event) | { "requires_realtime_wait": True, "model_elapsed_ms": 10000} self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) self.restart() record = self.runner.pending(self.snapshot) self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result") self.runner.journal.update(record, record["phase"], battle_ready_at=1) self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.runtime.run.call_count, 1) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) def test_save_combat_request_normalizes_comma_lineup_without_losing_slots_or_inputs(self): from ranch_assistant.battle_quick import simulate_quick from ranch_assistant.tests.test_battle_simulator import monster, request for members in ([100001, 0, 100002], "100001,0,100002"): with self.subTest(members=members): combat = request(players=[monster(mid=100001), monster(mid=100002)], master_level=62, battle_mode="experimental") combat["roster"]["teams"][0]["monsters"] = members combat["roster"]["master"]["sessionKey"] = "credential-canary" combat["roster"]["monsters"][0]["nicName"] = "nickname-canary" combat["roster"]["monsters"][0]["token"] = "credential-canary" before = deepcopy(combat) saved = self.runner.save_combat_request({}, combat)["combat_request"] self.assertEqual(saved["roster"]["teams"][0]["monsters"], [100001, 0, 100002]) self.assertEqual([row["id"] for row in saved["roster"]["monsters"]], [100001, 100002]) normalized = deepcopy(before) normalized["roster"]["teams"][0]["monsters"] = [100001, 0, 100002] self.assertEqual(simulate_quick(saved), simulate_quick(normalized)) self.assertNotIn("canary", json.dumps(saved)) self.assertEqual(combat, before) def test_combat_input_is_durable_before_start_and_original_profile_survives_timeout(self): self.runner.request_builder = lambda snapshot, action, chosen, request: request | {"damage_profile": "client_v4_x10"} original = self.client.call.side_effect def call(path, payload): if path.endswith("stageStart"): pending = BattleJournal(self.path).pending(self.snapshot) self.assertEqual(pending["combat_request"]["damage_profile"], "client_v4_x10") self.assertFalse(pending["settlement_dispatched"]) return original(path, payload) self.client.call.side_effect = call self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental", "execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit", "faithful": False, "approximate": True, "damage_profile": None} self.runner.run(self.client, self.snapshot, self.action, self.policy) self.restart() self.assertEqual(self.runner.pending(self.snapshot)["combat_request"]["damage_profile"], "client_v4_x10") self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "retry_local_runtime") def test_settlement_lost_reply_is_never_replayed_even_with_saved_inputs(self): def call(path, payload): if path.endswith("battleEnd"): raise TimeoutError() return {"resCode": 0, "triggerEvent": False} self.client.call.side_effect = call with self.assertRaises(TimeoutError): self.runner.run(self.client, self.snapshot, self.action, self.policy) self.restart() self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "blocked") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"]) def test_cancel_before_settlement_dispatch_remains_resumable(self): cancel = threading.Event() update = self.runner.journal.update def stop(record, phase, **fields): update(record, phase, **fields) if phase == "settlement_pending": cancel.set() self.runner.journal.update = stop self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) self.restart() record = self.runner.pending(self.snapshot) self.assertFalse(record["settlement_dispatched"]) self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) def test_preaccept_retry_requires_current_offer_day_and_never_reopens_entry(self): self.action.update(source_task_id=0, source_task_type_id="4001004", source_step_number=0) self.snapshot.raw["history"].update(loopTask={"1": ["4001004"]}, loopTaskTime=self.snapshot.now) self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental", "execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit", "faithful": False, "approximate": True} self.runner.run(self.client, self.snapshot, self.action, self.policy) self.restart() record = self.runner.pending(self.snapshot) self.assertEqual(self.runner.recovery_status(record, snapshot=self.snapshot)["state"], "retry_local_runtime") self.snapshot.raw["history"]["loopTaskTime"] -= 86400 self.assertEqual(self.runner.recovery_status(record, snapshot=self.snapshot)["state"], "abandon_stage") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.runtime.run.call_count, 1) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"]) self.assertEqual(self.client.call.call_args.args[1]["result"], 0) def test_local_retry_is_bounded_then_uses_failure_exit_without_another_worker(self): self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental", "execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit", "faithful": False, "approximate": True} self.runner.run(self.client, self.snapshot, self.action, self.policy) self.restart() self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.restart() self.assertEqual(self.runner.pending(self.snapshot)["runtime_recovery_attempts"], 1) self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "abandon_stage") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.runtime.run.call_count, 2) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"]) def test_stage_battle_with_confirmed_settlement_restart_only_finishes_record(self): with patch.object(self.runner, "_record", side_effect=SystemExit("crash after durable settlement reply")): with self.assertRaises(SystemExit): self.runner.run(self.client, self.snapshot, self.action, self.policy) self.restart() self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "resume_result") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.runtime.run.call_count, 1) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) def test_stop_during_recovery_settlement_keeps_ack_and_resumes_only_optional_record(self): initial_cancel = threading.Event() def complete(request, *, cancel_event): result = self.runtime._run(request, cancel_event=cancel_event) cancel_event.set() return result self.runtime.run.side_effect = complete self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=initial_cancel) self.restart() self.assertEqual(self.paths(), ["stageService/stageStart"]) recovery_cancel = threading.Event() def settlement_ack_after_stop(path, payload): if path == "battleService/battleEnd": recovery_cancel.set() return {"resCode": 0, "reward": {"money": 11}} self.client.call.side_effect = settlement_ack_after_stop self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=recovery_cancel) self.assertTrue(recovery_cancel.is_set()) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"]) self.restart() record = self.runner.pending(self.snapshot) self.assertEqual(record["phase"], "settlement_acknowledged") self.assertTrue(record["settlement_confirmed"]) self.assertFalse(record["record_dispatched"]) self.assertIsNot(record.get("record_confirmed"), True) self.assertEqual(record["response"], {"resCode": 0, "reward": {"money": 11}}) self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=recovery_cancel) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"]) self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) self.assertIsNone(self.runner.pending(self.snapshot)) self.assertEqual(self.runtime.run.call_count, 1) self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(len(self.paths()), 3) def legacy_timeout(self, **changes): record = self.runner.journal.begin(self.snapshot, self.action) self.runner.journal.update(record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart", start_response={"resCode": 0, "stageEvent": None, "triggerEvent": False}, battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False, terminal_reason="worker_wall_clock_limit", message="战斗已取消、超时或结果不确定,等待核对") self.runner.journal.update(record, "unknown", **changes) return record def test_legacy_worker_timeout_uses_original_failure_exit_once(self): self.legacy_timeout() before = deepcopy(self.snapshot.raw) self.restart() status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot) self.assertEqual(status["state"], "abandon_stage") self.assertIn("原始战斗输入", status["message"]) self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0101", "cityId": "1", "result": 0}) self.assertIsNone(self.runner.pending(self.snapshot)) done = self.runner.journal.records(self.snapshot)[0] self.assertEqual(done["outcome"], "abandoned") self.assertTrue(done["record_confirmed"]) self.assertNotIn("battle_data", done) self.assertEqual(self.snapshot.raw, before) self.runtime.run.assert_not_called() self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(len(self.paths()), 1) def test_lost_failure_response_stays_pending_and_is_never_replayed(self): self.legacy_timeout() self.client.call.side_effect = TimeoutError("lost failure acknowledgement") with self.assertRaises(TimeoutError): self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.restart() record = self.runner.pending(self.snapshot) self.assertEqual(record["phase"], "record_unknown") self.assertTrue(record["record_dispatched"]) self.assertEqual(self.runner.recovery_status(record)["state"], "blocked") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) def test_real_preaccept_source_zero_legacy_timeout_exits_without_task_or_offer(self): self.action.update(stage_id="0102", task_type_id="", source_task_id=0, source_task_type_id="4001004", source_step_number=0, stage_category=None) self.legacy_timeout() before = deepcopy(self.snapshot.raw) self.restart() status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot.raw) self.assertEqual(status["state"], "abandon_stage") self.assertIn("旧记录缺少原始战斗输入", status["message"]) self.assertNotIn("来源委托已变化", status["message"]) self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0102", "cityId": "1", "result": 0}) self.assertIsNone(self.runner.pending(self.snapshot)) self.assertEqual(self.snapshot.raw, before) self.assertEqual(self.runner.journal.role(self.snapshot)["losses"], 0) self.assertEqual(self.runner.journal.records(self.snapshot)[0]["outcome"], "abandoned") def test_failure_acknowledged_before_crash_finishes_locally_without_second_record(self): self.legacy_timeout() finish = self.runner.journal.finish self.runner.journal.finish = Mock(side_effect=SystemExit("crash after durable failure reply")) with self.assertRaises(SystemExit): self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.runner.journal.finish = finish self.restart() self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "finish_abandonment") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.assertIsNone(self.runner.pending(self.snapshot)) self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) def test_unconfirmed_start_or_changed_source_or_settlement_attempt_blocks_failure_exit(self): self.legacy_timeout() for changes in ({"start_response": None}, {"settlement_dispatched": True}, {"path": "battleService/battleEnd"}, {"source_task_id": 999}, {"terminal_reason": "unclassified_failure"}): with self.subTest(changes=changes): original = deepcopy(self.runner.pending(self.snapshot)) self.runner.journal.update(self.runner.pending(self.snapshot), "unknown", **changes) status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot) self.assertEqual(status["state"], "blocked") self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) self.runner.journal.role(self.snapshot)["records"][-1] = original self.runner.journal.save() self.assertIsNotNone(self.runner.pending(self.snapshot)) self.client.call.assert_not_called() self.runtime.run.assert_not_called() class EngineBattleRecoveryTests(unittest.TestCase): def setUp(self): from ranch_assistant.engine import Engine, demo_snapshot from ranch_assistant.game_data import ProgressionData from ranch_assistant.model import Catalog, Policy, Snapshot from ranch_assistant.progression import ProgressionPolicy self.folder = self.enterContext(workspace_temp()) self.catalog = Catalog() self.raw = deepcopy(demo_snapshot(self.catalog).raw) self.raw["currentTasks"] = [{"id": 71, "typeId": "1002013", "curStep": 1}] self.client = Mock() self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.raw)) self.client.call.return_value = {"resCode": 0, "triggerEvent": False} self.engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=ProgressionData({"task_info": {}, "stage_info": {}, "game_setting": {}}), experimental_runtime=ExperimentalRuntime()) self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False) self.engine.progression_policy = ProgressionPolicy(enabled=True, battle_mode="experimental") self.engine.snapshot = Snapshot(deepcopy(self.raw)) self.engine.master_sync.settle = Mock() self.action = intent(kind="stage_battle", stage_id="0102", task_type_id="", source_task_id=0, source_task_type_id="4001004", source_step_number=0) self.record = self.engine.battle_journal.begin(self.engine.snapshot, self.action) self.engine.battle_journal.update(self.record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart", start_response={"resCode": 0, "stageEvent": None, "triggerEvent": False}, battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False, terminal_reason="worker_wall_clock_limit") self.engine.auto = False def test_disabled_cold_commission_origin_blocks_until_quest_policy_is_enabled(self): self.engine.game_data = None self.engine.quest_policy.enabled = False self.engine.daily_policy.enabled = True before = self.engine.battle_journal.path.read_bytes() record = deepcopy(self.record) status = self.engine.pending_battle_recovery() self.assertEqual(status["state"], "blocked_policy") self.assertFalse(status["resumable"]) self.assertIn("等待启用自动委托来源策略", status["message"]) self.assertEqual(self.engine.battle_journal.path.read_bytes(), before) self.engine.poll(resume_pending=True) self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record) self.client.call.assert_not_called() self.assertFalse(self.engine.quest_policy.enabled) self.assertTrue(self.engine.daily_policy.enabled) self.engine.quest_policy.enabled = True self.assertTrue(self.engine.pending_battle_recovery()["resumable"]) self.engine.poll(resume_pending=True) self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot)) self.assertEqual(self.client.call.call_count, 1) self.assertEqual(self.client.call.call_args.args[0], "battleService/recordBattleResult") def test_enabled_cold_commission_origin_does_not_require_mainline_policy(self): self.engine.game_data = None self.engine.progression_policy.enabled = False self.engine.quest_policy.enabled = True status = self.engine.pending_battle_recovery() self.assertEqual(status["state"], "abandon_stage") self.assertTrue(status["resumable"]) self.assertIsNotNone(self.engine.game_data) self.assertTrue(self.engine._is_commission(self.record)) self.assertFalse(self.engine.progression_policy.enabled) self.client.call.assert_not_called() def test_disabled_map_and_mainline_origins_name_their_policies(self): self.engine.progression_policy.enabled = False self.engine.sweep_policy.enabled = False for kind, source_id, source_type, source_step, label in ( ("map_battle", 0, "", 0, "自动扫荡"), ("stage_battle", 71, "1002013", 1, "自动主线")): with self.subTest(kind=kind): self.engine.game_data = None self.engine.battle_journal.update(self.record, "waiting_for_battle_clock", kind=kind, source_task_id=source_id, source_task_type_id=source_type, source_step_number=source_step, battle_data={"win": True}, execution_status="completed", terminal=True, experimental_settlement_eligible=True, approximate=True, faithful=False, resume_clock_ready=True) self.assertTrue(self.engine.battles.recovery_status(self.record, snapshot=self.engine.snapshot)["resumable"]) status = self.engine.pending_battle_recovery() self.assertEqual(status["state"], "blocked_policy") self.assertFalse(status["resumable"]) self.assertIn("等待启用" + label + "来源策略", status["message"]) self.client.call.assert_not_called() def test_web_explicit_running_resumes_preaccept_failure_while_auto_stays_false(self): self.engine.cancel_progression() self.engine.poll(resume_pending=False) self.client.call.assert_not_called() self.assertTrue(self.engine.pending_battle_recovery()["resumable"]) self.engine.poll(resume_pending=True) self.assertFalse(self.engine.auto) self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot)) self.assertEqual(self.client.call.call_count, 1) self.assertEqual(self.client.call.call_args.args, ("battleService/recordBattleResult", {"stageId": "0102", "cityId": "1", "result": 0})) self.assertEqual(self.engine.snapshot.raw["currentTasks"], self.raw["currentTasks"]) self.assertFalse(self.engine._progression_pending()) self.engine._require_no_battle() # Other selected strategies are no longer blocked. self.engine.poll(resume_pending=True) self.assertEqual(self.client.call.call_count, 1) def test_new_stop_during_snapshot_read_wins_over_old_running_argument(self): read = self.client.snapshot.side_effect def read_then_stop(): result = read() self.engine.cancel_progression() return result self.client.snapshot.side_effect = read_then_stop self.engine.poll(resume_pending=True) self.assertTrue(self.engine._progression_cancel.is_set()) self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot)) self.client.call.assert_not_called() self.client.snapshot.side_effect = read self.engine.poll(resume_pending=True) self.assertEqual(self.client.call.call_count, 1) def test_guard_is_read_only_and_unknown_settlement_is_blocked(self): self.engine.battle_journal.update(self.record, "unknown", path="battleService/battleEnd", settlement_dispatched=True) before = self.engine.battle_journal.path.read_bytes() status = self.engine.pending_battle_recovery() self.assertEqual(status["state"], "blocked") self.assertFalse(status["resumable"]) self.assertEqual(self.engine.battle_journal.path.read_bytes(), before) record = deepcopy(self.engine.battle_journal.pending(self.engine.snapshot)) self.engine.poll(resume_pending=True) self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record) self.client.call.assert_not_called() self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot)) def test_engine_generation_cancel_in_worker_resumes_single_started_entry(self): from ranch_assistant.model import Snapshot from ranch_assistant.progression import ProgressionIntent self.engine.battle_journal.finish(self.engine.snapshot, self.record, "cancelled") self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [900]}] self.raw["history"]["unlockStage"] = {"0102": [1]} self.raw["history"].update(loopTask={"1": ["4001004"]}, loopTaskTime=self.engine.snapshot.now) self.engine.snapshot = Snapshot(deepcopy(self.raw)) self.engine.battles.catalog = fixture()[0] self.engine.game_data.stages["0102"] = {"level": {"1": {"battle": {"fixture": True}}}} self.engine._battle_catalog_ready = True self.engine._ensure_progression() scope, _ = self.engine.progression_planner._account(self.engine.snapshot) action = ProgressionIntent(kind="stage_battle", description="offline preaccept farming", stage_id="0102", difficulty=1, battle_kind="ordinary_stage", path="stageService/stageStart", team="teamA", battle_mode="experimental", account_key=scope, token="offline-fixture", source_task_type_id="4001004") self.engine.progression_planner._issued[action.token] = action.to_dict() self.engine._select_battle_runtime("experimental") runtime = self.engine.battles.runtime def interrupted(request, *, cancel_event): self.engine.cancel_progression() return {"outcome": "cancelled", "execution_mode": "experimental", "execution_status": "cancelled", "faithful": False, "approximate": True, "terminal": False, "terminal_reason": "worker_cancelled"} runtime.run.side_effect = interrupted self.engine.battles.run(self.client, self.engine.snapshot, action, self.engine.progression_policy, cancel=self.engine._progression_cancel) self.assertEqual(self.engine._progression_cancel_generation, 1) self.assertEqual(self.engine.pending_battle_recovery()["state"], "retry_local_runtime") runtime.run.side_effect = runtime._run self.engine.poll(resume_pending=True) self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot)) self.assertEqual([call.args[0] for call in self.client.call.call_args_list], ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) self.assertEqual(runtime.run.call_count, 2) if __name__ == "__main__": unittest.main()