227 lines
12 KiB
Python
227 lines
12 KiB
Python
import copy
|
|
from dataclasses import asdict
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
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 Engine, demo_snapshot
|
|
from ranch_assistant.api import Session
|
|
from ranch_assistant.gifts import GiftPlanner
|
|
from ranch_assistant.gui import Window
|
|
from ranch_assistant.model import Action, Catalog, Policy
|
|
from ranch_assistant.policy_io import import_policy, portable_policy
|
|
from ranch_assistant.quests import QuestPolicy
|
|
from ranch_assistant.sessions import SessionStore
|
|
from ranch_assistant.tests.test_core import workspace_temp
|
|
|
|
|
|
class GiftTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.catalog = Catalog()
|
|
self.snapshot = demo_snapshot(self.catalog)
|
|
self.target = self.snapshot.monsters[900]
|
|
self.target.update(feel=0, entangleLevel=0, giftTime=0)
|
|
self.liked = next(key for key, value in self.catalog.monster(self.target["typeId"])["like"].items() if value > 0)
|
|
self.disliked = next(key for key, value in self.catalog.monster(self.target["typeId"])["like"].items() if value < 0)
|
|
self.snapshot.raw["items"] += [{"id": 2000, "typeId": int(self.liked), "num": 3},
|
|
{"id": 2001, "typeId": int(self.disliked), "num": 30}]
|
|
self.policy = Policy(gift_enabled=True, gift_targets={"900": 1},
|
|
gift_items={self.liked: {"enabled": True, "reserve": 2}, self.disliked: {"enabled": True, "reserve": 0}})
|
|
self.planner = GiftPlanner(self.catalog)
|
|
|
|
def test_defaults_never_consume_items(self):
|
|
self.assertEqual(self.planner.plan(self.snapshot, Policy()), [])
|
|
self.policy.gift_items[self.liked]["enabled"] = False
|
|
self.policy.gift_items[self.disliked]["enabled"] = False
|
|
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
|
|
|
def test_liked_item_respects_reserve_cap_and_cooldown(self):
|
|
action = self.planner.plan(self.snapshot, self.policy)[0]
|
|
self.assertEqual(action.payload, {"monsterId": 900, "itemId": 2000})
|
|
self.snapshot.raw["items"][-2]["num"] = 2
|
|
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
|
self.snapshot.raw["items"][-2]["num"] = 3
|
|
self.target["giftTime"] = int(self.snapshot.now * 1000)
|
|
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
|
self.target.update(feel=100, entangleLevel=0)
|
|
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
|
self.target.update(entangleLevel=1)
|
|
self.target["giftTime"] = 0
|
|
self.assertTrue(self.planner.plan(self.snapshot, self.policy))
|
|
|
|
def test_optional_neutral_or_disliked_requires_disabling_preference_guard(self):
|
|
self.policy.gift_items[self.liked]["enabled"] = False
|
|
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
|
self.policy.gift_liked_only = False
|
|
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["itemId"], 2001)
|
|
|
|
def test_quest_reserves_take_precedence(self):
|
|
self.assertEqual(self.planner.plan(self.snapshot, self.policy, QuestPolicy(item_reserves={self.liked: 3})), [])
|
|
|
|
def test_cooling_manual_target_does_not_block_other_selected_targets(self):
|
|
other = copy.deepcopy(self.target)
|
|
other["id"] = 901
|
|
self.snapshot.raw["monsters"].append(other)
|
|
self.policy.gift_targets["901"] = 2
|
|
self.target["giftTime"] = self.snapshot.now * 1000
|
|
plans = self.planner.plan(self.snapshot, self.policy)
|
|
self.assertTrue(plans, "A cooling first target blocked another ready target")
|
|
self.assertEqual(plans[0].payload["monsterId"], 901)
|
|
|
|
def test_demo_consumes_one_item_and_clamps_feel(self):
|
|
engine = Engine(self.catalog)
|
|
engine.snapshot = self.snapshot
|
|
action = self.planner.plan(self.snapshot, self.policy)[0]
|
|
engine.apply_demo(action)
|
|
self.assertEqual(self.snapshot.raw["items"][-2]["num"], 2)
|
|
self.assertEqual(self.target["feel"], int(self.catalog.monster(self.target["typeId"])["like"][self.liked]))
|
|
self.assertGreater(self.target["giftTime"], 0)
|
|
|
|
|
|
class PolicyFileTests(unittest.TestCase):
|
|
def test_export_has_no_instance_ids_or_credentials_and_import_matches_species(self):
|
|
snapshot = demo_snapshot(Catalog())
|
|
snapshot.monsters[900]["feel"] = 0
|
|
policy = Policy(feed_targets={"900": 2}, gift_targets={"900": 3},
|
|
gift_items={"30001": {"enabled": True, "reserve": 4}})
|
|
exported = portable_policy(policy, snapshot)
|
|
text = json.dumps(exported)
|
|
self.assertNotIn("900", text)
|
|
self.assertNotIn("token", text.lower())
|
|
imported = import_policy(exported, snapshot)
|
|
self.assertFalse(imported.enabled)
|
|
self.assertFalse(imported.gift_enabled)
|
|
self.assertEqual(imported.feed_targets, {"900": 2})
|
|
self.assertEqual(imported.gift_targets, {"900": 3})
|
|
self.assertEqual(imported.gift_items["30001"]["reserve"], 4)
|
|
with self.assertRaises(ValueError):
|
|
import_policy({"policy": {}})
|
|
|
|
|
|
class V11GuiTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.app = W.QApplication.instance() or W.QApplication([])
|
|
|
|
def wait(self, window):
|
|
for _ in range(400):
|
|
self.app.processEvents()
|
|
QTest.qWait(3)
|
|
if not window.busy:
|
|
return
|
|
self.fail("Offline job did not finish")
|
|
|
|
def test_layout_inventory_gifts_and_master_exp(self):
|
|
with workspace_temp() as folder:
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
labels = [window.tabs.tabText(i) for i in range(window.tabs.count())]
|
|
self.assertLess(labels.index("背包"), labels.index("牧场"))
|
|
self.assertLess(labels.index("牧场"), labels.index("自动孵蛋"))
|
|
self.assertNotIn("魔物", labels)
|
|
self.assertNotIn("牧场策略", labels)
|
|
self.assertIn("Lv.62", window.summary.text())
|
|
self.assertIn("经验", window.summary.text())
|
|
self.assertNotIn("真实", window.data_summary.text())
|
|
self.assertIn("退出登录并清除登录记录", window.log.toPlainText() + " ".join(b.text() for b in window.tabs.widget(0).findChildren(W.QPushButton)))
|
|
self.assertEqual([window.inventory_tabs.tabText(i) for i in range(window.inventory_tabs.count())],
|
|
["魔物蛋", "可使用", "消耗品", "材料", "其他", "装备"])
|
|
for category in window.inventory_tables:
|
|
key = next(key for key in window.catalog.data["item_info"] if window.catalog.item_type(key) == category)
|
|
window.engine.snapshot.raw["items"].append({"id": 4000 + category, "typeId": int(key), "num": 2})
|
|
self.assertTrue(all(table.rowCount() == 0 for table in window.inventory_tables.values()))
|
|
window.tabs.setCurrentWidget(window.inventory_tabs)
|
|
for index, (category, inventory) in enumerate(window.inventory_tables.items(), 1):
|
|
window.inventory_tabs.setCurrentIndex(index)
|
|
while inventory.row_batch.running:
|
|
QTest.qWait(2)
|
|
self.assertGreater(inventory.rowCount(), 0)
|
|
for row in range(inventory.rowCount()):
|
|
key = inventory.item(row, 0).data(C.Qt.ItemDataRole.UserRole)
|
|
self.assertEqual(window.catalog.item_type(key), category)
|
|
key = str(window.catalog.monster(window.engine.snapshot.monsters[900]["typeId"])["like"].keys().__iter__().__next__())
|
|
window.engine.snapshot.raw["items"].append({"id": 3000, "typeId": int(key), "num": 3})
|
|
category = window.catalog.item_type(key)
|
|
inventory = window.inventory_tables[category]
|
|
window.inventory_tabs.setCurrentIndex(list(window.inventory_tables).index(category) + 1)
|
|
while inventory.row_batch.running:
|
|
QTest.qWait(2)
|
|
row = next(i for i in range(inventory.rowCount()) if inventory.item(i, 0).data(C.Qt.ItemDataRole.UserRole) == key)
|
|
inventory.cellWidget(row, 6).setChecked(True)
|
|
self.assertTrue(window.read_policy().gift_items[key]["enabled"])
|
|
search = window.inventory_tabs.currentWidget().findChild(W.QLineEdit)
|
|
search.setText("no-such-inventory-item")
|
|
while inventory.row_batch.running:
|
|
QTest.qWait(2)
|
|
self.assertEqual(inventory.rowCount(), 0)
|
|
search.clear()
|
|
while inventory.row_batch.running:
|
|
QTest.qWait(2)
|
|
row = next(i for i in range(inventory.rowCount()) if inventory.item(i, 0).data(C.Qt.ItemDataRole.UserRole) == key)
|
|
self.assertTrue(inventory.cellWidget(row, 6).isChecked())
|
|
window.tabs.setCurrentWidget(window.room_page)
|
|
for _ in range(100):
|
|
self.app.processEvents()
|
|
QTest.qWait(2)
|
|
target_item = window.monsters.monster_items[900]
|
|
window.monsters.itemWidget(target_item, 19).setChecked(True)
|
|
self.assertIn("900", window.read_policy().gift_targets)
|
|
window.monster_view.setCurrentIndex(1)
|
|
self.assertFalse(window.monsters.rootIsDecorated())
|
|
self.assertTrue(all(item.parent() is None for item in window.monsters.monster_items.values()))
|
|
finally:
|
|
window.close()
|
|
|
|
def test_logout_keeps_records_and_clear_only_removes_current_profile(self):
|
|
with workspace_temp() as folder, workspace_temp() as other:
|
|
for root in (folder, other):
|
|
path = Path(root)
|
|
SessionStore(path).save(Session(server_url="https://example.invalid/", token="local-test", role_id=1), "本地测试")
|
|
(path / "roles" / "role").mkdir(parents=True)
|
|
(path / "roles" / "role" / "settings.json").write_text("{}", encoding="utf-8")
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
window.demo()
|
|
self.wait(window)
|
|
self.assertEqual(len(list((Path(folder) / "sessions").glob("*.json"))), 1)
|
|
self.assertTrue((Path(folder) / "roles" / "role" / "settings.json").exists())
|
|
with patch("ranch_assistant.gui.W.QMessageBox.question", return_value=W.QMessageBox.StandardButton.Yes):
|
|
window.logout_and_clear()
|
|
self.assertEqual(list((Path(folder) / "sessions").glob("*.json")), [])
|
|
self.assertTrue((Path(folder) / "roles" / "role" / "settings.json").exists())
|
|
self.assertEqual(len(list((Path(other) / "sessions").glob("*.json"))), 1)
|
|
self.assertEqual(window.account.text(), "")
|
|
self.assertEqual(window.password.text(), "")
|
|
finally:
|
|
window.close()
|
|
|
|
def test_policy_import_keeps_auto_execution_stopped(self):
|
|
with workspace_temp() as folder:
|
|
window = Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
policy = Policy(gift_enabled=True)
|
|
path = Path(folder) / "import.json"
|
|
path.write_text(json.dumps(portable_policy(policy, window.engine.snapshot)), 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.read_policy().gift_enabled)
|
|
finally:
|
|
window.close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|