Refine ranch tree, growth sync and monitoring policies
This commit is contained in:
@@ -172,7 +172,8 @@ class AccountGuiTests(unittest.TestCase):
|
||||
hub.tabs.setCurrentWidget(first)
|
||||
for page in (first.egg_page, first.monster_page, first.room_page):
|
||||
first.tabs.setCurrentWidget(page)
|
||||
self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), first.monsters.rowCount(), first.rooms_table.rowCount()], [11, 4, 4, 1])
|
||||
self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), len(first.monsters.monster_items)], [11, 4, 4])
|
||||
self.assertIn("room:1", first.monsters.group_items)
|
||||
self.assertEqual(first.saved_sessions.count(), 1)
|
||||
first.start_monitor.setChecked(True)
|
||||
hub.tabs.setCurrentWidget(second)
|
||||
@@ -204,10 +205,6 @@ class AccountGuiTests(unittest.TestCase):
|
||||
self.assertTrue(all(url.endswith("masterService/masterQueryDetail") for _, url, _ in calls[before:]))
|
||||
self.assertFalse(first.engine.auto)
|
||||
self.assertIs(first.tabs.currentWidget(), first.egg_page)
|
||||
first.farm.running = True
|
||||
first.farm.adb.serial = "phone-a"
|
||||
self.assertFalse(hub.allow_device(second, "phone-a"))
|
||||
self.assertTrue(hub.allow_device(second, "phone-b"))
|
||||
self.assertFalse(hub.allow_login(second, "account-a"))
|
||||
self.assertFalse(hub.allow_connection(second, first.engine.client.session))
|
||||
finally:
|
||||
|
||||
@@ -19,6 +19,9 @@ def scenario():
|
||||
# One ordinary stage, one not fully passed, one special activity.
|
||||
catalog.data["stage_info"] = {k: catalog.data["stage_info"][k] for k in ("0101", "0102", "bd00")}
|
||||
snapshot = demo_snapshot(catalog)
|
||||
for mon in snapshot.raw["monsters"]:
|
||||
if mon.get("process") == 2:
|
||||
mon["mode"] = snapshot.expected_growth_mode(mon, catalog)
|
||||
snapshot.raw["history"].update(unlockStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]},
|
||||
passStage={"0101": ["1", "2", "3"], "0102": ["1"], "bd00": ["1", "2", "3"]})
|
||||
snapshot.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [900, 0]}]
|
||||
@@ -241,13 +244,11 @@ class ActivityGuiTests(unittest.TestCase):
|
||||
self.assertEqual(settings["sweep_policy"]["rules"]["0101"]["limit"], 12)
|
||||
window.resize(1100, 650)
|
||||
window.show()
|
||||
window.tabs.setCurrentWidget(window.capture_scroll)
|
||||
window.tabs.setCurrentWidget(window.automation_page)
|
||||
window.automation_tabs.setCurrentWidget(window.policy_scroll)
|
||||
window.log_splitter.setSizes([180, 450])
|
||||
self.app.processEvents()
|
||||
table_rect = window.capture_rows.geometry()
|
||||
next_button = next(b for b in window.capture_page_widget.findChildren(W.QPushButton) if b.text() == "检查已保存截图")
|
||||
self.assertGreater(next_button.geometry().top(), table_rect.bottom())
|
||||
self.assertGreater(window.capture_scroll.verticalScrollBar().maximum(), 0)
|
||||
self.assertGreater(window.policy_scroll.verticalScrollBar().maximum(), 0)
|
||||
self.assertEqual(window.styleSheet(), "")
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
@@ -418,8 +418,8 @@ class AutomationGuiTests(unittest.TestCase):
|
||||
before = len(window.engine.snapshot.raw["monsters"])
|
||||
def select(mid):
|
||||
window.tabs.setCurrentWidget(window.monster_page)
|
||||
row = next(i for i in range(window.monsters.rowCount()) if int(window.monsters.item(i, 0).text()) == mid)
|
||||
window.monsters.selectRow(row)
|
||||
window.monsters.clearSelection()
|
||||
window.monsters.setCurrentItem(window.monsters.monster_items[mid])
|
||||
select(101)
|
||||
self.assertTrue(window.lock_monsters.isEnabled())
|
||||
window.lock_monsters.click()
|
||||
|
||||
@@ -11,11 +11,9 @@ import uuid
|
||||
from unittest.mock import patch
|
||||
|
||||
import requests
|
||||
from PIL import Image, ImageDraw
|
||||
|
||||
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode
|
||||
from ranch_assistant.engine import Engine, demo_snapshot
|
||||
from ranch_assistant.farming import FarmBudget, FarmConfig, FarmRunner, matches
|
||||
from ranch_assistant.model import Catalog, Planner, Policy, Snapshot
|
||||
|
||||
|
||||
@@ -144,63 +142,7 @@ class CoreTests(unittest.TestCase):
|
||||
self.assertEqual(post.call_count, 1)
|
||||
self.assertNotIn("private-token", str(raised.exception))
|
||||
|
||||
def test_budget_stamina_tickets_stale_and_persistent_daily_limit(self):
|
||||
snapshot = self.snapshot()
|
||||
config = FarmConfig(daily_limit=1)
|
||||
with workspace_temp() as folder:
|
||||
budget = FarmBudget(Path(folder) / "runs.json")
|
||||
self.assertTrue(budget.check(snapshot, config, self.catalog)[0])
|
||||
snapshot.raw["master"]["ti"] = 5
|
||||
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
|
||||
snapshot.raw["master"]["ti"] = 100
|
||||
snapshot.raw["items"] = []
|
||||
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
|
||||
snapshot = self.snapshot()
|
||||
snapshot.received_at -= 60
|
||||
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
|
||||
snapshot.received_at = time.time()
|
||||
budget.reserve(snapshot, config)
|
||||
restarted = FarmBudget(Path(folder) / "runs.json")
|
||||
self.assertFalse(restarted.check(snapshot, config, self.catalog)[0])
|
||||
|
||||
def test_farm_screen_gate_and_real_tap_sequence(self):
|
||||
with workspace_temp() as folder:
|
||||
folder = Path(folder)
|
||||
blank = Image.new("RGB", (200, 400), "black")
|
||||
ready, victory = blank.copy(), blank.copy()
|
||||
draw = ImageDraw.Draw(ready)
|
||||
draw.rectangle((10, 10, 99, 39), fill="green")
|
||||
draw.rectangle((20, 300, 99, 349), fill="red")
|
||||
ImageDraw.Draw(victory).rectangle((100, 200, 179, 249), fill="blue")
|
||||
boxes = {"stage": (10, 10, 100, 40), "entry": (20, 300, 100, 350), "victory": (100, 200, 180, 250)}
|
||||
templates = {}
|
||||
for name, box in boxes.items():
|
||||
(victory if name == "victory" else ready).crop(box).save(folder / f"{name}.png")
|
||||
templates[name] = {"screen": [200, 400], "box": box, "file": name + ".png", "stage_id": "bd00"}
|
||||
class FakeAdb:
|
||||
image = ready
|
||||
taps = []
|
||||
def foreground(self): return True
|
||||
def screenshot(self): return self.image
|
||||
def tap(self, x, y): self.taps.append((x, y))
|
||||
adb = FakeAdb()
|
||||
runner = FarmRunner(adb, self.catalog, folder)
|
||||
runner.config = FarmConfig(templates=templates)
|
||||
runner.start()
|
||||
bad = ready.copy()
|
||||
ImageDraw.Draw(bad).rectangle(boxes["stage"], fill="black")
|
||||
adb.image = bad
|
||||
runner.tick(self.snapshot())
|
||||
self.assertEqual(adb.taps, [])
|
||||
adb.image = ready
|
||||
with patch("ranch_assistant.farming.time.monotonic", return_value=10): runner.tick(self.snapshot())
|
||||
self.assertEqual(len(adb.taps), 1)
|
||||
adb.image = victory
|
||||
with patch("ranch_assistant.farming.time.monotonic", return_value=13): runner.tick(self.snapshot())
|
||||
adb.image = ready
|
||||
with patch("ranch_assistant.farming.time.monotonic", return_value=16): runner.tick(self.snapshot())
|
||||
self.assertEqual(runner.completed, 1)
|
||||
self.assertEqual(len(adb.taps), 2)
|
||||
|
||||
|
||||
class WireIntegrationTests(unittest.TestCase):
|
||||
@@ -242,7 +184,8 @@ class WireIntegrationTests(unittest.TestCase):
|
||||
engine = Engine(catalog, client)
|
||||
engine.policy = Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False)
|
||||
engine.poll()
|
||||
self.assertFalse(any(p.endswith("stackCheckProcess") or p.endswith("monsterSell") for p, _ in calls))
|
||||
self.assertTrue(any(p.endswith("stackCheckProcess") for p, _ in calls))
|
||||
self.assertFalse(any(p.endswith("monsterSell") for p, _ in calls))
|
||||
engine.auto = True
|
||||
snapshot, _, _ = engine.poll()
|
||||
self.assertEqual(sum(p.endswith("monsterSell") for p, _ in calls), 1)
|
||||
|
||||
@@ -8,13 +8,10 @@ import unittest
|
||||
from urllib.parse import parse_qs, urlsplit
|
||||
from unittest.mock import patch
|
||||
|
||||
from PIL import Image, ImageDraw
|
||||
|
||||
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode, server_entries, server_id
|
||||
from ranch_assistant.capture import load_buttons, save_page, saved_profiles, write_buttons
|
||||
from ranch_assistant.engine import Engine, demo_snapshot
|
||||
from ranch_assistant.debug import TraceLog
|
||||
from ranch_assistant.farming import FarmConfig, FarmRunner
|
||||
from ranch_assistant.login import PasswordLogin, SDK_APP_ID, SDK_APP_SECRET, server_labels
|
||||
from ranch_assistant.maps import stages
|
||||
from ranch_assistant.model import Catalog, Policy
|
||||
@@ -230,67 +227,6 @@ class PlanningTests(unittest.TestCase):
|
||||
self.assertEqual((first.stamina, second.stamina), (7, 8))
|
||||
|
||||
|
||||
class CaptureTests(unittest.TestCase):
|
||||
def test_profile_scope_button_binding_and_changed_capture(self):
|
||||
with workspace_temp() as folder:
|
||||
ready = Image.new("RGB", (100, 200), "blue")
|
||||
victory = Image.new("RGB", (100, 200), "green")
|
||||
path, _ = save_page(folder, ready, "phone-a", "bd00", "1", "stage_ready")
|
||||
save_page(folder, victory, "phone-a", "bd00", "1", "victory")
|
||||
alternate, _ = save_page(folder, ready.resize((200, 400)), "phone-a", "bd00", "1", "stage_ready")
|
||||
other, _ = save_page(folder, ready, "phone-b", "bd00", "1", "stage_ready")
|
||||
self.assertEqual(len({path, alternate, other}), 3)
|
||||
self.assertEqual(len(saved_profiles(folder, "bd00", "1", "phone-a")), 2)
|
||||
regions = {"stage": {"box": [0, 0, 20, 20]}, "entry": {"box": [20, 20, 40, 40]},
|
||||
"victory": {"box": [40, 40, 60, 60], "tap": [70, 180]}}
|
||||
write_buttons(path, folder, regions)
|
||||
templates = load_buttons(path, folder, "bd00", "1", "phone-a")
|
||||
self.assertEqual(templates["victory"]["tap"], [70, 180])
|
||||
with self.assertRaises(ValueError):
|
||||
load_buttons(path, folder, "bd00", "2")
|
||||
with self.assertRaises(ValueError):
|
||||
load_buttons(path, folder, "bd00", "1", "phone-b")
|
||||
save_page(folder, Image.new("RGB", ready.size, "red"), "phone-a", "bd00", "1", "stage_ready")
|
||||
with self.assertRaises(ValueError):
|
||||
load_buttons(path, folder, "bd00", "1")
|
||||
|
||||
def test_runtime_device_resolution_and_separate_victory_tap(self):
|
||||
with workspace_temp() as folder:
|
||||
ready = Image.new("RGB", (100, 200), "black")
|
||||
victory = ready.copy()
|
||||
ImageDraw.Draw(ready).rectangle((0, 0, 40, 40), fill="blue")
|
||||
ImageDraw.Draw(victory).rectangle((40, 40, 60, 60), fill="green")
|
||||
path, _ = save_page(folder, ready, "phone-a", "bd00", "1", "stage_ready")
|
||||
save_page(folder, victory, "phone-a", "bd00", "1", "victory")
|
||||
write_buttons(path, folder, {"stage": {"box": [0, 0, 20, 20]}, "entry": {"box": [20, 20, 40, 40]},
|
||||
"victory": {"box": [40, 40, 60, 60], "tap": [70, 180]}})
|
||||
class FakeAdb:
|
||||
serial = "phone-a"
|
||||
image = ready
|
||||
taps = []
|
||||
def foreground(self): return True
|
||||
def screenshot(self): return self.image
|
||||
def tap(self, x, y): self.taps.append((x, y))
|
||||
adb = FakeAdb()
|
||||
catalog = Catalog()
|
||||
runner = FarmRunner(adb, catalog, folder)
|
||||
runner.config = FarmConfig(capture_profile=str(path.relative_to(folder)))
|
||||
runner.start()
|
||||
with patch("ranch_assistant.farming.time.monotonic", return_value=10):
|
||||
runner.tick(demo_snapshot(catalog))
|
||||
adb.image = victory
|
||||
with patch("ranch_assistant.farming.time.monotonic", return_value=13):
|
||||
runner.tick(demo_snapshot(catalog))
|
||||
self.assertEqual(adb.taps[-1], (70, 180))
|
||||
adb.serial = "phone-b"
|
||||
with self.assertRaises(RuntimeError):
|
||||
runner.tick(demo_snapshot(catalog))
|
||||
adb.serial = "phone-a"
|
||||
runner.start()
|
||||
adb.image = ready.resize((200, 400))
|
||||
with self.assertRaises(RuntimeError):
|
||||
runner.tick(demo_snapshot(catalog))
|
||||
self.assertEqual(len(adb.taps), 2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -150,17 +150,16 @@ class GrowthTests(unittest.TestCase):
|
||||
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
|
||||
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
||||
|
||||
def test_monitor_is_read_only_and_explicit_sync_does_not_dispatch(self):
|
||||
def test_monitor_automatically_syncs_growth_without_dispatch(self):
|
||||
client = GrowthClient(self.catalog, age=610)
|
||||
engine = self.engine(client)
|
||||
engine.auto = False
|
||||
snapshot, _, message = engine.poll()
|
||||
self.assertFalse(any(name == "growth" for name, _ in client.calls))
|
||||
self.assertIn("仅监控", message)
|
||||
snapshot, plans, _ = engine.sync_growth()
|
||||
self.assertTrue(any(name == "growth" for name, _ in client.calls))
|
||||
self.assertIn("成长结算", message)
|
||||
self.assertEqual(snapshot.monsters[501]["mode"], 2)
|
||||
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "C/C/C/C")
|
||||
self.assertTrue(any(action.kind == "sell" for action in plans))
|
||||
self.assertTrue(any(action.kind == "sell" for action in engine.plans()))
|
||||
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
||||
|
||||
def test_mature_protected_monster_with_null_room_id_can_be_collected(self):
|
||||
@@ -203,8 +202,9 @@ class GrowthGuiTests(unittest.TestCase):
|
||||
row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1")
|
||||
self.assertIn("待同步", window.slots.item(row, 5).text())
|
||||
self.assertIn("待成熟", window.slots.item(row, 7).text())
|
||||
self.assertNotEqual(window.monsters.item(0, 4).text(), "C/C/C/C")
|
||||
window.sync_growth_button.click()
|
||||
self.assertNotEqual(window.monsters.monster_items[501].text(4), "C/C/C/C")
|
||||
window.engine.last_heartbeat = __import__("time").monotonic()
|
||||
window.schedule()
|
||||
for _ in range(200):
|
||||
self.app.processEvents()
|
||||
QTest.qWait(5)
|
||||
@@ -213,7 +213,7 @@ class GrowthGuiTests(unittest.TestCase):
|
||||
row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1")
|
||||
self.assertEqual(window.slots.item(row, 7).text(), "S/S/S/S")
|
||||
self.assertIn("资质", window.slots.item(row, 8).text())
|
||||
self.assertIn("S/S/S/S", window.monsters.item(0, 4).text())
|
||||
self.assertIn("S/S/S/S", window.monsters.monster_items[501].text(4))
|
||||
self.assertFalse(window.execute.isChecked())
|
||||
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
||||
finally:
|
||||
|
||||
@@ -29,7 +29,13 @@ class GuiTests(unittest.TestCase):
|
||||
window.timer.stop()
|
||||
try:
|
||||
self.wait(window)
|
||||
self.assertIn("页面截图配置", [window.tabs.tabText(i) for i in range(window.tabs.count())])
|
||||
labels = [window.tabs.tabText(i) for i in range(window.tabs.count())]
|
||||
self.assertNotIn("页面截图配置", labels)
|
||||
self.assertNotIn("体力刷图", labels)
|
||||
self.assertIn("自动扫荡", labels)
|
||||
self.assertNotIn("地图关卡", labels)
|
||||
self.assertEqual(labels[-1], "收益资料")
|
||||
self.assertLess(labels.index("自动孵蛋"), labels.index("自动扫荡"))
|
||||
self.assertEqual(window.yields.rowCount(), 749)
|
||||
self.assertEqual(window.styleSheet(), "")
|
||||
window.strategy.setCurrentIndex(window.strategy.findData("gold"))
|
||||
@@ -58,57 +64,6 @@ class GuiTests(unittest.TestCase):
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_page_buttons_only_capture_and_restore_profile(self):
|
||||
from PIL import Image
|
||||
from ranch_assistant.capture import PAGES
|
||||
operations = []
|
||||
class FakeAdb:
|
||||
def __init__(self, executable="", serial=""):
|
||||
self.serial = serial
|
||||
def foreground(self):
|
||||
operations.append("foreground")
|
||||
return True
|
||||
def run(self, *args):
|
||||
operations.append(args)
|
||||
if args != ("get-serialno",):
|
||||
raise AssertionError("Screenshot flow attempted another ADB command")
|
||||
return "test-phone"
|
||||
def screenshot(self):
|
||||
operations.append("screenshot")
|
||||
return Image.new("RGB", (320, 640), "green")
|
||||
def tap(self, *args):
|
||||
raise AssertionError("Screenshot flow must never tap")
|
||||
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
|
||||
window = gui.Window()
|
||||
window.timer.stop()
|
||||
try:
|
||||
self.wait(window)
|
||||
window.start_monitor.setChecked(True)
|
||||
with patch.object(gui, "Adb", FakeAdb):
|
||||
for index in range(len(PAGES)):
|
||||
window.capture_rows.cellWidget(index, 2).click()
|
||||
self.wait(window)
|
||||
self.assertFalse(window.monitoring)
|
||||
profile = json.loads(window.capture_profile.read_text(encoding="utf-8"))
|
||||
self.assertEqual(set(profile["captures"]), {p[0] for p in PAGES})
|
||||
self.assertEqual(operations.count("screenshot"), len(PAGES))
|
||||
self.assertFalse(window.capture_preview.selectable)
|
||||
original = window.capture_profile
|
||||
window.stage.setCurrentIndex(1)
|
||||
self.assertIsNone(window.capture_profile)
|
||||
window.stage.setCurrentIndex(0)
|
||||
self.assertEqual(window.capture_profile, original)
|
||||
finally:
|
||||
window.close()
|
||||
restored = gui.Window()
|
||||
restored.timer.stop()
|
||||
try:
|
||||
self.wait(restored)
|
||||
self.assertEqual(restored.capture_profile, original)
|
||||
restored.preview_capture(0, 0)
|
||||
self.assertEqual(restored.capture_preview.image.size, (320, 640))
|
||||
finally:
|
||||
restored.close()
|
||||
|
||||
def test_password_result_accepts_serverId_and_handles_missing_identifier(self):
|
||||
from unittest.mock import Mock
|
||||
|
||||
@@ -0,0 +1,135 @@
|
||||
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.execute.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.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.execute.isChecked())
|
||||
self.assertFalse(any("同步孵化" in button.text() for button in window.slot_page.findChildren(W.QPushButton)))
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,174 @@
|
||||
import copy
|
||||
import os
|
||||
import time
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
||||
from PySide6 import QtCore as C, QtWidgets as W
|
||||
from PySide6.QtTest import QTest
|
||||
|
||||
from ranch_assistant.engine import demo_snapshot
|
||||
from ranch_assistant.gui import Window
|
||||
from ranch_assistant.model import Catalog
|
||||
from ranch_assistant.presentation import monster_rows
|
||||
from ranch_assistant.ranch_gui import RanchView
|
||||
from ranch_assistant.tests.test_core import workspace_temp
|
||||
|
||||
|
||||
class RanchTreeTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.app = W.QApplication.instance() or W.QApplication([])
|
||||
|
||||
def drain(self, tree):
|
||||
for _ in range(500):
|
||||
self.app.processEvents()
|
||||
if not tree.row_batch.running:
|
||||
return
|
||||
QTest.qWait(2)
|
||||
self.fail("Ranch rows did not finish")
|
||||
|
||||
def scenario(self):
|
||||
catalog = Catalog()
|
||||
snapshot = demo_snapshot(catalog)
|
||||
room = snapshot.raw["rooms"][0]
|
||||
snapshot.raw["rooms"] += [room | {"id": 2, "name": "第二牧场"}, room | {"id": 3, "name": "空牧场"}]
|
||||
snapshot.raw["monsters"].append(snapshot.monsters[900] | {"id": 901, "roomId": 2})
|
||||
return catalog, snapshot
|
||||
|
||||
def render(self, tree, snapshot, feeds=None, gifts=None):
|
||||
tree.set_data(snapshot, monster_rows(tree.catalog, snapshot, set()), feeds or {}, gifts or {})
|
||||
self.drain(tree)
|
||||
|
||||
def test_ranch_headers_children_and_refresh_preserve_controls_and_collapse(self):
|
||||
catalog, snapshot = self.scenario()
|
||||
tree = RanchView(catalog)
|
||||
try:
|
||||
self.render(tree, snapshot)
|
||||
self.assertEqual(tree.group_items["room:1"].childCount(), 1)
|
||||
self.assertEqual(tree.group_items["room:2"].childCount(), 1)
|
||||
self.assertEqual(tree.group_items["room:3"].childCount(), 0)
|
||||
self.assertEqual(tree.group_items["incubator"].childCount(), 4)
|
||||
self.assertIn("魔物 1 /", tree.group_items["room:1"].text(0))
|
||||
self.assertIn("魔物 0 /", tree.group_items["room:3"].text(0))
|
||||
item = tree.monster_items[900]
|
||||
check, priority = tree.itemWidget(item, 8), tree.itemWidget(item, 9)
|
||||
tree.setCurrentItem(item)
|
||||
tree.group_items["room:1"].setExpanded(False)
|
||||
updated = copy.deepcopy(snapshot)
|
||||
updated.monsters[900]["feel"] = 30
|
||||
self.render(tree, updated, {"900": 2}, {"900": 3})
|
||||
self.assertIs(tree.monster_items[900], item)
|
||||
self.assertIs(tree.itemWidget(item, 8), check)
|
||||
self.assertIs(tree.itemWidget(item, 9), priority)
|
||||
self.assertTrue(check.isChecked())
|
||||
self.assertEqual(priority.value(), 2)
|
||||
self.assertTrue(tree.itemWidget(item, 17).isChecked())
|
||||
self.assertEqual(tree.itemWidget(item, 18).value(), 3)
|
||||
self.assertFalse(tree.group_items["room:1"].isExpanded())
|
||||
self.assertEqual(tree.selected_monster_ids(), [900])
|
||||
self.assertTrue(item.text(15).startswith("30 /"))
|
||||
finally:
|
||||
tree.row_batch.stop()
|
||||
tree.close()
|
||||
|
||||
def test_flat_toggle_room_transfer_and_removed_monsters_keep_correct_ids(self):
|
||||
catalog, snapshot = self.scenario()
|
||||
tree = RanchView(catalog)
|
||||
messages = []
|
||||
previous = C.qInstallMessageHandler(lambda kind, context, message: messages.append(message))
|
||||
try:
|
||||
self.render(tree, snapshot)
|
||||
tree.set_view(False)
|
||||
self.render(tree, snapshot)
|
||||
self.assertEqual(tree.topLevelItemCount(), 6)
|
||||
self.assertFalse(tree.rootIsDecorated())
|
||||
self.assertTrue(all(item.parent() is None for item in tree.monster_items.values()))
|
||||
tree.set_view(True)
|
||||
self.render(tree, snapshot)
|
||||
self.assertIs(tree.monster_items[900].parent(), tree.group_items["room:1"])
|
||||
updated = copy.deepcopy(snapshot)
|
||||
updated.monsters[900]["roomId"] = 2
|
||||
updated.raw["monsters"] = [mon for mon in updated.raw["monsters"] if mon["id"] != 901]
|
||||
self.render(tree, updated)
|
||||
self.assertNotIn(901, tree.monster_items)
|
||||
self.assertEqual(tree.group_items["room:1"].childCount(), 0)
|
||||
self.assertIs(tree.monster_items[900].parent(), tree.group_items["room:2"])
|
||||
tree.set_view(True, 2)
|
||||
self.render(tree, updated)
|
||||
self.assertEqual(set(tree.monster_items), {900})
|
||||
tree.set_view(False, 2)
|
||||
self.render(tree, updated)
|
||||
self.assertEqual(len(tree.monster_items), 5)
|
||||
self.assertFalse(any("already owned" in message for message in messages))
|
||||
finally:
|
||||
C.qInstallMessageHandler(previous)
|
||||
tree.row_batch.stop()
|
||||
tree.close()
|
||||
|
||||
def test_tree_rules_context_menu_and_double_click_use_monster_ids(self):
|
||||
with workspace_temp() as folder:
|
||||
window = Window(folder)
|
||||
window.timer.stop()
|
||||
try:
|
||||
for _ in range(400):
|
||||
self.app.processEvents()
|
||||
QTest.qWait(2)
|
||||
if not window.busy:
|
||||
break
|
||||
window.tabs.setCurrentWidget(window.monster_page)
|
||||
tree = window.monsters
|
||||
self.drain(tree)
|
||||
item = tree.monster_items[900]
|
||||
tree.itemWidget(item, 8).setChecked(True)
|
||||
tree.itemWidget(item, 9).setValue(4)
|
||||
tree.itemWidget(item, 17).setChecked(True)
|
||||
tree.itemWidget(item, 18).setValue(5)
|
||||
self.assertEqual(window.read_policy().feed_targets, {"900": 4})
|
||||
self.assertEqual(window.read_policy().gift_targets, {"900": 5})
|
||||
tree.setCurrentItem(item)
|
||||
with patch("PySide6.QtWidgets.QMenu.popup"):
|
||||
window.page_menu(tree.viewport(), C.QPoint(-1, -1), window.monster_page)
|
||||
lock = next(action for action in window.refresh_menu.actions() if action.text() == "解锁选中魔物")
|
||||
self.assertTrue(lock.isEnabled())
|
||||
lock.trigger()
|
||||
for _ in range(400):
|
||||
self.app.processEvents()
|
||||
QTest.qWait(2)
|
||||
if not window.busy:
|
||||
break
|
||||
self.assertFalse(window.engine.snapshot.monsters[900].get("lock"))
|
||||
with patch("PySide6.QtWidgets.QMessageBox.information") as detail:
|
||||
tree.itemDoubleClicked.emit(tree.monster_items[900], 1)
|
||||
self.assertIn("#900", detail.call_args.args[2])
|
||||
tree.clearSelection()
|
||||
with patch("PySide6.QtWidgets.QMenu.popup"):
|
||||
window.page_menu(tree.viewport(), C.QPoint(-1, -1), window.monster_page)
|
||||
dispatch = next(action for action in window.refresh_menu.actions() if action.text() == "派遣选中魔物…")
|
||||
self.assertFalse(dispatch.isEnabled())
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
def test_large_monster_tree_renders_in_batches(self):
|
||||
catalog, snapshot = self.scenario()
|
||||
template = snapshot.monsters[900]
|
||||
snapshot.raw["monsters"] = [template | {"id": 10000 + index} for index in range(500)]
|
||||
tree = RanchView(catalog)
|
||||
timer, beats = C.QTimer(), []
|
||||
timer.setInterval(5)
|
||||
timer.timeout.connect(lambda: beats.append(time.perf_counter()))
|
||||
try:
|
||||
timer.start()
|
||||
self.render(tree, snapshot)
|
||||
self.assertEqual(len(tree.monster_items), 500)
|
||||
self.assertGreater(len(beats), 2)
|
||||
self.assertLess(max(b - a for a, b in zip(beats, beats[1:])), .25)
|
||||
finally:
|
||||
timer.stop()
|
||||
tree.row_batch.stop()
|
||||
tree.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -54,7 +54,7 @@ class ResponsivenessTests(unittest.TestCase):
|
||||
snapshot = demo_snapshot(window.catalog)
|
||||
template = snapshot.raw["monsters"][-1]
|
||||
snapshot.raw["monsters"] = [copy.deepcopy(template) | {"id": 1000 + i} for i in range(500)]
|
||||
with patch.object(window.monsters, "setCellWidget") as cells:
|
||||
with patch.object(window.monsters, "setItemWidget") as cells:
|
||||
window.engine.snapshot = snapshot
|
||||
window.render(snapshot, [])
|
||||
self.assertEqual(cells.call_count, 0)
|
||||
@@ -171,7 +171,7 @@ class ResponsivenessTests(unittest.TestCase):
|
||||
break
|
||||
self.assertFalse(any(w.busy for w in windows))
|
||||
self.assertEqual(windows[0].eggs.rowCount(), 200)
|
||||
self.assertEqual(windows[1].monsters.rowCount(), 0)
|
||||
self.assertEqual(len(windows[1].monsters.monster_items), 0)
|
||||
self.assertGreater(len(beats), 10)
|
||||
self.assertLess(max(b - a for a, b in zip(beats, beats[1:])), .25)
|
||||
self.assertTrue(any(e["operation"] == "刷新耗时" for e in windows[0].trace.events))
|
||||
|
||||
@@ -194,9 +194,9 @@ class ManualGuiTests(unittest.TestCase):
|
||||
self.assertEqual(window.eggs.item(row, 2).text(), "0")
|
||||
self.assertTrue(window.eggs.cellWidget(row, 3).isChecked())
|
||||
window.tabs.setCurrentWidget(window.monster_page)
|
||||
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == "900")
|
||||
window.monsters.cellWidget(row, 8).setChecked(True)
|
||||
window.monsters.cellWidget(row, 9).setValue(1)
|
||||
item = window.monsters.monster_items[900]
|
||||
window.monsters.itemWidget(item, 8).setChecked(True)
|
||||
window.monsters.itemWidget(item, 9).setValue(1)
|
||||
self.assertEqual(window.read_policy().feed_targets, {"900": 1})
|
||||
self.assertFalse(window.server.isVisible())
|
||||
window.save_config()
|
||||
@@ -276,8 +276,8 @@ class ManualGuiTests(unittest.TestCase):
|
||||
self.wait(window)
|
||||
def select(mid):
|
||||
window.tabs.setCurrentWidget(window.monster_page)
|
||||
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == str(mid))
|
||||
window.monsters.selectRow(row)
|
||||
window.monsters.clearSelection()
|
||||
window.monsters.setCurrentItem(window.monsters.monster_items[mid])
|
||||
select(101)
|
||||
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.No):
|
||||
window.request_monster_action("sell")
|
||||
|
||||
@@ -161,11 +161,12 @@ class V11GuiTests(unittest.TestCase):
|
||||
for _ in range(100):
|
||||
self.app.processEvents()
|
||||
QTest.qWait(2)
|
||||
target_row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == "900")
|
||||
window.monsters.cellWidget(target_row, 17).setChecked(True)
|
||||
target_item = window.monsters.monster_items[900]
|
||||
window.monsters.itemWidget(target_item, 17).setChecked(True)
|
||||
self.assertIn("900", window.read_policy().gift_targets)
|
||||
window.monster_view.setCurrentIndex(1)
|
||||
self.assertTrue(window.rooms_table.isHidden())
|
||||
self.assertFalse(window.monsters.rootIsDecorated())
|
||||
self.assertTrue(all(item.parent() is None for item in window.monsters.monster_items.values()))
|
||||
finally:
|
||||
window.close()
|
||||
|
||||
|
||||
Reference in New Issue
Block a user