feat: add configurable battle loss cooldown in Web 2.0.13
Web image / image (push) Waiting to run

This commit is contained in:
AttilaNet
2026-11-17 00:17:52 +08:00
parent 598bdf5c1c
commit b976151263
23 changed files with 297 additions and 43 deletions
+139
View File
@@ -0,0 +1,139 @@
"""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, [])