323 lines
18 KiB
Python
323 lines
18 KiB
Python
"""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()
|