Files
myrzx_bot/ranch_assistant/tests/test_sweep_hidden_battles.py

292 lines
16 KiB
Python

"""Hidden sweep handoff/recovery regressions; every game operation is mocked."""
from copy import deepcopy
import threading
import unittest
from unittest.mock import Mock
from ranch_assistant.battles import BattleJournal, BattleOrchestrator
from ranch_assistant.sweeping import SweepRunner
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime, fixture, intent, policy
from ranch_assistant.tests.test_core import workspace_temp
class HiddenSweepBattleTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.catalog, self.snapshot = fixture()
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
self.runtime = ExperimentalRuntime()
self.client = Mock()
self.start = {"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": "0102", "result": {"money": 999}, "costTi": 99}}
self.client.call.side_effect = lambda path, payload: deepcopy(self.start) if path.endswith("stageStart") else {
"resCode": 0, "reward": {"money": 17}, "costTi": 6}
self.chosen = policy(battle_mode="experimental")
self.action = intent(kind="sweep", battle_kind="sweep", difficulty="3")
self.restart()
def restart(self):
self.sweeper = SweepRunner(self.catalog, self.folder / "sweep_runs.json")
self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.folder / "journal.json"),
self.runtime, self.sweeper)
def run_sweep(self, cancel=None):
return self.runner.run(self.client, self.snapshot, self.action, self.chosen, cancel=cancel)
def paths(self):
return [call.args[0] for call in self.client.call.call_args_list]
def test_hidden_win_uses_hidden_inputs_metadata_and_record_with_one_entry(self):
self.run_sweep()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
request = self.runtime.run.call_args.args[0]
self.assertEqual((request["stage_id"], request["difficulty"], request["battle_kind"]), ("0102", "1", "hidden"))
data = self.client.call.call_args_list[1].args[1]["battleData"]
self.assertEqual(data["battlePosition"]["stageId"], "0102")
self.assertEqual(data["totalDamage"], 47)
self.assertEqual(self.client.call.call_args_list[2].args[1], {"stageId": "0102", "cityId": "1", "result": 1})
record = self.runner.journal.records(self.snapshot)[0]
self.assertEqual((record["stage_id"], record["difficulty"], record["battle_kind"]), ("0102", "1", "hidden"))
self.assertEqual((record["parent_stage_id"], record["parent_difficulty"], record["outcome"]), ("0101", "3", "win"))
self.assertEqual(sum(self.sweeper.state["counts"].values()), 1)
self.assertIsNone(self.sweeper.state["pending"])
totals = self.sweeper.statistics.snapshot(7)["totals"]
self.assertEqual(totals["0102:1:sweep"]["n"], 1)
self.assertNotIn("0101:3:event", totals)
self.assertEqual(self.sweeper.last_reward["money"], 17)
def test_hidden_loss_records_hidden_id_without_victory_settlement(self):
self.runtime.win = False
self.run_sweep()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"])
self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0102", "cityId": "1", "result": 0})
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(self.runner.journal.records(self.snapshot)[0]["outcome"], "loss")
self.assertEqual(self.runner.journal.role(self.snapshot)["losses"], 0)
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"], {})
def test_stop_during_computation_resumes_saved_result_without_second_worker_or_entry(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.run_sweep(cancel)
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.restart()
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.runtime.run.call_count, 1)
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(sum(self.sweeper.state["counts"].values()), 1)
def test_stop_after_start_keeps_original_inputs_for_restart(self):
cancel = threading.Event()
def start(path, payload):
cancel.set()
return deepcopy(self.start)
self.client.call.side_effect = start
self.run_sweep(cancel)
self.runtime.run.assert_not_called()
self.snapshot.raw["monsters"][0]["level"] = 999
self.restart()
self.client.call.side_effect = lambda path, payload: {"resCode": 0, "reward": {}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
request = self.runtime.run.call_args.args[0]
self.assertNotIn("level", request.get("roster", request["snapshot"])["monsters"][0])
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
self.assertIsNone(self.sweeper.state["pending"])
def test_unknown_settlement_is_never_replayed_or_cleared(self):
def call(path, payload):
if path.endswith("battleEnd"):
raise TimeoutError("offline lost settlement response")
return deepcopy(self.start)
self.client.call.side_effect = call
with self.assertRaises(TimeoutError):
self.run_sweep()
self.restart()
before = deepcopy(self.sweeper.state)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"])
self.assertEqual(self.sweeper.state, before)
self.assertIsNotNone(self.runner.pending(self.snapshot))
def test_unknown_record_keeps_confirmed_rewards_and_never_replays(self):
def call(path, payload):
if path.endswith("recordBattleResult"):
raise TimeoutError("offline lost record response")
return deepcopy(self.start) if path.endswith("stageStart") else {"resCode": 0, "reward": {"money": 17}}
self.client.call.side_effect = call
with self.assertRaises(TimeoutError):
self.run_sweep()
self.restart()
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(len(self.paths()), 3)
self.assertIsNotNone(self.runner.pending(self.snapshot)["sweep_entry"])
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"]["0102:1:sweep"]["n"], 1)
def test_role_mismatch_cannot_adopt_hidden_sweep(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
self.restart()
self.snapshot.raw["master"]["id"] = 8
before = deepcopy(self.sweeper.state)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.sweeper.state, before)
self.assertEqual(len(self.paths()), 1)
self.runtime.run.assert_not_called()
def test_no_hidden_evidence_keeps_legacy_pending_and_journal(self):
self.sweeper.state["pending"] = {"stage": "0101", "level": "3", "sampleId": "old",
"phase": "遭遇隐藏关卡,请在游戏内手动战斗"}
self.sweeper.save()
before = deepcopy(self.sweeper.state)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen, cancel=threading.Event())
self.assertEqual(self.sweeper.state, before)
self.client.call.assert_not_called()
self.runtime.run.assert_not_called()
def test_cross_day_handoff_and_completed_journal_cleanup_keep_original_reservation(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
record = self.runner.pending(self.snapshot)
entry = deepcopy(record["sweep_entry"])
counts = deepcopy(self.sweeper.state["counts"])
# Emulate a crash after journal.save but before sweep.save.
self.sweeper.state["pending"] = deepcopy(entry)
self.sweeper.save()
self.snapshot.server_offset += 86400
self.restart()
self.runner.handoff_sweep(self.snapshot)
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(self.sweeper.state["counts"], counts)
self.client.call.side_effect = lambda *args: {"resCode": 0, "reward": {"money": 17}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
self.sweeper.state["pending"] = deepcopy(entry)
self.sweeper.save()
self.restart()
self.runner.handoff_sweep(self.snapshot)
self.assertIsNone(self.sweeper.state["pending"])
self.assertEqual(self.sweeper.state["counts"], counts)
self.assertEqual(len(self.runner.journal.records(self.snapshot)), 1)
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"]["0102:1:sweep"]["n"], 1)
def test_runtime_clock_stop_and_resume_does_not_resimulate_or_enter(self):
cancel = threading.Event()
cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True)
self.runner.clock = lambda: 0
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.run_sweep(cancel)
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.restart()
record = self.runner.pending(self.snapshot)
self.assertEqual(record["battle_clock_seconds"], 10)
self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result")
self.runner.journal.update(record, record["phase"], battle_ready_at=1)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.runtime.run.call_count, 1)
self.assertEqual(len(self.paths()), 3)
def test_confirmed_hidden_start_does_not_recover_with_wrong_hidden_id(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
record = self.runner.pending(self.snapshot)
self.runner.journal.update(record, record["phase"], stage_id="0101")
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.runtime.run.assert_not_called()
def test_empty_settlement_or_record_response_never_confirms_or_retries_hidden_write(self):
for target in ("battleEnd", "recordBattleResult"):
with self.subTest(target=target):
self.setUp()
def call(path, payload):
if path.endswith(target):
return {}
return deepcopy(self.start) if path.endswith("stageStart") else {"resCode": 0, "reward": {}}
self.client.call.side_effect = call
with self.assertRaises(ValueError):
self.run_sweep()
count = len(self.paths())
self.restart()
record = self.runner.pending(self.snapshot)
self.assertFalse(self.runner.recovery_status(record)["resumable"])
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(len(self.paths()), count)
def test_crash_after_trusted_response_save_derives_hidden_only_from_response(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
entry = deepcopy(self.runner.pending(self.snapshot)["sweep_entry"])
self.runner.journal.state = {"version": 1, "roles": {}}
self.runner.journal.save()
entry.pop("hidden_stage_id")
entry["phase"] = "开始请求待确认"
self.sweeper.state["pending"] = entry
self.sweeper.save()
self.restart()
self.client.call.side_effect = lambda *args: {"resCode": 0, "reward": {}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
self.assertEqual(self.runner.journal.records(self.snapshot)[0]["stage_id"], "0102")
def test_crash_after_new_journal_begin_keeps_sample_role_and_recovers_same_record(self):
cancel = threading.Event()
self.client.call.side_effect = lambda *args: cancel.set() or deepcopy(self.start)
self.run_sweep(cancel)
entry = deepcopy(self.runner.pending(self.snapshot)["sweep_entry"])
self.runner.journal.state = {"version": 1, "roles": {}}
self.runner.journal.save()
self.sweeper.state["pending"] = entry
self.sweeper.save()
begin = self.runner.journal.begin
def crash(*args, **kwargs):
record = begin(*args, **kwargs)
self.assertEqual((record["sweep_sample_id"], record["role_id"]), (entry["sampleId"], "7"))
raise OSError("offline crash after durable begin")
self.runner.journal.begin = crash
with self.assertRaises(OSError):
self.runner.handoff_sweep(self.snapshot)
self.restart()
self.client.call.side_effect = lambda *args: {"resCode": 0, "reward": {}}
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertIsNone(self.runner.pending(self.snapshot))
self.assertEqual(len(self.runner.journal.records(self.snapshot)), 1)
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
def test_commission_farming_sweep_keeps_source_and_single_entry_during_resume(self):
self.action.update(kind="progression_farm_sweep", task_id=0, task_type_id="", step_number=0,
source_task_id=51, source_task_type_id="400", source_step_number=1)
self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "400", "curStep": 1}]
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.run_sweep(cancel)
self.restart()
record = self.runner.pending(self.snapshot)
self.assertEqual((record["kind"], record["source_task_id"], record["source_task_type_id"]),
("progression_farm_sweep", 51, "400"))
self.runner.continue_sweep(self.client, self.snapshot, policy(enabled=False, battle_mode="experimental"))
self.assertEqual(len(self.paths()), 1)
self.runner.continue_sweep(self.client, self.snapshot, self.chosen)
self.assertEqual(self.runtime.run.call_count, 1)
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(sum(self.sweeper.state["counts"].values()), 1)
self.assertEqual(self.sweeper.statistics.snapshot(7)["totals"]["0102:1:sweep"]["n"], 1)
self.assertEqual(self.runner.journal.role(self.snapshot)["losses"], 0)
if __name__ == "__main__":
unittest.main()