Fix fast automation routing and blocked quest navigation loops

Isolate hatch, gift, exploration and breakthrough timers; cancel queued automation after settings change. Check battle readiness before local quest navigation and reject exploring teams or disabled sweeps before entry.
This commit is contained in:
AttilaNet
2026-11-09 12:14:47 +08:00
parent 9f819d828a
commit eaaad3488b
9 changed files with 931 additions and 37 deletions
@@ -0,0 +1,315 @@
"""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_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()