140 lines
7.4 KiB
Python
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, [])
|