Files
myrzx_bot/ranch_assistant/tests/test_battle_retry.py
T
2026-11-17 00:17:52 +08:00

140 lines
7.4 KiB
Python

"""Offline checks for cooldown recovery and midnight quota refresh."""
from datetime import datetime, timedelta, timezone
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.battles import BattleJournal
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.policy_io import checked_progression_policy
from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy
from ranch_assistant.quests import QuestPolicy
from ranch_assistant.tests.test_progression import config, snapshot, step, task
class BattleRetryTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.tasks = {"400": task("400", type=4, steps=[step("battle", battle={"teams": []})])}
self.snapshot = snapshot(currentTasks=[{"id": 40, "typeId": "400", "curStep": 1}])
self.planner = ProgressionPlanner(self.catalog, config(self.tasks))
self.quest = QuestPolicy(enabled=True, battle_tasks=True)
self.policy = ProgressionPolicy()
def test_configured_interval_controls_next_battle_attempt(self):
self.policy.loss_retry_hours = 2
with patch("ranch_assistant.model.time.time", return_value=100000):
self.planner.battle_lost(self.snapshot, self.plan()[0])
with patch("ranch_assistant.model.time.time", return_value=107199):
self.assertTrue(self.plan()[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=107200):
self.assertFalse(self.plan()[0].blocked)
def test_retry_hour_validation(self):
self.assertEqual(checked_progression_policy({}).loss_retry_hours, 3)
for hours in (0, 169, True, 1.5):
with self.subTest(hours=hours), self.assertRaises(ValueError):
checked_progression_policy({"loss_retry_hours": hours})
def test_legacy_loss_wait_survives_planner_restore(self):
account = self.planner._account(self.snapshot)[1]
account.update(losses=1)
account.pop("last_loss_at")
state = self.planner.export_state()
self.planner.restore_state(state)
with patch("ranch_assistant.model.time.time", return_value=100000):
self.assertTrue(self.plan()[0].blocked)
state = self.planner.export_state()
self.planner.restore_state(state)
with patch("ranch_assistant.model.time.time", return_value=110799):
self.assertTrue(self.plan()[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=110800):
self.assertFalse(self.plan()[0].blocked)
def plan(self):
return self.planner.commission_plan(self.snapshot, self.quest, Policy(), battle_policy=self.policy)
def test_loss_wait_expires_without_changing_task_progress(self):
with patch("ranch_assistant.model.time.time", return_value=100000):
intent = self.plan()[0]
self.planner.battle_lost(self.snapshot, intent)
blocked = self.plan()[0]
self.assertIn("冷却", blocked.block_reason)
with patch("ranch_assistant.model.time.time", return_value=110799):
self.assertTrue(self.plan()[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=110800):
resumed = self.plan()[0]
self.assertFalse(resumed.blocked)
self.assertEqual(resumed.kind, "progression_battle")
self.assertEqual(resumed.step_number, 1)
def test_quota_exhaustion_waits_for_midnight_reset(self):
now = datetime(2026, 11, 16, 12, tzinfo=timezone(timedelta(hours=8))).timestamp()
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"].update(loopTaskTime=now, loopTaskNum=0, loopTask={"1": ["400"]})
with patch("ranch_assistant.model.time.time", return_value=now):
self.assertEqual(self.plan(), [])
row = self.planner.commission_offers(self.snapshot, self.quest, Policy())[0]
self.assertIn("00:00", row["reason"])
self.assertIn("自动", row["reason"])
with patch("ranch_assistant.model.time.time", return_value=now + 2 * 86400):
self.assertEqual(self.plan()[0].kind, "progression_loop_reset")
def test_old_policy_uses_three_hour_default(self):
self.assertEqual(self.policy.loss_retry_hours, 3)
def test_restart_keeps_original_loss_deadline(self):
with tempfile.TemporaryDirectory() as root:
path = Path(root) / "battle.json"
with patch("ranch_assistant.model.time.time", return_value=100000):
journal = BattleJournal(path)
record = journal.begin(self.snapshot, {"kind": "progression_battle"})
journal.finish(self.snapshot, record, "loss")
original = journal.loss_reason(self.snapshot, self.policy)
with patch("ranch_assistant.model.time.time", return_value=103600):
restarted = BattleJournal(path)
self.assertEqual(restarted.loss_reason(self.snapshot, self.policy), original)
with patch("ranch_assistant.model.time.time", return_value=110800):
restarted = BattleJournal(path)
self.assertEqual(restarted.loss_reason(self.snapshot, self.policy), "")
self.assertEqual(restarted.role(self.snapshot)["losses"], 0)
def test_expired_cooldown_preserves_unknown_request(self):
journal = BattleJournal()
journal.role(self.snapshot).update(losses=1, last_loss_at=100000)
record = journal.begin(self.snapshot, {"kind": "progression_battle"})
journal.update(record, "unknown", message="verify first")
with patch("ranch_assistant.model.time.time", return_value=110800):
self.assertEqual(journal.loss_reason(self.snapshot, self.policy), "")
self.assertEqual(journal.pending(self.snapshot)["phase"], "unknown")
def test_cooldown_boundary_invalidates_engine_cached_intents(self):
engine = Engine(self.catalog, game_data=ProgressionData(config(self.tasks)))
engine.snapshot = self.snapshot
engine.quest_policy = self.quest
engine._battle_capability = Mock(return_value=(True, ""))
with patch("ranch_assistant.model.time.time", return_value=100000):
engine._ensure_progression()
engine.progression_planner._account(self.snapshot)[1].update(losses=1, last_loss_at=100000)
engine.battle_journal.role(self.snapshot).update(losses=1, last_loss_at=100000)
engine._refresh_progression_cache(force=True)
self.assertTrue(engine._progression_intents[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=110800):
engine._refresh_progression_cache()
self.assertFalse(engine._progression_intents[0].blocked)
self.assertEqual(engine.battle_journal.role(self.snapshot)["losses"], 0)
engine.auto = False
engine.demo = False
engine.client = Mock()
engine.read_snapshot = Mock(return_value=self.snapshot)
engine.settle_pending_growth = Mock(return_value=False)
engine.poll()
self.assertFalse(engine.last_executed)
engine.client.call.assert_not_called()
engine.quest_policy.enabled = False
engine._refresh_progression_cache(force=True)
self.assertEqual(engine._progression_intents, [])