Files
myrzx_bot/ranch_assistant/tests/test_battle_capability_presentation.py

140 lines
8.1 KiB
Python

"""Offline presentation regressions: input support never predicts a victory."""
from copy import deepcopy
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Catalog, Policy, Snapshot
from ranch_assistant.progression import ProgressionPolicy
from ranch_web.policies import default_config
from ranch_web.views import build_view
class BattleCapabilityPresentationTests(unittest.TestCase):
def setUp(self):
self.runtime = Mock()
self.runtime.inspect.return_value = {"supported": True, "settlement_eligible": True,
"faithful": True, "approximate": False}
self.runtime.run.side_effect = AssertionError("presentation must not simulate")
self.client = Mock()
self.client.call.side_effect = AssertionError("offline: no game calls")
self.client.snapshot.side_effect = AssertionError("offline: no snapshot requests")
self.step = {"statusType": "passStage", "statusValue": {"stage": "0216", "level": "1"},
"position": "city1_wild_stage0216_level1", "story": "before", "afterStory": "after"}
self.data = ProgressionData({"task_info": {"1002013": {"type": 1, "name": "offline mainline",
"steps": [self.step]}}, "scripts": {"before": {"supported": True}, "after": {"supported": True}},
"game_setting": {"cityInfo": {"1": {"name": "offline city"}}},
"stage_info": {"0216": {"city": 1, "cost": {"ti": 6},
"level": {"1": {"cost": 0, "battle": {"fixture": True}}}}}})
self.engine = Engine(Catalog(), self.client, game_data=self.data, battle_runtime=self.runtime)
self.engine.progression_policy = ProgressionPolicy(enabled=True)
self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False)
self.engine.snapshot = Snapshot({"master": {"id": 1, "level": 20, "ti": 100, "money": 1000},
"currentTasks": [{"id": 11, "typeId": "1002013", "curStep": 1, "stepValue": 0}],
"monsters": [{"id": 101, "typeId": 1001010, "mode": 2, "process": 3, "level": 20}],
"teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [101]}],
"items": [], "stacks": [], "rooms": [],
"history": {"unlockCity": {"1": True}, "unlockStage": {"0216": [1]}}})
self.addCleanup(self.assert_read_only)
def assert_read_only(self):
self.client.call.assert_not_called()
self.client.snapshot.assert_not_called()
self.runtime.run.assert_not_called()
def refresh(self):
self.engine._refresh_progression_cache(force=True)
self.assertEqual(self.engine._progression_error, "")
return next(row for row in self.engine.progression_rows() if row["task_type_id"] == "1002013")
def mainline_view(self):
# Rendering consumes prepared DTOs; it must never inspect or plan.
with patch.object(self.engine, "_battle_capability", side_effect=AssertionError("view inspection")), \
patch.object(self.engine, "_refresh_progression_cache", side_effect=AssertionError("view planning")):
return build_view(self.engine, "mainline", default_config())
def test_navigation_and_before_story_reuse_positive_preflight_without_a_false_block(self):
row = self.refresh()
self.assertEqual(self.engine._progression_intents[0].kind, "progression_navigate")
self.assertTrue(row["supported"])
self.assertEqual((row["block_reason"], row["blocked_reason"], row["reason_kind"]), ("", "", "ready"))
self.assertIn("前往任务位置", row["next_action"])
self.refresh()
self.runtime.inspect.assert_called_once()
self.assertEqual(self.mainline_view()["rows"][0]["support"], "已支持")
_, account = self.engine.progression_planner._account(self.engine.snapshot)
account["position"] = self.step["position"]
row = self.refresh()
action = self.engine._progression_intents[0]
self.assertEqual((action.kind, action.phase), ("progression_dialogue", "before"))
self.assertIs(row["supported"], True)
self.assertEqual(row["blocked_reason"], "")
self.runtime.inspect.assert_called_once()
def test_disabled_mainline_is_neutral_without_execution_intents(self):
self.engine.progression_policy.enabled = False
row = self.refresh()
self.assertEqual(self.engine._progression_intents, [])
self.assertIsNone(row["supported"])
self.assertEqual((row["blocked_reason"], row["reason_kind"]), ("", "unchecked"))
self.assertEqual(row["status"], "自动主线策略未启用")
self.assertIn("前往任务位置", row["next_action"])
view = self.mainline_view()
self.assertEqual(view["rows"][0]["support"], "支持状态未确认")
self.assertNotIn("模型尚未支持", str(view))
self.engine.progression_policy.enabled = True
self.assertIs(self.refresh()["supported"], True)
self.runtime.inspect.assert_called_once()
def test_real_unsupported_inputs_keep_their_reason_even_while_paused(self):
reason = "Unsupported monster controller: fixture"
self.runtime.inspect.return_value.update(supported=False, reasons=[reason])
for enabled in (True, False):
with self.subTest(enabled=enabled):
self.engine.progression_policy.enabled = enabled
row = self.refresh()
self.assertIs(row["supported"], False)
self.assertEqual((row["blocked_reason"], row["reason_kind"]), (reason, "model_unsupported"))
self.runtime.inspect.assert_called_once()
def test_resource_policy_and_unchecked_rows_keep_truthful_reasons_without_inspections(self):
for field, invalid, word in (("teams", [], "队"), ("ti", 0, "体力")):
with self.subTest(field=field):
target = self.engine.snapshot.raw if field == "teams" else self.engine.snapshot.raw["master"]
original = target[field]
target[field] = invalid
row = self.refresh()
self.assertIs(row["supported"], False)
self.assertIn(word, row["blocked_reason"])
self.assertNotEqual(row["reason_kind"], "model_unsupported")
target[field] = original
source = [{"task_type_id": str(i), "battle_kind": "passStage", "supported": supported,
"block_reason": reason} for i, (supported, reason) in enumerate((
(False, ""), (True, "自动对话未启用"), (False, "前置任务尚未完成")))]
rows, _ = self.engine._overlay_battle_capabilities(deepcopy(source), [])
self.assertTrue(all(row["supported"] is False for row in rows))
self.assertEqual([row["blocked_reason"] for row in rows], [row["block_reason"] for row in source])
rows = [{"task_type_id": str(i), "state": state, "category": "mainline", "battle_kind": "passStage",
"supported": state == "received"} for i, state in enumerate(["finished", "locked", "received"] * 400)]
rows, _ = self.engine._overlay_battle_capabilities(rows, [])
self.assertTrue(all(row["block_reason"] == "" and row["reason_kind"] != "model_unsupported" for row in rows))
self.assertTrue(all(row["supported"] is None and row["reason_kind"] == "unchecked"
for row in rows if row["state"] == "received"))
self.runtime.inspect.assert_not_called()
def test_inspect_support_does_not_relabel_a_recorded_loss_as_unsupported_or_win(self):
row = self.refresh()
self.assertIs(row["supported"], True)
self.engine._progression_records = [{"task_type_id": "1002013", "task_id": 11,
"battle_kind": "passStage", "battle_mode": "experimental", "outcome": "loss"}]
before = deepcopy(self.engine._progression_records)
view = build_view(self.engine, "battles", default_config())
self.assertEqual(view["rows"][0]["outcome"], "loss")
self.assertIn("打不过", view["rows"][0]["outcome_label"])
self.assertEqual(self.engine._progression_records, before)
if __name__ == "__main__":
unittest.main()