"""Offline coverage for the durable sweep-to-hidden-battle handoff.""" from copy import deepcopy import json from pathlib import Path from tempfile import TemporaryDirectory from threading import Event from types import SimpleNamespace import unittest from unittest.mock import Mock from ranch_assistant.battles import CancelledBeforeDispatch from ranch_assistant.sweeping import SweepPolicy, SweepRunner, hidden_stage_id class HiddenSweepHandoffTests(unittest.TestCase): def setUp(self): self.temp = TemporaryDirectory() self.addCleanup(self.temp.cleanup) self.folder = Path(self.temp.name) self.catalog = SimpleNamespace(data={}) self.snapshot = SimpleNamespace(now=1794618000, monsters={9: {}}, raw={ "master": {"id": 17, "sessionKey": "never-save"}, "teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [9]}], "nested": {"token": "never-save", "safe": 1}}) self.stage = SimpleNamespace(stage_id="0101", level="3") self.policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 4}}) self.runner = SweepRunner(self.catalog, self.folder / "sweeps.json") self.runner.reason = Mock(return_value="") self.response = {"resCode": 0, "triggerEvent": True, "stageEvent": { "hideStageId": "00109", "costTi": 16, "result": {"money": 999}}} self.client = Mock() self.client.call.return_value = self.response def test_hidden_handoff_counts_once_without_settlement_or_reward(self): result = self.runner.run(self.client, self.snapshot, self.stage, self.policy, origin={"kind": "map_sweep"}) self.assertIs(result, self.response) self.client.call.assert_called_once_with("stageService/stageStart", { "stageTypeId": "0101", "stageLevel": "3"}) self.assertEqual(self.runner.used(self.snapshot, self.stage), 1) self.assertEqual(self.runner.last_outcome, "hidden") self.assertIsNone(self.runner.last_reward) self.assertEqual(self.runner.statistics.snapshot(17)["totals"], {}) pending = self.runner.state["pending"] self.assertEqual((pending["phase"], pending["hidden_stage_id"]), ("hidden_started", "00109")) def test_restart_has_sanitized_entry_and_trusted_start_evidence(self): self.response["sessionKey"] = "never-save" self.runner.run(self.client, self.snapshot, self.stage, self.policy, origin={"kind": "sweep", "secret": "never-save"}) restored = SweepRunner(self.catalog, self.runner.path) pending = restored.state["pending"] self.assertEqual(pending["role_id"], "17") self.assertEqual((pending["stage"], pending["level"], pending["team"]), ("0101", "3", "teamA")) self.assertEqual(pending["counts_key"], self.runner.key(self.snapshot, self.stage)) self.assertTrue(pending["sampleId"]) self.assertEqual(pending["entry_snapshot_now"], self.snapshot.now) self.assertEqual(pending["entry_snapshot"]["nested"], {"safe": 1}) self.assertEqual(pending["origin"], {"kind": "sweep"}) self.assertEqual(pending["start_path"], "stageService/stageStart") self.assertTrue(pending["start_dispatched"]) self.assertTrue(pending["start_confirmed"]) self.assertGreater(pending["start_confirmed_at"], 0) self.assertNotIn("sessionKey", pending["start_response"]) self.assertNotIn("never-save", restored.path.read_text(encoding="utf-8")) def test_hidden_ids_and_trigger_require_exact_protocol_types(self): for identifier, expected in (("00109", "00109"), (109, "109"), (" hidden ", " hidden "), (None, None), ("", None), (" ", None), (0, None), (-1, None), (True, None), (1.0, None), ({}, None), ([], None)): with self.subTest(identifier=identifier): response = dict(self.response, stageEvent={"hideStageId": identifier}) self.assertEqual(hidden_stage_id(response), expected) for flag in (False, 0, "1", 1.0, None): self.assertIsNone(hidden_stage_id(dict(self.response, triggerEvent=flag))) self.assertEqual(hidden_stage_id(dict(self.response, triggerEvent=1)), "00109") def test_ordinary_and_settled_event_paths_still_complete(self): self.client.call.side_effect = [{"resCode": 0, "triggerEvent": False}, {"resCode": 0, "reward": {"money": 1}}, {"resCode": 0}] self.runner.run(self.client, self.snapshot, self.stage, self.policy) self.assertEqual([call.args[0] for call in self.client.call.call_args_list], [ "stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) self.assertEqual(self.runner.last_outcome, "sweep") self.assertIsNone(self.runner.state["pending"]) self.client.reset_mock(side_effect=True) self.client.call.return_value = {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": None, "result": {"money": 2}}} self.runner.run(self.client, self.snapshot, self.stage, self.policy) self.assertEqual(self.client.call.call_count, 1) self.assertEqual(self.runner.last_outcome, "event") self.assertIsNone(self.runner.state["pending"]) self.assertEqual(self.runner.used(self.snapshot, self.stage), 2) def test_timeout_preserves_dispatched_pending_and_cannot_reenter(self): self.client.call.side_effect = TimeoutError("entry not confirmed") with self.assertRaises(TimeoutError): self.runner.run(self.client, self.snapshot, self.stage, self.policy) restored = SweepRunner(self.catalog, self.runner.path) self.assertTrue(restored.state["pending"]["start_dispatched"]) self.assertFalse(restored.state["pending"]["start_confirmed"]) self.assertNotIn("start_response", restored.state["pending"]) with self.assertRaises(ValueError): restored.run(self.client, self.snapshot, self.stage, self.policy) self.assertEqual(self.client.call.call_count, 1) def test_malformed_and_unsuccessful_start_keeps_pending(self): for response in (None, [], {}, {"resCode": False, "triggerEvent": False}, {"resCode": 9, "triggerEvent": False}, {"resCode": 0, "triggerEvent": "1"}, {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": []}}): with self.subTest(response=response): self.runner.state = {"counts": {}, "pending": None} self.client.reset_mock() self.client.call.return_value = response with self.assertRaises(ValueError): self.runner.run(self.client, self.snapshot, self.stage, self.policy) self.assertIsNotNone(SweepRunner(self.catalog, self.runner.path).state["pending"]) self.assertEqual(self.runner.used(self.snapshot, self.stage), 1) self.assertEqual(self.client.call.call_count, 1) def test_cancel_after_reservation_rolls_back_only_unissued_entry(self): cancel = Event() original_save = self.runner.save def save_and_stop(): original_save() cancel.set() self.runner.save = save_and_stop before = deepcopy(self.runner.state) with self.assertRaises(CancelledBeforeDispatch): self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel) self.client.call.assert_not_called() self.assertEqual(self.runner.state, before) self.assertEqual(SweepRunner(self.catalog, self.runner.path).state, before) def test_cancel_after_start_preserves_pending_without_settlement(self): cancel = Event() def start(*args): cancel.set() return {"resCode": 0, "triggerEvent": False} self.client.call.side_effect = start with self.assertRaises(CancelledBeforeDispatch): self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel) self.assertEqual(self.client.call.call_count, 1) self.assertTrue(self.runner.state["pending"]["start_confirmed"]) self.assertEqual(self.runner.used(self.snapshot, self.stage), 1) def test_cancel_at_dispatch_boundary_restores_existing_quota(self): key = self.runner.key(self.snapshot, self.stage) self.runner.state["counts"][key] = 2 before = deepcopy(self.runner.state) cancel = Event() original_save = self.runner.save def save_and_stop(): original_save() if (self.runner.state.get("pending") or {}).get("start_dispatched"): cancel.set() self.runner.save = save_and_stop with self.assertRaises(CancelledBeforeDispatch): self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel) self.client.call.assert_not_called() self.assertEqual(self.runner.state, before) def test_stop_at_settlement_boundary_keeps_entry_reserved(self): cancel = Event() self.client.call.return_value = {"resCode": 0, "triggerEvent": False} original_save = self.runner.save def save_and_stop(): original_save() if self.runner.state["pending"]["phase"] == "扫荡结算待确认": cancel.set() self.runner.save = save_and_stop with self.assertRaises(CancelledBeforeDispatch): self.runner.run(self.client, self.snapshot, self.stage, self.policy, cancel=cancel) self.assertEqual(self.client.call.call_count, 1) self.assertEqual(self.runner.used(self.snapshot, self.stage), 1) def test_invalid_or_failed_settlement_remains_pending(self): for result in (None, [], {}, {"resCode": 7}): with self.subTest(result=result): self.runner.state = {"counts": {}, "pending": None} self.client.reset_mock() self.client.call.side_effect = [{"resCode": 0, "triggerEvent": False}, result] with self.assertRaises(ValueError): self.runner.run(self.client, self.snapshot, self.stage, self.policy) self.assertIsNotNone(self.runner.state["pending"]) self.assertEqual(self.client.call.call_count, 2) def trace_rows(self): return [{"kind": "response", "operation": "读取角色", "body": {"master": {"id": 17}}}, {"kind": "request", "operation": "stageService/stageStart", "request_id": "start-1", "body": {"stageTypeId": "0101", "stageLevel": "3"}}, {"kind": "response", "operation": "stageService/stageStart", "request_id": "start-1", "http_status": 200, "time": "2026-11-14T09:00:00+08:00", "body": deepcopy(self.response)}] def legacy_pending(self, phase="遭遇隐藏关卡,请在游戏内手动战斗"): self.runner.state = {"counts": {self.runner.key(self.snapshot, self.stage): 1}, "pending": { "stage": "0101", "level": "3", "phase": phase, "sampleId": "old"}} self.runner.save() def write_trace(self, rows): trace = self.folder / "network_debug.jsonl" trace.write_text("\n".join(json.dumps(row) for row in rows), encoding="utf-8") return trace def test_valid_rotated_trace_recovers_without_new_write_or_count(self): self.legacy_pending() rows = self.trace_rows() trace = self.write_trace(rows[2:]) trace.with_name("network_debug.previous.jsonl").write_text( "\n".join(json.dumps(row) for row in rows[:2]), encoding="utf-8") counts = deepcopy(self.runner.state["counts"]) self.assertTrue(self.runner.recover_hidden_start(self.snapshot, trace)) pending = SweepRunner(self.catalog, self.runner.path).state["pending"] self.assertEqual((pending["role_id"], pending["hidden_stage_id"]), ("17", "00109")) self.assertEqual(pending["phase"], "hidden_started") self.assertEqual(pending["start_request_id"], "start-1") self.assertTrue(pending["start_confirmed"]) self.assertEqual(pending["start_confirmed_at"], self.snapshot.now) self.assertEqual(self.runner.state["counts"], counts) self.assertNotIn("entry_snapshot", pending) self.assertNotIn("entry_snapshot_now", pending) self.client.call.assert_not_called() def test_unknown_entry_and_old_event_phase_can_recover(self): for phase in ("开始请求待确认", "遇到事件或响应缺少事件状态,请在游戏内处理"): with self.subTest(phase=phase): self.legacy_pending(phase) self.assertTrue(self.runner.recover_hidden_start(self.snapshot, self.write_trace(self.trace_rows()))) def test_only_latest_matching_start_can_supply_recovery_id(self): self.legacy_pending() rows = self.trace_rows() newer = deepcopy(rows[1:]) for row in newer: row["request_id"] = "latest" newer[1]["body"]["stageEvent"]["hideStageId"] = "new-hidden" self.assertTrue(self.runner.recover_hidden_start(self.snapshot, self.write_trace(rows + newer))) self.assertEqual(self.runner.state["pending"]["hidden_stage_id"], "new-hidden") self.assertEqual(self.runner.state["pending"]["start_request_id"], "latest") def test_bound_pending_role_must_match_snapshot(self): self.legacy_pending() self.runner.state["pending"]["role_id"] = "18" before = deepcopy(self.runner.state) self.assertFalse(self.runner.recover_hidden_start(self.snapshot, self.write_trace(self.trace_rows()))) self.assertEqual(self.runner.state, before) def test_nonlegacy_or_persisted_unknown_response_is_not_recovered(self): for phase in ("hidden_started", "扫荡结算待确认", "开始请求待确认"): with self.subTest(phase=phase): self.legacy_pending(phase) if phase == "开始请求待确认": self.runner.state["pending"]["start_response"] = {} before = deepcopy(self.runner.state) self.assertFalse(self.runner.recover_hidden_start(self.snapshot, self.write_trace(self.trace_rows()))) self.assertEqual(self.runner.state, before) def test_subsequent_combat_and_task_writes_always_prevent_recovery(self): for operation in ("stageService/stageStart", "battleService/battleStart", "battleService/battleEnd", "battleService/recordBattleResult", "taskService/taskCompleteStep"): with self.subTest(operation=operation): self.legacy_pending() rows = self.trace_rows() + [{"kind": "request", "operation": operation, "request_id": "later", "body": {}}] before = deepcopy(self.runner.state) self.assertFalse(self.runner.recover_hidden_start(self.snapshot, self.write_trace(rows))) self.assertEqual(self.runner.state, before) def test_insufficient_trace_proof_never_mutates_journal(self): for problem in ("role", "request_id", "later_settlement", "uncertain_write", "ambiguous_owner", "second_reservation", "role_switch", "missing_role", "failed_http", "failed_code", "wrong_level", "duplicate_response", "newer_unknown_start", "corrupt", "duplicate_field", "invalid_reservation", "corrupt_other_owner_reservation"): with self.subTest(problem=problem): self.legacy_pending() rows = self.trace_rows() if problem == "role": rows[0]["body"]["master"]["id"] = 18 elif problem == "request_id": rows[2]["request_id"] = "different" elif problem in ("later_settlement", "uncertain_write"): rows.append({"kind": "request", "request_id": "later", "body": {}, "operation": "battleService/battleEnd" if problem == "later_settlement" else "unknownService/doSomething"}) elif problem == "ambiguous_owner": self.runner.state["counts"][self.runner.key(self.snapshot, self.stage).replace("17:", "18:", 1)] = 1 elif problem == "second_reservation": self.runner.state["counts"]["17:2026-11-13:0101:3"] = 1 elif problem == "invalid_reservation": self.runner.state["counts"] = {"17:invalid:0101:3": 1} elif problem == "corrupt_other_owner_reservation": self.runner.state["counts"]["18:2026-11-14:0101:3"] = "1" elif problem == "role_switch": rows.insert(2, {"kind": "response", "operation": "读取角色", "body": {"master": {"id": 18}}}) elif problem == "missing_role": rows.pop(0) elif problem == "failed_http": rows[2]["http_status"] = 500 elif problem == "failed_code": rows[2]["body"]["resCode"] = 2 elif problem == "wrong_level": rows[1]["body"]["stageLevel"] = "1" elif problem == "duplicate_response": rows.append(deepcopy(rows[2])) rows[-1]["body"]["stageEvent"]["hideStageId"] = "another" elif problem == "newer_unknown_start": rows.append(dict(rows[1], request_id="newer")) self.runner.save() before = deepcopy(self.runner.state) disk = self.runner.path.read_bytes() trace = self.write_trace(rows) if problem == "corrupt": with trace.open("a", encoding="utf-8") as stream: stream.write("\n{broken") elif problem == "duplicate_field": trace.write_text(trace.read_text(encoding="utf-8").replace( '"request_id": "start-1"', '"request_id": "other", "request_id": "start-1"'), encoding="utf-8") self.assertFalse(self.runner.recover_hidden_start(self.snapshot, trace)) self.assertEqual(self.runner.state, before) self.assertEqual(self.runner.path.read_bytes(), disk) if __name__ == "__main__": unittest.main()