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