248 lines
15 KiB
Python
248 lines
15 KiB
Python
"""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()
|