230 lines
11 KiB
Python
230 lines
11 KiB
Python
import copy
|
|
import os
|
|
from dataclasses import asdict
|
|
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 import gui
|
|
from ranch_assistant.tests.test_core import workspace_temp
|
|
|
|
from ranch_assistant.engine import Engine, demo_snapshot
|
|
from ranch_assistant.model import Catalog, EggRule, Planner, Policy, Snapshot
|
|
|
|
|
|
NOW = 1800000000
|
|
|
|
|
|
class GrowthClient:
|
|
def __init__(self, catalog, age=310, grade="C"):
|
|
self.catalog, self.calls = catalog, []
|
|
self.raw = copy.deepcopy(demo_snapshot(catalog).raw)
|
|
self.raw["stacks"] = [{"id": 1, "position": 0, "monsterId": 501}]
|
|
self.raw["monsters"] = [{"id": 501, "typeId": 1001010, "process": 2, "mode": 0,
|
|
"timeStart": (NOW - age) * 1000, "level": 1, "gAtk": 0, "gDef": 0, "gHp": 0, "gDex": 0}]
|
|
self.raw["items"] = []
|
|
self.stage = 1 if age < 600 else 2
|
|
self.grade = grade
|
|
self.empty_growth_response = False
|
|
|
|
def snapshot(self):
|
|
self.calls.append(("read", {}))
|
|
# This deliberately remains stale after growth settlement. The client
|
|
# code applies datas + stackMonsterInfos from the growth response.
|
|
return Snapshot(copy.deepcopy(self.raw))
|
|
|
|
def persist_session(self):
|
|
pass
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
def settle_growth(self):
|
|
self.calls.append(("growth", {}))
|
|
if self.empty_growth_response:
|
|
return {"resCode": 0, "datas": [], "stackMonsterInfos": None}
|
|
infos = None
|
|
if self.stage == 2:
|
|
row = self.catalog.monster(1001010)
|
|
infos = [{"monsterId": 501} | {"g" + stat.capitalize(): row[stat + ("_grow_max" if self.grade == "S" else "_grow_min")]
|
|
for stat in ("atk", "def", "hp", "dex")}]
|
|
return {"resCode": 0, "datas": [{"monsterId": 501, "mode": self.stage}], "stackMonsterInfos": infos, "allExp": 0}
|
|
|
|
def call(self, path, payload):
|
|
self.calls.append((path, payload))
|
|
if path == "monsterService/monsterSell":
|
|
self.raw["monsters"] = []
|
|
self.raw["stacks"][0]["monsterId"] = -1
|
|
return {"resCode": 0}
|
|
|
|
|
|
class GrowthTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.catalog = Catalog()
|
|
self.clock = patch("ranch_assistant.model.time.time", return_value=NOW)
|
|
self.now = self.clock.start()
|
|
self.addCleanup(self.clock.stop)
|
|
|
|
def engine(self, client):
|
|
engine = Engine(self.catalog, client)
|
|
engine.policy = Policy(manual_eggs=True, fill=False, buy=False, collect=False, protect_star=4, protect_quality=3,
|
|
egg_rules={"1001010": asdict(EggRule(enabled=True, action="sell", keep_count=0))})
|
|
engine.auto = True
|
|
return engine
|
|
|
|
def test_unhatched_zero_growth_is_unknown_not_four_c(self):
|
|
mon = GrowthClient(self.catalog).raw["monsters"][0]
|
|
self.assertEqual(self.catalog.quality(mon), [None] * 4)
|
|
self.assertNotEqual(self.catalog.quality_text(mon), "C/C/C/C")
|
|
mon["mode"] = 2
|
|
self.assertEqual(self.catalog.quality(mon), [None] * 4)
|
|
plans = Planner(self.catalog).plan(Snapshot(GrowthClient(self.catalog).raw | {"monsters": [mon]}),
|
|
Policy(strategy="gold", fill=False, protect_quality=5))
|
|
self.assertFalse(any(a.kind in ("sell", "feed", "collect") for a in plans))
|
|
|
|
def test_hatching_phase_settles_before_full_maturity(self):
|
|
client = GrowthClient(self.catalog, age=310)
|
|
engine = self.engine(client)
|
|
snapshot, _, _ = engine.poll()
|
|
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
|
|
self.assertEqual(snapshot.monsters[501]["mode"], 1)
|
|
self.assertEqual(self.catalog.quality(snapshot.monsters[501]), [None] * 4)
|
|
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
|
|
|
def test_mature_response_growth_is_applied_before_dispatch_and_reads_cannot_revert_it(self):
|
|
client = GrowthClient(self.catalog, age=610)
|
|
engine = self.engine(client)
|
|
snapshot, _, _ = engine.poll()
|
|
self.assertEqual([body for name, body in client.calls if name == "monsterService/monsterSell"], [{"monsterIds": [501]}])
|
|
self.assertNotIn(501, snapshot.monsters)
|
|
self.assertLess([name for name, _ in client.calls].index("growth"), [name for name, _ in client.calls].index("monsterService/monsterSell"))
|
|
|
|
def test_s_grade_is_retained_with_specific_reason_and_survives_stale_snapshots(self):
|
|
client = GrowthClient(self.catalog, age=610, grade="S")
|
|
engine = self.engine(client)
|
|
snapshot, _, _ = engine.poll()
|
|
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
|
|
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
|
self.assertTrue(any("资质" in note for note in engine.planner.notes))
|
|
snapshot, _, _ = engine.poll()
|
|
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
|
|
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 1)
|
|
|
|
def test_two_phase_transition_updates_same_monster_without_retry_delay(self):
|
|
client = GrowthClient(self.catalog, age=310)
|
|
engine = self.engine(client)
|
|
engine.poll()
|
|
self.now.return_value = NOW + 310
|
|
client.stage = 2
|
|
snapshot, _, _ = engine.poll()
|
|
self.assertNotIn(501, snapshot.monsters)
|
|
self.assertEqual(sum(name == "growth" for name, _ in client.calls), 2)
|
|
self.assertEqual(sum(name == "monsterService/monsterSell" for name, _ in client.calls), 1)
|
|
|
|
def test_stale_positive_c_grade_cannot_overwrite_s_from_settlement(self):
|
|
client = GrowthClient(self.catalog, age=610, grade="S")
|
|
original = client.settle_growth
|
|
def settle():
|
|
response = original()
|
|
client.raw["monsters"][0]["mode"] = 2
|
|
for stat in ("atk", "def", "hp", "dex"):
|
|
client.raw["monsters"][0]["g" + stat.capitalize()] = self.catalog.monster(1001010)[stat + "_grow_min"]
|
|
return response
|
|
client.settle_growth = settle
|
|
engine = self.engine(client)
|
|
snapshot, _, _ = engine.poll()
|
|
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
|
|
snapshot, _, _ = engine.poll()
|
|
self.assertEqual(self.catalog.quality_text(snapshot.monsters[501]), "S/S/S/S")
|
|
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
|
|
|
def test_no_progress_is_throttled_and_never_consumes_pending_monsters(self):
|
|
client = GrowthClient(self.catalog, age=610)
|
|
client.empty_growth_response = True
|
|
engine = self.engine(client)
|
|
engine.poll()
|
|
engine.poll()
|
|
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_automatically_syncs_growth_without_dispatch(self):
|
|
client = GrowthClient(self.catalog, age=610)
|
|
engine = self.engine(client)
|
|
engine.auto = False
|
|
snapshot, _, message = engine.poll()
|
|
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 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):
|
|
client = GrowthClient(self.catalog, age=610, grade="S")
|
|
mon = client.raw["monsters"][0]
|
|
mon.update(mode=2, roomId=None)
|
|
for stat in ("atk", "def", "hp", "dex"):
|
|
mon["g" + stat.capitalize()] = self.catalog.monster(1001010)[stat + "_grow_max"]
|
|
engine = self.engine(client)
|
|
engine.policy.collect = True
|
|
engine.snapshot = Snapshot(copy.deepcopy(client.raw))
|
|
plans = engine.plans()
|
|
self.assertEqual(plans[0].kind, "collect")
|
|
self.assertEqual(plans[0].payload["datas"][0]["monsterId"], [501])
|
|
|
|
|
|
class GrowthGuiTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.app = W.QApplication.instance() or W.QApplication([])
|
|
|
|
def test_pending_display_and_explicit_sync_update_grade_and_keep_reason(self):
|
|
with workspace_temp() as folder, patch("ranch_assistant.model.time.time", return_value=NOW):
|
|
window = gui.Window(folder)
|
|
window.timer.stop()
|
|
try:
|
|
for _ in range(200):
|
|
self.app.processEvents()
|
|
QTest.qWait(5)
|
|
if not window.busy and window.slots.rowCount():
|
|
break
|
|
client = GrowthClient(window.catalog, age=610, grade="S")
|
|
client.session = Session("http://127.0.0.1/", "synthetic-test-token")
|
|
window.engine = Engine(window.catalog, client)
|
|
window.egg_rules = {"1001010": asdict(EggRule(enabled=True, action="sell", keep_count=0))}
|
|
window.engine.policy = window.read_policy()
|
|
window.engine.snapshot = client.snapshot()
|
|
window.render(window.engine.snapshot, window.engine.plans())
|
|
window.tabs.setCurrentWidget(window.monster_page)
|
|
for _ in range(200):
|
|
self.app.processEvents()
|
|
QTest.qWait(5)
|
|
if not window.busy and 501 in window.monsters.monster_items:
|
|
break
|
|
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.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)
|
|
if not window.busy:
|
|
break
|
|
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.monster_items[501].text(4))
|
|
self.assertFalse(window.strategy_toggle.isChecked())
|
|
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
|
|
finally:
|
|
window.close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|