Files
myrzx_bot/ranch_assistant/tests/test_cultivation.py
T

216 lines
12 KiB
Python

import copy
from dataclasses import asdict
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.cultivation import CultivationSelector, growth_score
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.gifts import GiftPlanner
from ranch_assistant.gui import Window
from ranch_assistant.model import Catalog, Planner, Policy, Snapshot
from ranch_assistant.policy_io import import_config, portable_config
from ranch_assistant.tests.test_core import workspace_temp
from ranch_assistant.tests.test_accounts import fake_client, role_snapshot
from ranch_assistant.api import Session
def monster(catalog, mid, *, level=10, feel=0, scale=.3, species=1001010, process=3):
row = catalog.monster(species)
return {"id": mid, "typeId": species, "process": process, "mode": 2, "level": level,
"feel": feel, "entangleLevel": 0, "giftTime": 0, "roomId": 1, "lock": 0,
**{"g" + stat.capitalize(): row[stat + "_grow_min"] + scale * (row[stat + "_grow_max"] - row[stat + "_grow_min"])
for stat in ("atk", "def", "hp", "dex")}}
class CultivationTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = demo_snapshot(self.catalog)
self.snapshot.raw.update(monsters=[], teams=[], stacks=[])
def test_representative_prefers_level_then_feel_then_growth(self):
rows = [monster(self.catalog, 1, level=11, feel=0, scale=.1),
monster(self.catalog, 2, level=10, feel=99, scale=1),
monster(self.catalog, 3, level=11, feel=1, scale=.1),
monster(self.catalog, 4, level=11, feel=1, scale=.8),
monster(self.catalog, 5, level=99, feel=200, scale=1, process=2)]
self.snapshot.raw["monsters"] = rows
selector = CultivationSelector(self.catalog)
self.assertEqual(selector.select(self.snapshot)["1001010"]["id"], 4)
rows[1]["level"] = 12
self.assertEqual(selector.select(self.snapshot)["1001010"]["id"], 2)
def test_ties_are_chosen_once_persisted_and_do_not_leak_to_other_role(self):
self.snapshot.raw["monsters"] = [monster(self.catalog, 1), monster(self.catalog, 2)]
with workspace_temp() as folder:
path = folder / "choices.json"
with patch("ranch_assistant.cultivation.random.choice", side_effect=lambda choices: choices[-1]) as draw:
selector = CultivationSelector(self.catalog, path)
self.assertEqual(selector.select(self.snapshot)["1001010"]["id"], 2)
selector.select(self.snapshot)
self.assertEqual(draw.call_count, 1)
with patch("ranch_assistant.cultivation.random.choice", side_effect=AssertionError("Re-selected an exact tie")):
self.assertEqual(CultivationSelector(self.catalog, path).select(self.snapshot)["1001010"]["id"], 2)
self.snapshot.raw["master"]["id"] += 1
with patch("ranch_assistant.cultivation.random.choice", side_effect=lambda choices: choices[0]):
self.assertEqual(CultivationSelector(self.catalog, path).select(self.snapshot)["1001010"]["id"], 1)
def test_cached_selection_uses_current_cooldown_and_bond_cap(self):
self.snapshot.raw["monsters"] = [monster(self.catalog, 1)]
selector = CultivationSelector(self.catalog)
selector.select(self.snapshot)
updated = Snapshot(copy.deepcopy(self.snapshot.raw))
updated.raw["monsters"][0].update(giftTime=123456789, entangleLevel=2)
chosen = selector.select(updated)["1001010"]
self.assertIs(chosen, updated.raw["monsters"][0])
self.assertEqual((chosen["giftTime"], chosen["entangleLevel"]), (123456789, 2))
def test_better_growth_is_kept_independently_of_four_s_and_equal_or_worse_is_not(self):
representative = monster(self.catalog, 1, level=50, feel=90, scale=.3)
hatched = monster(self.catalog, 2, level=1, scale=.4, process=2)
self.snapshot.raw["monsters"] = [representative, hatched]
planner = Planner(self.catalog)
policy = Policy(strategy="gold", protect_star=6, protect_quality=6, keep_better_quality=True)
self.assertEqual(planner.disposition(hatched, self.snapshot, policy), "keep")
self.assertIn("同种培养代表 #1", planner.protection_reason(hatched, self.snapshot, policy))
policy.keep_better_quality = False
self.assertEqual(planner.disposition(hatched, self.snapshot, policy), "sell")
policy.keep_better_quality = True
for scale in (.3, .2):
self.snapshot.raw["monsters"][1] = monster(self.catalog, 2, scale=scale, process=2)
self.assertEqual(planner.disposition(self.snapshot.monsters[2], self.snapshot, policy), "sell")
def test_missing_species_or_unknown_reference_is_conservatively_retained(self):
hatched = monster(self.catalog, 2, process=2)
self.snapshot.raw["monsters"] = [hatched]
policy = Policy(protect_star=6, protect_quality=5, keep_better_quality=True)
planner = Planner(self.catalog)
self.assertIn("首次", planner.protection_reason(hatched, self.snapshot, policy))
reference = monster(self.catalog, 1, level=50)
reference["gAtk"] = None
self.snapshot.raw["monsters"].append(reference)
self.assertIn("尚未同步", planner.protection_reason(hatched, self.snapshot, policy))
def test_gifts_target_only_the_representative_and_do_not_move_to_duplicates_at_cap(self):
best = monster(self.catalog, 1, level=30)
duplicate = monster(self.catalog, 2, level=29, feel=50, scale=1)
self.snapshot.raw["monsters"] = [best, duplicate]
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30005, "num": 20}]
policy = Policy(gift_enabled=True, gift_auto_representative=True, gift_liked_only=False,
gift_targets={"2": 1}, gift_items={"30005": {"enabled": True, "reserve": 2}})
planner = GiftPlanner(self.catalog)
self.assertEqual(planner.plan(self.snapshot, policy)[0].payload["monsterId"], 1)
best["feel"] = self.catalog.max_feel(best)
self.assertEqual(planner.plan(self.snapshot, policy), [])
best["feel"] = 0
best["giftTime"] = self.snapshot.now * 1000
self.assertEqual(planner.plan(self.snapshot, policy), [])
def test_cooldown_or_unavailable_food_skips_to_other_species_without_wasting_on_duplicates(self):
self.snapshot.raw["monsters"] = [monster(self.catalog, 1, level=50), monster(self.catalog, 2, level=40),
monster(self.catalog, 3, level=20, species=1002010)]
self.snapshot.raw["monsters"][0]["giftTime"] = self.snapshot.now * 1000
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30005, "num": 3}]
policy = Policy(gift_enabled=True, gift_auto_representative=True, gift_liked_only=False,
gift_items={"30005": {"enabled": True, "reserve": 2}})
planner = GiftPlanner(self.catalog)
self.assertEqual(planner.plan(self.snapshot, policy)[0].payload["monsterId"], 3)
self.snapshot.raw["items"][0]["num"] = 2
self.assertEqual(planner.plan(self.snapshot, policy), [])
def test_auto_gift_representative_is_also_protected_from_hatch_disposal(self):
representative = monster(self.catalog, 1, level=20)
self.snapshot.raw["monsters"] = [representative, monster(self.catalog, 2, level=1)]
policy = Policy(strategy="gold", protect_star=6, protect_quality=5, gift_auto_representative=True)
planner = Planner(self.catalog)
self.assertTrue(planner.protected(representative, self.snapshot, policy))
self.assertFalse(planner.protected(self.snapshot.monsters[2], self.snapshot, policy))
def test_growth_score_normalizes_health_and_attack_to_their_own_ranges(self):
mon = monster(self.catalog, 1, scale=.5)
self.assertAlmostEqual(growth_score(self.catalog, mon), .5, places=3)
mon["gHp"] = self.catalog.monster(1001010)["hp_grow_max"]
self.assertAlmostEqual(growth_score(self.catalog, mon), .625, places=3)
class CultivationGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, predicate):
for _ in range(800):
self.app.processEvents()
QTest.qWait(2)
if predicate():
return
self.fail("Cultivation preview did not finish")
def test_rule_flags_autosave_and_portable_settings_and_representative_preview(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
window.keep_better_quality.setChecked(True)
window.gift_auto_representative.setChecked(True)
self.wait(lambda: not window.auto_save_timer.isActive())
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
self.assertTrue(saved["policy"]["keep_better_quality"])
self.assertTrue(window.engine.policy.gift_auto_representative)
imported = import_config(portable_config(window.config_value(), window.engine.snapshot), window.engine.snapshot)
self.assertTrue(imported["policy"]["keep_better_quality"])
self.assertTrue(imported["policy"]["gift_auto_representative"])
window.engine.plans()
window.tabs.setCurrentWidget(window.gift_page)
self.assertGreater(window.gift_representatives.rowCount(), 0)
self.assertFalse(window.strategy_toggle.isChecked())
window.load_config()
self.assertTrue(window.keep_better_quality.isChecked())
self.assertTrue(window.gift_auto_representative.isChecked())
finally:
window.close()
def test_selecting_representatives_replans_locally_without_an_api_request(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
calls = []
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
session = Session("http://127.0.0.1/", "synthetic-token", account_id="fixture", server_id=1, role_id=101)
client = fake_client(session, window.catalog, calls)
window.result("connected", (client, Snapshot(role_snapshot(window.catalog, 101))))
window.gift_auto_representative.setChecked(True)
self.wait(lambda: not window.auto_save_timer.isActive() and not window.busy and bool(window.engine.cultivation.selected))
self.assertEqual(calls, [])
self.assertTrue(window.monitoring)
self.assertFalse(window.strategy_toggle.isChecked())
finally:
window.close()
def test_local_selection_failure_is_recorded_as_local_and_keeps_monitoring(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
window.monitoring = True
with patch.object(window.engine.cultivation, "select", side_effect=ValueError("fixture-selection-failure")):
window.gift_auto_representative.setChecked(True)
self.wait(lambda: any("fixture-selection-failure" in e.get("message", "") for e in window.trace.events))
self.wait(lambda: not window.busy)
event = next(e for e in window.trace.events if "fixture-selection-failure" in e.get("message", ""))
self.assertEqual(event["scope"], "local")
self.assertEqual(event["kind"], "error")
self.assertTrue(window.monitoring)
self.assertFalse(window.strategy_toggle.isChecked())
finally:
window.close()