1226 lines
68 KiB
Python
1226 lines
68 KiB
Python
"""Offline protocol/state-machine tests. Every game request is a mock."""
|
|
from copy import deepcopy
|
|
import json
|
|
from pathlib import Path
|
|
import threading
|
|
from types import SimpleNamespace
|
|
import unittest
|
|
from unittest.mock import Mock, patch
|
|
|
|
from ranch_assistant.battles import BattleJournal, BattleOrchestrator, public_data
|
|
from ranch_assistant.model import Snapshot
|
|
from ranch_assistant.tests.test_core import workspace_temp
|
|
from ranch_assistant.engine import Engine, demo_snapshot
|
|
from ranch_assistant.game_data import ProgressionData
|
|
from ranch_assistant.model import Catalog, Policy
|
|
from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy
|
|
from ranch_assistant.quests import QuestPolicy
|
|
|
|
|
|
def policy(**changes):
|
|
return SimpleNamespace(**({"enabled": True, "mainline": True, "sidequests": False,
|
|
"commissions": False, "accept": True, "auto_dialogue": True, "team": "teamA",
|
|
"reserve_ti": 0, "allow_sweep": True, "max_money": 0, "allow_items": False,
|
|
"allow_monsters": False, "item_reserves": {}, "stop_after_loss": 1} | changes))
|
|
|
|
|
|
def intent(**changes):
|
|
return {"kind": "battle", "description": "offline fixture", "path": "", "payload": {},
|
|
"task_id": None, "task_type_id": None, "step_number": 1, "position": "city1_wild_stage0101_level1",
|
|
"stage_id": "0101", "difficulty": "1", "battle_kind": "ordinary_stage", "block_reason": ""} | changes
|
|
|
|
|
|
def fixture():
|
|
row = {"name": "fixture", "city": 1, "cost": {"ti": 6},
|
|
"level": {str(i): {"cost": 0} for i in (1, 2, 3)}}
|
|
catalog = SimpleNamespace(data={"stage_info": {"0101": deepcopy(row), "0102": deepcopy(row)},
|
|
"game_setting": {"cityInfo": {"1": {}}}, "stage_sp": {}, "stage_task_positions": {}})
|
|
snapshot = Snapshot({"master": {"id": 7, "ti": 100, "money": 1000}, "stacks": [], "rooms": [],
|
|
"items": [], "monsters": [{"id": 101, "typeId": 1, "mode": 2}],
|
|
"teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [101]}],
|
|
"history": {"unlockStage": {"0101": [1, 2, 3], "0102": [1]}}, "currentTasks": []})
|
|
return catalog, snapshot
|
|
|
|
|
|
class Runtime:
|
|
"""Explicit fake of the faithful-adapter seam; never uses an estimator."""
|
|
def __init__(self, win=True, supported=True):
|
|
self.win, self.supported = win, supported
|
|
self.inspect = Mock(side_effect=self._inspect)
|
|
self.run = Mock(side_effect=self._run)
|
|
|
|
def _inspect(self, request):
|
|
return {"supported": self.supported, "settlement_eligible": self.supported, "faithful": True,
|
|
"approximate": False, "reasons": ["fixture unsupported"]}
|
|
|
|
def _run(self, request, *, cancel_event):
|
|
return {"outcome": "win" if self.win else "loss", "settlement_eligible": True, "faithful": True, "approximate": False,
|
|
"battle_data": {"battlePosition": deepcopy(request["battle_position"]), "win": self.win,
|
|
"battleMonIds": [101], "leftTime": 123, "killNum": 2, "totalDamage": 47, "deadNum": 0,
|
|
"aliveNum": 4, "apLeft": 33, "bossDamage": 1, "killMonster": {"100": 1},
|
|
"cheatNum": 2, "cheatRecords": "original-integrity-records"}}
|
|
|
|
|
|
class ExperimentalRuntime(Runtime):
|
|
def _inspect(self, request):
|
|
return super()._inspect(request) | {"faithful": False, "approximate": True,
|
|
"execution_mode": "experimental", "settlement_eligible": False}
|
|
|
|
def _run(self, request, *, cancel_event):
|
|
return super()._run(request, cancel_event=cancel_event) | {"faithful": False, "approximate": True,
|
|
"execution_mode": "experimental", "execution_status": "completed", "terminal": True,
|
|
"supported": True, "settlement_eligible": False, "experimental_settlement_eligible": True,
|
|
"limitations": ["fixture model limitation"], "trace": [{"kind": "model-complete", "win": self.win}]}
|
|
|
|
|
|
class BattleOrchestrationTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.folder = self.enterContext(workspace_temp())
|
|
self.path = self.folder / "journal.json"
|
|
self.catalog, self.snapshot = fixture()
|
|
self.runtime = Runtime()
|
|
self.client = Mock()
|
|
self.client.call.side_effect = lambda path, payload: {"resCode": 0, "triggerEvent": False} if path.endswith("stageStart") else {"resCode": 0, "reward": {}}
|
|
self.journal = BattleJournal(self.path)
|
|
self.runner = BattleOrchestrator(self.catalog, self.journal, self.runtime)
|
|
|
|
def paths(self):
|
|
return [call.args[0] for call in self.client.call.call_args_list]
|
|
|
|
def task(self, kind="battle"):
|
|
self.snapshot.raw["currentTasks"] = [{"id": 5, "typeId": "100", "curStep": 1, "stepValue": 0}]
|
|
return intent(task_id=5, task_type_id="100", battle_kind=kind,
|
|
stage_id="0101" if kind == "passStage" else None)
|
|
|
|
def test_direct_reward_event_is_not_battle_and_never_settles_twice(self):
|
|
self.client.call.return_value = None
|
|
self.client.call.side_effect = lambda *args: {"triggerEvent": True,
|
|
"stageEvent": {"result": {"money": 12}, "costTi": 6}}
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
|
self.runtime.run.assert_not_called()
|
|
self.assertIsNone(self.journal.pending(self.snapshot))
|
|
self.assertEqual(self.journal.records(self.snapshot)[0]["outcome"], "event")
|
|
|
|
def test_ordinary_win_preserves_real_statistics_and_integrity_records(self):
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
|
self.assertEqual(self.client.call.call_args_list[0].args[1], {"stageTypeId": "0101", "stageLevel": "1"})
|
|
battle = self.client.call.call_args_list[1].args[1]["battleData"]
|
|
self.assertEqual((battle["cheatNum"], battle["cheatRecords"], battle["leftTime"]), (2, "original-integrity-records", 123))
|
|
self.assertEqual(self.client.call.call_args_list[2].args[1], {"stageId": "0101", "cityId": "1", "result": 1})
|
|
|
|
def test_unsupported_preflight_and_probe_only_support_never_start(self):
|
|
for report in ({"supported": False, "settlement_eligible": False},
|
|
{"supported": True, "settlement_eligible": False}, {"supported": True}):
|
|
self.runtime.inspect.side_effect = None
|
|
self.runtime.inspect.return_value = report
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.client.call.assert_not_called()
|
|
self.runtime.run.assert_not_called()
|
|
self.assertIsNone(self.journal.pending(self.snapshot))
|
|
|
|
def test_cancel_after_start_pending_persistence_does_not_dispatch(self):
|
|
cancel = threading.Event()
|
|
update = self.journal.update
|
|
def persisted(record, phase, **fields):
|
|
update(record, phase, **fields)
|
|
if phase == "start_pending":
|
|
cancel.set()
|
|
self.journal.update = persisted
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(), cancel=cancel)
|
|
self.client.call.assert_not_called()
|
|
self.runtime.run.assert_not_called()
|
|
self.assertIsNone(self.journal.pending(self.snapshot))
|
|
restored = BattleJournal(self.path)
|
|
self.assertIsNone(restored.pending(self.snapshot))
|
|
self.assertEqual(restored.records(self.snapshot)[0]["outcome"], "cancelled")
|
|
|
|
def test_known_experimental_preflight_anomalies_block_before_any_request(self):
|
|
self.runtime = self.runner.runtime = ExperimentalRuntime()
|
|
anomaly = {"code": "+15overfeel", "source_cheat_points": 50, "feel": 201}
|
|
self.runtime.inspect.side_effect = lambda request: self.runtime._inspect(request) | {"anomalies": [anomaly]}
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(battle_mode="experimental"))
|
|
self.client.call.assert_not_called()
|
|
self.runtime.run.assert_not_called()
|
|
self.assertIsNone(self.journal.pending(self.snapshot))
|
|
record = self.journal.records(self.snapshot)[0]
|
|
self.assertEqual(record["outcome"], "unsupported")
|
|
self.assertEqual(record["anomalies"], [anomaly])
|
|
|
|
def test_concrete_model_feel_anomaly_blocks_entry_without_rewriting_snapshot(self):
|
|
from ranch_assistant.battle_simulator import ExperimentalBattleRuntime
|
|
from ranch_assistant.tests.test_battle_simulator import monster, request
|
|
model_request = request(players=[monster(mid=100001, feel=201)])
|
|
baseline = deepcopy(model_request)
|
|
self.runner.request_builder = lambda snapshot, action, policy, prepared: prepared | deepcopy(model_request)
|
|
runtime = self.runner.runtime = ExperimentalBattleRuntime()
|
|
runtime.run = Mock(side_effect=AssertionError("preflight must reject before simulation"))
|
|
message = self.runner.run(self.client, self.snapshot, intent(), policy(battle_mode="experimental"))
|
|
self.client.call.assert_not_called()
|
|
runtime.run.assert_not_called()
|
|
self.assertIn("+15overfeel", message)
|
|
self.assertEqual(model_request, baseline)
|
|
self.assertIn("+15overfeel", {row["code"] for row in self.journal.records(self.snapshot)[0]["anomalies"]})
|
|
|
|
def test_task_battle_and_pass_stage_use_task_only_settlement(self):
|
|
for kind in ("battle", "passStage"):
|
|
with self.subTest(kind=kind):
|
|
self.client.call.reset_mock()
|
|
action = self.task(kind)
|
|
action["task_id"] = 5 if kind == "battle" else 6
|
|
self.snapshot.raw["currentTasks"][0]["id"] = action["task_id"]
|
|
self.runner.run(self.client, self.snapshot, action, policy())
|
|
self.assertEqual(self.paths(), ["battleService/battleStart", "taskService/taskCompleteStep"])
|
|
self.assertEqual(self.client.call.call_args_list[0].args[1], {"battleType": "task", "taskTypeId": "100"})
|
|
payload = self.client.call.call_args_list[1].args[1]
|
|
self.assertEqual(set(payload), {"taskId", "taskTypeId", "removeIds", "battleData"})
|
|
self.assertIsNone(payload["removeIds"])
|
|
self.assertEqual(payload["battleData"]["battlePosition"], {"battleType": "task", "stageId": None,
|
|
"stageLevel": None, "taskTypeId": "100", "taskStep": 0})
|
|
|
|
def test_null_stage_reward_falls_back_to_task_reward_in_durable_record(self):
|
|
response = {"stageReward": None, "reward": {"money": 17}}
|
|
self.client.call.side_effect = lambda path, payload: deepcopy(response) if path.endswith("taskCompleteStep") else {}
|
|
self.runner.run(self.client, self.snapshot, self.task(), policy())
|
|
record = BattleJournal(self.path).records(self.snapshot)[0]
|
|
self.assertEqual(record["reward"], {"money": 17})
|
|
self.assertEqual(record["response"], response)
|
|
|
|
def test_empty_stage_reward_remains_authoritative_over_task_reward(self):
|
|
response = {"stageReward": {}, "reward": {"money": 17}}
|
|
self.client.call.side_effect = lambda path, payload: deepcopy(response) if path.endswith("taskCompleteStep") else {}
|
|
self.runner.run(self.client, self.snapshot, self.task(), policy())
|
|
record = BattleJournal(self.path).records(self.snapshot)[0]
|
|
self.assertEqual(record["reward"], {})
|
|
self.assertEqual(record["response"], response)
|
|
|
|
def test_task_loss_does_not_complete_step_or_call_battle_end(self):
|
|
self.runtime.win = False
|
|
self.runner.run(self.client, self.snapshot, self.task(), policy())
|
|
self.assertEqual(self.paths(), ["battleService/battleStart"])
|
|
self.assertEqual(self.journal.role(self.snapshot)["losses"], 1)
|
|
|
|
def test_ordinary_and_pass_stage_losses_record_loss_only(self):
|
|
self.runtime.win = False
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"])
|
|
self.assertEqual(self.client.call.call_args.args[1]["result"], 0)
|
|
|
|
def test_loss_threshold_prevents_later_starts(self):
|
|
self.runtime.win = False
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.client.call.reset_mock()
|
|
message = self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertIn("战败停止", message)
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_no_event_requires_runtime_and_unfaithful_result_stays_pending(self):
|
|
self.runtime.run.side_effect = None
|
|
self.runtime.run.return_value = {"outcome": "win", "settlement_eligible": False, "battle_data": {"win": True}}
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.runtime.run.assert_called_once()
|
|
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
|
self.assertIsNotNone(self.journal.pending(self.snapshot))
|
|
|
|
def test_start_timeout_is_durable_and_restart_does_not_replay(self):
|
|
self.client.call.side_effect = TimeoutError("fixture")
|
|
with self.assertRaises(TimeoutError):
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
restored = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime)
|
|
self.client.call.reset_mock()
|
|
self.assertIn("待核对", restored.run(self.client, self.snapshot, intent(), policy()))
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_settlement_timeout_requires_new_trusted_progress(self):
|
|
def call(path, payload):
|
|
if path.endswith("battleEnd"):
|
|
raise TimeoutError()
|
|
return {"triggerEvent": False}
|
|
self.client.call.side_effect = call
|
|
with self.assertRaises(TimeoutError):
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertFalse(self.journal.reconcile(self.snapshot, trusted=True))
|
|
self.snapshot.raw["history"]["passStage"] = {"0101": [1]}
|
|
self.assertFalse(self.journal.reconcile(self.snapshot))
|
|
self.assertTrue(self.journal.reconcile(self.snapshot, trusted=True))
|
|
|
|
def test_old_cleared_record_cannot_resolve_a_new_uncertain_battle(self):
|
|
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
|
|
self.client.call.side_effect = TimeoutError()
|
|
with self.assertRaises(TimeoutError):
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertFalse(self.journal.reconcile(self.snapshot, trusted=True))
|
|
|
|
def test_task_unknown_and_stale_snapshot_no_duplicate_but_step_change_reconciles(self):
|
|
action = self.task()
|
|
self.client.call.side_effect = TimeoutError()
|
|
with self.assertRaises(TimeoutError):
|
|
self.runner.run(self.client, self.snapshot, action, policy())
|
|
self.assertFalse(self.journal.reconcile(self.snapshot, trusted=True))
|
|
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
|
|
self.assertTrue(self.journal.reconcile(self.snapshot, trusted=True))
|
|
|
|
def test_acknowledged_task_step_checkpoint_blocks_stale_snapshot_replay(self):
|
|
action = self.task()
|
|
self.runner.run(self.client, self.snapshot, action, policy())
|
|
restored = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime)
|
|
restored.journal.reconcile(self.snapshot, trusted=True)
|
|
self.client.call.reset_mock()
|
|
message = restored.run(self.client, self.snapshot, action, policy())
|
|
self.assertIn("确认记录", message)
|
|
self.client.call.assert_not_called()
|
|
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
|
|
restored.journal.reconcile(self.snapshot, trusted=True)
|
|
self.assertFalse(next(iter(restored.journal.cursors(self.snapshot).values()))["steps"])
|
|
|
|
def test_cancel_before_start_has_no_network_or_pending(self):
|
|
cancel = threading.Event()
|
|
cancel.set()
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(), cancel=cancel)
|
|
self.client.call.assert_not_called()
|
|
self.assertIsNone(self.journal.pending(self.snapshot))
|
|
|
|
def test_cancel_after_start_cooperates_with_runtime_and_keeps_pending(self):
|
|
cancel = threading.Event()
|
|
def run(request, *, cancel_event):
|
|
self.assertIs(cancel_event, cancel)
|
|
cancel_event.set()
|
|
return {"outcome": "cancelled"}
|
|
self.runtime.run.side_effect = run
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(), cancel=cancel)
|
|
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
|
self.assertIsNotNone(BattleJournal(self.path).pending(self.snapshot))
|
|
|
|
def test_runtime_timeout_unknown_and_wrong_context_do_not_settle(self):
|
|
for result in ({"outcome": "timeout"}, {"outcome": "unknown"},
|
|
{"outcome": "win", "settlement_eligible": True, "battle_data": {"win": True, "battlePosition": {}}}):
|
|
journal = BattleJournal()
|
|
runner = BattleOrchestrator(self.catalog, journal, self.runtime)
|
|
self.runtime.run.side_effect = None
|
|
self.runtime.run.return_value = result
|
|
self.client.call.reset_mock()
|
|
runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
|
self.assertIsNotNone(journal.pending(self.snapshot))
|
|
|
|
def test_unknown_event_never_guesses_a_normal_battle(self):
|
|
self.client.call.side_effect = lambda *args: {"stageEvent": None}
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.runtime.run.assert_not_called()
|
|
self.assertIsNotNone(self.journal.pending(self.snapshot))
|
|
|
|
def test_hidden_event_rechecks_capability_without_a_second_start(self):
|
|
self.client.call.side_effect = lambda *args: {"triggerEvent": True, "stageEvent": {"hideStageId": "0102"}}
|
|
self.runtime.inspect.side_effect = [{"supported": True, "settlement_eligible": True},
|
|
{"supported": False, "settlement_eligible": False, "reasons": ["hidden unsupported"]}]
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
|
self.assertEqual(self.runtime.inspect.call_count, 2)
|
|
self.runtime.run.assert_not_called()
|
|
self.assertIn("隐藏", self.journal.pending(self.snapshot)["message"])
|
|
|
|
def test_map_position_task_has_precedence(self):
|
|
self.task()
|
|
self.catalog.data["stage_task_positions"]["100"] = ["city1_wild_stage0101_level1"]
|
|
message = self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertIn("任务优先", message)
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_resource_reserves_prevent_start(self):
|
|
cases = [(policy(reserve_ti=95), {}), (policy(), {"money": 10}),
|
|
(policy(max_money=10), {"money": 100}), (policy(), {"ke": 1}),
|
|
(policy(), {"items": [{"typeId": 50, "num": 1}]}),
|
|
(policy(allow_items=True, item_reserves={"50": 3}), {"items": [{"typeId": 50, "num": 2}]})]
|
|
self.snapshot.raw["items"] = [{"id": 50, "typeId": 50, "num": 4}]
|
|
for chosen, changes in cases:
|
|
self.catalog.data["stage_info"]["0101"]["cost"] = {"ti": 6} | changes
|
|
self.runner.run(self.client, self.snapshot, intent(), chosen)
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_strategy_disabled_never_starts(self):
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(enabled=False))
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_sweep_reuses_existing_runner_only_after_three_difficulty_permission(self):
|
|
sweeper = Mock(state={"pending": None}, last_outcome="sweep")
|
|
sweeper.used.return_value = 0
|
|
self.runner.sweeper = sweeper
|
|
action = intent(kind="sweep")
|
|
self.runner.run(self.client, self.snapshot, action, policy())
|
|
sweeper.run.assert_not_called()
|
|
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
|
|
self.runner.run(self.client, self.snapshot, action, policy())
|
|
sweeper.run.assert_called_once()
|
|
self.runtime.run.assert_not_called()
|
|
self.runtime.inspect.assert_not_called()
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_journal_isolation_between_roles_and_storage_folders(self):
|
|
self.journal.begin(self.snapshot, intent())
|
|
other = Snapshot(deepcopy(self.snapshot.raw))
|
|
other.raw["master"]["id"] = 8
|
|
self.assertIsNone(self.journal.pending(other))
|
|
self.assertFalse(self.journal.records(other))
|
|
isolated = BattleJournal(self.folder / "other" / "journal.json")
|
|
self.assertIsNone(isolated.pending(self.snapshot))
|
|
self.assertIsNotNone(BattleJournal(self.path).pending(self.snapshot))
|
|
|
|
def test_single_flight_concurrent_call_does_not_queue_a_second_start(self):
|
|
entered, release = threading.Event(), threading.Event()
|
|
original = self.runtime._run
|
|
def run(request, *, cancel_event):
|
|
entered.set()
|
|
self.assertTrue(release.wait(2))
|
|
return original(request, cancel_event=cancel_event)
|
|
self.runtime.run.side_effect = run
|
|
result = []
|
|
worker = threading.Thread(target=lambda: result.append(self.runner.run(self.client, self.snapshot, intent(), policy())))
|
|
worker.start()
|
|
try:
|
|
self.assertTrue(entered.wait(2))
|
|
other = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime)
|
|
self.assertIn("正在执行", other.run(self.client, self.snapshot, intent(), policy()))
|
|
finally:
|
|
release.set()
|
|
worker.join(3)
|
|
self.assertFalse(worker.is_alive())
|
|
self.assertEqual(self.paths().count("stageService/stageStart"), 1)
|
|
|
|
def test_history_is_bounded_pending_preserved_and_baseline_contains_no_secrets(self):
|
|
action = self.task()
|
|
self.snapshot.raw["currentTasks"][0].update(token="private", sessionKey="private", extra="large")
|
|
self.journal.path = None
|
|
for _ in range(505):
|
|
record = self.journal.begin(self.snapshot, action)
|
|
self.journal.finish(self.snapshot, record, "unsupported")
|
|
self.journal.path = self.path
|
|
pending = self.journal.begin(self.snapshot, action)
|
|
self.journal.update(pending, "unknown", response=public_data({"key": "private", "session_key": "private", "token": "private"}))
|
|
restored = BattleJournal(self.path)
|
|
self.assertEqual(len(restored.records(self.snapshot)), 501)
|
|
self.assertEqual(restored.pending(self.snapshot)["attempt_id"], pending["attempt_id"])
|
|
raw = self.path.read_text(encoding="utf-8")
|
|
self.assertNotIn("private", raw)
|
|
self.assertNotIn("large", raw)
|
|
self.assertEqual(set(pending["baseline"]["tasks"][0]), {"id", "typeId", "curStep", "stepValue"})
|
|
|
|
def test_computed_battle_clock_waits_only_for_remaining_monotonic_time(self):
|
|
clock = [100.0]
|
|
self.runner.clock = lambda: clock[0]
|
|
waits = []
|
|
def wait(timeout):
|
|
self.assertEqual(self.journal.pending(self.snapshot)["phase"], "waiting_for_battle_clock")
|
|
waits.append(timeout)
|
|
clock[0] += timeout
|
|
return False
|
|
cancel = SimpleNamespace(is_set=lambda: False, wait=wait)
|
|
def run(request, *, cancel_event):
|
|
clock[0] += .5 # accelerated computation also consumes real time
|
|
return self.runtime._run(request, cancel_event=cancel_event) | {
|
|
"requires_realtime_wait": True, "model_elapsed_ms": 2000}
|
|
self.runtime.run.side_effect = run
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(), cancel=cancel)
|
|
self.assertAlmostEqual(sum(waits), 1.5)
|
|
self.assertEqual(clock[0], 102)
|
|
self.assertEqual(self.journal.records(self.snapshot)[0]["battle_clock_seconds"], 2)
|
|
self.assertIn("battleService/battleEnd", self.paths())
|
|
|
|
def test_cancel_during_battle_clock_wait_preserves_started_pending_without_settlement(self):
|
|
clock = [0.0]
|
|
self.runner.clock = lambda: clock[0]
|
|
cancel = threading.Event()
|
|
cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True)
|
|
original = self.runtime._run
|
|
self.runtime.run.side_effect = lambda request, cancel_event: original(request, cancel_event=cancel_event) | {
|
|
"requires_realtime_wait": True, "model_elapsed_ms": 10000}
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(), cancel=cancel)
|
|
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
|
pending = BattleJournal(self.path).pending(self.snapshot)
|
|
self.assertIsNotNone(pending)
|
|
self.assertIn("战斗时钟", pending["message"])
|
|
self.assertEqual(pending["battle_clock_seconds"], 10)
|
|
|
|
def test_completed_simulation_past_deadline_requires_no_additional_wait(self):
|
|
clock = [0.0]
|
|
self.runner.clock = lambda: clock[0]
|
|
cancel = SimpleNamespace(is_set=lambda: False, wait=Mock(side_effect=AssertionError("unexpected wait")))
|
|
def run(request, *, cancel_event):
|
|
clock[0] = 3
|
|
return self.runtime._run(request, cancel_event=cancel_event) | {
|
|
"requires_realtime_wait": True, "model_elapsed_ms": 2000}
|
|
self.runtime.run.side_effect = run
|
|
self.runner.run(self.client, self.snapshot, intent(), policy(), cancel=cancel)
|
|
cancel.wait.assert_not_called()
|
|
|
|
def test_clock_flag_without_computed_time_never_settles(self):
|
|
original = self.runtime._run
|
|
self.runtime.run.side_effect = lambda request, cancel_event: original(request, cancel_event=cancel_event) | {
|
|
"requires_realtime_wait": True}
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.assertEqual(self.paths(), ["stageService/stageStart"])
|
|
self.assertIsNotNone(self.journal.pending(self.snapshot))
|
|
|
|
def test_record_request_timeout_cannot_be_resolved_by_an_old_or_new_clear(self):
|
|
def call(path, payload):
|
|
if path.endswith("recordBattleResult"):
|
|
raise TimeoutError()
|
|
return {"triggerEvent": False, "reward": {}}
|
|
self.client.call.side_effect = call
|
|
with self.assertRaises(TimeoutError):
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.snapshot.raw["history"]["passStage"] = {"0101": [1]}
|
|
self.assertFalse(self.journal.reconcile(self.snapshot, trusted=True))
|
|
self.assertEqual(self.journal.pending(self.snapshot)["phase"], "record_unknown")
|
|
|
|
def test_unwritable_journal_blocks_the_first_game_request(self):
|
|
with patch.object(self.journal, "save", side_effect=OSError("fixture disk failure")):
|
|
with self.assertRaises(OSError):
|
|
self.runner.run(self.client, self.snapshot, intent(), policy())
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_natural_time_limit_loss_waits_then_uses_pass_stage_loss_record_only(self):
|
|
clock = [0.0]
|
|
self.runner.clock = lambda: clock[0]
|
|
cancel = SimpleNamespace(is_set=lambda: False, wait=lambda timeout: clock.__setitem__(0, clock[0] + timeout) or False)
|
|
self.runtime.win = False
|
|
def run(request, *, cancel_event):
|
|
result = self.runtime._run(request, cancel_event=cancel_event)
|
|
result["battle_data"]["leftTime"] = 0
|
|
return result | {"terminal_reason": "battle_time_limit", "requires_realtime_wait": True, "model_elapsed_ms": 2000}
|
|
self.runtime.run.side_effect = run
|
|
def call(path, payload):
|
|
if path.endswith("recordBattleResult"):
|
|
self.assertGreaterEqual(clock[0], 2)
|
|
return {}
|
|
self.client.call.side_effect = call
|
|
self.runner.run(self.client, self.snapshot, self.task("passStage"), policy(), cancel=cancel)
|
|
self.assertEqual(self.paths(), ["battleService/battleStart", "battleService/recordBattleResult"])
|
|
self.assertEqual(self.client.call.call_args.args[1]["result"], 0)
|
|
self.assertEqual(self.journal.records(self.snapshot)[0]["terminal_reason"], "battle_time_limit")
|
|
|
|
|
|
class EngineProgressionTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.folder = self.enterContext(workspace_temp())
|
|
self.catalog = Catalog()
|
|
self.raw = deepcopy(demo_snapshot(self.catalog).raw)
|
|
self.raw["master"].update(id=71, ti=100, money=1000, timeTi=0)
|
|
self.raw["currentTasks"] = [{"id": 51, "typeId": "100", "curStep": 1, "stepValue": 0}]
|
|
self.raw["history"] = {"unlockCity": {"1": True}, "unlockStage": {"0101": [1, 2, 3]}}
|
|
self.data = ProgressionData({"task_info": {"100": {"type": 1, "name": "fixture mainline",
|
|
"steps": [{"statusType": "none", "statusValue": {}, "story": "before", "afterStory": "after"}]}},
|
|
"scripts": {"before": {"supported": True}, "after": {"supported": True}},
|
|
"game_setting": {"cityInfo": {"1": {"name": "fixture city"}}}, "stage_info": {"0101": {"city": 1, "cost": {"ti": 6},
|
|
"level": {str(n): {"cost": 0, "battle": {"fixture": True}} for n in (1, 2, 3)}}}})
|
|
self.client = Mock()
|
|
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.raw))
|
|
self.client.call.side_effect = lambda path, payload: {"resCode": 0, "taskStepValue": 0, "reward": {}}
|
|
self.engine = self.make_engine()
|
|
|
|
def make_engine(self, folder="account", runtime=None, experimental_runtime=None):
|
|
engine = Engine(self.catalog, self.client, self.folder / folder / "purchase.json",
|
|
game_data=self.data, battle_runtime=runtime, experimental_runtime=experimental_runtime)
|
|
engine.progression_policy = ProgressionPolicy(enabled=True)
|
|
engine.policy = Policy(enabled=False, gift_enabled=False, fill=False)
|
|
return engine
|
|
|
|
def next_kind(self, engine=None):
|
|
engine = engine or self.engine
|
|
return engine._progression_intents[0].kind if engine._progression_intents else None
|
|
|
|
def test_cold_hidden_poll_with_task_policies_off_does_not_prepare_progression(self):
|
|
self.engine.progression_policy.enabled = False
|
|
self.engine.quest_policy.enabled = False
|
|
self.engine.game_data = None
|
|
with patch("ranch_assistant.game_data.load_progression_data", return_value=self.data) as load, \
|
|
patch.object(ProgressionPlanner, "rows", autospec=True, side_effect=ProgressionPlanner.rows) as rows, \
|
|
patch.object(ProgressionPlanner, "plan", autospec=True, side_effect=ProgressionPlanner.plan) as plan:
|
|
self.engine.poll()
|
|
load.assert_not_called()
|
|
rows.assert_not_called()
|
|
plan.assert_not_called()
|
|
self.assertIsNone(self.engine.progression_planner)
|
|
self.assertEqual(self.engine.progression_rows(), [])
|
|
|
|
def test_hidden_disabled_poll_preserves_existing_progression_cache(self):
|
|
self.engine.refresh_progression()
|
|
cached = self.engine.progression_rows()
|
|
self.engine.progression_policy.enabled = False
|
|
self.engine.quest_policy.enabled = False
|
|
self.raw["currentTasks"][0]["stepValue"] = 99
|
|
with patch.object(self.engine, "_ensure_progression", side_effect=AssertionError("hidden planning")):
|
|
self.engine.poll()
|
|
self.assertEqual(self.engine.progression_rows(), cached)
|
|
|
|
def test_visible_readonly_poll_and_explicit_hidden_refresh_prepare_progression(self):
|
|
for visible, explicit in ((True, False), (False, True)):
|
|
with self.subTest(visible=visible, explicit=explicit):
|
|
engine = self.make_engine(folder=str(visible))
|
|
engine.progression_policy.enabled = False
|
|
engine.quest_policy.enabled = False
|
|
engine.progression_view_active = visible
|
|
engine.game_data = None
|
|
with patch("ranch_assistant.game_data.load_progression_data", return_value=self.data) as load:
|
|
engine.refresh_progression() if explicit else engine.poll()
|
|
load.assert_called_once_with()
|
|
self.assertTrue(engine.progression_rows())
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_enabled_task_policy_prepares_when_account_page_hidden(self):
|
|
for progression, quests in ((True, False), (False, True)):
|
|
with self.subTest(progression=progression, quests=quests):
|
|
engine = self.make_engine(folder=str(progression))
|
|
engine.progression_policy.enabled = progression
|
|
engine.quest_policy.enabled = quests
|
|
engine.game_data = None
|
|
with patch("ranch_assistant.game_data.load_progression_data", return_value=self.data) as load:
|
|
engine.poll()
|
|
load.assert_called_once_with()
|
|
self.assertTrue(engine.progression_rows())
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_run_entry_does_not_clear_a_stop_after_operation_entry(self):
|
|
self.battle_task()
|
|
self.engine.battles.runtime = Runtime()
|
|
self.engine.auto = True
|
|
lock = self.engine.battle_journal.lock
|
|
class StopAtEntry:
|
|
fired = False
|
|
def acquire(_, *args, **kwargs):
|
|
if not _.fired:
|
|
_.fired = True
|
|
self.engine.cancel_progression()
|
|
return lock.acquire(*args, **kwargs)
|
|
def release(_):
|
|
lock.release()
|
|
def __enter__(_):
|
|
return lock.__enter__()
|
|
def __exit__(_, *args):
|
|
return lock.__exit__(*args)
|
|
with patch.object(self.engine.battle_journal, "lock", StopAtEntry()):
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
self.engine.battles.runtime.run.assert_not_called()
|
|
|
|
def test_restart_of_authorized_poll_arms_a_new_cancellation_generation(self):
|
|
self.engine.cancel_progression()
|
|
cancelled = self.engine._progression_cancel
|
|
self.engine.auto = True
|
|
self.engine.poll()
|
|
self.assertTrue(cancelled.is_set())
|
|
self.assertIsNot(self.engine._progression_cancel, cancelled)
|
|
self.assertFalse(self.engine._progression_cancel.is_set())
|
|
|
|
def test_cancel_after_plain_task_request_pending_rolls_back_unsent_marker(self):
|
|
self.engine.run_progression_once() # before-story, local
|
|
update = self.engine.battle_journal.update
|
|
def persisted(record, phase, **fields):
|
|
update(record, phase, **fields)
|
|
if phase == "request_pending":
|
|
self.engine.cancel_progression()
|
|
self.engine.battle_journal.update = persisted
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
|
self.assertIsNone(self.engine.progression_planner.pending(self.engine.snapshot))
|
|
|
|
def test_cancel_before_task_battle_dispatch_clears_only_unsent_planner_pending(self):
|
|
self.battle_task()
|
|
self.engine.battles.runtime = Runtime()
|
|
update = self.engine.battle_journal.update
|
|
def persisted(record, phase, **fields):
|
|
update(record, phase, **fields)
|
|
if phase == "start_pending":
|
|
self.engine.cancel_progression()
|
|
self.engine.battle_journal.update = persisted
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
|
self.assertIsNone(self.engine.progression_planner.pending(self.engine.snapshot))
|
|
restored = self.make_engine()
|
|
restored.refresh_progression()
|
|
self.assertIsNone(restored.progression_planner.pending(restored.snapshot))
|
|
self.assertEqual(self.next_kind(restored), "progression_battle")
|
|
|
|
def test_restart_replays_only_local_ack_of_durable_task_battle_settlement(self):
|
|
self.battle_task()
|
|
self.data.tasks["100"]["steps"][0]["afterStory"] = "after"
|
|
self.engine.battles.runtime = Runtime()
|
|
observer = self.engine.battles.observer
|
|
def crash(event, action, response):
|
|
if event == "settled":
|
|
raise SystemExit("crash after durable settlement receipt")
|
|
return observer(event, action, response)
|
|
self.engine.battles.observer = crash
|
|
self.engine._recover_confirmed_progression = Mock() # A killed process cannot run its finally recovery.
|
|
with self.assertRaises(SystemExit):
|
|
self.engine.run_progression_once()
|
|
self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot)["phase"], "settlement_acknowledged")
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine(runtime=Runtime())
|
|
restored.refresh_progression()
|
|
self.assertIsNone(restored.battle_journal.pending(restored.snapshot))
|
|
self.assertIsNone(restored.progression_planner.pending(restored.snapshot))
|
|
self.assertEqual(self.next_kind(restored), "progression_dialogue")
|
|
self.assertEqual(restored._progression_intents[0].phase, "after")
|
|
restored.run_progression_once()
|
|
self.assertEqual(self.next_kind(restored), "progression_local_step")
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_restart_after_saved_local_ack_finishes_journal_idempotently(self):
|
|
self.battle_task()
|
|
self.data.tasks["100"]["steps"][0]["afterStory"] = "after"
|
|
self.engine.battles.runtime = Runtime()
|
|
observer = self.engine.battles.observer
|
|
def crash(event, action, response):
|
|
result = observer(event, action, response)
|
|
if event == "settled":
|
|
raise SystemExit("crash after local ack persisted but before journal finish")
|
|
return result
|
|
self.engine.battles.observer = crash
|
|
self.engine._recover_confirmed_progression = Mock()
|
|
with self.assertRaises(SystemExit):
|
|
self.engine.run_progression_once()
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine(runtime=Runtime())
|
|
restored.refresh_progression()
|
|
self.assertIsNone(restored.battle_journal.pending(restored.snapshot))
|
|
state = restored.progression_planner.export_state()
|
|
restored.refresh_progression()
|
|
self.assertEqual(restored.progression_planner.export_state(), state)
|
|
self.assertEqual(self.next_kind(restored), "progression_dialogue")
|
|
self.assertEqual(restored._progression_intents[0].phase, "after")
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_restart_of_acknowledged_plain_step_uses_saved_reply_without_http(self):
|
|
self.engine.run_progression_once() # before-story
|
|
update = self.engine.battle_journal.update
|
|
def crash(record, phase, **fields):
|
|
update(record, phase, **fields)
|
|
if phase == "acknowledged":
|
|
raise SystemExit("crash after durable task response")
|
|
self.engine.battle_journal.update = crash
|
|
self.engine._recover_confirmed_progression = Mock()
|
|
with self.assertRaises(SystemExit):
|
|
self.engine.run_progression_once()
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine()
|
|
restored.refresh_progression()
|
|
self.assertIsNone(restored.battle_journal.pending(restored.snapshot))
|
|
self.assertEqual(self.next_kind(restored), "progression_dialogue")
|
|
self.assertEqual(restored._progression_intents[0].phase, "after")
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_unconfirmed_or_mismatched_settlement_cannot_clear_planner_pending(self):
|
|
self.battle_task()
|
|
self.engine.battles.runtime = Runtime()
|
|
self.engine.refresh_progression()
|
|
action = self.engine._progression_intents[0]
|
|
record = self.engine.battle_journal.begin(self.engine.snapshot, action)
|
|
self.engine._battle_observer("started", action, None)
|
|
self.engine.battle_journal.update(record, "unknown", start_response={"reward": {}, "taskStepValue": 0})
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine()
|
|
restored.refresh_progression()
|
|
self.assertIsNotNone(restored.battle_journal.pending(restored.snapshot))
|
|
self.assertIsNotNone(restored.progression_planner.pending(restored.snapshot))
|
|
record = restored.battle_journal.pending(restored.snapshot)
|
|
restored.battle_journal.update(record, "settlement_acknowledged", path="taskService/taskCompleteStep",
|
|
response={"reward": {}, "taskStepValue": 0}, intent_id="another-issued-intent")
|
|
restored.refresh_progression()
|
|
self.assertIsNotNone(restored.battle_journal.pending(restored.snapshot))
|
|
self.assertIsNotNone(restored.progression_planner.pending(restored.snapshot))
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_capability_overlay_preserves_planner_unsupported_categories(self):
|
|
source = [{"task_type_id": str(i), "category": category, "supported": False, "state": "locked",
|
|
"status": "unsupported category", "block_reason": ""} for i, category in enumerate(("event", "bond", "unknown"))]
|
|
rows, _ = self.engine._overlay_battle_capabilities(deepcopy(source), [])
|
|
self.assertTrue(all(row["supported"] is False for row in rows))
|
|
self.assertEqual([row["status"] for row in rows], [row["status"] for row in source])
|
|
|
|
def test_plain_story_step_afterstory_and_local_finish_use_exact_planner_contract(self):
|
|
self.engine.refresh_progression()
|
|
self.assertEqual(self.next_kind(), "progression_dialogue")
|
|
self.engine.run_progression_once() # before dialogue, client-local
|
|
self.assertEqual(self.next_kind(), "progression_step")
|
|
self.client.call.assert_not_called()
|
|
self.engine.run_progression_once() # the only step API submission
|
|
self.assertEqual(self.next_kind(), "progression_dialogue")
|
|
self.assertEqual(self.engine._progression_intents[0].phase, "after")
|
|
self.engine.run_progression_once()
|
|
self.assertEqual(self.next_kind(), "progression_local_step")
|
|
self.engine.run_progression_once()
|
|
self.assertEqual(self.next_kind(), "progression_complete")
|
|
self.assertEqual(self.engine.snapshot.raw["currentTasks"][0]["curStep"], 1)
|
|
self.engine.run_progression_once()
|
|
paths = [c.args[0] for c in self.client.call.call_args_list]
|
|
self.assertEqual(paths, ["taskService/taskCompleteStep", "taskService/taskComplete"])
|
|
self.assertEqual(self.engine.progression_rows()[0]["state"], "finished")
|
|
|
|
def test_restart_with_stale_snapshot_preserves_acknowledged_step_and_afterstory(self):
|
|
self.engine.run_progression_once()
|
|
self.engine.run_progression_once()
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine()
|
|
restored.refresh_progression()
|
|
self.assertEqual(self.next_kind(restored), "progression_dialogue")
|
|
self.assertEqual(restored._progression_intents[0].phase, "after")
|
|
restored.run_progression_once()
|
|
restored.run_progression_once()
|
|
self.assertEqual(self.next_kind(restored), "progression_complete")
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_unknown_task_write_persists_planner_pending_and_never_replays(self):
|
|
self.engine.run_progression_once()
|
|
self.client.call.side_effect = TimeoutError()
|
|
with self.assertRaises(TimeoutError):
|
|
self.engine.run_progression_once()
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine()
|
|
restored.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
self.assertIsNotNone(restored.battle_journal.pending(restored.snapshot))
|
|
saved = restored.battle_journal.path.read_text(encoding="utf-8")
|
|
self.assertNotIn('"token"', saved)
|
|
self.assertIn('"intent_id"', saved)
|
|
|
|
def test_fresh_trusted_server_step_reconciles_unknown_submission(self):
|
|
self.engine.run_progression_once()
|
|
self.client.call.side_effect = TimeoutError()
|
|
with self.assertRaises(TimeoutError):
|
|
self.engine.run_progression_once()
|
|
self.raw["currentTasks"][0]["curStep"] = 2
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine()
|
|
restored.refresh_progression()
|
|
self.assertIsNone(restored.battle_journal.pending(restored.snapshot))
|
|
self.client.call.assert_not_called()
|
|
|
|
def battle_task(self):
|
|
self.data.tasks["100"]["steps"] = [{"statusType": "passStage", "statusValue": {"stage": "0101", "level": 1}}]
|
|
# A real configured roster selected by team name is passed intact.
|
|
mid = int(self.raw["monsters"][0]["id"])
|
|
self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [mid]}]
|
|
|
|
def test_task_battle_capability_overlay_cannot_claim_config_is_runtime_support(self):
|
|
self.battle_task()
|
|
runtime = Runtime(supported=False)
|
|
self.engine.battles.runtime = runtime
|
|
self.engine.refresh_progression()
|
|
row = self.engine.progression_rows()[0]
|
|
self.assertFalse(row["supported"])
|
|
self.assertIn("fixture unsupported", row["blocked_reason"])
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
runtime.run.assert_not_called()
|
|
|
|
def test_task_battle_runtime_and_planner_settlement_share_one_durable_cursor(self):
|
|
self.battle_task()
|
|
self.engine.battles.runtime = Runtime()
|
|
self.engine.run_progression_once()
|
|
paths = [c.args[0] for c in self.client.call.call_args_list]
|
|
self.assertEqual(paths, ["battleService/battleStart", "taskService/taskCompleteStep"])
|
|
self.assertEqual(self.next_kind(), "progression_local_step")
|
|
self.assertFalse(self.engine.battle_journal.cursors(self.engine.snapshot))
|
|
restored = self.make_engine(runtime=Runtime())
|
|
restored.refresh_progression()
|
|
self.assertEqual(self.next_kind(restored), "progression_local_step")
|
|
|
|
def test_rows_and_records_getters_only_return_cached_copies(self):
|
|
self.engine.refresh_progression()
|
|
self.engine.progression_planner.rows = Mock(side_effect=AssertionError("planning on Qt"))
|
|
self.engine.battle_journal.records = Mock(side_effect=AssertionError("disk I/O on Qt"))
|
|
rows = self.engine.progression_rows()
|
|
rows.clear()
|
|
self.assertTrue(self.engine.progression_rows())
|
|
self.assertIsInstance(self.engine.progression_records(), list)
|
|
|
|
def test_capability_inspection_is_cached_for_unchanged_inputs(self):
|
|
self.battle_task()
|
|
runtime = Runtime(supported=False)
|
|
self.engine.battles.runtime = runtime
|
|
self.engine.refresh_progression()
|
|
self.engine.refresh_progression()
|
|
self.assertEqual(runtime.inspect.call_count, 1)
|
|
self.raw["monsters"][0]["level"] = int(self.raw["monsters"][0].get("level", 1)) + 1
|
|
self.engine.refresh_progression()
|
|
self.assertEqual(runtime.inspect.call_count, 2)
|
|
|
|
def test_cancel_progression_is_nonblocking_and_started_battle_remains_pending(self):
|
|
self.battle_task()
|
|
runtime = Runtime()
|
|
entered = threading.Event()
|
|
def run(request, *, cancel_event):
|
|
entered.set()
|
|
self.assertTrue(cancel_event.wait(3))
|
|
return {"outcome": "cancelled", "settlement_eligible": False}
|
|
runtime.run.side_effect = run
|
|
self.engine.battles.runtime = runtime
|
|
failures = []
|
|
def work():
|
|
try:
|
|
self.engine.run_progression_once()
|
|
except Exception as error:
|
|
failures.append(error)
|
|
worker = threading.Thread(target=work)
|
|
worker.start()
|
|
self.assertTrue(entered.wait(3))
|
|
self.engine.cancel_progression()
|
|
worker.join(4)
|
|
self.assertFalse(worker.is_alive())
|
|
self.assertFalse(failures)
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list], ["battleService/battleStart"])
|
|
self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot))
|
|
|
|
def test_pending_pauses_ranch_gifts_growth_and_manual_mutations(self):
|
|
self.engine.refresh_progression()
|
|
self.engine.battle_journal.begin(self.engine.snapshot, intent())
|
|
self.engine.auto = True
|
|
self.engine.poll(hatch_only=True)
|
|
self.assertEqual(self.engine.plans(), [])
|
|
self.assertEqual(self.engine.pending_hatches, [])
|
|
self.engine.settle_pending_growth(force=True)
|
|
with self.assertRaises(ValueError):
|
|
self.engine.manage_monsters("sell", [int(self.raw["monsters"][0]["id"])])
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_top_switch_and_strategy_enable_both_gate_execution(self):
|
|
self.engine.auto = False
|
|
self.engine.poll()
|
|
self.assertEqual(self.next_kind(), "progression_dialogue")
|
|
self.engine.progression_policy.enabled = False
|
|
self.engine.auto = True
|
|
self.engine.poll()
|
|
self.client.call.assert_not_called()
|
|
self.assertFalse(any(a.kind == "progression" for a in self.engine.plans()))
|
|
|
|
def test_same_role_in_two_account_workspaces_has_independent_local_progress(self):
|
|
other = self.make_engine(folder="other")
|
|
self.engine.run_progression_once()
|
|
other.refresh_progression()
|
|
self.assertEqual(self.next_kind(), "progression_step")
|
|
self.assertEqual(self.next_kind(other), "progression_dialogue")
|
|
self.assertNotEqual(self.engine.progression_planner.export_state(), other.progression_planner.export_state())
|
|
|
|
def test_legacy_task_planner_only_owns_commissions_even_with_wider_catalog(self):
|
|
from ranch_assistant.quests import QuestPolicy, TaskPlanner
|
|
self.catalog.data["task_info"] = {"100": {"type": 1, "name": "main", "steps": [{"statusType": "none"}]},
|
|
"400": {"type": 4, "name": "commission", "steps": [{"statusType": "none"}]}}
|
|
self.raw["currentTasks"].append({"id": 52, "typeId": "400", "curStep": 1})
|
|
planner = TaskPlanner(self.catalog)
|
|
current = planner.current(Snapshot(self.raw))
|
|
self.assertEqual([t["typeId"] for t in current], ["400"])
|
|
self.assertEqual(planner.plan(Snapshot(self.raw), QuestPolicy(enabled=True), Policy())[0].payload["taskTypeId"], "400")
|
|
|
|
def commission(self, kind="battle", *, offer=False, runtime=None):
|
|
self.data.tasks["400"] = {"type": 4, "name": "fixture commission", "steps": [{"statusType": kind,
|
|
"statusValue": {"stage": "0101", "level": 1} if kind == "passStage" else {},
|
|
"battle": {"fixture": True} if kind == "battle" else None}]}
|
|
self.raw["currentTasks"] = [] if offer else [{"id": 52, "typeId": "400", "curStep": 1, "stepValue": 0}]
|
|
self.raw["history"].update(loopTaskNum=1, loopTask={"1": ["400"]})
|
|
self.engine.progression_policy.enabled = False
|
|
self.engine.quest_policy = QuestPolicy(enabled=True, battle_tasks=True)
|
|
mid = int(self.raw["monsters"][0]["id"])
|
|
self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [mid]}]
|
|
self.engine.battles.runtime = runtime or Runtime()
|
|
self.engine.tasks.plan = Mock(side_effect=AssertionError("duplicate commission scheduler"))
|
|
|
|
def test_commission_battle_and_pass_stage_execute_with_only_quest_policy_enabled(self):
|
|
for kind in ("battle", "passStage"):
|
|
with self.subTest(kind=kind):
|
|
self.engine = self.make_engine(folder=kind, runtime=Runtime())
|
|
self.client.call.reset_mock()
|
|
self.commission(kind)
|
|
self.engine.run_progression_once()
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list],
|
|
["battleService/battleStart", "taskService/taskCompleteStep"])
|
|
self.assertEqual(self.client.call.call_args_list[0].args[1], {"battleType": "task", "taskTypeId": "400"})
|
|
self.assertEqual(self.next_kind(), "progression_local_step")
|
|
self.engine.tasks.plan.assert_not_called()
|
|
|
|
def test_commission_battle_flag_and_real_runtime_support_both_gate_start(self):
|
|
self.commission(runtime=Runtime(supported=False))
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
self.engine.quest_policy.battle_tasks = False
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_unsupported_future_commission_battle_never_consumes_an_offer(self):
|
|
runtime = Runtime(supported=False)
|
|
self.commission(offer=True, runtime=runtime)
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
runtime.inspect.assert_called_once()
|
|
self.assertTrue(self.engine._progression_intents[0].block_reason)
|
|
self.engine.tasks.plan.assert_not_called()
|
|
|
|
def test_supported_commission_offer_is_accepted_once_despite_stale_snapshot_and_restart(self):
|
|
self.commission(offer=True)
|
|
self.client.call.side_effect = lambda path, payload: {"task": {"id": 52, "typeId": "400", "curStep": 1, "stepValue": 0}}
|
|
self.engine.run_progression_once()
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list], ["taskService/taskLoopReceive"])
|
|
restored = self.make_engine(runtime=Runtime())
|
|
restored.progression_policy.enabled = False
|
|
restored.quest_policy = QuestPolicy(enabled=True, battle_tasks=True)
|
|
restored.refresh_progression()
|
|
self.assertEqual(self.next_kind(restored), "progression_battle")
|
|
self.client.call.reset_mock()
|
|
restored.refresh_progression()
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_commission_afterstory_and_completion_remain_durable_after_battle(self):
|
|
self.commission()
|
|
self.data.tasks["400"]["steps"][0]["afterStory"] = "after"
|
|
self.engine.run_progression_once()
|
|
self.assertEqual(self.next_kind(), "progression_dialogue")
|
|
self.client.call.reset_mock()
|
|
restored = self.make_engine(runtime=Runtime())
|
|
restored.progression_policy.enabled = False
|
|
restored.quest_policy = QuestPolicy(enabled=True, battle_tasks=True)
|
|
restored.run_progression_once()
|
|
self.assertEqual(self.next_kind(restored), "progression_local_step")
|
|
restored.run_progression_once()
|
|
self.assertEqual(self.next_kind(restored), "progression_complete")
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_commission_loss_never_settles_or_advances_and_stops_further_battles(self):
|
|
self.commission(runtime=Runtime(win=False))
|
|
self.engine.run_progression_once()
|
|
self.engine.run_progression_once()
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list], ["battleService/battleStart"])
|
|
self.assertTrue(self.engine._progression_intents[0].block_reason)
|
|
|
|
def test_legacy_commission_timeout_is_also_protected_by_the_journal(self):
|
|
from ranch_assistant.model import Action
|
|
self.engine.refresh_progression()
|
|
self.client.call.side_effect = TimeoutError()
|
|
action = Action("quest_accept", "fixture", "taskService/taskLoopReceive", {"taskTypeId": "400", "city": 1})
|
|
with self.assertRaises(TimeoutError):
|
|
self.engine._execute_legacy_task(action)
|
|
restored = self.make_engine()
|
|
self.client.call.reset_mock()
|
|
restored.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
self.assertIsNotNone(restored.battle_journal.pending(restored.snapshot))
|
|
|
|
def test_original_mode_does_not_select_experimental_runtime_without_explicit_policy(self):
|
|
self.battle_task()
|
|
experimental = ExperimentalRuntime()
|
|
self.engine = self.make_engine(runtime=Runtime(supported=False), experimental_runtime=experimental)
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
experimental.inspect.assert_not_called()
|
|
experimental.run.assert_not_called()
|
|
|
|
def test_explicit_experimental_mode_settles_computed_result_and_records_honest_metadata(self):
|
|
self.battle_task()
|
|
experimental = ExperimentalRuntime()
|
|
self.engine = self.make_engine(runtime=Runtime(supported=False), experimental_runtime=experimental)
|
|
self.engine.progression_policy.battle_mode = "experimental"
|
|
self.engine.run_progression_once()
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list],
|
|
["battleService/battleStart", "taskService/taskCompleteStep"])
|
|
record = self.engine.progression_records()[0]
|
|
self.assertEqual(record["battle_mode"], "experimental")
|
|
self.assertIs(record["faithful"], False)
|
|
self.assertIs(record["approximate"], True)
|
|
self.assertIs(record["settlement_eligible"], False)
|
|
self.assertIs(record["experimental_settlement_eligible"], True)
|
|
self.assertIn("fixture model limitation", record["limitations"])
|
|
self.assertTrue(record["trace"])
|
|
|
|
def test_experimental_model_result_cannot_be_submitted_in_original_mode(self):
|
|
self.battle_task()
|
|
self.engine.battles.runtime = ExperimentalRuntime()
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_experimental_unknown_objective_still_blocks_before_start(self):
|
|
self.battle_task()
|
|
runtime = ExperimentalRuntime(supported=False)
|
|
self.engine = self.make_engine(experimental_runtime=runtime)
|
|
self.engine.progression_policy.battle_mode = "experimental"
|
|
self.engine.run_progression_once()
|
|
self.client.call.assert_not_called()
|
|
runtime.run.assert_not_called()
|
|
|
|
def test_experimental_commission_uses_selected_model_but_preserves_loss_path(self):
|
|
self.commission(runtime=Runtime(supported=False))
|
|
experimental = ExperimentalRuntime(win=False)
|
|
self.engine._battle_runtimes["experimental"] = experimental
|
|
self.engine.progression_policy.battle_mode = "experimental"
|
|
self.engine.run_progression_once()
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list], ["battleService/battleStart"])
|
|
record = self.engine.progression_records()[0]
|
|
self.assertEqual(record["outcome"], "loss")
|
|
self.assertIs(record["faithful"], False)
|
|
|
|
def farming_intent(self, *, commission=False, sweep=False):
|
|
self.battle_task()
|
|
source = "400" if commission else "100"
|
|
if commission:
|
|
self.data.tasks[source] = {"type": 4, "name": "farm source", "steps": []}
|
|
self.engine.quest_policy = QuestPolicy(enabled=True, battle_tasks=True)
|
|
self.engine.progression_policy.enabled = False
|
|
self.raw["currentTasks"] = [{"id": 51, "typeId": source, "curStep": 1, "stepValue": 2}]
|
|
self.raw["history"]["numKillMonsters"] = {"100": 0}
|
|
self.engine.battles.runtime = Runtime()
|
|
self.engine.refresh_progression()
|
|
self.engine.battles.runtime.inspect.reset_mock()
|
|
self.engine.battles.runtime.run.reset_mock()
|
|
# The farming selector is a separate owner's seam. This mock issues
|
|
# only logical acknowledgements, never any history/items/progress.
|
|
planner = Mock()
|
|
planner.rows.return_value = []
|
|
planner.plan.return_value = []
|
|
planner.commission_plan.return_value = []
|
|
planner.export_state.return_value = {"version": 1, "accounts": {}}
|
|
planner.acknowledge.return_value = True
|
|
planner.state_signature.return_value = "synthetic-farming-state"
|
|
self.engine.progression_planner = planner
|
|
action = SimpleNamespace(**intent(kind="progression_farm_sweep" if sweep else "progression_farm_battle",
|
|
task_id=0, task_type_id="", step_number=0, battle_kind="sweep" if sweep else "ordinary_stage",
|
|
source_task_id=51, source_task_type_id=source, source_step_number=1))
|
|
return action, planner
|
|
|
|
def test_farming_battle_uses_ordinary_endpoints_and_does_not_forge_task_kills(self):
|
|
action, planner = self.farming_intent()
|
|
self.client.call.side_effect = lambda path, payload: {"triggerEvent": False} if path.endswith("stageStart") else {"reward": {}}
|
|
self.engine._run_progression_intent(action)
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list],
|
|
["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
|
self.assertEqual(self.engine.snapshot.raw["history"]["numKillMonsters"]["100"], 0)
|
|
self.assertEqual(self.engine.snapshot.raw["currentTasks"][0]["curStep"], 1)
|
|
planner.acknowledge.assert_not_called()
|
|
self.assertEqual(self.engine.progression_records()[0]["source_task_type_id"], "100")
|
|
|
|
def test_commission_farming_selects_quest_policy_but_keeps_ordinary_route(self):
|
|
action, _ = self.farming_intent(commission=True)
|
|
self.client.call.side_effect = lambda path, payload: {"triggerEvent": False} if path.endswith("stageStart") else {"reward": {}}
|
|
self.engine._run_progression_intent(action)
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list],
|
|
["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
|
|
|
def test_farming_locked_map_premium_cost_and_stamina_reserve_block_before_start(self):
|
|
action, _ = self.farming_intent()
|
|
self.engine.snapshot.raw["history"]["unlockStage"] = {}
|
|
self.engine._run_progression_intent(action)
|
|
self.client.call.assert_not_called()
|
|
self.engine.snapshot.raw["history"]["unlockStage"] = {"0101": [1]}
|
|
self.engine.battles.catalog.data["stage_info"]["0101"]["cost"]["ke"] = 1
|
|
self.engine._run_progression_intent(action)
|
|
self.client.call.assert_not_called()
|
|
self.engine.battles.catalog.data["stage_info"]["0101"]["cost"].pop("ke")
|
|
self.engine.progression_policy.reserve_ti = 95
|
|
self.engine._run_progression_intent(action)
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_farming_sweep_uses_existing_runner_and_needs_no_runtime(self):
|
|
action, _ = self.farming_intent(sweep=True)
|
|
self.engine.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
|
|
runtime = self.engine.battles.runtime
|
|
self.client.call.side_effect = lambda path, payload: {"triggerEvent": False} if path.endswith("stageStart") else {"reward": {}}
|
|
self.engine._run_progression_intent(action)
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list],
|
|
["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
|
runtime.inspect.assert_not_called()
|
|
runtime.run.assert_not_called()
|
|
|
|
def test_real_planner_farms_kills_then_submits_only_after_trusted_snapshot_updates(self):
|
|
self.battle_task()
|
|
self.data.tasks["100"]["steps"] = [{"statusType": "killMonster", "statusValue": {"type": "100", "num": 2}}]
|
|
self.data.farming = {"kills": {"100": [{"stage_id": "0101", "difficulty": 1}]}}
|
|
self.raw["currentTasks"][0]["stepValue"] = 2
|
|
self.raw["history"]["numKillMonsters"] = {"100": 0}
|
|
self.engine.battles.runtime = Runtime()
|
|
def call(path, payload):
|
|
if path.endswith("stageStart"):
|
|
return {"triggerEvent": False}
|
|
if path.endswith("battleEnd"):
|
|
self.raw["history"]["numKillMonsters"]["100"] = 2
|
|
return {"reward": {}, "taskStepValue": 0}
|
|
self.client.call.side_effect = call
|
|
self.engine.run_progression_once()
|
|
self.assertEqual(self.next_kind(), "progression_step")
|
|
self.engine.run_progression_once()
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list], ["stageService/stageStart",
|
|
"battleService/battleEnd", "battleService/recordBattleResult", "taskService/taskCompleteStep"])
|
|
|
|
def test_real_planner_does_not_credit_model_kills_when_server_snapshot_stays_unchanged(self):
|
|
self.battle_task()
|
|
self.data.tasks["100"]["steps"] = [{"statusType": "killMonster", "statusValue": {"type": "100", "num": 2}}]
|
|
self.data.farming = {"kills": {"100": [{"stage_id": "0101", "difficulty": 1}]}}
|
|
self.raw["currentTasks"][0]["stepValue"] = 2
|
|
self.raw["history"]["numKillMonsters"] = {"100": 0}
|
|
self.engine.battles.runtime = Runtime()
|
|
self.client.call.side_effect = lambda path, payload: {"triggerEvent": False} if path.endswith("stageStart") else {"reward": {}}
|
|
self.engine.run_progression_once()
|
|
self.assertEqual(self.next_kind(), "stage_battle")
|
|
self.assertEqual(self.engine.snapshot.raw["history"]["numKillMonsters"]["100"], 0)
|
|
self.assertNotIn("taskService/taskCompleteStep", [c.args[0] for c in self.client.call.call_args_list])
|
|
|
|
def test_real_planner_uses_three_difficulty_sweep_for_unmet_material_then_rechecks_items(self):
|
|
self.battle_task()
|
|
self.data.tasks["100"]["steps"] = [{"statusType": "getItem", "statusValue": {"type": "20047", "num": 4, "remove": False}}]
|
|
self.data.farming = {"items": {"20047": [{"stage_id": "0101", "difficulty": 1}]}}
|
|
self.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
|
|
self.engine.battles.runtime = Runtime(supported=False)
|
|
def call(path, payload):
|
|
if path.endswith("stageStart"):
|
|
return {"triggerEvent": False}
|
|
if path.endswith("battleEnd"):
|
|
next(i for i in self.raw["items"] if i["typeId"] == 20047)["num"] = 4
|
|
return {"reward": {"items": [{"typeId": 20047, "num": 1}]}}
|
|
self.client.call.side_effect = call
|
|
self.engine.run_progression_once()
|
|
self.assertEqual(self.next_kind(), "progression_step")
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list],
|
|
["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
|
|
self.engine.battles.runtime.run.assert_not_called()
|
|
|
|
def test_concrete_original_adapter_receives_only_its_public_request_fields(self):
|
|
from dataclasses import fields
|
|
from ranch_assistant.battle_runtime import BattleRequest, BattleRuntime
|
|
self.battle_task()
|
|
runtime = BattleRuntime()
|
|
runtime.inspect = Mock(wraps=runtime.inspect)
|
|
self.engine = self.make_engine(runtime=runtime)
|
|
with patch("tools.battle_runtime.trusted.verify_files", return_value=[]):
|
|
self.engine.refresh_progression()
|
|
request = runtime.inspect.call_args.args[0]
|
|
self.assertFalse(set(request) - {field.name for field in fields(BattleRequest)})
|
|
self.assertEqual(request["purpose"], "settlement")
|
|
self.assertFalse(self.engine.progression_rows()[0]["supported"])
|
|
self.client.call.assert_not_called()
|
|
|
|
def test_concrete_experimental_worker_connects_to_task_settlement_with_mocked_game_api(self):
|
|
from ranch_assistant.battle_simulator import ExperimentalBattleRuntime as ConcreteRuntime
|
|
from ranch_assistant.tests.test_battle_simulator import request as model_request
|
|
model = model_request()
|
|
self.battle_task()
|
|
self.data.stages["0101"]["level"]["1"]["battle"] = model["original_data"]["battle"]
|
|
self.raw["monsters"] = deepcopy(model["roster"]["monsters"])
|
|
self.raw["teams"] = [deepcopy(model["roster"]["teams"][0]) | {"teamType": "battleTeam"}]
|
|
self.raw["monsterAttributes"] = []
|
|
self.engine = self.make_engine()
|
|
self.engine.progression_policy.battle_mode = "experimental"
|
|
with patch.object(self.engine.battles, "wait_for_battle_clock", return_value=True) as wait:
|
|
self.engine.run_progression_once()
|
|
self.assertIsInstance(self.engine.battles.runtime, ConcreteRuntime)
|
|
self.assertEqual([c.args[0] for c in self.client.call.call_args_list],
|
|
["battleService/battleStart", "taskService/taskCompleteStep"])
|
|
wait.assert_called_once()
|
|
record = self.engine.progression_records()[0]
|
|
self.assertEqual(record["execution_mode"], "experimental")
|
|
self.assertIs(record["faithful"], False)
|
|
self.assertIs(record["settlement_eligible"], False)
|
|
self.assertIs(record["experimental_settlement_eligible"], True)
|
|
self.assertTrue(record["trace"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|