185 lines
10 KiB
Python
185 lines
10 KiB
Python
from dataclasses import asdict
|
|
import copy
|
|
import json
|
|
import os
|
|
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.daily import DailyPolicy
|
|
from ranch_assistant.engine import demo_snapshot
|
|
from ranch_assistant.gui import Window
|
|
from ranch_assistant.model import Catalog, Policy
|
|
from ranch_assistant.policy_io import portable_config, import_config, portable_policy
|
|
from ranch_assistant.quests import QuestPolicy
|
|
from ranch_assistant.sweeping import SweepPolicy
|
|
from ranch_assistant.tests.test_core import workspace_temp
|
|
|
|
|
|
class UnifiedPolicyTests(unittest.TestCase):
|
|
def config(self):
|
|
return {"policy": asdict(Policy(buy=True, gift_enabled=True, feed_target=900, room_id=999999,
|
|
gift_targets={"900": 2}, breakthrough_targets={"900": 3}, gift_items={"30001": {"enabled": True, "reserve": 5}})),
|
|
"quest_policy": asdict(QuestPolicy(enabled=True, max_money=100, item_reserves={"30001": 6})),
|
|
"daily_policy": asdict(DailyPolicy(enabled=True, selected=["mail"])),
|
|
"sweep_policy": asdict(SweepPolicy(enabled=True, rules={"0101": {"enabled": True, "level": 3, "limit": 5}}, keep_stamina=22)),
|
|
"interval": 120, "overrides": {"1001010": {"sell_money": 151}}, "yield_stars": [1, 2],
|
|
"token": "secret-test-only", "account": "private-test-only", "log_sizes": [600, 200]}
|
|
|
|
def test_all_strategies_round_trip_and_targets_match_other_account(self):
|
|
snapshot = demo_snapshot(Catalog())
|
|
exported = portable_config(self.config(), snapshot)
|
|
text = json.dumps(exported)
|
|
for secret in ("secret-test-only", "private-test-only", "999999", '"900"', "log_sizes"):
|
|
self.assertNotIn(secret, text)
|
|
snapshot.monsters[900]["id"] = 999
|
|
config = import_config(exported, snapshot)
|
|
self.assertEqual(config["policy"]["feed_targets"], {"999": 1})
|
|
self.assertEqual(config["policy"]["gift_targets"], {"999": 2})
|
|
self.assertEqual(config["policy"]["breakthrough_targets"], {"999": 3})
|
|
self.assertEqual(config["policy"]["feed_target"], 0)
|
|
self.assertEqual(config["policy"]["room_id"], 0)
|
|
self.assertTrue(config["policy"]["gift_enabled"])
|
|
for key in ("quest_policy", "daily_policy", "sweep_policy", "interval", "overrides", "yield_stars"):
|
|
self.assertEqual(config[key], self.config()[key])
|
|
|
|
def test_old_files_import_without_replacing_other_strategy_sections(self):
|
|
config = import_config(portable_policy(Policy(protect_quality=6)))
|
|
self.assertEqual(list(config), ["policy"])
|
|
self.assertEqual(config["policy"]["protect_quality"], 6)
|
|
self.assertFalse(config["policy"]["enabled"])
|
|
|
|
def test_explore_round_trip_rebinds_team_order_and_species_without_instance_ids(self):
|
|
snapshot = demo_snapshot(Catalog())
|
|
snapshot.raw["exploreTeams"] = [{"id": 800, "status": 0}, {"id": 700, "status": 0}]
|
|
snapshot.monsters[900].update(id=900, typeId=1001010)
|
|
snapshot.monsters[101].update(id=101, typeId=1001010, process=3)
|
|
snapshot.monsters[102].update(id=102, typeId=1001010, process=3)
|
|
config = self.config() | {"explore_policy": {"enabled": True, "reserve_ti": 21,
|
|
"teams": {"800": {"enabled": True, "area": "1", "monsters": [900, 101, 102]}}}}
|
|
exported = portable_config(config, snapshot)
|
|
text = json.dumps(exported)
|
|
self.assertNotIn('"800"', text)
|
|
self.assertNotIn('"900"', text)
|
|
snapshot.raw["exploreTeams"] = [{"id": 90, "status": 0}, {"id": 80, "status": 0}]
|
|
for mon in snapshot.raw["monsters"]:
|
|
mon["process"] = 2
|
|
for index, mid in enumerate((901, 902, 903), 1):
|
|
mon = copy.deepcopy(snapshot.monsters[900])
|
|
mon.update(id=mid, process=3)
|
|
snapshot.raw["monsters"].append(mon)
|
|
snapshot.monsters[mid] = mon
|
|
imported = import_config(exported, snapshot)
|
|
self.assertEqual(imported["explore_policy"]["teams"]["80"]["monsters"], [901, 902, 903])
|
|
self.assertFalse(imported["explore_policy"]["enabled"])
|
|
self.assertNotIn("800", imported["explore_policy"]["teams"])
|
|
|
|
def test_invalid_bundle_rejected_before_applying(self):
|
|
exported = portable_config(self.config())
|
|
for value in (exported | {"schema": 100}, exported | {"interval": 0},
|
|
exported | {"daily_policy": []}, exported | {"yield_stars": [None]},
|
|
exported | {"policy": exported["policy"] | {"target_level": "bad"}},
|
|
exported | {"sweep_policy": exported["sweep_policy"] | {"rules": {"0101": None}}}):
|
|
with self.assertRaises((ValueError, TypeError)):
|
|
import_config(value)
|
|
|
|
|
|
class StrategyGuiTests(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("Offline task did not finish")
|
|
|
|
def test_separate_pages_and_unified_import_apply_without_starting_execution(self):
|
|
with workspace_temp() as folder:
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
self.assertEqual([window.automation_tabs.tabText(i) for i in range(3)],
|
|
["孵蛋策略", "牧场策略", "喂养策略"])
|
|
self.assertEqual(window.tabs.tabText(window.tabs.indexOf(window.gift_page)), "自动赠礼")
|
|
self.assertTrue(window.gift_page.isAncestorOf(window.gift_enabled))
|
|
self.assertTrue(window.feed_scroll.isAncestorOf(window.feed))
|
|
self.assertFalse(hasattr(window, "target"))
|
|
self.assertFalse(hasattr(window, "target_level"))
|
|
value = portable_config(UnifiedPolicyTests().config(), window.engine.snapshot)
|
|
path = folder / "portable.json"
|
|
path.write_text(json.dumps(value), encoding="utf-8")
|
|
with patch("ranch_assistant.gui.W.QFileDialog.getOpenFileName", return_value=(str(path), "")):
|
|
window.import_policies()
|
|
self.assertFalse(window.strategy_toggle.isChecked())
|
|
self.assertFalse(window.engine.auto)
|
|
self.assertTrue(window.engine.policy.gift_enabled)
|
|
self.assertEqual(window.engine.quest_policy.max_money, 100)
|
|
self.assertEqual(window.engine.sweep_policy.keep_stamina, 22)
|
|
self.assertEqual(window.engine.daily_policy.selected, ["mail"])
|
|
self.assertEqual(window.interval.currentData(), 120)
|
|
self.assertLess(window.tabs.indexOf(window.map_page), window.tabs.indexOf(window.analysis_page))
|
|
self.assertEqual(window.tabs.indexOf(window.analysis_page) - window.tabs.indexOf(window.map_page), 1)
|
|
window.quest_money.setValue(42)
|
|
window.gift_liked_only.setChecked(False)
|
|
QTest.qWait(400)
|
|
self.assertEqual(window.engine.quest_policy.max_money, 42)
|
|
self.assertFalse(window.engine.policy.gift_liked_only)
|
|
window.monster_breakthrough_changed("900", True, 6)
|
|
window._exploration_policy = window.read_explore_policy()
|
|
window._exploration_policy.enabled = True
|
|
window._exploration_policy.reserve_ti = 9
|
|
window._save_exploration_policy()
|
|
QTest.qWait(400)
|
|
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
|
|
self.assertEqual(saved["policy"]["breakthrough_targets"], {"900": 6})
|
|
self.assertTrue(saved["explore_policy"]["enabled"])
|
|
self.assertEqual(saved["explore_policy"]["reserve_ti"], 9)
|
|
with patch("ranch_assistant.gui.W.QFileDialog.getSaveFileName", return_value=(str(path), "")):
|
|
window.export_policies()
|
|
exported = json.loads(path.read_text(encoding="utf-8"))
|
|
self.assertEqual(import_config(exported, window.engine.snapshot)["quest_policy"]["max_money"], 42)
|
|
self.assertFalse(any("保存规则" in b.text() for b in window.findChildren(W.QPushButton)))
|
|
finally:
|
|
window.close()
|
|
|
|
def test_legacy_feeding_target_migrates_and_unchecking_removes_it(self):
|
|
with workspace_temp() as folder:
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
window.load_config({"policy": asdict(Policy(feed_target=900, target_level=10))})
|
|
self.assertEqual(window.read_policy().feed_targets, {"900": 1})
|
|
self.assertEqual(window.read_policy().feed_target, 0)
|
|
window.monster_feed_changed("900", False, 1)
|
|
self.assertEqual(window.read_policy().feed_targets, {})
|
|
self.assertFalse(window.engine.planner.feed_status(window.engine.snapshot, window.read_policy())[0])
|
|
window.save_config()
|
|
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
|
|
self.assertEqual(saved["policy"]["feed_targets"], {})
|
|
self.assertEqual(saved["policy"]["feed_target"], 0)
|
|
finally:
|
|
window.close()
|
|
|
|
def test_gift_only_workflow_does_not_require_hatch_rules(self):
|
|
with workspace_temp() as folder:
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
window.ranch_enabled.setChecked(False)
|
|
window.gift_enabled.setChecked(True)
|
|
with patch.object(window, "refresh"):
|
|
window.start_workflow()
|
|
self.assertTrue(window.strategy_toggle.isChecked())
|
|
finally:
|
|
window.close()
|