Automatically reconcile and resume interrupted task battle clock waits

This commit is contained in:
AttilaNet
2026-11-08 20:21:35 +08:00
parent 001ed9d36d
commit 0ec95bbe65
6 changed files with 206 additions and 6 deletions
@@ -804,6 +804,95 @@ class EngineProgressionTests(unittest.TestCase):
mid = int(self.raw["monsters"][0]["id"])
self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [mid]}]
def interrupted_model_wait(self):
self.battle_task()
runtime = ExperimentalRuntime()
original = runtime._run
runtime.run.side_effect = lambda request, cancel_event: original(request, cancel_event=cancel_event) | {
"requires_realtime_wait": True, "model_elapsed_ms": 10000}
self.engine = self.make_engine(experimental_runtime=runtime)
self.engine.progression_policy.battle_mode = "experimental"
self.engine.battles.clock = lambda: 0
cancel = self.engine._progression_cancel
cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True)
self.engine.run_progression_once()
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], ["battleService/battleStart"])
record = self.engine.battle_journal.pending(self.engine.snapshot)
self.assertIsNotNone(record)
cancel.clear()
return runtime, record
def test_poll_resumes_interrupted_clock_without_restarting_or_simulating_again(self):
runtime, record = self.interrupted_model_wait()
record["battle_ready_at"] = 1
self.engine.battle_journal.save()
self.engine.auto = True
self.engine.poll()
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
self.assertIsNone(self.engine.progression_planner.pending(self.engine.snapshot))
self.assertEqual([call.args[0] for call in self.client.call.call_args_list],
["battleService/battleStart", "taskService/taskCompleteStep"])
self.assertEqual(runtime.run.call_count, 1)
def test_interrupted_clock_never_submits_while_stopped_or_before_deadline(self):
_, record = self.interrupted_model_wait()
record["battle_ready_at"] = 1
self.engine.battle_journal.save()
self.engine.poll()
self.assertEqual(self.client.call.call_count, 1)
self.engine.auto = True
record = self.engine.battle_journal.pending(self.engine.snapshot)
record["battle_ready_at"] = 10**12
self.engine.battle_journal.save()
self.engine.poll()
self.assertEqual(self.client.call.call_count, 1)
def test_uncertain_settlement_is_never_replayed_by_recovery(self):
_, record = self.interrupted_model_wait()
self.engine.battle_journal.update(record, "unknown", path="taskService/taskCompleteStep", battle_ready_at=1)
self.engine.auto = True
self.engine.poll()
self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot))
self.assertEqual(self.client.call.call_count, 1)
def test_legacy_interrupted_clock_resumes_after_restart_without_new_battle(self):
runtime, record = self.interrupted_model_wait()
record.pop("resume_clock_ready", None)
record.pop("battle_ready_at", None)
record["battle_data"]["battlePosition"] = {
key: val for key, val in record["battle_data"]["battlePosition"].items() if val is not None}
record["updated_at"] = 1
self.engine.battle_journal.save()
restored = self.make_engine(experimental_runtime=runtime)
restored.progression_policy.battle_mode = "experimental"
restored.auto = True
restored.poll()
self.assertIsNone(restored.battle_journal.pending(restored.snapshot))
self.assertIsNone(restored.progression_planner.pending(restored.snapshot))
self.assertEqual(runtime.run.call_count, 1)
self.assertEqual([call.args[0] for call in self.client.call.call_args_list],
["battleService/battleStart", "taskService/taskCompleteStep"])
def test_pending_background_check_becomes_due_after_two_minutes(self):
self.interrupted_model_wait()
self.engine.last_pending_check = 100
with patch("ranch_assistant.engine.time.monotonic", return_value=219):
self.assertFalse(self.engine.pending_recovery_due())
with patch("ranch_assistant.engine.time.monotonic", return_value=220):
self.assertTrue(self.engine.pending_recovery_due())
def test_resumed_settlement_timeout_remains_query_only_on_later_polls(self):
_, record = self.interrupted_model_wait()
record["battle_ready_at"] = 1
self.engine.battle_journal.save()
self.engine.auto = True
self.client.call.side_effect = TimeoutError("synthetic lost reply")
with self.assertRaises(TimeoutError):
self.engine.poll()
self.engine.poll()
self.assertEqual(self.client.call.call_count, 2)
self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot))
def test_task_battle_capability_overlay_cannot_claim_config_is_runtime_support(self):
self.battle_task()
runtime = Runtime(supported=False)