320 lines
17 KiB
Python
320 lines
17 KiB
Python
import copy
|
|
from dataclasses import asdict, replace
|
|
import os
|
|
import unittest
|
|
from unittest.mock import Mock, 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.management import expansion_quote, manual_monster_actions
|
|
from ranch_assistant.model import Catalog, EggRule, Planner, Policy, Snapshot
|
|
from ranch_assistant import gui
|
|
from ranch_assistant.tests.test_core import workspace_temp
|
|
|
|
|
|
class ManualRuleTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.catalog = Catalog()
|
|
self.snapshot = demo_snapshot(self.catalog)
|
|
self.planner = Planner(self.catalog)
|
|
|
|
def rule(self, **values):
|
|
return asdict(EggRule(enabled=True, **values))
|
|
|
|
def test_only_checked_eggs_hatch_in_manual_priority_order(self):
|
|
slow = next(k for k, row in self.catalog.monsters.items() if row.get("star") == 1 and self.catalog.total_time(k) > 600)
|
|
self.snapshot.raw["stacks"] = [{"id": 1, "position": 0, "monsterId": -1}]
|
|
self.snapshot.raw["monsters"] = []
|
|
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 2}, {"id": 502, "typeId": int(slow), "num": 2}]
|
|
policy = Policy(manual_eggs=True, egg_rules={"1001010": self.rule(priority=20), slow: self.rule(priority=1)})
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["eggs"][0]["itemId"], 502)
|
|
policy.egg_rules[slow]["enabled"] = False
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["eggs"][0]["itemId"], 501)
|
|
policy.egg_rules["1001010"]["enabled"] = False
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
|
|
|
|
def test_manual_disposition_overrides_legacy_strategy_and_feed_priority_skips_caps(self):
|
|
food = self.snapshot.raw["monsters"][0]
|
|
food.update(process=3, roomId=1)
|
|
self.planner.managed.add(food["id"])
|
|
primary = self.snapshot.monsters[900]
|
|
primary.update(potentialLevel=2, level=20)
|
|
secondary = dict(primary, id=901, level=9, potentialLevel=1)
|
|
self.snapshot.raw["monsters"].append(secondary)
|
|
policy = Policy(manual_eggs=True, strategy="gold", fill=False, protect_star=6, protect_quality=5,
|
|
egg_rules={str(food["typeId"]): self.rule(action="feed", keep_count=0)}, feed_targets={"900": 1, "901": 2})
|
|
action = self.planner.plan(self.snapshot, policy)[0]
|
|
self.assertEqual(action.kind, "feed")
|
|
self.assertEqual(action.payload["targetId"], 901)
|
|
self.assertTrue(self.planner.protected(secondary, self.snapshot, policy))
|
|
secondary["level"] = 10
|
|
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(self.snapshot, policy)))
|
|
policy.egg_rules[str(food["typeId"])]["action"] = "sell"
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].kind, "sell")
|
|
|
|
def test_restock_tracks_selected_type_and_market_pool_and_continues_to_target(self):
|
|
self.snapshot.raw["stacks"] = []
|
|
self.snapshot.raw["monsters"] = []
|
|
self.snapshot.raw["items"] = [{"id": 502, "typeId": 1002010, "num": 100}]
|
|
policy = Policy(manual_eggs=True, buy=True, fill=False, buy_ten=False, allow_single_draw=True, buy_batch=2,
|
|
egg_rules={"1001010": self.rule(refill_below=1, refill_target=5, market_id="sc_city1")})
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["num"], 2)
|
|
self.snapshot.raw["items"].append({"id": 501, "typeId": 1001010, "num": 2})
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["num"], 2)
|
|
self.snapshot.raw["items"][-1]["num"] = 5
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
|
|
self.snapshot.raw["items"][-1]["num"] = 0
|
|
policy.egg_rules["1001010"]["market_id"] = "sc_city2"
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
|
|
self.assertTrue(any("蛋池不包含" in note for note in self.planner.notes))
|
|
policy.egg_rules["1001010"]["market_id"] = "sc_city1"
|
|
policy.egg_rules["1001010"]["refill_below"] = 0
|
|
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
|
|
|
|
def test_reference_stats_and_gift_preferences_have_shipped_data(self):
|
|
mon = {"typeId": 1001010, "level": 1, "feel": 0, "gAtk": 4.9, "gDef": 4.9, "gHp": 67, "gDex": 1.9}
|
|
self.assertEqual(self.catalog.reference_stats(mon), [28, 24, 335, 6])
|
|
mon["feel"] = 100
|
|
self.assertEqual(self.catalog.reference_stats(mon)[2], 351)
|
|
self.assertIn("(+5)", self.catalog.likes_text(1001010))
|
|
self.assertNotEqual(self.catalog.likes_text(1001010), "无已知偏好")
|
|
with self.assertRaises(ValueError):
|
|
Policy(egg_rules={"1001010": {"refill_below": 5, "refill_target": 2}})
|
|
|
|
def test_quota_and_breakthrough_targets_validate_instead_of_silently_dropping_bad_values(self):
|
|
self.assertEqual(EggRule().keep_count, 1)
|
|
self.assertEqual(EggRule(keep_count="2").keep_count, 2)
|
|
for value in (True, 1.0, 1.5, "1.0", " 1", "+1", -1, 1001, None):
|
|
with self.subTest(keep_count=value), self.assertRaises(ValueError):
|
|
EggRule(keep_count=value)
|
|
self.assertEqual(Policy(breakthrough_targets={"900": 2}).breakthrough_targets, {"900": 2})
|
|
self.assertTrue(self.planner.protected(self.snapshot.monsters[900], self.snapshot,
|
|
Policy(protect_star=6, protect_quality=6, breakthrough_targets={"900": 2})))
|
|
for targets in ([], {"0": 1}, {"900": 0}, {"900": 1000}, {"900": True}, {"900": 1.5}, {"x": 1}):
|
|
with self.subTest(targets=targets), self.assertRaises(ValueError):
|
|
Policy(breakthrough_targets=targets)
|
|
|
|
|
|
class ManagementTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.catalog = Catalog()
|
|
self.snapshot = demo_snapshot(self.catalog)
|
|
|
|
def test_prices_use_open_types_not_stale_history_and_reject_vip_level_and_funds(self):
|
|
self.snapshot.raw["stacks"][0]["openType"] = 1
|
|
quote = expansion_quote(self.catalog, self.snapshot, "stack", "money", 6)
|
|
self.assertEqual((quote.cost, quote.index, quote.level), (2500, 1, 10))
|
|
self.assertEqual(quote.payload, {"openType": 1, "position": 6})
|
|
self.assertEqual(expansion_quote(self.catalog, self.snapshot, "room", "ke").cost, 150)
|
|
with self.assertRaisesRegex(ValueError, "VIP"):
|
|
expansion_quote(self.catalog, self.snapshot, "stack", "ke", 3)
|
|
self.snapshot.raw["master"]["ke"] = 0
|
|
with self.assertRaisesRegex(ValueError, "不足"):
|
|
expansion_quote(self.catalog, self.snapshot, "stack", "ke", 6)
|
|
self.snapshot.raw["master"]["level"] = 1
|
|
with self.assertRaisesRegex(ValueError, "级"):
|
|
expansion_quote(self.catalog, self.snapshot, "stack", "money", 6)
|
|
|
|
def test_changed_quote_cannot_charge_without_new_confirmation(self):
|
|
quote = expansion_quote(self.catalog, self.snapshot, "stack", "money", 6)
|
|
raw = copy.deepcopy(self.snapshot.raw)
|
|
raw["stacks"].append({"id": 99, "position": 7, "monsterId": -1, "openType": 1})
|
|
client = Mock()
|
|
client.snapshot.return_value = Snapshot(raw)
|
|
engine = Engine(self.catalog, client)
|
|
with self.assertRaisesRegex(ValueError, "已变化"):
|
|
engine.expand(quote)
|
|
client.call.assert_not_called()
|
|
|
|
def test_room_unlock_is_derived_from_completed_task(self):
|
|
self.snapshot.raw["history"].pop("openFarmBuild")
|
|
self.snapshot.raw["history"]["passTask"] = {"1001011": True}
|
|
self.assertEqual(expansion_quote(self.catalog, self.snapshot, "room", "money").cost, 1500)
|
|
self.snapshot.raw["history"]["passTask"] = {}
|
|
with self.assertRaisesRegex(ValueError, "解锁"):
|
|
expansion_quote(self.catalog, self.snapshot, "room", "money")
|
|
|
|
def test_real_api_payloads_add_stack_and_room_then_read_back(self):
|
|
state, calls = copy.deepcopy(self.snapshot.raw), []
|
|
class LocalClient:
|
|
def snapshot(self):
|
|
return Snapshot(copy.deepcopy(state))
|
|
def call(self, path, payload):
|
|
calls.append((path, payload))
|
|
if path == "stackService/stackOpen":
|
|
state["master"]["ke"] -= 110
|
|
state["stacks"].append({"id": 99, "position": payload["position"], "monsterId": -1, "openType": payload["openType"]})
|
|
elif path == "roomService/roomCreateByMoney":
|
|
state["master"]["money"] -= 1500
|
|
state["rooms"].append({"id": 99, "typeId": 1000, "openType": 1})
|
|
return {"resCode": 0}
|
|
engine = Engine(self.catalog, LocalClient())
|
|
engine.snapshot = self.snapshot
|
|
snapshot, _, _ = engine.expand(expansion_quote(self.catalog, self.snapshot, "stack", "ke", 6))
|
|
self.assertEqual(len(snapshot.raw["stacks"]), 7)
|
|
self.assertEqual(snapshot.raw["master"]["ke"], 1890)
|
|
snapshot, _, _ = engine.expand(expansion_quote(self.catalog, snapshot, "room", "money"))
|
|
self.assertEqual(len(snapshot.raw["rooms"]), 2)
|
|
self.assertEqual(calls, [("stackService/stackOpen", {"openType": 2, "position": 6}), ("roomService/roomCreateByMoney", {})])
|
|
|
|
def test_manual_dispatch_payloads_and_feed_guards(self):
|
|
self.snapshot.monsters[102]["process"] = 3
|
|
actions = manual_monster_actions(self.catalog, self.snapshot, "sell", [101, 102])
|
|
self.assertEqual([a.payload for a in actions], [{"monsterIds": [101, 102]}])
|
|
action = manual_monster_actions(self.catalog, self.snapshot, "feed", [102], 900)[0]
|
|
self.assertEqual(action.payload, {"targetId": 900, "foods": [102]})
|
|
self.snapshot.monsters[900].update(level=20, potentialLevel=2)
|
|
with self.assertRaisesRegex(ValueError, "上限"):
|
|
manual_monster_actions(self.catalog, self.snapshot, "feed", [102], 900)
|
|
self.snapshot.monsters[101]["lock"] = 1
|
|
with self.assertRaisesRegex(ValueError, "锁定"):
|
|
manual_monster_actions(self.catalog, self.snapshot, "sell", [101])
|
|
|
|
|
|
class ManualGuiTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.app = W.QApplication.instance() or W.QApplication([])
|
|
|
|
def wait(self, window):
|
|
for _ in range(250):
|
|
self.app.processEvents()
|
|
QTest.qWait(5)
|
|
if not window.busy and window.slots.rowCount():
|
|
return
|
|
self.fail("Qt request did not complete")
|
|
|
|
def test_edit_rule_sort_zero_stock_and_restore_feed_targets(self):
|
|
with workspace_temp() as folder:
|
|
window = gui.Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
self.assertEqual(window.tabs.tabText(0), "登录")
|
|
window.tabs.setCurrentWidget(window.egg_page)
|
|
key = window.eggs.item(0, 0).data(C.Qt.ItemDataRole.UserRole)
|
|
window.eggs.cellWidget(0, 3).setChecked(True)
|
|
window.eggs.cellWidget(0, 4).setValue(1)
|
|
action = window.eggs.cellWidget(0, 5)
|
|
action.setCurrentIndex(action.findData("feed"))
|
|
self.assertEqual(window.read_policy().egg_rules[key]["action"], "feed")
|
|
self.assertEqual(window.read_policy().egg_rules[key]["priority"], 1)
|
|
window.engine.snapshot.raw["items"] = [i for i in window.engine.snapshot.raw["items"] if str(i["typeId"]) != key]
|
|
window.render(window.engine.snapshot, [])
|
|
row = next(i for i in range(window.eggs.rowCount()) if window.eggs.item(i, 0).data(C.Qt.ItemDataRole.UserRole) == key)
|
|
self.assertEqual(window.eggs.item(row, 2).text(), "0")
|
|
self.assertTrue(window.eggs.cellWidget(row, 3).isChecked())
|
|
window.tabs.setCurrentWidget(window.monster_page)
|
|
self.wait(window)
|
|
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()
|
|
finally:
|
|
window.close()
|
|
restored = gui.Window(folder)
|
|
restored.timer.stop()
|
|
try:
|
|
self.wait(restored)
|
|
self.assertTrue(restored.egg_rules[key]["enabled"])
|
|
self.assertEqual(restored.egg_rules[key]["action"], "feed")
|
|
self.assertEqual(restored.feed_targets, {"900": 1})
|
|
self.assertFalse(restored.strategy_toggle.isChecked())
|
|
finally:
|
|
restored.close()
|
|
|
|
def test_log_can_grow_hide_keep_records_and_restore_visibility(self):
|
|
with workspace_temp() as folder:
|
|
window = gui.Window(folder)
|
|
window.timer.stop()
|
|
window.show()
|
|
try:
|
|
self.wait(window)
|
|
window.log_splitter.setSizes([200, 300])
|
|
self.app.processEvents()
|
|
self.assertGreater(window.log.height(), 140)
|
|
window.show_log.click()
|
|
self.assertTrue(window.log.isHidden())
|
|
window.report("hidden-log-record")
|
|
self.assertIn("hidden-log-record", window.log.toPlainText())
|
|
saved_sizes = list(window.log_sizes)
|
|
window.show_log.click()
|
|
self.app.processEvents()
|
|
self.assertFalse(window.log.isHidden())
|
|
self.assertGreater(window.log.height(), 140)
|
|
self.assertEqual(window.log_sizes, saved_sizes)
|
|
window.show_log.click()
|
|
window.save_config()
|
|
finally:
|
|
window.close()
|
|
restored = gui.Window(folder)
|
|
restored.timer.stop()
|
|
try:
|
|
self.wait(restored)
|
|
self.assertFalse(restored.show_log.isChecked())
|
|
self.assertTrue(restored.log.isHidden())
|
|
self.assertEqual(restored.log_sizes, saved_sizes)
|
|
finally:
|
|
restored.close()
|
|
|
|
def test_paid_expansion_requires_confirmation_and_cancel_sends_nothing(self):
|
|
with workspace_temp() as folder:
|
|
window = gui.Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.No) as confirm, patch.object(window.engine, "expand") as expand:
|
|
window.request_expansion("stack", "ke")
|
|
expand.assert_not_called()
|
|
self.assertIn("110 氪金", confirm.call_args.args[2])
|
|
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
|
|
window.request_expansion("stack", "ke")
|
|
self.wait(window)
|
|
self.assertEqual(len(window.engine.snapshot.raw["stacks"]), 7)
|
|
window.request_expansion("room", "money")
|
|
self.wait(window)
|
|
self.assertEqual(len(window.engine.snapshot.raw["rooms"]), 2)
|
|
self.assertEqual(window.slots.rowCount(), 11)
|
|
finally:
|
|
window.close()
|
|
|
|
def test_manual_dispatch_and_feed_preview_are_user_confirmed(self):
|
|
with workspace_temp() as folder:
|
|
window = gui.Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
self.wait(window)
|
|
def select(mid):
|
|
window.tabs.setCurrentWidget(window.monster_page)
|
|
self.wait(window)
|
|
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")
|
|
self.assertIn(101, window.engine.snapshot.monsters)
|
|
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
|
|
window.request_monster_action("sell")
|
|
self.wait(window)
|
|
self.assertNotIn(101, window.engine.snapshot.monsters)
|
|
window.engine.snapshot.monsters[102].update(process=3, roomId=1)
|
|
window.render(window.engine.snapshot, [])
|
|
select(102)
|
|
target = window.engine.snapshot.monsters[900]
|
|
label = f"{window.catalog.monster(target['typeId']).get('name')} Lv.20/70 #900"
|
|
with patch.object(gui.W.QInputDialog, "getItem", return_value=(label, True)), patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
|
|
window.request_monster_action("feed")
|
|
self.wait(window)
|
|
self.assertNotIn(102, window.engine.snapshot.monsters)
|
|
self.assertGreater(window.engine.snapshot.monsters[900]["exp"], 0)
|
|
finally:
|
|
window.close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|