fix: continue hidden sweep battles safely in Web 2.0.12
This commit is contained in:
@@ -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()
|
||||
Reference in New Issue
Block a user