fix: recover interrupted Web battles in 2.0.10
This commit is contained in:
@@ -0,0 +1,492 @@
|
||||
"""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()
|
||||
Reference in New Issue
Block a user