Files
myrzx_bot/ranch_assistant/tests/test_automation.py
T

442 lines
23 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)
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.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.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_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.assertFalse(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_workflow_start_monitor_stop_and_settings_restore(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.monitor_only()
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
self.assertIn("仅监控", window.workflow_status.text())
window.workflow_start.click()
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
self.assertIn("执行中", window.workflow_status.text())
window.workflow_stop.click()
self.assertTrue(window.monitoring)
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.execute.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.render(snapshot, [])
window.target.setCurrentIndex(window.target.findData(900))
self.assertIn("上限 20", window.target_status.text())
reward = window.catalog.data["task_info"][key]["reward"]
self.assertEqual(int(window.quests_table.item(0, 4).text()), reward["ke"])
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.execute.setChecked(True)
window.start_monitor.setChecked(True)
before = len(window.engine.snapshot.raw["monsters"])
def select(mid):
row = next(i for i in range(window.monsters.rowCount()) if int(window.monsters.item(i, 0).text()) == mid)
window.monsters.selectRow(row)
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.execute.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()