Files

493 lines
31 KiB
Python

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