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,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()