fix: continue hidden sweep battles safely in Web 2.0.12

This commit is contained in:
AttilaNet
2026-11-14 12:41:11 +08:00
parent 7ca2ee13e3
commit 69b59e18dd
21 changed files with 1691 additions and 102 deletions
@@ -0,0 +1,291 @@
"""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()
@@ -0,0 +1,331 @@
"""Account-worker sweep recovery, with local files and mocked transport only."""
from copy import deepcopy
import json
import threading
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.api import Session
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Policy, Snapshot
from ranch_assistant.sessions import identity
from ranch_assistant.sweeping import SweepPolicy
from ranch_assistant.maps import stages
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime
from ranch_assistant.tests.test_core import workspace_temp
class HiddenSweepEngineTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.catalog, self.snapshot = scenario()
self.raw = deepcopy(self.snapshot.raw)
self.raw["master"].update(id=7, ti=100, timeTi=0)
self.raw["currentTasks"] = []
self.session = Session(account_id="offline", role_id=7, server_id=1)
self.root = self.folder / "roles" / identity(self.session)
self.trace = self.folder / "network_debug.jsonl"
self.client = Mock()
self.client.session = self.session
self.client.trace = Mock(path=self.trace, events=[])
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.raw))
self.runtime = ExperimentalRuntime()
data = {"stage_info": deepcopy(self.catalog.data["stage_info"]), "game_setting": self.catalog.data["game_setting"],
"task_info": {}, "stage_battles": {}}
data["stage_info"]["0102"]["level"]["1"]["battle"] = {"fixture_hidden": True}
self.engine = Engine(self.catalog, self.client, self.root / "purchase.json",
game_data=ProgressionData(data), experimental_runtime=self.runtime)
self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False)
self.engine.progression_policy.enabled = False
self.engine.sweep_policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}}, allow_challenge=False)
self.engine.master_sync.settle = Mock()
self.engine.snapshot = Snapshot(deepcopy(self.raw))
def legacy(self, phase="遭遇隐藏关卡,请在游戏内手动战斗"):
pending = {"stage": "0101", "level": "3", "phase": phase, "sampleId": "legacy-entry"}
self.engine.sweeper.state = {"counts": {"7:2026-11-13:0101:3": 1}, "pending": pending}
self.engine.sweeper.save()
events = [{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
return deepcopy(pending)
def test_exact_legacy_missing_id_is_archived_after_trusted_read_without_reward_or_write(self):
original = self.legacy()
self.engine.sweep_policy.enabled = False
self.engine.cancel_progression()
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
record = self.engine.battle_journal.records(self.engine.snapshot)[0]
self.assertEqual(record["outcome"], "abandoned_missing_hidden_id")
self.assertEqual(record["sweep_entry"], original)
self.assertIn("旧版未保存隐藏关卡编号,本次未完成已放弃;未结算奖励", record["message"])
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
self.client.call.assert_not_called()
self.assertEqual(self.engine.sweeper.statistics.snapshot(7)["totals"], {})
self.engine.read_snapshot(sync_master=False)
self.assertEqual(len(self.engine.battle_journal.records(self.engine.snapshot)), 1)
def test_legacy_archive_accepts_exact_local_login_info_then_role_read_and_heartbeat(self):
original = self.legacy()
events = [{"kind": "info", "operation": "进入参数检查", "scope": "local",
"sign_date": "20261114", "date_format": "yyyyMMdd", "signature_rule": "2|2|1|2|3",
"tj_channel": "unknow", "platform": "ANDROID", "channel": "DYD", "uid_length": 7, "token_length": 16},
{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}},
{"kind": "request", "operation": "heartBeatService/keepAlive", "request_id": "heartbeat", "body": {}},
{"kind": "response", "operation": "heartBeatService/keepAlive", "request_id": "heartbeat",
"http_status": 200, "body": {"resCode": 0}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
record = self.engine.battle_journal.records(self.engine.snapshot)[0]
self.assertEqual(record["outcome"], "abandoned_missing_hidden_id")
self.assertEqual(record["sweep_entry"], original)
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
self.assertTrue(next(iter(self.engine._sweep_recovery_cache.values()))["valid"])
self.client.call.assert_not_called()
self.runtime.run.assert_not_called()
self.assertEqual(self.engine.sweeper.statistics.snapshot(7)["totals"], {})
def test_unknown_info_or_login_info_without_local_scope_blocks_legacy_archive(self):
for info in ({"kind": "info", "operation": "未知信息", "scope": "local"},
{"kind": "info", "operation": "进入参数检查", "scope": "network"},
{"kind": "info", "operation": "进入参数检查"}):
with self.subTest(info=info):
original = self.legacy()
self.engine._sweep_recovery_cache.clear()
events = [info, {"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.assertFalse(next(iter(self.engine._sweep_recovery_cache.values()))["valid"])
self.assertEqual(self.engine.battle_journal.records(self.engine.snapshot), [])
self.client.call.assert_not_called()
self.runtime.run.assert_not_called()
def test_uncertain_phases_are_never_archived(self):
for phase in ("开始请求待确认", "扫荡结算待确认", "start_pending", "settlement_pending"):
original = self.legacy(phase)
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.client.call.assert_not_called()
def test_archive_requires_role_path_binding_and_fresh_read(self):
original = self.legacy()
self.engine.sweeper.path = self.folder / "other" / "sweep_runs.json"
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.client.snapshot.side_effect = TimeoutError("offline read failed")
with self.assertRaises(TimeoutError):
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
def test_later_consumption_or_conflicting_journal_blocks_archive(self):
original = self.legacy()
with self.trace.open("a", encoding="utf-8") as stream:
stream.write(json.dumps({"kind": "request", "operation": "battleService/battleEnd",
"request_id": "later", "body": {"battleData": {}}}) + "\n")
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.legacy()
self.engine.battle_journal.begin(self.engine.snapshot, {"kind": "battle", "stage_id": "0102", "difficulty": "1"})
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], original)
self.client.call.assert_not_called()
def test_map_sweep_origin_uses_enabled_sweep_with_challenges_disabled(self):
self.assertTrue(self.engine._intent_policy({"kind": "map_sweep"}).enabled)
self.engine.sweep_policy.enabled = False
self.assertFalse(self.engine._intent_policy({"kind": "map_sweep"}).enabled)
def test_commission_farming_origin_uses_quest_policy(self):
self.engine.game_data.tasks["400"] = {"type": 4}
self.engine.quest_policy.enabled = True
origin = {"kind": "progression_farm_sweep", "source_task_type_id": "400"}
self.assertTrue(self.engine._intent_policy(origin).enabled)
self.engine.quest_policy.enabled = False
self.engine.progression_policy.enabled = True
self.assertFalse(self.engine._intent_policy(origin).enabled)
def prepare_hidden(self):
response = {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": "0102", "result": {"money": 999}}}
self.client.call.side_effect = lambda path, payload: deepcopy(response) if path.endswith("stageStart") else {
"resCode": 0, "reward": {"money": 17}}
stage = next(s for s in stages(self.catalog, self.engine.snapshot) if s.stage_id == "0101" and s.level == "3")
self.engine.sweeper.run(self.client, self.engine.snapshot, stage, self.engine.sweep_policy,
origin={"kind": "map_sweep", "stage_id": "0101", "difficulty": "3", "battle_kind": "sweep", "battle_mode": "experimental"})
self.engine.read_snapshot(sync_master=False)
def test_worker_migrates_before_web_start_and_resumes_without_challenge_or_mainline(self):
self.prepare_hidden()
self.assertIsNone(self.engine.sweeper.state["pending"])
self.assertEqual(self.engine.pending_battle_recovery()["state"], "prepare_hidden_sweep")
self.engine.poll(resume_pending=True)
self.assertFalse(self.engine.auto)
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"])
request = self.runtime.run.call_args.args[0]
self.assertEqual((request["stage_id"], request["difficulty"]), ("0102", "1"))
self.assertEqual(request["roster"]["teams"][0]["monsters"], [900, 0])
self.assertEqual(sum(self.engine.sweeper.state["counts"].values()), 1)
totals = self.engine.sweeper.statistics.snapshot(7)["totals"]
self.assertEqual(totals["0102:1:sweep"]["n"], 1)
self.assertNotIn("0101:3:sweep", totals)
def test_stop_disabled_source_and_stale_generation_do_not_resume_consumption(self):
self.prepare_hidden()
self.engine.cancel_progression()
self.engine.poll(resume_pending=False)
self.engine.sweep_policy.enabled = False
self.assertEqual(self.engine.pending_battle_recovery()["state"], "blocked_policy")
self.engine.poll(resume_pending=True)
self.engine.sweep_policy.enabled = True
self.assertEqual(self.engine._resume_pending_task_clock(running=True,
generation=self.engine._progression_cancel_generation - 1), "")
self.runtime.run.assert_not_called()
self.assertEqual(self.client.call.call_count, 1)
self.engine.poll(resume_pending=True)
self.assertEqual(self.client.call.call_count, 3)
def test_legacy_scan_is_cached_and_never_runs_in_recovery_presentation(self):
self.legacy()
with patch("ranch_assistant.sweep_recovery.scan_trace", wraps=__import__(
"ranch_assistant.sweep_recovery", fromlist=["scan_trace"]).scan_trace) as scan:
for _ in range(3):
self.engine.pending_battle_recovery()
self.assertEqual(scan.call_count, 0)
self.engine.read_snapshot(sync_master=False)
self.engine.read_snapshot(sync_master=False)
self.assertEqual(scan.call_count, 1)
def test_archive_crash_after_journal_finish_repairs_without_second_record(self):
original = self.legacy()
self.engine.read_snapshot(sync_master=False)
self.engine.sweeper.state["pending"] = original
self.engine.sweeper.save()
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
self.assertEqual(len(self.engine.battle_journal.records(self.engine.snapshot)), 1)
self.client.call.assert_not_called()
def test_archive_crash_after_begin_recovers_same_sample_without_generic_prepared_record(self):
original = self.legacy()
begin = self.engine.battle_journal.begin
def crash(*args, **kwargs):
begin(*args, **kwargs)
raise OSError("offline interrupted archive")
self.engine.battle_journal.begin = crash
with self.assertRaises(OSError):
self.engine.read_snapshot(sync_master=False)
self.engine.battle_journal.begin = begin
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
records = self.engine.battle_journal.records(self.engine.snapshot)
self.assertEqual(len(records), 1)
self.assertEqual(records[0]["sweep_entry"], original)
self.assertEqual(records[0]["outcome"], "abandoned_missing_hidden_id")
def test_normal_sweep_stop_before_dispatch_archives_but_unknown_dispatch_stays_pending(self):
cancel = threading.Event()
stage = next(s for s in stages(self.catalog, self.engine.snapshot) if s.stage_id == "0101" and s.level == "3")
def start(path, payload):
cancel.set()
return {"resCode": 0, "triggerEvent": False}
self.client.call.side_effect = start
from ranch_assistant.battles import CancelledBeforeDispatch
with self.assertRaises(CancelledBeforeDispatch):
self.engine.sweeper.run(self.client, self.engine.snapshot, stage, self.engine.sweep_policy,
cancel=cancel, origin={"kind": "map_sweep"})
pending = deepcopy(self.engine.sweeper.state["pending"])
self.assertIs(pending["settlement_dispatched"], False)
self.engine.read_snapshot(sync_master=False)
self.assertIsNone(self.engine.sweeper.state["pending"])
self.assertEqual(self.engine.battle_journal.records(self.engine.snapshot)[0]["outcome"], "abandoned_cancelled_sweep")
self.assertEqual(self.client.call.call_count, 1)
for dispatched in (True, None):
unknown = dict(pending, phase="扫荡结算待确认")
unknown.pop("settlement_dispatched")
if dispatched is not None:
unknown["settlement_dispatched"] = dispatched
self.engine.sweeper.state["pending"] = unknown
self.engine.sweeper.save()
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.sweeper.state["pending"], unknown)
def test_ordinary_automatic_entry_runs_hidden_battle_and_counts_once(self):
self.client.call.side_effect = lambda path, payload=None: {"resCode": 0, "triggerEvent": True,
"stageEvent": {"hideStageId": "0102", "result": {"money": 999}}} if path.endswith("stageStart") else {
"resCode": 0, "reward": {"money": 17}}
self.engine.auto = True
_, _, message = self.engine.poll()
self.assertIn("隐藏关卡", message)
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], [
"stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(sum(self.engine.sweeper.state["counts"].values()), 1)
def test_trace_proven_legacy_hidden_id_runs_first_computation_without_new_entry(self):
self.legacy()
original_roster = deepcopy(self.raw)
self.engine.sweeper.state["pending"].update(entry_snapshot=original_roster,
entry_snapshot_now=self.engine.snapshot.now, team="teamA")
self.engine.sweeper.save()
next(mon for mon in self.raw["monsters"] if mon["id"] == 900)["level"] = 999
events = [{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}},
{"kind": "request", "operation": "stageService/stageStart", "request_id": "old-start",
"body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"kind": "response", "operation": "stageService/stageStart", "request_id": "old-start", "http_status": 200,
"body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": "0102"}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.client.call.return_value = {"resCode": 0, "reward": {"money": 17}}
self.engine.read_snapshot(sync_master=False)
self.assertEqual(self.engine.pending_battle_recovery()["state"], "prepare_hidden_sweep")
self.engine.poll(resume_pending=True)
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], [
"battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
saved = self.engine.battle_journal.records(self.engine.snapshot)[0]["sweep_entry"]
self.assertEqual(saved["entry_snapshot"], original_roster)
runtime_roster = self.runtime.run.call_args.args[0]["roster"]
self.assertEqual(next(mon for mon in runtime_roster["monsters"] if mon["id"] == 900)["level"], 20)
def test_legacy_hidden_id_without_original_inputs_blocks_changed_current_roster(self):
self.legacy()
next(mon for mon in self.raw["monsters"] if mon["id"] == 900)["level"] = 999
events = [{"kind": "response", "operation": "读取角色", "http_status": 200,
"body": {"resCode": 0, "master": {"id": 7}}},
{"kind": "request", "operation": "stageService/stageStart", "request_id": "old-start",
"body": {"stageTypeId": "0101", "stageLevel": "3"}},
{"kind": "response", "operation": "stageService/stageStart", "request_id": "old-start", "http_status": 200,
"body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"hideStageId": "0102"}}}]
self.trace.write_text("\n".join(json.dumps(row) for row in events) + "\n", encoding="utf-8")
self.engine.read_snapshot(sync_master=False)
record = self.engine.battle_journal.pending(self.engine.snapshot)
self.assertEqual(record["stage_id"], "0102")
self.assertEqual(record["sweep_sample_id"], "legacy-entry")
self.assertNotIn("entry_snapshot", record["sweep_entry"])
self.assertNotIn("entry_snapshot_now", record["sweep_entry"])
self.assertNotIn("input_evidence", record["sweep_entry"])
self.assertNotIn("combat_request", record)
self.assertNotIn("combat_request_digest", record)
recovery = self.engine.pending_battle_recovery()
self.assertEqual(recovery["state"], "blocked")
self.assertFalse(recovery["resumable"])
self.assertIn("缺少原始战斗输入", recovery["message"])
for _ in range(2):
self.engine.poll(resume_pending=True)
self.runtime.inspect.assert_not_called()
self.runtime.run.assert_not_called()
self.client.call.assert_not_called()
self.assertEqual(self.engine.sweeper.state["counts"], {"7:2026-11-13:0101:3": 1})
self.assertEqual(self.engine.sweeper.statistics.snapshot(7)["totals"], {})
self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,322 @@
"""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()