512 lines
27 KiB
Python
512 lines
27 KiB
Python
import copy
|
||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||
import json
|
||
import os
|
||
from pathlib import Path
|
||
import threading
|
||
import time
|
||
import unittest
|
||
from unittest.mock import Mock, patch
|
||
from dataclasses import asdict, replace
|
||
|
||
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
||
from PySide6.QtTest import QTest
|
||
from PySide6.QtWidgets import QApplication
|
||
|
||
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode
|
||
from ranch_assistant.engine import Engine, demo_snapshot
|
||
from ranch_assistant.market import PurchaseBudget
|
||
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 AutomationTests(unittest.TestCase):
|
||
def setUp(self):
|
||
self.catalog = Catalog()
|
||
self.snapshot = demo_snapshot(self.catalog)
|
||
self.snapshot.raw["monsters"] = []
|
||
self.snapshot.raw["stacks"] = [{"id": 1, "position": 0, "monsterId": 0}]
|
||
self.snapshot.raw["items"] = []
|
||
self.planner = Planner(self.catalog)
|
||
self.policy = Policy(strategy="gold", buy=True, protect_star=4, protect_quality=5,
|
||
hatch_max_star=3, egg_stock=3, buy_batch=2, keep_money=1000, daily_buy_money=1000, allow_single_draw=True)
|
||
|
||
def test_market_city_price_and_nonpremium_payload(self):
|
||
action = self.planner.plan(self.snapshot, self.policy)[0]
|
||
self.assertEqual(action.kind, "buy")
|
||
self.assertEqual(action.payload, {"id": "sc_city1", "num": 2, "voucherNum": 0,
|
||
"traceInfo": {"money": 12345, "ke": 2000}})
|
||
self.assertEqual(self.catalog.data["markets"]["sc_city1"]["money"], 100)
|
||
self.assertEqual(self.catalog.total_time(1001010), 600)
|
||
self.policy.market_id = "sc_city7"
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
# The shipped table has legacy city=4; the actual market UI uses city 7.
|
||
self.snapshot.raw["history"]["unlockCity"] = {"7": True}
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["id"], "sc_city7")
|
||
self.policy.market_id = "ke"
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
|
||
def test_buy_limits_reserve_balance_daily_and_stock(self):
|
||
self.snapshot.raw["master"]["money"] = 1150
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy, 500)[0].payload["num"], 1)
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy, 99), [])
|
||
self.snapshot.raw["master"]["money"] = 1000
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
|
||
self.snapshot.raw["master"]["money"] = 10000
|
||
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 3}]
|
||
self.policy.fill = False
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
self.policy.reserved_eggs = {"1001010": 1}
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 1)
|
||
self.policy.enabled = False
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
|
||
def test_city_unlock_accepts_recorded_id_lists_and_legacy_maps(self):
|
||
for value in (["1"], [1], {"1": True}, [False, True]):
|
||
self.snapshot.raw["history"]["unlockCity"] = value
|
||
self.assertTrue(self.snapshot.city_unlocked(1))
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].kind, "buy")
|
||
self.assertFalse(self.snapshot.city_unlocked(2))
|
||
self.snapshot.raw["history"]["unlockCity"] = []
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
|
||
def test_shortest_hatching_precedes_buying_and_excludes_high_stars(self):
|
||
high = next(int(k) for k, r in self.catalog.monsters.items() if r.get("star") == 5 and self.catalog.total_time(k) > 0)
|
||
slow = next(int(k) for k, r in self.catalog.monsters.items() if r.get("star") == 1 and self.catalog.total_time(k) > 600)
|
||
self.snapshot.raw["items"] = [{"id": 501, "typeId": slow, "num": 1},
|
||
{"id": 502, "typeId": 1001010, "num": 1}, {"id": 503, "typeId": high, "num": 10}]
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["eggs"][0]["itemId"], 502)
|
||
self.snapshot.raw["items"] = [self.snapshot.raw["items"][-1]]
|
||
self.assertTrue(all(a.kind != "hatch" for a in self.planner.plan(self.snapshot, self.policy)))
|
||
|
||
def test_official_negative_empty_slots_hatch_existing_eggs_before_buy(self):
|
||
self.snapshot.raw["stacks"] = [{"id": i + 1, "position": i, "monsterId": -1} for i in range(4)]
|
||
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 6}]
|
||
plans = self.planner.plan(self.snapshot, self.policy)
|
||
self.assertEqual([a.kind for a in plans], ["hatch"] * 3)
|
||
self.assertEqual([a.payload["eggs"][0]["stackId"] for a in plans], [1, 2, 3])
|
||
self.assertNotIn(-1, self.planner.managed)
|
||
|
||
def test_reserve_count_spans_multiple_inventory_rows(self):
|
||
self.snapshot.raw["items"] = [{"id": i, "typeId": 1001010, "num": 1} for i in (501, 502, 503)]
|
||
self.policy.reserved_eggs = {"1001010": 2}
|
||
self.snapshot.raw["stacks"] += [{"id": 2, "position": 1, "monsterId": 0}]
|
||
plans = self.planner.plan(self.snapshot, self.policy)
|
||
self.assertEqual([a.kind for a in plans], ["hatch"])
|
||
self.assertEqual(plans[0].payload["eggs"][0]["itemId"], 503)
|
||
|
||
def test_ten_draw_waits_for_stock_gap_and_honors_money_limits(self):
|
||
self.policy.allow_single_draw = False
|
||
self.policy.egg_stock, self.policy.buy_batch = 12, 5
|
||
self.policy.fill = False
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 10)
|
||
self.snapshot.raw["items"] = [{"id": 501, "typeId": 1001010, "num": 11}]
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
self.snapshot.raw["items"][0]["num"] = 2
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 10)
|
||
self.snapshot.raw["master"]["money"] = 1900
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
self.snapshot.raw["items"] = []
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy), [])
|
||
self.policy.allow_single_draw = True
|
||
self.assertLess(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 10)
|
||
self.snapshot.raw["master"]["money"] = 12345
|
||
self.policy.buy_ten = False
|
||
self.assertEqual(self.planner.plan(self.snapshot, self.policy)[0].payload["num"], 5)
|
||
|
||
def test_single_draw_is_disabled_by_default_even_with_no_eggs(self):
|
||
policy = Policy(buy=True, fill=False, egg_stock=12, keep_money=1000, daily_buy_money=5000)
|
||
self.assertFalse(policy.allow_single_draw)
|
||
self.snapshot.raw["master"]["money"] = 1900
|
||
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
|
||
self.assertIn("单抽已关闭", ";".join(self.planner.notes))
|
||
self.snapshot.raw["master"]["money"] = 2000
|
||
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["num"], 10)
|
||
self.assertEqual(self.planner.plan(self.snapshot, policy, 999), [])
|
||
policy.buy_ten = False
|
||
self.assertEqual(self.planner.plan(self.snapshot, policy)[0].payload["num"], 10)
|
||
|
||
def test_manual_refill_keeps_single_draw_disabled(self):
|
||
policy = Policy(buy=True, fill=False, manual_eggs=True, keep_money=1000, daily_buy_money=5000,
|
||
egg_rules={"1001010": asdict(EggRule(enabled=True, refill_below=1, refill_target=10, market_id="sc_city1"))})
|
||
self.snapshot.raw["master"]["money"] = 1900
|
||
self.assertEqual(self.planner.plan(self.snapshot, policy), [])
|
||
policy.allow_single_draw = True
|
||
self.assertLess(self.planner.plan(self.snapshot, policy)[0].payload["num"], 10)
|
||
|
||
def test_independent_dispatch_collection_and_feeding_switches(self):
|
||
snapshot = demo_snapshot(self.catalog)
|
||
policy = Policy(strategy="gold", fill=False, dispatch=False, collect=False)
|
||
self.assertEqual(self.planner.plan(snapshot, policy), [])
|
||
policy.collect = True
|
||
self.assertTrue(all(a.kind == "collect" for a in self.planner.plan(snapshot, policy)))
|
||
policy.dispatch = True
|
||
self.assertTrue(all(a.kind == "sell" for a in self.planner.plan(snapshot, policy)))
|
||
policy.strategy, policy.feed, policy.feed_target = "experience", False, 900
|
||
mon = snapshot.raw["monsters"][0]
|
||
mon["process"] = 3
|
||
snapshot.raw["stacks"][0]["monsterId"] = 0
|
||
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
|
||
|
||
def test_feed_uses_actual_breakthrough_cap_and_unknown_stops(self):
|
||
snapshot = demo_snapshot(self.catalog)
|
||
policy = Policy(strategy="experience", fill=False, feed_target=900, target_level=70)
|
||
mon = snapshot.raw["monsters"][0]
|
||
self.planner.managed.add(mon["id"])
|
||
mon.update(process=3, roomId=1)
|
||
target = snapshot.monsters[900]
|
||
target.update(level=20, potentialLevel=2)
|
||
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
|
||
self.assertIn("上限 20", self.planner.feed_status(snapshot, policy)[1])
|
||
target["level"] = 19
|
||
self.assertTrue(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
|
||
policy.target_level = 19
|
||
self.assertTrue(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
|
||
policy.target_level = 70
|
||
del target["potentialLevel"]
|
||
self.assertFalse(any(a.kind == "feed" for a in self.planner.plan(snapshot, policy)))
|
||
self.assertIn("未知", self.planner.feed_status(snapshot, policy)[1])
|
||
|
||
def test_daily_budget_survives_restart_and_is_role_local(self):
|
||
with workspace_temp() as folder:
|
||
path = folder / "role-a" / "purchase_budget.json"
|
||
budget = PurchaseBudget(path)
|
||
now = 1794048000
|
||
budget.record(now, 200, 500)
|
||
self.assertEqual(PurchaseBudget(path).remaining(now, 500), 300)
|
||
self.assertEqual(PurchaseBudget(folder / "role-b.json").remaining(now, 500), 500)
|
||
self.assertEqual(PurchaseBudget(path).remaining(now + 86400, 500), 500)
|
||
with self.assertRaises(ValueError):
|
||
budget.record(now, 301, 500)
|
||
path.write_text('{"day":"x","spent":-1}', encoding="utf-8")
|
||
with self.assertRaises(ValueError):
|
||
PurchaseBudget(path)
|
||
|
||
def test_failed_purchase_is_accounted_before_send_and_not_retried(self):
|
||
with workspace_temp() as folder:
|
||
client = Mock()
|
||
client.snapshot.return_value = self.snapshot
|
||
client.call.side_effect = ApiError("测试超时")
|
||
engine = Engine(self.catalog, client, folder / "purchase_budget.json")
|
||
engine.policy = self.policy
|
||
engine.policy.daily_buy_money = 200
|
||
engine.auto = True
|
||
with self.assertRaises(ApiError):
|
||
engine.poll()
|
||
client.call.assert_called_once()
|
||
restored = Engine(self.catalog, client, folder / "purchase_budget.json")
|
||
restored.policy = self.policy
|
||
restored.snapshot = self.snapshot
|
||
self.assertEqual(restored.plans(), [])
|
||
|
||
def test_stop_during_snapshot_prevents_next_write(self):
|
||
client = Mock()
|
||
engine = Engine(self.catalog, client)
|
||
engine.policy, engine.auto = self.policy, True
|
||
def read():
|
||
engine.auto = False
|
||
return self.snapshot
|
||
client.snapshot.side_effect = read
|
||
engine.poll()
|
||
client.call.assert_not_called()
|
||
|
||
def test_monster_lock_uses_normal_api_rechecks_state_and_respects_system_lock(self):
|
||
state = demo_snapshot(self.catalog).raw
|
||
calls = []
|
||
class LockClient:
|
||
def snapshot(self):
|
||
return Snapshot(copy.deepcopy(state))
|
||
def call(self, path, payload):
|
||
calls.append((path, payload))
|
||
next(m for m in state["monsters"] if m["id"] == payload["monsterId"])["lock"] = payload["lock"]
|
||
return {"resCode": 0}
|
||
engine = Engine(self.catalog, LockClient())
|
||
engine.auto = True
|
||
snapshot, _, _ = engine.set_monster_lock([101, 101], True)
|
||
self.assertFalse(engine.auto)
|
||
self.assertEqual(snapshot.monsters[101]["lock"], 1)
|
||
self.assertEqual(calls, [("monsterService/monsterLock", {"monsterId": 101, "lock": 1})])
|
||
engine.set_monster_lock([101], True)
|
||
self.assertEqual(len(calls), 1)
|
||
snapshot, _, _ = engine.set_monster_lock([101], False)
|
||
self.assertEqual(snapshot.monsters[101]["lock"], 0)
|
||
state["monsters"][0]["sysLock"] = 1
|
||
with self.assertRaisesRegex(ValueError, "系统锁定"):
|
||
engine.set_monster_lock([101, 102], False)
|
||
self.assertEqual(len(calls), 2)
|
||
with self.assertRaises(ValueError):
|
||
engine.set_monster_lock([999999], True)
|
||
|
||
def test_monster_lock_stops_on_unconfirmed_server_state(self):
|
||
client = Mock()
|
||
client.snapshot.side_effect = lambda: demo_snapshot(self.catalog)
|
||
engine = Engine(self.catalog, client)
|
||
with self.assertRaisesRegex(ValueError, "未更新"):
|
||
engine.set_monster_lock([101, 102], True)
|
||
self.assertEqual(client.call.call_count, 1)
|
||
|
||
def test_encrypted_http_buy_hatch_mature_dispatch_and_balance(self):
|
||
state = copy.deepcopy(self.snapshot.raw)
|
||
state["stacks"][0]["monsterId"] = -1
|
||
initial_money = state["master"]["money"]
|
||
calls, catalog = [], self.catalog
|
||
with workspace_temp() as folder:
|
||
budget_path = folder / "purchase_budget.json"
|
||
class Handler(BaseHTTPRequestHandler):
|
||
def log_message(self, *args):
|
||
pass
|
||
def do_POST(self):
|
||
body = decode(self.rfile.read(int(self.headers["Content-Length"])), DEFAULT_KEY)
|
||
name = self.path.rsplit("/", 1)[-1]
|
||
calls.append((name, body))
|
||
if name == "gachaGetEggs":
|
||
assert PurchaseBudget(budget_path).spent(time.time()) == 1000
|
||
assert body["voucherNum"] == 0 and body["id"] == "sc_city1" and body["num"] == 10
|
||
state["master"]["money"] -= 1000
|
||
state["items"] = [{"id": 501, "typeId": 1001010, "num": 11}]
|
||
elif name == "stackAddMonster":
|
||
assert body["eggs"] == [{"itemId": 501, "stackId": 1}]
|
||
state["items"][0]["num"] -= 1
|
||
mon = {"id": 101, "typeId": 1001010, "mode": 0, "process": 2,
|
||
"timeStart": time.time() * 1000, "level": 1}
|
||
mon.update({"g" + s.capitalize(): catalog.monster(1001010)[s + "_grow_min"] for s in ("atk", "def", "hp", "dex")})
|
||
state["monsters"] = [mon]
|
||
state["stacks"][0]["monsterId"] = 101
|
||
elif name == "stackCheckProcess":
|
||
state["monsters"][0]["mode"] = 2
|
||
elif name == "monsterSell":
|
||
assert body["monsterIds"] == [101]
|
||
state["monsters"] = []
|
||
state["stacks"][0]["monsterId"] = -1
|
||
state["master"]["money"] += 150
|
||
elif name != "masterQueryDetail":
|
||
raise AssertionError(name)
|
||
response = state | {"resCode": 0} if name == "masterQueryDetail" else {"resCode": 0}
|
||
if name == "gachaGetEggs":
|
||
response["eggs"] = state["items"]
|
||
data = encode(response, DEFAULT_KEY)
|
||
self.send_response(200)
|
||
self.send_header("Content-Length", str(len(data)))
|
||
self.end_headers()
|
||
self.wfile.write(data)
|
||
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
|
||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||
thread.start()
|
||
client = Client(Session(f"http://127.0.0.1:{server.server_port}/", "synthetic-test-token"))
|
||
try:
|
||
engine = Engine(catalog, client, budget_path)
|
||
engine.policy = replace(self.policy, manual_eggs=True, egg_rules={"1001010": asdict(EggRule(enabled=True, priority=1, refill_target=12, market_id="sc_city1"))})
|
||
engine.policy.egg_stock = 12
|
||
engine.policy.buy_batch = 5
|
||
engine.policy.daily_buy_money = 1000
|
||
engine.poll()
|
||
self.assertEqual([n for n, _ in calls], ["masterQueryDetail"])
|
||
engine.auto = True
|
||
engine.poll() # Buy, re-read, plan hatch.
|
||
self.assertEqual(state["master"]["money"], initial_money - 1000)
|
||
self.assertIn("共 11 枚", engine.last_draw)
|
||
engine.poll() # Hatch, re-read, wait.
|
||
state["monsters"][0]["timeStart"] = (time.time() - 601) * 1000
|
||
snapshot, _, _ = engine.poll() # Settle growth, dispatch, re-read.
|
||
self.assertEqual(snapshot.raw["master"]["money"], initial_money - 850)
|
||
self.assertEqual(snapshot.raw["stacks"][0]["monsterId"], -1)
|
||
self.assertEqual([n for n, _ in calls if n != "masterQueryDetail"],
|
||
["gachaGetEggs", "stackAddMonster", "stackCheckProcess", "monsterSell"])
|
||
engine.poll()
|
||
self.assertEqual(sum(n == "gachaGetEggs" for n, _ in calls), 1)
|
||
self.assertEqual([b["reqid"] for _, b in calls], list(range(len(calls))))
|
||
finally:
|
||
client.close()
|
||
server.shutdown()
|
||
server.server_close()
|
||
thread.join(2)
|
||
|
||
|
||
class AutomationGuiTests(unittest.TestCase):
|
||
@classmethod
|
||
def setUpClass(cls):
|
||
cls.app = QApplication.instance() or QApplication([])
|
||
|
||
def wait(self, window):
|
||
for _ in range(250):
|
||
self.app.processEvents()
|
||
QTest.qWait(5)
|
||
if not window.busy and not window.pending_execute and window.slots.rowCount():
|
||
return
|
||
self.fail("Qt task did not finish")
|
||
|
||
def test_single_draw_switch_defaults_off_and_autosaves_across_restart(self):
|
||
with workspace_temp() as folder:
|
||
window = gui.Window(folder)
|
||
window.timer.stop()
|
||
try:
|
||
self.wait(window)
|
||
self.assertFalse(window.allow_single_draw.isChecked())
|
||
self.assertFalse(window.buy_ten.isEnabled())
|
||
window.allow_single_draw.setChecked(True)
|
||
self.assertTrue(window.buy_ten.isEnabled())
|
||
QTest.qWait(400)
|
||
self.wait(window)
|
||
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
|
||
self.assertTrue(saved["policy"]["allow_single_draw"])
|
||
from ranch_assistant.policy_io import portable_config, import_config
|
||
exported = portable_config(saved, window.engine.snapshot)
|
||
self.assertTrue(import_config(exported, window.engine.snapshot)["policy"]["allow_single_draw"])
|
||
finally:
|
||
window.close()
|
||
restored = gui.Window(folder)
|
||
restored.timer.stop()
|
||
try:
|
||
self.wait(restored)
|
||
self.assertTrue(restored.allow_single_draw.isChecked())
|
||
restored.allow_single_draw.setChecked(False)
|
||
self.assertFalse(restored.read_policy().allow_single_draw)
|
||
self.assertFalse(restored.buy_ten.isEnabled())
|
||
finally:
|
||
restored.close()
|
||
|
||
def test_strategy_toggle_off_keeps_refreshing_and_settings_restore_with_strategy_off(self):
|
||
with workspace_temp() as folder:
|
||
window = gui.Window(folder)
|
||
window.timer.stop()
|
||
try:
|
||
self.wait(window)
|
||
self.assertIn("自动孵蛋", [window.tabs.tabText(i) for i in range(window.tabs.count())])
|
||
window.gold_preset()
|
||
self.wait(window)
|
||
window.egg_rules = {str(m["typeId"]): {"enabled": True, "action": "sell"} for m in window.engine.snapshot.raw["monsters"][:2]}
|
||
window.fill.setChecked(False)
|
||
window.buy_eggs.setChecked(False)
|
||
before = len(window.engine.snapshot.raw["monsters"])
|
||
window.refresh()
|
||
self.wait(window)
|
||
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
|
||
self.assertIn("策略已关闭", window.workflow_status.text())
|
||
window.strategy_toggle.click()
|
||
self.wait(window)
|
||
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
|
||
self.assertIn("策略已开启", window.workflow_status.text())
|
||
window.strategy_toggle.click()
|
||
self.assertTrue(window.monitoring)
|
||
self.assertFalse(window.engine.auto)
|
||
self.assertEqual(window.strategy_toggle.text(), "开启")
|
||
remaining = len(window.engine.snapshot.raw["monsters"])
|
||
window.next_poll = 0
|
||
window.schedule()
|
||
self.wait(window)
|
||
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), remaining)
|
||
self.assertFalse(window.engine.auto)
|
||
window.buy_eggs.setChecked(True)
|
||
window.market.setCurrentIndex(window.market.findData("sc_city2"))
|
||
window.daily_buy_money.setValue(700)
|
||
window.yield_stars[4].setChecked(False)
|
||
window.yield_stars[5].setChecked(False)
|
||
self.assertTrue(all(int(window.yields.item(i, 2).text()) <= 3 for i in range(window.yields.rowCount())))
|
||
self.assertLess(window.yields.rowCount(), 749)
|
||
window.save_config()
|
||
finally:
|
||
window.close()
|
||
restored = gui.Window(folder)
|
||
restored.timer.stop()
|
||
try:
|
||
self.wait(restored)
|
||
self.assertTrue(restored.buy_eggs.isChecked())
|
||
self.assertEqual(restored.market.currentData(), "sc_city2")
|
||
self.assertEqual(restored.daily_buy_money.value(), 700)
|
||
self.assertFalse(restored.strategy_toggle.isChecked())
|
||
self.assertFalse(restored.yield_stars[5].isChecked())
|
||
self.assertEqual(restored.hatch_max_star.currentData(), 3)
|
||
finally:
|
||
restored.close()
|
||
|
||
def test_start_during_busy_queues_execution_and_stop_cancels_it(self):
|
||
with workspace_temp() as folder:
|
||
window = gui.Window(folder)
|
||
window.timer.stop()
|
||
try:
|
||
self.wait(window)
|
||
window.strategy.setCurrentIndex(window.strategy.findData("gold"))
|
||
window.egg_rules = {str(m["typeId"]): {"enabled": True, "action": "sell"} for m in window.engine.snapshot.raw["monsters"][:2]}
|
||
window.fill.setChecked(False)
|
||
before = len(window.engine.snapshot.raw["monsters"])
|
||
window.refresh()
|
||
window.start_workflow()
|
||
self.assertTrue(window.pending_execute)
|
||
self.wait(window)
|
||
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
|
||
window.refresh()
|
||
window.start_workflow()
|
||
window.stop_workflow()
|
||
self.wait(window)
|
||
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
|
||
self.assertFalse(window.pending_execute)
|
||
finally:
|
||
window.close()
|
||
|
||
def test_quest_rewards_and_target_cap_are_visible(self):
|
||
with workspace_temp() as folder:
|
||
window = gui.Window(folder)
|
||
window.timer.stop()
|
||
try:
|
||
self.wait(window)
|
||
key = next(iter(window.catalog.data["task_info"]))
|
||
snapshot = window.engine.snapshot
|
||
snapshot.raw["currentTasks"] = [{"id": 88, "typeId": key, "curStep": 1}]
|
||
snapshot.monsters[900].update(level=20, potentialLevel=2)
|
||
window.feed_targets = {"900": 1}
|
||
window.render(snapshot, [])
|
||
window.refresh_target_choices(snapshot)
|
||
self.assertIn("上限 20", window.target_status.text())
|
||
reward = window.catalog.data["task_info"][key]["reward"]
|
||
window.tabs.setCurrentWidget(window.quests_table.parentWidget())
|
||
self.assertEqual(int(window.quests_table.item(0, 4).text()), reward["ke"])
|
||
window.engine._progression_rows = [{"task_type_id": key, "category": "commission",
|
||
"block_reason": "Unsupported monster controller: monSteps"}]
|
||
window.render_quests(snapshot)
|
||
self.assertEqual(window.quests_table.item(0, 2).text(), "等待条件")
|
||
self.assertIn("尚未支持", window.quests_table.item(0, 5).text())
|
||
self.assertNotIn("Unsupported", window.quests_table.item(0, 5).text())
|
||
self.assertIn("氪金", window.summary.text())
|
||
finally:
|
||
window.close()
|
||
|
||
def test_monster_buttons_and_context_menu_update_real_selection_without_auto_sale(self):
|
||
from PySide6.QtCore import QPoint
|
||
with workspace_temp() as folder:
|
||
window = gui.Window(folder)
|
||
window.timer.stop()
|
||
try:
|
||
self.wait(window)
|
||
window.set_strategy_checked(True)
|
||
window.monitoring = True
|
||
before = len(window.engine.snapshot.raw["monsters"])
|
||
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)
|
||
self.assertTrue(window.lock_monsters.isEnabled())
|
||
window.lock_monsters.click()
|
||
self.wait(window)
|
||
self.assertEqual(window.engine.snapshot.monsters[101]["lock"], 1)
|
||
self.assertFalse(window.strategy_toggle.isChecked())
|
||
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
|
||
select(101)
|
||
with patch("PySide6.QtWidgets.QMenu.popup"):
|
||
window.page_menu(window.monsters.viewport(), QPoint(-1, -1), window.monster_page)
|
||
action = next(a for a in window.refresh_menu.actions() if a.text() == "解锁选中魔物")
|
||
action.trigger()
|
||
self.wait(window)
|
||
self.assertEqual(window.engine.snapshot.monsters[101]["lock"], 0)
|
||
self.assertFalse(window.engine.auto)
|
||
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
|
||
finally:
|
||
window.close()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|