fix: recover interrupted Web battles in 2.0.10
This commit is contained in:
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user