140 lines
8.1 KiB
Python
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()
|