137 lines
6.4 KiB
Python
137 lines
6.4 KiB
Python
import os
|
|
import time
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
|
from PySide6 import QtWidgets as W
|
|
from PySide6.QtTest import QTest
|
|
|
|
from ranch_assistant.api import Session
|
|
from ranch_assistant.engine import Engine, demo_snapshot
|
|
from ranch_assistant.gui import Window
|
|
from ranch_assistant.model import Catalog, Planner, Policy
|
|
from ranch_assistant.policy_io import import_policy, portable_policy
|
|
from ranch_assistant.tests.test_core import workspace_temp
|
|
from ranch_assistant.tests.test_growth import GrowthClient, NOW
|
|
|
|
|
|
class FourSProtectionTests(unittest.TestCase):
|
|
def test_four_s_requires_every_stat_instead_of_average_grade(self):
|
|
catalog = Catalog()
|
|
snapshot = demo_snapshot(catalog)
|
|
mon = snapshot.monsters[101]
|
|
mon.update(mode=2, lock=0)
|
|
info = catalog.monster(mon["typeId"])
|
|
for stat in ("atk", "def", "hp", "dex"):
|
|
mon["g" + stat.capitalize()] = info[stat + "_grow_max"]
|
|
policy = Policy(strategy="gold", protect_star=6, protect_quality=6)
|
|
planner = Planner(catalog)
|
|
self.assertEqual(catalog.quality(mon), [4, 4, 4, 4])
|
|
self.assertIn("4S", planner.protection_reason(mon, snapshot, policy))
|
|
self.assertEqual(planner.disposition(mon, snapshot, policy), "keep")
|
|
for stat in ("atk", "def", "hp", "dex"):
|
|
with self.subTest(stat=stat):
|
|
mon["g" + stat.capitalize()] = info[stat + "_grow_min"]
|
|
self.assertEqual(planner.disposition(mon, snapshot, policy), "sell")
|
|
self.assertTrue(planner.protected(mon, snapshot, Policy(protect_star=6, protect_quality=4)))
|
|
mon["g" + stat.capitalize()] = info[stat + "_grow_max"]
|
|
|
|
def test_four_s_keeps_locks_unknown_grades_star_guards_and_round_trips(self):
|
|
catalog = Catalog()
|
|
snapshot = demo_snapshot(catalog)
|
|
mon = snapshot.monsters[101]
|
|
policy = Policy(protect_star=6, protect_quality=6)
|
|
planner = Planner(catalog)
|
|
mon["lock"] = 1
|
|
self.assertTrue(planner.protected(mon, snapshot, policy))
|
|
mon["lock"] = 0
|
|
policy.protect_star = 1
|
|
self.assertTrue(planner.protected(mon, snapshot, policy))
|
|
policy.protect_star = 6
|
|
mon["gAtk"] = None
|
|
self.assertTrue(planner.protected(mon, snapshot, policy))
|
|
self.assertEqual(import_policy(portable_policy(policy, snapshot), snapshot).protect_quality, 6)
|
|
|
|
|
|
class MonitoringGuiTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.app = W.QApplication.instance() or W.QApplication([])
|
|
|
|
def wait(self, window):
|
|
for _ in range(500):
|
|
self.app.processEvents()
|
|
QTest.qWait(2)
|
|
if not window.busy:
|
|
return
|
|
self.fail("Background job did not finish")
|
|
|
|
def test_random_intervals_are_redrawn_and_saved_and_old_settings_migrate(self):
|
|
with workspace_temp() as folder:
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
self.assertEqual([window.interval.itemData(i) for i in range(window.interval.count())], [30, 60, 120, 300])
|
|
with patch("ranch_assistant.gui.random.uniform", side_effect=[0, 29.9]) as draw:
|
|
self.assertEqual(window.poll_delay(), 0)
|
|
self.assertEqual(window.poll_delay(), 29.9)
|
|
self.assertEqual(draw.call_args_list[0].args, (0, 30))
|
|
self.assertEqual(draw.call_count, 2)
|
|
window.interval.setCurrentIndex(3)
|
|
window.save_config(quiet=True)
|
|
window.load_config({"interval": 5, "farm": {"stage_id": "bd00"}, "capture_profile": "old.json"})
|
|
self.assertEqual(window.interval.currentData(), 30)
|
|
self.assertFalse(hasattr(window, "farm"))
|
|
self.assertFalse(hasattr(window, "capture_scroll"))
|
|
window.load_config()
|
|
self.assertEqual(window.interval.currentData(), 300)
|
|
window.protect_quality.setCurrentIndex(window.protect_quality.findData(6))
|
|
window.save_config(quiet=True)
|
|
finally:
|
|
window.close()
|
|
restored = Window(folder)
|
|
restored.timer.stop()
|
|
try:
|
|
self.wait(restored)
|
|
self.assertEqual(restored.interval.currentData(), 300)
|
|
self.assertEqual(restored.read_policy().protect_quality, 6)
|
|
self.assertFalse(restored.strategy_toggle.isChecked())
|
|
finally:
|
|
restored.close()
|
|
|
|
def test_growth_deadline_sync_runs_without_waiting_for_monitor_poll(self):
|
|
with workspace_temp() as folder, patch("ranch_assistant.model.time.time", return_value=NOW):
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
client = GrowthClient(window.catalog, age=599, grade="S")
|
|
client.raw["monsters"][0]["mode"] = 1
|
|
client.session = Session("http://127.0.0.1/", "synthetic-test-token")
|
|
window.engine = Engine(window.catalog, client)
|
|
window.engine.last_heartbeat = time.monotonic()
|
|
window.engine.snapshot = client.snapshot()
|
|
self.assertFalse(window.engine.growth_sync_due())
|
|
window.engine.snapshot.server_offset = 2
|
|
client.raw["monsters"][0]["timeStart"] -= 2000
|
|
client.stage = 2
|
|
window.next_poll = float("inf")
|
|
self.assertFalse(window.monitoring)
|
|
window.schedule()
|
|
self.wait(window)
|
|
self.assertTrue(window.monitoring)
|
|
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
|
|
self.assertEqual(window.engine.snapshot.monsters[501]["mode"], 2)
|
|
self.assertEqual(window.catalog.quality_text(window.engine.snapshot.monsters[501]), "S/S/S/S")
|
|
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
|
self.assertFalse(window.strategy_toggle.isChecked())
|
|
self.assertFalse(any("同步孵化" in button.text() for button in window.slot_page.findChildren(W.QPushButton)))
|
|
finally:
|
|
window.close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|