Files
myrzx_bot/ranch_assistant/tests/test_automation_scheduling.py

372 lines
15 KiB
Python

"""Fast GUI timers must not dispatch unrelated account automation."""
import os
import threading
import time
import unittest
from types import SimpleNamespace
from unittest.mock import Mock
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from PySide6 import QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant import gui
from ranch_assistant.model import Action
from ranch_assistant.tests.test_core import workspace_temp
class FakeAutomationEngine:
"""A plan-first-mainline fake which records the Engine dispatch seam."""
def __init__(self, snapshot, actions):
self.snapshot = snapshot
self.actions = actions
self.calls = []
self.pending_hatches = []
self.gift_planner = SimpleNamespace(next_ready_at=None)
self.demo = False
self.auto = True
self.heartbeat_enabled = False
self.last_heartbeat = time.monotonic()
def __getattr__(self, name):
# Window still uses the real offline Engine for rendering and policy state.
return getattr(self.offline, name)
def poll(self, **kwargs):
self.calls.append(("poll", kwargs))
return self.snapshot, self.actions, "unfiltered poll"
def poll_automation(self, kind):
self.calls.append(("poll_automation", kind))
return self.snapshot, self.actions, f"isolated {kind}"
def pending_recovery_due(self):
return False
def master_sync_due(self):
return False
def growth_sync_due(self):
return False
class AutomationSchedulingTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.window = gui.Window(self.folder)
self.window.timer.stop()
self.window.auto_save_timer.stop()
self.wait()
def tearDown(self):
self.window.stop_workflow()
self.window.pool.clear()
self.window.pool.waitForDone(3000)
self.window.close()
self.app.processEvents()
def wait(self, predicate=lambda: True, timeout=5):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
self.app.processEvents()
QTest.qWait(2)
if not self.window.busy and predicate():
return
self.fail("Real Window/fake Engine Qt scheduling did not settle")
def action(self, kind):
return Action(kind=kind, description=kind, path="synthetic/" + kind, payload={})
def install_engine(self, *kinds):
actions = [self.action("progression"), self.action("map_challenge"), self.action("sweep")]
actions.extend(self.action(kind) for kind in kinds)
offline = self.window.engine
engine = FakeAutomationEngine(offline.snapshot, actions)
engine.offline = offline
engine.demo = True
self.window.engine = engine
self.window.latest_render = (engine.snapshot, actions)
self.window.monitoring = True
self.window.set_strategy_checked(True)
self.window.next_poll = float("inf")
return engine
def install_engine_policy(self):
self.window.engine.policy = self.window.read_policy()
self.window.apply_explore_policy(self.window.read_explore_policy())
def drain(self):
"""Let already queued real Jobs start after a stop request."""
self.window.pool.waitForDone(3000)
self.wait()
def test_real_window_expired_extended_timer_never_uses_full_poll(self):
engine = self.install_engine("explore_start")
self.window.explore_enabled.setChecked(True)
self.window.arm_extended_automation()
self.window.next_explore = time.monotonic() - 1
self.window.schedule()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll_automation", "explore")])
def test_each_due_extended_kind_is_dispatched_separately(self):
engine = self.install_engine("explore_start", "breakthrough")
self.window.explore_enabled.setChecked(True)
self.window.breakthrough_targets = {"900": 1}
self.window.arm_extended_automation()
self.window.next_explore = self.window.next_breakthrough = time.monotonic() - 1
self.window.run_extended_automation()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll_automation", "explore")])
self.wait()
self.window.next_breakthrough = time.monotonic() - 1
self.window.run_extended_automation()
self.wait(lambda: len(engine.calls) >= 2)
self.assertEqual([call[1] for call in engine.calls], ["explore", "breakthrough"])
def test_finished_team_dispatches_claim_without_restart_opt_in(self):
engine = self.install_engine("explore_finish")
self.window.explore_enabled.setChecked(False)
self.window.arm_extended_automation()
self.assertLess(self.window.next_explore, float("inf"))
self.window.next_explore = time.monotonic() - 1
self.window.run_extended_automation()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll_automation", "explore")])
def test_idle_team_does_not_arm_when_restart_is_disabled(self):
self.install_engine()
self.window.explore_enabled.setChecked(False)
self.window.next_explore = float("inf")
self.window.arm_extended_automation()
self.assertEqual(self.window.next_explore, float("inf"))
def test_global_stop_blocks_claim_dispatch_and_disarms_timer(self):
engine = self.install_engine("explore_finish")
self.window.explore_enabled.setChecked(False)
self.window.arm_extended_automation()
self.assertLess(self.window.next_explore, float("inf"))
self.window.stop_workflow()
self.assertEqual(self.window.next_explore, float("inf"))
self.window.run_extended_automation()
self.wait()
self.assertEqual(engine.calls, [])
def test_pending_reconciliation_defers_claim_timer_and_active_countdown(self):
for pending in ("exploration", "battle"):
with self.subTest(pending=pending):
self.setUp()
engine = self.install_engine("explore_finish")
self.window.explore_enabled.setChecked(False)
if pending == "exploration":
engine.explore_planner.pending = Mock(return_value={"uncertain": True})
else:
engine._progression_pending = Mock(return_value=True)
self.assertEqual(self.window.latest_render[1][-1].kind, "explore_finish")
self.window.next_explore = float("inf")
self.window.arm_extended_automation()
self.assertEqual(self.window.next_explore, float("inf"))
self.window.arm_extended_automation()
self.assertEqual(self.window.next_explore, float("inf"))
engine.pending_recovery_due = Mock(return_value=True)
engine.demo = False
self.window.monitoring = True
self.window.set_strategy_checked(True)
self.window.next_breakthrough = float("inf")
self.window.schedule()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll", {"hatch_only": False, "defer_hatch": True})])
def test_fast_hatch_and_gift_dispatch_only_their_own_kind(self):
for kind in ("hatch", "gift"):
with self.subTest(kind=kind):
engine = self.install_engine()
if kind == "hatch":
engine.pending_hatches = [self.action("hatch")]
self.window.fill.setChecked(True)
self.window.ranch_enabled.setChecked(True)
else:
self.window.gift_enabled.setChecked(True)
setattr(self.window, "next_" + kind, time.monotonic() - 1)
self.window.schedule()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll_automation", kind)])
self.wait()
def test_disabling_explore_cancels_unsent_queue_before_worker_entry(self):
engine = self.install_engine("explore_start")
self.window.explore_enabled.setChecked(True)
self.window.next_explore = time.monotonic() - 1
release = threading.Event()
blocker = threading.Event()
def held_job():
blocker.set()
if not release.wait(4):
raise TimeoutError("test blocker was not released")
return "held"
queued = []
original_start = self.window.pool.start
def hold_next(runnable):
queued.append(runnable)
try:
self.install_engine_policy()
self.window.submit("fixture_blocker", held_job)
self.assertTrue(blocker.wait(1))
self.window.pool.start = hold_next
self.window.schedule()
self.assertTrue(self.window.busy)
self.window.explore_enabled.setChecked(False)
self.window.persist_settings()
self.assertEqual(self.window.next_explore, float("inf"))
finally:
self.window.pool.start = original_start
for runnable in queued:
original_start(runnable)
release.set()
self.drain()
self.assertNotIn(("poll_automation", "explore"), engine.calls)
self.assertFalse(self.window.busy)
def test_stop_cancels_every_fast_deadline_and_queued_worker(self):
engine = self.install_engine("explore_start", "breakthrough")
self.window.explore_enabled.setChecked(True)
self.window.fill.setChecked(True)
self.window.ranch_enabled.setChecked(True)
self.window.gift_enabled.setChecked(True)
self.window.breakthrough_targets = {"900": 1}
engine.pending_hatches = [self.action("hatch")]
self.install_engine_policy()
self.window.next_explore = self.window.next_breakthrough = time.monotonic() - 1
self.window.next_hatch = self.window.next_gift = time.monotonic() - 1
queued = []
original_start = self.window.pool.start
self.window.pool.start = queued.append
try:
self.window.schedule()
self.window.stop_workflow()
self.assertTrue(all(getattr(self.window, "next_" + kind) == float("inf")
for kind in ("explore", "breakthrough", "hatch", "gift")))
finally:
self.window.pool.start = original_start
for runnable in queued:
original_start(runnable)
self.drain()
self.assertEqual(engine.calls, [])
self.assertFalse(self.window.busy)
def test_completed_kind_does_not_postpone_other_due_extended_kind(self):
engine = self.install_engine("explore_start", "breakthrough")
self.window.explore_enabled.setChecked(True)
self.window.breakthrough_targets = {"900": 1}
self.window.arm_extended_automation()
self.window.next_explore = self.window.next_breakthrough = time.monotonic() - 1
due_breakthrough = self.window.next_breakthrough
self.window.schedule()
self.wait(lambda: bool(engine.calls))
self.assertEqual(self.window.next_breakthrough, due_breakthrough)
self.window.schedule()
self.wait(lambda: len(engine.calls) == 2)
self.assertEqual([call[1] for call in engine.calls], ["explore", "breakthrough"])
def test_gift_completion_preserves_due_hatch_and_gift_is_not_starved(self):
engine = self.install_engine()
self.window.fill.setChecked(True)
self.window.ranch_enabled.setChecked(True)
self.window.gift_enabled.setChecked(True)
engine.pending_hatches = [self.action("hatch")]
self.window.arm_hatching()
self.window.arm_gifting()
self.window.next_hatch = self.window.next_gift = time.monotonic() - 1
due_hatch = self.window.next_hatch
self.window.schedule()
self.wait(lambda: bool(engine.calls))
self.assertEqual(engine.calls, [("poll_automation", "hatch")])
engine.gift_planner.next_ready_at = engine.snapshot.now
self.window.arm_gifting()
self.window.next_gift = time.monotonic() - 1
self.window.schedule()
self.wait(lambda: len(engine.calls) == 2)
self.assertEqual(engine.calls[-1], ("poll_automation", "gift"))
self.assertGreaterEqual(self.window.next_hatch, due_hatch)
def test_closing_map_cancels_queued_automatic_poll_before_engine_entry(self):
engine = self.install_engine()
self.window.map_enabled.setChecked(True)
self.install_engine_policy()
self.window.next_poll = time.monotonic() - 1
queued = []
original_start = self.window.pool.start
self.window.pool.start = queued.append
try:
self.window.schedule()
self.assertTrue(self.window.busy)
self.window.map_enabled.setChecked(False)
finally:
self.window.pool.start = original_start
for runnable in queued:
original_start(runnable)
self.drain()
self.assertEqual(engine.calls, [])
self.assertFalse(self.window.map_enabled.isChecked())
def test_disabling_while_busy_applies_before_next_fast_dispatch(self):
engine = self.install_engine("explore_start")
self.window.explore_enabled.setChecked(True)
self.install_engine_policy()
release = threading.Event()
entered = threading.Event()
def held_automation(kind):
engine.calls.append(("poll_automation", kind))
entered.set()
if not release.wait(4):
raise TimeoutError("test automation was not released")
return engine.snapshot, [], "held automation"
engine.poll_automation = held_automation
self.window.next_explore = time.monotonic() - 1
self.window.schedule()
self.assertTrue(entered.wait(1))
self.window.explore_enabled.setChecked(False)
self.window.persist_settings()
self.assertIsNotNone(self.window.pending_policy)
self.assertEqual(self.window.next_explore, float("inf"))
release.set()
self.drain()
self.window.schedule()
self.drain()
self.assertEqual(engine.calls, [("poll_automation", "explore")])
self.assertIsNone(self.window.pending_policy)
self.assertFalse(self.window.explore_enabled.isChecked())
self.assertEqual(self.window.next_explore, float("inf"))
if __name__ == "__main__":
unittest.main()