fix: recover interrupted Web battles in 2.0.10

This commit is contained in:
AttilaNet
2026-11-14 10:56:43 +08:00
parent bbdf578c87
commit 9f3945a717
24 changed files with 1912 additions and 127 deletions
@@ -0,0 +1,247 @@
"""Web authorization of Engine-classified recovery, using offline clients only."""
from copy import deepcopy
import math
import time
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Snapshot
from ranch_web.service import AccountWorker
from ranch_web.tests import test_lifecycle_recovery as lifecycle
from ranch_web.tests import test_service as fixtures
from ranch_web.views import build_view
class RecoveryGuardContractTests(unittest.TestCase):
def worker(self, runtime):
worker = AccountWorker.__new__(AccountWorker)
worker.active_identity, worker._legacy_pending = None, {}
record = {"kind": "stage_battle", "stage_id": "0102", "phase": "unknown",
"execution_status": "timed_out", "terminal_reason": "worker_wall_clock_limit",
"path": "stageService/stageStart"}
worker.engine = SimpleNamespace(snapshot=object(), battles=runtime,
battle_journal=SimpleNamespace(pending=lambda snapshot: record),
_progression_pending=lambda: record, sweeper=SimpleNamespace(state={}),
explore_planner=SimpleNamespace(pending=lambda snapshot: None), _breakthrough_pending=None)
return worker, record
def test_engine_recovery_contract_overrides_old_clock_predicate(self):
for allowed in (False, True):
with self.subTest(allowed=allowed):
runtime = SimpleNamespace(recovery_status=Mock(return_value={
"state": "abandon_stage" if allowed else "blocked", "resumable": allowed,
"message": "已确认开战,按原客户端协议退出"}),
resumable_task_clock=Mock(return_value=not allowed))
worker, record = self.worker(runtime)
worker.engine.pending_battle_recovery = Mock(return_value=runtime.recovery_status.return_value)
self.assertEqual(worker._pending_execution_reason() == "", allowed)
worker.engine.pending_battle_recovery.assert_called_once_with()
runtime.recovery_status.assert_not_called()
runtime.resumable_task_clock.assert_not_called()
def test_truthy_recovery_flag_does_not_grant_write_permission(self):
for flag in (1, "true", None):
with self.subTest(flag=flag):
worker, _ = self.worker(SimpleNamespace(recovery_status=lambda *args, **kwargs: {
"state": "abandon_stage", "resumable": flag, "message": ""},
resumable_task_clock=lambda record: True))
worker.engine.pending_battle_recovery = lambda: {"state": "abandon_stage", "resumable": flag, "message": ""}
self.assertTrue(worker._pending_execution_reason())
def test_runtime_without_recovery_helper_keeps_old_clock_fallback(self):
for allowed in (False, True):
with self.subTest(allowed=allowed):
worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: allowed))
self.assertEqual(worker._pending_execution_reason() == "", allowed)
def test_disabled_origin_uses_specific_engine_policy_message(self):
worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: True))
message = "对应委托策略已关闭,等待启用委托策略后恢复原战斗"
worker.engine.pending_battle_recovery = lambda: {
"state": "blocked_policy", "resumable": False, "message": message}
self.assertEqual(worker._pending_execution_reason(), message)
class LegacyBattleRecoveryTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
connected = lifecycle.LifecycleRecoveryTests.connected
tick = lifecycle.LifecycleRecoveryTests.tick
paths = lifecycle.LifecycleRecoveryTests.paths
def login(self, identifier):
return fixtures.ServiceTests.login(self, identifier, account="recovery-" + identifier)
def legacy_timeout(self, *, unaccepted=False):
identifier, worker = self.connected()
engine = worker.engine
source_id, source_type, source_step = (0, "4001004", 0) if unaccepted else (51, "1002013", 1)
engine.client.raw["currentTasks"] = ([] if unaccepted else [
{"id": source_id, "typeId": source_type, "curStep": source_step, "stepValue": 0}])
engine.snapshot = Snapshot(deepcopy(engine.client.raw))
engine.game_data = ProgressionData({"task_info": {source_type: {"type": 4, "name": "离线材料委托",
"steps": [{"statusType": "none", "statusValue": {}}]}}})
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = True
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
journal = engine.battle_journal
record = journal.begin(engine.snapshot, {"kind": "stage_battle", "stage_id": "0102", "difficulty": 1,
"battle_kind": "ordinary_stage", "description": "离线委托材料关卡", "task_id": None,
"task_type_id": None, "source_task_id": source_id,
"source_task_type_id": source_type, "source_step_number": source_step})
journal.update(record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart",
start_response={"resCode": 0, "triggerEvent": False, "stageEvent": None},
battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False,
terminal_reason="worker_wall_clock_limit", message="战斗已取消、超时或结果不确定,等待核对")
self.assertEqual(engine.battles.recovery_status(record, snapshot=engine.snapshot)["state"], "abandon_stage")
engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
return identifier, worker
def test_legacy_timeout_blocked_by_default_when_engine_denies_recovery(self):
identifier, worker = self.legacy_timeout()
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
before = len(fixtures.FakeClient.calls)
with patch.object(worker.engine, "pending_battle_recovery", return_value={
"state": "blocked", "resumable": False, "message": "尚无可验证的安全恢复证据"}):
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
def test_strict_safe_legacy_timeout_starts_then_exits_on_reconcile_without_reentry(self):
identifier, worker = self.legacy_timeout()
self.assert_failure_exit(identifier, worker)
def test_unaccepted_commission_legacy_timeout_exits_without_reentry_or_reward(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
self.assert_failure_exit(identifier, worker)
def assert_failure_exit(self, identifier, worker):
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto, "Start must not dispatch recovery inline")
self.assertEqual(len(fixtures.FakeClient.calls), before)
state = self.manager.status(identifier)
self.assertEqual(state["strategy_state"], "recovering")
self.assertIn("退出", state["strategy_message"])
self.assertNotIn("战果已保存", state["strategy_message"])
worker.schedule.next_poll = math.inf
after = self.manager.logs(identifier)["next"]
poll = worker.engine.poll
def recovery_poll(**kwargs):
self.assertFalse(worker.engine.auto, "Recovery must not enable other strategies")
self.assertIs(kwargs.get("resume_pending"), True)
return poll(**kwargs)
with patch.object(worker.engine, "poll", side_effect=recovery_poll):
self.assertEqual(self.tick(identifier, worker)["result"]["kind"], "reconcile")
writes = [("/".join(url.rsplit("/", 2)[-2:]),
{key: value for key, value in payload.items() if key not in {"token", "reqid", "reqsid"}})
for _, url, payload in fixtures.FakeClient.calls[before:]
if not url.endswith("masterService/masterQueryDetail")]
self.assertEqual(writes, [("battleService/recordBattleResult", {"stageId": "0102", "cityId": "1", "result": 0})])
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
record = worker.engine.battle_journal.records(worker.engine.snapshot)[0]
self.assertEqual(record["outcome"], "abandoned")
self.assertNotIn("battle_data", record)
rows = build_view(worker.engine, "battles", worker.config)["rows"]
row = next(row for row in rows if row["outcome"] == "abandoned")
self.assertIn("已放弃(本地计算失败)", row["outcome_label"])
self.assertNotIn("打不过", row["outcome_label"])
logs = self.manager.logs(identifier, after=after)["entries"]
self.assertTrue(any("退出" in row["message"] for row in logs))
self.assertFalse(any("打不过" in row["message"] for row in logs))
def test_manual_refresh_never_authorizes_safe_source_zero_recovery(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
self.job(identifier, self.manager.submit(identifier, "start"))
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
def test_manual_stop_prevents_safe_legacy_failure_exit(self):
identifier, worker = self.legacy_timeout()
self.manager.submit(identifier, "stop")
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.tick(identifier, worker)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertFalse(worker.running)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
def test_disabled_source_policy_prevents_safe_legacy_failure_exit(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = False
config["config"]["daily_policy"].update(enabled=True, selected=["gift"])
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
worker.schedule.next_poll = math.inf
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
state = self.manager.status(identifier)
self.assertFalse(state["running"])
self.assertEqual(state["strategy_state"], "blocked")
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
recovery = worker.engine.pending_battle_recovery()
self.assertEqual(recovery["state"], "blocked_policy")
self.assertEqual(state["strategy_message"], recovery["message"])
self.assertIn("委托", state["strategy_message"])
self.assertIn("启用", state["strategy_message"])
self.assertFalse(worker.engine.quest_policy.enabled)
self.assertTrue(worker.engine.daily_policy.enabled)
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = True
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
self.tick(identifier, worker)
writes = [("/".join(url.rsplit("/", 2)[-2:]), payload.get("result"))
for _, url, payload in fixtures.FakeClient.calls[before:]
if not url.endswith("masterService/masterQueryDetail")]
self.assertEqual(writes, [("battleService/recordBattleResult", 0)])
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
def test_unknown_start_settlement_or_failure_reply_never_grants_recovery(self):
for changes in ({"start_response": None}, {"settlement_dispatched": True, "path": "battleService/battleEnd"},
{"record_dispatched": True}):
with self.subTest(changes=changes):
identifier, worker = self.legacy_timeout()
journal = worker.engine.battle_journal
journal.update(journal.pending(worker.engine.snapshot), "unknown", **changes)
evidence = deepcopy(journal.pending(worker.engine.snapshot))
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
self.assertEqual(journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
if __name__ == "__main__":
unittest.main()
+345
View File
@@ -0,0 +1,345 @@
"""Web recovery through real Engine barriers, temporary stores and offline HTTP."""
from copy import deepcopy
import json
import math
import threading
import time
import unittest
from unittest.mock import patch
import requests
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Snapshot
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime
from ranch_web.service import WebManager
from ranch_web.tests import test_service as fixtures
class LifecycleRecoveryTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
def connected(self):
identifier = self.account(False)
self.login(identifier)
worker = self.manager._worker(identifier)
self.now = 1000.0
worker.schedule.clock = lambda: self.now
worker.schedule.uniform = lambda low, high: high
worker.engine.last_heartbeat = self.now
self.enterContext(patch.object(worker.engine, "master_sync_due", return_value=False))
self.enterContext(patch.object(worker.engine, "growth_sync_due", return_value=False))
return identifier, worker
def battle(self, identifier, worker, *, timed_out=False):
"""Small task fixture already used by Engine's orchestration regressions."""
engine = worker.engine
raw = engine.client.raw
raw["master"].update(ti=1000, money=1000, timeTi=0)
raw["currentTasks"] = [{"id": 51, "typeId": "100", "curStep": 1, "stepValue": 0}]
raw["history"] = {"unlockCity": {"1": True}, "unlockStage": {"0101": [1, 2, 3]}}
raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [raw["monsters"][0]["id"]]}]
raw["taskStepValue"] = 0
engine.snapshot = Snapshot(deepcopy(raw))
engine.game_data = ProgressionData({
"task_info": {"100": {"type": 1, "name": "离线任务", "steps": [
{"statusType": "passStage", "statusValue": {"stage": "0101", "level": 1}}]}},
"game_setting": {"cityInfo": {"1": {"name": "离线城市"}}},
"stage_info": {"0101": {"city": 1, "cost": {"ti": 6}, "level": {
str(n): {"cost": 0, "battle": {"fixture": True}} for n in (1, 2, 3)}}}})
runtime = ExperimentalRuntime()
original = runtime._run
if timed_out:
runtime.run.return_value = {"outcome": "timeout", "execution_mode": "experimental",
"execution_status": "timed_out", "terminal_reason": "worker_wall_clock_limit"}
runtime.run.side_effect = None
else:
runtime.run.side_effect = lambda request, cancel_event: original(request, cancel_event=cancel_event) | {
"requires_realtime_wait": True, "model_elapsed_ms": 10000}
engine._battle_runtimes["experimental"] = runtime
engine.battles.request_builder = None
config = self.manager.get_config(identifier)
config["config"]["progression_policy"].update(enabled=True, battle_mode="experimental", reserve_ti=0)
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
worker.schedule.next_poll = 0
return runtime
def tick(self, identifier, worker):
return self.job(identifier, worker.enqueue("__tick"))
def paths(self, start=0):
return ["/".join(url.rsplit("/", 2)[-2:]) for _, url, _ in fixtures.FakeClient.calls[start:]]
def interrupted_clock(self):
identifier, worker = self.connected()
runtime = self.battle(identifier, worker)
entered = threading.Event()
original = worker.engine.battles.wait_for_battle_clock
def computed_wait(record, request, result, data, started, cancel):
wait = cancel.wait
def clock_wait(timeout):
entered.set()
return wait(timeout)
with patch.object(cancel, "wait", side_effect=clock_wait):
return original(record, request, result, data, started, cancel)
with patch.object(worker.engine.battles, "wait_for_battle_clock", side_effect=computed_wait):
tick = worker.enqueue("__tick")
self.assertTrue(entered.wait(3), "Offline battle never entered the computed clock wait")
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
changed = self.manager.set_config(identifier, config["config"], config["revision"])
self.job(identifier, tick)
self.job(identifier, changed["job"])
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertTrue(worker.engine.battles.resumable_task_clock(record), record)
self.assertTrue(worker.engine._progression_cancel.is_set())
return identifier, worker, runtime, record
def ready(self, worker):
journal = worker.engine.battle_journal
record = journal.pending(worker.engine.snapshot)
journal.update(record, record["phase"], battle_ready_at=1)
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
def test_config_cancelled_computed_clock_resumes_on_reconcile_without_new_start(self):
identifier, worker, runtime, record = self.interrupted_clock()
saved = deepcopy(record["battle_data"])
self.ready(worker)
before = len(fixtures.FakeClient.calls)
self.assertEqual(self.tick(identifier, worker)["result"]["kind"], "reconcile")
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
writes = [path for path in self.paths(before) if path != "masterService/masterQueryDetail"]
self.assertEqual(writes, ["taskService/taskCompleteStep"])
payload = next(payload for _, url, payload in fixtures.FakeClient.calls[before:]
if url.endswith("taskService/taskCompleteStep"))
self.assertEqual(payload["battleData"], saved)
self.assertEqual(runtime.run.call_count, 1)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertTrue(worker.running)
def test_start_accepts_saved_computed_result_but_does_not_settle_inline(self):
identifier, worker, _, _ = self.interrupted_clock()
self.manager.submit(identifier, "stop")
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto)
self.assertEqual(len(fixtures.FakeClient.calls), before)
self.assertEqual(self.manager.status(identifier)["strategy_state"], "recovering")
def test_computed_result_waits_for_deadline_and_manual_refresh_stays_read_only(self):
identifier, worker, runtime, _ = self.interrupted_clock()
journal = worker.engine.battle_journal
record = journal.pending(worker.engine.snapshot)
journal.update(record, record["phase"], battle_ready_at=time.time() + 3600)
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
before = len(fixtures.FakeClient.calls)
self.tick(identifier, worker)
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertIsNotNone(journal.pending(worker.engine.snapshot))
self.assertEqual(runtime.run.call_count, 1)
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto)
self.assertEqual(self.manager.status(identifier)["strategy_state"], "recovering")
def test_lost_resumed_settlement_reply_becomes_query_only_without_replay(self):
identifier, worker, runtime, _ = self.interrupted_clock()
self.ready(worker)
post = worker.engine.client.http.post
attempted = []
def lost_reply(url, *args, **kwargs):
if url.endswith("taskService/taskCompleteStep"):
attempted.append(url)
raise requests.ReadTimeout("offline lost settlement reply")
return post(url, *args, **kwargs)
with patch.object(worker.engine.client.http, "post", side_effect=lost_reply):
self.job(identifier, worker.enqueue("__tick"), status="failed")
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertTrue(record["settlement_dispatched"])
self.assertFalse(worker.engine.battles.resumable_task_clock(record))
for _ in range(3):
self.now += 121
worker.engine.last_heartbeat = self.now
worker.engine.last_pending_check = time.monotonic() - 121
self.tick(identifier, worker)
self.assertEqual(len(attempted), 1)
self.assertEqual(runtime.run.call_count, 1)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
def test_manual_stop_keeps_computed_result_unsent_through_config_and_restart(self):
identifier, worker, _, _ = self.interrupted_clock()
self.manager.submit(identifier, "stop")
self.ready(worker)
journal_path = worker.engine.battle_journal.path
evidence = journal_path.read_bytes()
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
before = len(fixtures.FakeClient.calls)
self.tick(identifier, worker)
self.assertEqual(journal_path.read_bytes(), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.manager.close()
self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertEqual(journal_path.read_bytes(), evidence)
def test_stop_racing_authorized_reconcile_cancels_settlement_before_dispatch(self):
identifier, worker, _, _ = self.interrupted_clock()
self.ready(worker)
entered, release = threading.Event(), threading.Event()
poll = worker.engine.poll
journal_path = worker.engine.battle_journal.path
evidence = journal_path.read_bytes()
def held_poll(**kwargs):
self.assertFalse(worker.engine.auto)
self.assertIs(kwargs.get("resume_pending"), True)
entered.set()
self.assertTrue(release.wait(3))
return poll(**kwargs)
before = len(fixtures.FakeClient.calls)
with patch.object(worker.engine, "poll", side_effect=held_poll):
tick = worker.enqueue("__tick")
try:
self.assertTrue(entered.wait(3), self.manager.job(identifier, tick["id"]))
self.manager.submit(identifier, "stop")
finally:
release.set()
self.job(identifier, tick, status="cancelled")
self.assertEqual(len(fixtures.FakeClient.calls), before)
self.assertEqual(journal_path.read_bytes(), evidence)
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
def test_runtime_recovery_timeout_stays_blocked_after_single_local_retry(self):
identifier, worker = self.connected()
runtime = self.battle(identifier, worker, timed_out=True)
self.tick(identifier, worker)
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertEqual(record["execution_status"], "timed_out")
self.assertFalse(worker.engine.battles.resumable_task_clock(record))
self.assertNotIn("battle_data", record)
self.assertTrue(worker.engine.pending_battle_recovery()["resumable"])
self.job(identifier, self.manager.submit(identifier, "start"))
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
self.tick(identifier, worker)
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertEqual(record["runtime_recovery_attempts"], 1)
self.assertFalse(worker.engine.pending_battle_recovery()["resumable"])
evidence = worker.engine.battle_journal.path.read_bytes()
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
for _ in range(3):
self.now += 121
worker.engine.last_heartbeat = self.now
worker.engine.last_pending_check = time.monotonic() - 121
self.tick(identifier, worker)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertEqual(worker.engine.battle_journal.path.read_bytes(), evidence)
self.assertEqual(runtime.run.call_count, 2)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
state = self.manager.status(identifier)
self.assertFalse(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertIn("本地战斗计算超时", state["strategy_message"])
self.assertIn("尚未提交结算", state["strategy_message"])
def test_stage_farming_timeout_reports_its_operation_without_promising_resolution(self):
identifier, worker = self.connected()
fixtures.ServiceTests.enable(self, identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
journal = worker.engine.battle_journal
record = journal.begin(worker.engine.snapshot, {"kind": "stage_battle", "stage_id": "0102",
"difficulty": 1, "path": "stageService/stageStart", "task_id": 0})
journal.update(record, "unknown", start_response={"resCode": 0, "triggerEvent": False, "stageEvent": None},
execution_status="timed_out", terminal_reason="worker_wall_clock_limit",
message="战斗已取消、超时或结果不确定,等待核对")
self.tick(identifier, worker)
state = self.manager.status(identifier)
self.assertTrue(state["connected"])
self.assertFalse(state["running"])
self.assertIn("0102", state["strategy_message"])
self.assertIn("本地战斗计算超时", state["strategy_message"])
worker.schedule.monitor(False)
reason = worker._pending_execution_reason()
self.assertNotIn("后台继续", reason)
self.assertNotIn("自动恢复", reason)
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
self.assertEqual(worker.config["policy"]["keep_money"], config["config"]["policy"]["keep_money"])
self.assertTrue(worker.strategy_requested)
intent = json.loads((worker.profile_root / "run_intent.json").read_text(encoding="utf-8"))
self.assertTrue(intent["roles"][worker.active_identity])
def test_config_cancellation_before_start_dispatch_replans_without_unknown_barrier(self):
identifier, worker = self.connected()
runtime = self.battle(identifier, worker, timed_out=True)
update = worker.engine.battle_journal.update
changed = []
def cancel_before_send(record, phase, **fields):
update(record, phase, **fields)
if phase == "start_pending":
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
changed.append(self.manager.set_config(identifier, config["config"], config["revision"])["job"])
with patch.object(worker.engine.battle_journal, "update", side_effect=cancel_before_send):
self.tick(identifier, worker)
self.job(identifier, changed[0])
self.assertNotIn("battleService/battleStart", self.paths())
self.assertFalse(worker.engine._progression_pending())
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertIsNone(worker.engine.progression_planner.pending(worker.engine.snapshot))
runtime.run.assert_not_called()
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
def test_internal_pending_pause_does_not_revoke_generation_or_persist_manual_stop(self):
identifier, worker = self.connected()
worker.schedule.next_poll = 0
generation = worker._generation
def paused(**kwargs):
journal = worker.engine.battle_journal
record = journal.begin(worker.engine.snapshot, {"kind": "stage_battle", "stage_id": "0102"})
journal.update(record, "unknown", message="请求结果未知")
worker.engine.auto = False
return worker.engine.snapshot, [], "请求结果未知"
with patch.object(worker.engine, "poll", side_effect=paused):
self.tick(identifier, worker)
self.assertEqual(worker._generation, generation)
self.assertTrue(worker.strategy_requested)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,44 @@
"""Public account summaries preserve execution intent without private recovery data."""
import unittest
from ranch_web.tests import test_api as fixtures
class RecoveryStatusApiTests(unittest.TestCase):
setUp = fixtures.ApiTests.setUp
def test_accounts_and_status_preserve_blocked_intent_and_explicit_stop(self):
source = self.manager.accounts[self.account_id]
fields = {"strategy_requested": True, "manual_stop": False, "strategy_state": "blocked",
"strategy_message": "本地战斗计算超时,尚未提交结算", "strategy_retry_at": None}
source.update(fields, running=False, journal={"payload": "PRIVATE_RECOVERY"})
for values in (fields, fields | {"strategy_requested": False, "manual_stop": True,
"strategy_state": "stopped", "strategy_message": "已按用户选择停止策略"}):
source.update(values)
for url in ("/api/accounts", self.url + "/status"):
with self.subTest(url=url, state=values["strategy_state"]):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
body = response.json()
summary = body[0] if isinstance(body, list) else body
for field, expected in values.items():
self.assertEqual(summary.get(field), expected, field)
self.assertFalse(summary["running"])
self.assertNotIn("journal", summary)
self.assertNotIn("PRIVATE_RECOVERY", response.text)
def test_strategy_message_uses_the_connection_error_redactor(self):
source = self.manager.accounts[self.account_id]
for message in ("本地计算失败 token=STATUS_PRIVATE C:/private/battle.json", "Traceback: STATUS_PRIVATE"):
source.update(strategy_message=message, connection_message=message)
response = self.client.get(self.url + "/status")
self.assertEqual(response.status_code, 200)
body = response.json()
self.assertIsInstance(body.get("strategy_message"), str)
self.assertEqual(body["strategy_message"], body["connection_message"])
self.assertNotIn("STATUS_PRIVATE", response.text)
self.assertNotIn("C:/private", response.text)
if __name__ == "__main__":
unittest.main()