Initialize local project and fix ranch growth synchronization

This commit is contained in:
AttilaNet
2026-11-07 22:14:49 +08:00
commit 657f5f33b5
1417 changed files with 202171 additions and 0 deletions
+259
View File
@@ -0,0 +1,259 @@
import copy
import json
import os
import time
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import requests
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant import gui
from ranch_assistant.accounts_gui import AccountsWindow
from ranch_assistant.api import ApiError, Client, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog, Snapshot
from ranch_assistant.sessions import SessionStore, identity
from ranch_assistant.tests.test_core import workspace_temp
def role_snapshot(catalog, role_id):
raw = demo_snapshot(catalog).raw
raw["master"].update(id=role_id, roleName=f"测试角色 {role_id}")
raw["activityHistory"]["vipInfo"] = None
raw["stacks"] = raw["stacks"][:4]
for slot in raw["stacks"]:
slot["monsterId"] = 0
raw["monsters"] = raw["monsters"][:4]
for mon in raw["monsters"]:
mon.update(process=3, mode=2, roomId=1)
raw["items"] = raw["items"][:4]
return raw
def fake_client(session, catalog, calls):
client = Client(session)
def post(url, data, **kwargs):
body = decode(data, session.key)
calls.append((session.account_id, url, body))
raw = role_snapshot(catalog, session.role_id)
return SimpleNamespace(status_code=200, content=encode(raw | {"resCode": 0}, session.key), headers={})
client.http.post = post
return client
class SessionTests(unittest.TestCase):
def test_encrypted_sessions_are_isolated_by_owner_region_and_role(self):
with workspace_temp() as folder:
store = SessionStore(folder)
first = Session("http://127.0.0.1/a/", "private-token-a", account_id="account-a", server_id=1, role_id=101, reqid=5, reqsid=7)
second = Session("http://127.0.0.1/b/", "private-token-b", account_id="account-b", server_id=1, role_id=202)
other_region = copy.deepcopy(first)
other_region.server_id, other_region.role_id = 2, 303
keys = [store.save(s, "测试会话") for s in (first, second, other_region)]
self.assertEqual(len(set(keys)), 3)
self.assertEqual(store.load(keys[0]), first)
first.reqid = 9
store.save(first, "测试会话")
self.assertEqual(len(store.entries()), 3)
self.assertEqual(store.load(keys[0]).reqid, 9)
for path in store.folder.glob("*.json"):
text = path.read_text(encoding="utf-8")
self.assertNotIn("private-token", text)
self.assertNotIn(first.key, text)
with self.assertRaises(ValueError):
store.load("../credentials")
def test_failed_request_persists_advanced_counters_without_retry(self):
with workspace_temp() as folder:
store = SessionStore(folder)
session = Session("http://127.0.0.1/", "private-token", account_id="account-a", server_id=1, role_id=101)
client = Client(session, on_session_change=lambda current: store.save(current, "测试会话"))
try:
with patch.object(client.http, "post", side_effect=requests.Timeout()) as post:
with self.assertRaises(ApiError):
client.call("masterService/masterQueryDetail")
self.assertEqual(post.call_count, 1)
restored = store.load(identity(session))
self.assertEqual((restored.reqid, restored.reqsid), (1, 1))
finally:
client.close()
def test_resume_rejects_another_role_before_any_strategy_runs(self):
catalog = Catalog()
session = Session("http://127.0.0.1/", "private-token", role_id=101)
client = Client(session)
response = SimpleNamespace(status_code=200, content=encode(role_snapshot(catalog, 202) | {"resCode": 0}, session.key), headers={})
try:
with patch.object(client.http, "post", return_value=response):
with self.assertRaisesRegex(ApiError, "其他角色"):
client.snapshot()
self.assertEqual(session.role_id, 101)
finally:
client.close()
class AccountGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, windows):
for _ in range(300):
self.app.processEvents()
QTest.qWait(5)
if all(not window.busy and window.slots.rowCount() for window in windows):
return
self.fail("Account workers did not complete")
def connect(self, window, owner, region, role_id, calls):
window.account.setText(owner)
session = Session("http://127.0.0.1/game/", f"test-token-{owner}", account_id=owner,
account_name=owner, server_id=region, role_id=role_id)
client = fake_client(session, window.catalog, calls)
window.result("connected", (client, Snapshot(role_snapshot(window.catalog, role_id))))
return client
def test_closed_fresh_tab_does_not_start_queued_refresh_and_can_reopen(self):
with workspace_temp() as folder:
hub = AccountsWindow(folder)
hub.add_profile()
profile = hub.profiles[-1]
try:
hub.close_profile(hub.tabs.count() - 1)
self.wait(list(hub.windows.values()))
self.assertEqual(hub.tabs.count(), 1)
hub.open_profile(profile)
self.wait(list(hub.windows.values()))
self.assertEqual(hub.tabs.count(), 2)
finally:
hub.close()
def test_failed_resume_saves_counters_before_response_and_keeps_execution_off(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait([window])
session = Session("http://127.0.0.1/", "private-resume-token", account_id="account-a", server_id=1, role_id=101)
key = window.session_store.save(session, "测试账号 / 区服 1 / 测试角色")
window.reload_saved_sessions()
def failing_client(current, **kwargs):
client = Client(current, **kwargs)
client.http.post = lambda *args, **kwargs: (_ for _ in ()).throw(requests.Timeout())
return client
with patch.object(gui, "Client", side_effect=failing_client):
window.resume_session()
self.wait([window])
self.assertEqual(window.session_store.load(key).reqid, 1)
self.assertFalse(window.execute.isChecked())
self.assertTrue(window.engine.demo)
finally:
window.close()
def test_two_accounts_run_independently_restore_and_right_click_read_only(self):
with workspace_temp() as folder:
hub = AccountsWindow(folder)
hub.add_profile()
windows = list(hub.windows.values())
for window in windows:
window.timer.stop()
calls = []
try:
self.wait(windows)
first, second = windows
self.connect(first, "account-a", 1, 101, calls)
self.connect(second, "account-b", 2, 202, calls)
self.assertNotEqual(first.state, second.state)
self.assertIsNot(first.pool, second.pool)
self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), first.monsters.rowCount(), first.rooms_table.rowCount()], [11, 4, 4, 1])
self.assertEqual(first.saved_sessions.count(), 1)
first.start_monitor.setChecked(True)
hub.tabs.setCurrentWidget(second)
self.assertTrue(first.monitoring)
hub.monitor_all()
for window in windows:
window.engine.last_heartbeat = time.monotonic()
window.next_poll = 0
window.schedule()
self.wait(windows)
self.assertEqual({owner for owner, _, _ in calls}, {"account-a", "account-b"})
self.assertEqual(first.engine.client.session.token, "test-token-account-a")
self.assertEqual(second.engine.client.session.token, "test-token-account-b")
self.assertEqual(first.engine.snapshot.raw["master"]["id"], 101)
self.assertEqual(second.engine.snapshot.raw["master"]["id"], 202)
first.execute.setChecked(True)
before = len(calls)
hub.tabs.setCurrentWidget(first)
first.tabs.setCurrentWidget(first.egg_page)
point = C.QPoint(3, 3)
event = G.QContextMenuEvent(G.QContextMenuEvent.Reason.Mouse, point, first.eggs.viewport().mapToGlobal(point))
self.app.sendEvent(first.eggs.viewport(), event)
self.app.processEvents()
self.assertEqual(first.refresh_menu.actions()[0].text(), "刷新本页")
first.refresh_menu.actions()[0].trigger()
first.refresh_menu.close()
self.wait(windows)
self.assertGreater(len(calls), before)
self.assertTrue(all(url.endswith("masterService/masterQueryDetail") for _, url, _ in calls[before:]))
self.assertFalse(first.engine.auto)
self.assertIs(first.tabs.currentWidget(), first.egg_page)
first.farm.running = True
first.farm.adb.serial = "phone-a"
self.assertFalse(hub.allow_device(second, "phone-a"))
self.assertTrue(hub.allow_device(second, "phone-b"))
self.assertFalse(hub.allow_login(second, "account-a"))
self.assertFalse(hub.allow_connection(second, first.engine.client.session))
finally:
hub.close()
restored = AccountsWindow(folder)
restarted = list(restored.windows.values())
for window in restarted:
window.timer.stop()
try:
self.wait(restarted)
self.assertEqual(len(restarted), 2)
self.assertTrue(all(window.saved_sessions.count() == 1 for window in restarted))
with patch.object(gui, "Client", side_effect=lambda session, **kwargs: fake_client(session, restarted[0].catalog, calls)):
restored.resume_all()
self.wait(restarted)
self.assertEqual({window.engine.snapshot.raw["master"]["id"] for window in restarted}, {101, 202},
"\n".join(window.log.toPlainText() for window in restarted))
self.assertTrue(all(not window.engine.demo and not window.execute.isChecked() and not window.monitoring for window in restarted))
finally:
restored.close()
def test_role_switch_restores_own_strategy_and_heartbeat_uses_normal_api(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
calls = []
try:
self.wait([window])
self.connect(window, "account-a", 1, 101, calls)
first_state = window.state
window.strategy.setCurrentIndex(window.strategy.findData("gold"))
self.connect(window, "account-a", 2, 202, calls)
self.assertNotEqual(window.state, first_state)
self.assertEqual(window.strategy.currentData(), "wiki")
self.connect(window, "account-a", 1, 101, calls)
self.assertEqual(window.state, first_state)
self.assertEqual(window.strategy.currentData(), "gold")
self.assertEqual(window.saved_sessions.count(), 2)
window.engine.last_heartbeat = 0
window.schedule()
self.wait([window])
self.assertTrue(calls[-1][1].endswith("heartBeatService/keepAlive"))
count = len(calls)
window.schedule()
self.app.processEvents()
self.assertEqual(len(calls), count)
finally:
window.close()
if __name__ == "__main__":
unittest.main()
+441
View File
@@ -0,0 +1,441 @@
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["monsterId"] == [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()
+259
View File
@@ -0,0 +1,259 @@
import copy
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
from pathlib import Path
from contextlib import contextmanager
import shutil
import threading
import time
import unittest
import uuid
from unittest.mock import patch
import requests
from PIL import Image, ImageDraw
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.farming import FarmBudget, FarmConfig, FarmRunner, matches
from ranch_assistant.model import Catalog, Planner, Policy, Snapshot
@contextmanager
def workspace_temp():
root = Path(__file__).resolve().parents[2] / "test-artifacts"
folder = root / uuid.uuid4().hex
folder.mkdir(parents=True)
try:
yield folder
finally:
target = folder.resolve()
if target.parent != root.resolve():
raise RuntimeError("Unexpected test cleanup path")
shutil.rmtree(target)
class CoreTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def snapshot(self):
return demo_snapshot(self.catalog)
def test_catalog_and_quality_boundaries(self):
self.assertEqual(len(self.catalog.monsters), 749)
mon = self.snapshot().raw["monsters"][0]
row = self.catalog.monster(mon["typeId"])
for fraction, expected in ((0, 1), (.25, 2), (.5, 3), (.75, 4), (1, 4)):
for stat in ("atk", "def", "hp", "dex"):
mon["g" + stat.capitalize()] = row[stat + "_grow_min"] + fraction * (row[stat + "_grow_max"] - row[stat + "_grow_min"])
# The client rounds growth values to three decimals first.
self.assertEqual(self.catalog.quality(mon), [expected] * 4)
mon.pop("gAtk")
self.assertIsNone(self.catalog.quality(mon)[0])
def test_locked_team_and_existing_monsters_are_preserved(self):
snapshot = self.snapshot()
planner = Planner(self.catalog)
policy = Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False)
snapshot.raw["monsters"][0]["lock"] = 1
snapshot.raw["teams"][0]["monsters"].append(snapshot.raw["monsters"][1]["id"])
plans = planner.plan(snapshot, policy)
self.assertFalse(any(a.kind in ("feed", "sell") for a in plans))
self.assertNotIn(900, planner.managed)
def test_collection_then_feed_with_target_cap(self):
snapshot = self.snapshot()
planner = Planner(self.catalog)
policy = Policy(strategy="experience", protect_star=6, protect_quality=5, feed_target=900, fill=False)
first = planner.plan(snapshot, policy)[0]
self.assertEqual(first.kind, "collect")
mon = snapshot.raw["monsters"][0]
mon.update(process=3, roomId=1)
snapshot.raw["stacks"][0]["monsterId"] = 0
plans = planner.plan(snapshot, policy)
self.assertEqual(plans[0].kind, "feed")
self.assertEqual(plans[0].payload, {"targetId": 900, "foods": [mon["id"]]})
snapshot.monsters[900]["level"] = policy.target_level
self.assertFalse(any(a.kind == "feed" for a in planner.plan(snapshot, policy)))
def test_unknown_quality_never_sold(self):
snapshot = self.snapshot()
for mon in snapshot.raw["monsters"]:
mon.pop("gHp", None)
plans = Planner(self.catalog).plan(snapshot, Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False))
self.assertTrue(all(a.kind != "sell" for a in plans))
def test_reserved_eggs_and_vip_slot(self):
snapshot = self.snapshot()
for slot in snapshot.raw["stacks"]:
slot["monsterId"] = 0
snapshot.raw["monsters"] = []
egg = snapshot.raw["items"][0]
snapshot.raw["items"] = [egg]
egg["num"] = 2
policy = Policy(reserved_eggs={str(egg["typeId"]): 1})
plans = Planner(self.catalog).plan(snapshot, policy)
self.assertEqual(len(plans), 1)
self.assertNotEqual(plans[0].payload["eggs"][0]["stackId"], 4)
egg["num"] = 10
plans = Planner(self.catalog).plan(snapshot, Policy())
self.assertEqual(len(plans), 5)
self.assertNotIn(4, [p.payload["eggs"][0]["stackId"] for p in plans])
def test_room_full_blocks_collecting(self):
snapshot = self.snapshot()
snapshot.raw["rooms"] = []
plans = Planner(self.catalog).plan(snapshot, Policy(strategy="keep", fill=False))
self.assertEqual(plans, [])
def test_null_vip_info_does_not_block_snapshot_preview(self):
snapshot = self.snapshot()
snapshot.raw["activityHistory"]["vipInfo"] = None
for slot in snapshot.raw["stacks"]:
slot["monsterId"] = 0
snapshot.raw["monsters"] = []
self.assertTrue(Planner(self.catalog).plan(snapshot, Policy()))
def test_policy_error_returns_fetched_data_and_stops_actions(self):
engine = Engine(self.catalog)
engine.snapshot = self.snapshot()
engine.auto = True
with patch.object(engine, "plans", side_effect=ValueError("invalid policy")):
snapshot, plans, message = engine.poll()
self.assertIs(snapshot, engine.snapshot)
self.assertEqual(plans, [])
self.assertFalse(engine.auto)
self.assertIn("策略暂不可用", message)
def test_codec_and_har_resume(self):
payload = {"token": "local-test", "reqid": 42, "reqsid": 43, "text": "魔物"}
self.assertEqual(decode(encode(payload, DEFAULT_KEY), DEFAULT_KEY), payload)
har = {"log": {"entries": [{"request": {"url": "http://127.0.0.1/game/masterService/masterQueryDetail", "postData": {"text": encode(payload, DEFAULT_KEY).decode()}}}]}}
session = Session.imported(har)
self.assertEqual(session.reqid, 43)
self.assertEqual(session.reqsid, 44)
self.assertEqual(session.server_url, "http://127.0.0.1/game/")
def test_writes_not_retried_or_secrets_logged(self):
client = Client(Session("http://127.0.0.1/", "private-token"))
with patch.object(client.http, "post", side_effect=requests.Timeout("private-token")) as post:
with self.assertRaises(ApiError) as raised:
client.call("monsterService/monsterSell", {"monsterIds": [1]})
self.assertEqual(post.call_count, 1)
self.assertNotIn("private-token", str(raised.exception))
def test_budget_stamina_tickets_stale_and_persistent_daily_limit(self):
snapshot = self.snapshot()
config = FarmConfig(daily_limit=1)
with workspace_temp() as folder:
budget = FarmBudget(Path(folder) / "runs.json")
self.assertTrue(budget.check(snapshot, config, self.catalog)[0])
snapshot.raw["master"]["ti"] = 5
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
snapshot.raw["master"]["ti"] = 100
snapshot.raw["items"] = []
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
snapshot = self.snapshot()
snapshot.received_at -= 60
self.assertFalse(budget.check(snapshot, config, self.catalog)[0])
snapshot.received_at = time.time()
budget.reserve(snapshot, config)
restarted = FarmBudget(Path(folder) / "runs.json")
self.assertFalse(restarted.check(snapshot, config, self.catalog)[0])
def test_farm_screen_gate_and_real_tap_sequence(self):
with workspace_temp() as folder:
folder = Path(folder)
blank = Image.new("RGB", (200, 400), "black")
ready, victory = blank.copy(), blank.copy()
draw = ImageDraw.Draw(ready)
draw.rectangle((10, 10, 99, 39), fill="green")
draw.rectangle((20, 300, 99, 349), fill="red")
ImageDraw.Draw(victory).rectangle((100, 200, 179, 249), fill="blue")
boxes = {"stage": (10, 10, 100, 40), "entry": (20, 300, 100, 350), "victory": (100, 200, 180, 250)}
templates = {}
for name, box in boxes.items():
(victory if name == "victory" else ready).crop(box).save(folder / f"{name}.png")
templates[name] = {"screen": [200, 400], "box": box, "file": name + ".png", "stage_id": "bd00"}
class FakeAdb:
image = ready
taps = []
def foreground(self): return True
def screenshot(self): return self.image
def tap(self, x, y): self.taps.append((x, y))
adb = FakeAdb()
runner = FarmRunner(adb, self.catalog, folder)
runner.config = FarmConfig(templates=templates)
runner.start()
bad = ready.copy()
ImageDraw.Draw(bad).rectangle(boxes["stage"], fill="black")
adb.image = bad
runner.tick(self.snapshot())
self.assertEqual(adb.taps, [])
adb.image = ready
with patch("ranch_assistant.farming.time.monotonic", return_value=10): runner.tick(self.snapshot())
self.assertEqual(len(adb.taps), 1)
adb.image = victory
with patch("ranch_assistant.farming.time.monotonic", return_value=13): runner.tick(self.snapshot())
adb.image = ready
with patch("ranch_assistant.farming.time.monotonic", return_value=16): runner.tick(self.snapshot())
self.assertEqual(runner.completed, 1)
self.assertEqual(len(adb.taps), 2)
class WireIntegrationTests(unittest.TestCase):
def test_encrypted_http_read_mature_settle_sell_refresh(self):
catalog = Catalog()
state = demo_snapshot(catalog).raw
for mon in state["monsters"]:
if mon.get("process") == 2:
mon["mode"] = 0
mon["timeStart"] = 1
calls = []
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)
calls.append((self.path, body))
if self.path.endswith("stackCheckProcess"):
for mon in state["monsters"]:
if mon.get("process") == 2: mon["mode"] = 2
response = {"resCode": 0}
elif self.path.endswith("monsterSell"):
mid = body["monsterId"][0]
state["monsters"] = [m for m in state["monsters"] if m["id"] != mid]
for slot in state["stacks"]:
if slot["monsterId"] == mid: slot["monsterId"] = 0
response = {"resCode": 0, "money": 150}
else:
response = state | {"resCode": 0}
raw = encode(response, DEFAULT_KEY)
self.send_response(200)
self.send_header("Content-Length", str(len(raw)))
self.end_headers()
self.wfile.write(raw)
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)
engine.policy = Policy(strategy="gold", protect_star=6, protect_quality=5, fill=False)
engine.poll()
self.assertFalse(any(p.endswith("stackCheckProcess") or p.endswith("monsterSell") for p, _ in calls))
engine.auto = True
snapshot, _, _ = engine.poll()
self.assertEqual(sum(p.endswith("monsterSell") for p, _ in calls), 1)
self.assertEqual(sum(m.get("process") == 2 for m in snapshot.raw["monsters"]), 3)
self.assertEqual([v["reqid"] for _, v in calls], list(range(len(calls))))
finally:
client.close()
server.shutdown()
server.server_close()
thread.join(2)
if __name__ == "__main__":
unittest.main()
+93
View File
@@ -0,0 +1,93 @@
import json
import os
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import requests
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, encode
from ranch_assistant.credentials import CredentialStore
from ranch_assistant.debug import HIDDEN, TraceLog
from ranch_assistant.login import PasswordLogin
from ranch_assistant.model import Catalog
from ranch_assistant.tests.test_core import workspace_temp
class DiagnosticsTests(unittest.TestCase):
@unittest.skipUnless(os.name == "nt", "Windows DPAPI")
def test_remember_password_round_trip_and_disable(self):
with workspace_temp() as folder:
store = CredentialStore(folder)
store.save("local-test-account", "test+密码&123")
self.assertEqual(store.load(), (True, "local-test-account", "test+密码&123"))
self.assertNotIn("test+密码&123", store.path.read_text(encoding="utf-8"))
store.save("local-test-account", "test+密码&123", False)
self.assertEqual(store.load(), (False, "", ""))
self.assertNotIn("password", json.loads(store.path.read_text(encoding="utf-8")))
def test_nested_secrets_previews_and_error_messages_are_redacted(self):
with workspace_temp() as folder:
events = []
trace = TraceLog(folder, events.append)
request = trace.begin("test", body={"password": "test-password"}, headers={"Authorization": "test-auth"})
trace.emit("response", "test", request_id=request, body={"data": {"userList": [{"token": "test-token"}]},
"servers": [{"regionId": 2}]})
trace.emit("error", "test", message="echo: test-password test-token test-auth")
trace.emit("response", "test", body_preview='{"token":"partial-secret", "field": 2, "password":"unknown')
text = trace.path.read_text(encoding="utf-8")
for secret in ("test-password", "test-token", "test-auth", "partial-secret", "unknown"):
self.assertNotIn(secret, text)
self.assertEqual(events[1]["body"]["data"]["userList"][0]["token"], HIDDEN)
self.assertEqual(events[1]["body"]["servers"], [{"regionId": 2}])
def test_failed_server_parsing_preserves_received_schema_in_trace(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
client = Client(Session(), trace)
body = {"resCode": 0, "playerInfo": {"token": "private-test-token"}, "servers": [{"regionId": 2, "serverName": "测试区"}]}
response = SimpleNamespace(status_code=200, content=encode(body, DEFAULT_KEY), headers={})
try:
with patch.object(client.http, "post", return_value=response):
with self.assertRaises(ApiError):
client.sdk_login("http://127.0.0.1/", "test-user", "test-sdk")
records = list(trace.events)
self.assertEqual(records[1]["body"]["servers"][0]["regionId"], 2)
self.assertEqual(records[2]["operation"], "本地区服整理")
self.assertNotIn("private-test-token", trace.text())
finally:
client.close()
def test_timeout_is_logged_at_the_request_stage_and_is_not_retried(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
client = Client(Session("http://127.0.0.1/", "private-test-token"), trace)
try:
with patch.object(client.http, "post", side_effect=requests.Timeout("echo private-test-token")) as post:
with self.assertRaises(ApiError):
client.call("masterService/masterQueryDetail")
self.assertEqual(post.call_count, 1)
self.assertEqual(list(trace.events)[-1]["operation"], "读取角色")
self.assertEqual(list(trace.events)[-1]["exception_type"], "Timeout")
self.assertNotIn("private-test-token", trace.text())
finally:
client.close()
def test_sdk_non_json_http_failure_retains_status_and_sanitized_preview(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
flow = PasswordLogin(Catalog(), "test-device", trace=trace)
with patch("ranch_assistant.login.requests.Session") as session:
response = session.return_value.__enter__.return_value.post.return_value
response.status_code, response.headers = 502, {}
response.content = b"gateway error test-password"
response.json.side_effect = ValueError("not json")
with self.assertRaisesRegex(ApiError, "HTTP 502"):
flow.authenticate("test-account", "test-password")
received = next(e for e in trace.events if e["kind"] == "response")
self.assertEqual(received["http_status"], 502)
self.assertIn("gateway error", received["body_preview"])
self.assertNotIn("test-password", trace.text())
if __name__ == "__main__":
unittest.main()
+297
View File
@@ -0,0 +1,297 @@
import hashlib
import hmac
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
from datetime import datetime, timedelta, timezone
import threading
import unittest
from urllib.parse import parse_qs, urlsplit
from unittest.mock import patch
from PIL import Image, ImageDraw
from ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode, server_entries, server_id
from ranch_assistant.capture import load_buttons, save_page, saved_profiles, write_buttons
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.debug import TraceLog
from ranch_assistant.farming import FarmConfig, FarmRunner
from ranch_assistant.login import PasswordLogin, SDK_APP_ID, SDK_APP_SECRET, server_labels
from ranch_assistant.maps import stages
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.quests import QuestPolicy, TaskPlanner, condition_ok
from ranch_assistant.tests.test_core import workspace_temp
class LoginTests(unittest.TestCase):
def entry_request(self):
catalog = Catalog()
catalog.data["tjchannel"] = {"tjchannel": "taptap"}
client = Client(Session(token="abcdefghijklmno"))
instant = datetime(2026, 11, 7, 19, 0, tzinfo=timezone(timedelta(hours=8)))
try:
with patch("ranch_assistant.api.datetime") as clock, patch.object(client, "call") as call:
clock.now.return_value = instant
client.enter_server("http://127.0.0.1/", {"id": 1, "gameServerAddress": "http://127.0.0.1/game/"}, "12345678", catalog)
return call.call_args.args[1]
finally:
client.close()
def test_entry_signature_matches_paster_full_year_format(self):
# Paster.timestampFormat replaces "yy" with Date.fullYear, yielding eight digits.
expected = hashlib.md5(b"202611075678defghijklmno").hexdigest()
self.assertEqual(self.entry_request()["random"], expected)
def test_entry_uses_apk_tracking_channel(self):
self.assertEqual(self.entry_request()["tjChannel"], "taptap")
def test_unknown_or_conflicting_server_ids_do_not_enter_any_server(self):
client = Client(Session(token="synthetic-test-token"))
try:
with patch.object(client, "call") as call:
for server in ({"serverName": "private-value"}, {"id": 1, "serverId": 2}, {"serverId": True}, {"serverId": 1.5}):
with self.assertRaises(ApiError) as raised:
client.enter_server("http://127.0.0.1/", server, "test-uid", Catalog())
self.assertNotIn("private-value", str(raised.exception))
with self.assertRaises(ApiError):
client.enter_server("http://127.0.0.1/", {"serverId": 2}, "test-uid", Catalog())
call.assert_not_called()
self.assertEqual(server_id({"serverId": "2"}), 2)
finally:
client.close()
def test_password_two_regions_and_enter_selected_game_server(self):
self.password_flow("id")
def test_password_serverId_regions_and_enter_selected_game_server(self):
self.password_flow("serverId")
def test_password_server_references_are_deduplicated_before_entering_second_region(self):
self.password_flow("id", references=True)
def test_reference_entries_resolve_to_two_real_servers_without_mutating_response(self):
response = {"servers": [{"id": 1, "serverName": "测试一区"}, {"id": 2, "serverName": "测试二区"},
{"$ref": "$.servers[0]"}, {"$ref": "$.servers[1]"}]}
self.assertEqual([row["id"] for row in server_entries(response)], [1, 2])
self.assertEqual(response["servers"][2], {"$ref": "$.servers[0]"})
def test_reference_chains_duplicates_and_invalid_targets(self):
response = {"servers": [{"$ref": "$.servers[1]"}, {"$ref": "$.servers[2]"}, {"id": 2}, {"id": "2"}]}
self.assertEqual([row["id"] for row in server_entries(response)], [2])
for rows in ([{"$ref": "$.servers[0]"}], [{"$ref": "$.servers[9]"}],
[{"$ref": "https://example.invalid/"}], [{"$ref": "$.servers[1]"}, {"$ref": "$.servers[0]"}],
[{"id": 2, "gameServerAddress": "http://127.0.0.1/a/"}, {"id": 2, "gameServerAddress": "http://127.0.0.1/b/"}]):
with self.subTest(rows=rows), self.assertRaises(ApiError):
server_entries({"servers": rows})
def test_debug_covers_all_four_login_requests_and_omits_secrets(self):
with workspace_temp() as folder:
trace = TraceLog(folder)
self.password_flow("serverId", trace)
text = trace.path.read_text(encoding="utf-8")
for secret in ("raw+p&ssword", "sdk-test-token", "game-test-token"):
self.assertNotIn(secret, text)
self.assertEqual([e["operation"] for e in trace.events if e["kind"] == "request"][:4],
["渠道账号验证", "获取官方区服", "进入选中区服", "读取角色"])
self.assertTrue(any(e.get("body", {}).get("servers") for e in trace.events if isinstance(e.get("body"), dict)))
def password_flow(self, id_field, trace=None, references=False):
catalog = Catalog()
calls = []
sdk_status = [200]
class Handler(BaseHTTPRequestHandler):
def log_message(self, *args):
pass
def do_POST(self):
raw = self.rfile.read(int(self.headers["Content-Length"]))
if self.path.startswith("/sdk"):
calls.append((self.path, parse_qs(raw.decode()), dict(self.headers)))
body = {"code": sdk_status[0], "data": {"userList": [{"userId": "12345678", "token": "sdk-test-token"}]}}
reply = json.dumps(body).encode()
else:
body = decode(raw, DEFAULT_KEY)
calls.append((self.path, body, {}))
address = f"http://127.0.0.1:{self.server.server_port}"
if self.path.endswith("loginUser"):
response = {"playerInfo": {"token": "game-test-token"},
"servers": [{id_field: 1, "serverName": "一区", "platform": "ANDROID", "gameServerAddress": address + "/one/"},
{id_field: "2", "serverName": "二区", "platform": "ANDROID", "gameServerAddress": address + "/two/"},
{id_field: 3, "serverName": "其他平台", "platform": "IOS"}],
"masterInfos": [{"id": 9001, "serverId": 2, "masterName": "本地测试角色"}]}
if references:
response["servers"] = response["servers"][:2] + [{"$ref": "$.servers[0]"}, {"$ref": "$.servers[1]"}]
elif self.path.endswith("enterGame"):
# Independent contract from NetUser + Paster, using fixed test UID/token tails.
today = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d")
expected = hashlib.md5((today + "5678e-test-token").encode()).hexdigest()
response = {} if body.get("random") == expected and body.get("tjChannel") == "taptap" else {"resCode": 990, "resMsg": "Illegal"}
else:
response = demo_snapshot(catalog).raw
reply = encode({"resCode": 0} | response, DEFAULT_KEY)
self.send_response(200)
self.send_header("Content-Length", str(len(reply)))
self.end_headers()
self.wfile.write(reply)
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
address = f"http://127.0.0.1:{server.server_port}"
flow = PasswordLogin(catalog, "desktop-test", sdk_url=address + "/sdk", center_url=address + "/center/", trace=trace)
client = None
try:
client, game, context = flow.authenticate(" local-account ", "raw+p&ssword")
self.assertIn("本地测试角色", server_labels(game)[1])
self.assertEqual([s["id"] for s in game["servers"]], [1, 2])
client.enter_server(context["center_url"], game["servers"][1], context["uid"], catalog)
self.assertEqual(client.snapshot().raw["master"]["id"], 1)
self.assertEqual(calls[0][1], {"account": ["local-account"], "password": ["raw+p&ssword"]})
self.assertEqual(parse_qs(urlsplit(calls[0][0]).query)["appChannel"], ["taptap"])
self.assertEqual(calls[0][2]["Authorization"], hmac.new(SDK_APP_SECRET.encode(), SDK_APP_ID.encode(), hashlib.sha256).hexdigest())
self.assertEqual(calls[1][1]["sdkToken"], "sdk-test-token")
self.assertEqual(calls[1][1]["channel"], "DYD")
self.assertEqual(calls[1][1]["tjChannel"], "taptap")
self.assertEqual(calls[2][1]["serverId"], 2)
self.assertEqual(calls[3][0], "/two/masterService/masterQueryDetail")
for status in (407, 408):
sdk_status[0] = status
before = len(calls)
with self.assertRaises(ApiError):
flow.authenticate("local-account", "raw+p&ssword")
self.assertEqual(len(calls), before + 1)
finally:
if client:
client.close()
server.shutdown()
server.server_close()
thread.join(2)
class PlanningTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.snapshot = demo_snapshot(self.catalog)
self.ranch = Policy(protect_star=6, protect_quality=5, fill=False)
self.policy = QuestPolicy(enabled=True)
self.catalog.data["task_info"] = {"test": {"name": "测试委托", "steps": [{"statusType": "none"}]}}
self.planner = TaskPlanner(self.catalog)
def test_quest_accept_step_reward_and_daily_limit(self):
history = self.snapshot.raw["history"]
history.update(loopTaskNum=1, unlockCity={"1": True}, loopTask={"1": ["test"]})
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "quest_accept")
engine = Engine(self.catalog)
engine.snapshot = self.snapshot
engine.apply_demo(action)
self.assertEqual(history["loopTaskNum"], 0)
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "quest_step")
engine.apply_demo(action)
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "quest_complete")
engine.apply_demo(action)
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
def test_consumable_reserves_and_protected_monsters(self):
egg = self.snapshot.raw["items"][0]
step = {"statusType": "getItem", "statusValue": {"type": egg["typeId"], "num": 2, "remove": True}}
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
self.policy.allow_items = True
self.policy.item_reserves[str(egg["typeId"])] = egg["num"] - 1
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
self.policy.item_reserves.clear()
self.assertTrue(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
mon = self.snapshot.raw["monsters"][0]
mon["typeId"] = str(mon["typeId"])
self.policy.allow_monsters = True
self.ranch.reserved_types = [int(mon["typeId"])]
step = {"statusType": "getMonster", "statusValue": {"type": mon["typeId"], "num": 1, "mode": 2, "remove": True}}
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
self.ranch.reserved_types.clear()
mon["lock"] = 1
self.assertFalse(self.planner.requirement(self.snapshot, step, {}, self.policy, self.ranch)[0])
def test_battle_steps_wait_for_actual_combat(self):
self.snapshot.raw["currentTasks"] = [{"id": 12, "typeId": "test", "curStep": 1}]
for kind in ("battle", "passStage"):
self.catalog.data["task_info"]["test"]["steps"] = [{"statusType": kind}]
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
step = {"statusType": "killMonster", "statusValue": {"type": 100, "num": 1}}
self.snapshot.raw["history"]["numKillMonsters"] = {"100": 12}
self.assertFalse(self.planner.requirement(self.snapshot, step, {"stepValue": 15}, self.policy, self.ranch)[0])
self.assertTrue(self.planner.requirement(self.snapshot, step, {"stepValue": 12}, self.policy, self.ranch)[0])
def test_map_unlocks_are_per_difficulty_and_conditions_accept_null(self):
self.assertTrue(condition_ok({"minLevel": None, "maxLevel": None, "week": None, "endTime": None}, self.snapshot))
self.catalog.data["stage_info"] = {"test": {"name": "地图测试", "level": {"1": {"cost": 1}, "2": {"cost": 2}}, "cost": {"ti": 6}}}
self.snapshot.raw["history"].update(unlockStage={"test": {"1": True, "2": False}}, passStage={"test": {"1": True}})
first, second = stages(self.catalog, self.snapshot)
self.assertTrue(first.unlocked and first.passed and first.open)
self.assertFalse(second.unlocked or second.passed)
self.assertEqual((first.stamina, second.stamina), (7, 8))
class CaptureTests(unittest.TestCase):
def test_profile_scope_button_binding_and_changed_capture(self):
with workspace_temp() as folder:
ready = Image.new("RGB", (100, 200), "blue")
victory = Image.new("RGB", (100, 200), "green")
path, _ = save_page(folder, ready, "phone-a", "bd00", "1", "stage_ready")
save_page(folder, victory, "phone-a", "bd00", "1", "victory")
alternate, _ = save_page(folder, ready.resize((200, 400)), "phone-a", "bd00", "1", "stage_ready")
other, _ = save_page(folder, ready, "phone-b", "bd00", "1", "stage_ready")
self.assertEqual(len({path, alternate, other}), 3)
self.assertEqual(len(saved_profiles(folder, "bd00", "1", "phone-a")), 2)
regions = {"stage": {"box": [0, 0, 20, 20]}, "entry": {"box": [20, 20, 40, 40]},
"victory": {"box": [40, 40, 60, 60], "tap": [70, 180]}}
write_buttons(path, folder, regions)
templates = load_buttons(path, folder, "bd00", "1", "phone-a")
self.assertEqual(templates["victory"]["tap"], [70, 180])
with self.assertRaises(ValueError):
load_buttons(path, folder, "bd00", "2")
with self.assertRaises(ValueError):
load_buttons(path, folder, "bd00", "1", "phone-b")
save_page(folder, Image.new("RGB", ready.size, "red"), "phone-a", "bd00", "1", "stage_ready")
with self.assertRaises(ValueError):
load_buttons(path, folder, "bd00", "1")
def test_runtime_device_resolution_and_separate_victory_tap(self):
with workspace_temp() as folder:
ready = Image.new("RGB", (100, 200), "black")
victory = ready.copy()
ImageDraw.Draw(ready).rectangle((0, 0, 40, 40), fill="blue")
ImageDraw.Draw(victory).rectangle((40, 40, 60, 60), fill="green")
path, _ = save_page(folder, ready, "phone-a", "bd00", "1", "stage_ready")
save_page(folder, victory, "phone-a", "bd00", "1", "victory")
write_buttons(path, folder, {"stage": {"box": [0, 0, 20, 20]}, "entry": {"box": [20, 20, 40, 40]},
"victory": {"box": [40, 40, 60, 60], "tap": [70, 180]}})
class FakeAdb:
serial = "phone-a"
image = ready
taps = []
def foreground(self): return True
def screenshot(self): return self.image
def tap(self, x, y): self.taps.append((x, y))
adb = FakeAdb()
catalog = Catalog()
runner = FarmRunner(adb, catalog, folder)
runner.config = FarmConfig(capture_profile=str(path.relative_to(folder)))
runner.start()
with patch("ranch_assistant.farming.time.monotonic", return_value=10):
runner.tick(demo_snapshot(catalog))
adb.image = victory
with patch("ranch_assistant.farming.time.monotonic", return_value=13):
runner.tick(demo_snapshot(catalog))
self.assertEqual(adb.taps[-1], (70, 180))
adb.serial = "phone-b"
with self.assertRaises(RuntimeError):
runner.tick(demo_snapshot(catalog))
adb.serial = "phone-a"
runner.start()
adb.image = ready.resize((200, 400))
with self.assertRaises(RuntimeError):
runner.tick(demo_snapshot(catalog))
self.assertEqual(len(adb.taps), 2)
if __name__ == "__main__":
unittest.main()
+223
View File
@@ -0,0 +1,223 @@
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"))})
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"], [{"monsterId": [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_is_read_only_and_explicit_sync_does_not_dispatch(self):
client = GrowthClient(self.catalog, age=610)
engine = self.engine(client)
engine.auto = False
snapshot, _, message = engine.poll()
self.assertFalse(any(name == "growth" for name, _ in client.calls))
self.assertIn("仅监控", message)
snapshot, plans, _ = engine.sync_growth()
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 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"))}
window.engine.policy = window.read_policy()
window.engine.snapshot = client.snapshot()
window.render(window.engine.snapshot, window.engine.plans())
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.item(0, 4).text(), "C/C/C/C")
window.sync_growth_button.click()
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.item(0, 4).text())
self.assertFalse(window.execute.isChecked())
self.assertFalse(any(name == "monsterService/monsterSell" for name, _ in client.calls))
finally:
window.close()
if __name__ == "__main__":
unittest.main()
+215
View File
@@ -0,0 +1,215 @@
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
import json
import unittest
from unittest.mock import patch
from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication
from ranch_assistant import gui
from ranch_assistant.tests.test_core import workspace_temp
class GuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = QApplication.instance() or QApplication([])
def wait(self, window):
for _ in range(200):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and window.slots.rowCount():
return
self.fail("Qt background refresh did not complete")
def test_preview_auto_execution_and_secret_free_settings(self):
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
self.assertIn("页面截图配置", [window.tabs.tabText(i) for i in range(window.tabs.count())])
self.assertEqual(window.yields.rowCount(), 749)
self.assertEqual(window.styleSheet(), "")
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.protect_star.setValue(6)
window.protect_quality.setCurrentIndex(window.protect_quality.findData(5))
window.fill.setChecked(False)
window.execute.setChecked(True)
before = len(window.engine.snapshot.raw["monsters"])
window.refresh()
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before)
window.start_monitor.setChecked(True)
window.refresh(automated=True)
self.wait(window)
self.assertEqual(len(window.engine.snapshot.raw["monsters"]), before - 1)
window.token.setText("never-save-this-token")
window.key.setText("never-save-this-key")
window.password.setText("never-save-this-password")
window.save_config()
settings = (folder / "settings.json").read_text(encoding="utf-8")
self.assertNotIn("never-save-this-token", settings)
self.assertNotIn("never-save-this-key", settings)
self.assertNotIn("never-save-this-password", settings)
self.assertEqual(json.loads(settings)["policy"]["strategy"], "gold")
finally:
window.close()
def test_page_buttons_only_capture_and_restore_profile(self):
from PIL import Image
from ranch_assistant.capture import PAGES
operations = []
class FakeAdb:
def __init__(self, executable="", serial=""):
self.serial = serial
def foreground(self):
operations.append("foreground")
return True
def run(self, *args):
operations.append(args)
if args != ("get-serialno",):
raise AssertionError("Screenshot flow attempted another ADB command")
return "test-phone"
def screenshot(self):
operations.append("screenshot")
return Image.new("RGB", (320, 640), "green")
def tap(self, *args):
raise AssertionError("Screenshot flow must never tap")
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
window.start_monitor.setChecked(True)
with patch.object(gui, "Adb", FakeAdb):
for index in range(len(PAGES)):
window.capture_rows.cellWidget(index, 2).click()
self.wait(window)
self.assertFalse(window.monitoring)
profile = json.loads(window.capture_profile.read_text(encoding="utf-8"))
self.assertEqual(set(profile["captures"]), {p[0] for p in PAGES})
self.assertEqual(operations.count("screenshot"), len(PAGES))
self.assertFalse(window.capture_preview.selectable)
original = window.capture_profile
window.stage.setCurrentIndex(1)
self.assertIsNone(window.capture_profile)
window.stage.setCurrentIndex(0)
self.assertEqual(window.capture_profile, original)
finally:
window.close()
restored = gui.Window()
restored.timer.stop()
try:
self.wait(restored)
self.assertEqual(restored.capture_profile, original)
restored.preview_capture(0, 0)
self.assertEqual(restored.capture_preview.image.size, (320, 640))
finally:
restored.close()
def test_password_result_accepts_serverId_and_handles_missing_identifier(self):
from unittest.mock import Mock
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
client = Mock()
try:
self.wait(window)
response = {"servers": [{"serverId": "1", "serverName": "一区"},
{"serverId": 2, "serverName": "二区"}], "masterInfos": [{"id": 9001, "serverId": 2, "roleName": "测试角色"}]}
window.result("password", (client, response, {}))
self.assertEqual(window.server_list.count(), 2)
window.server_list.setCurrentIndex(1)
self.assertIn("测试角色", window.server_list.currentText())
self.assertTrue(window.enter_button.isEnabled())
window.result("password", (client, {"servers": [{"serverName": "坏条目"}]}, {}))
self.assertFalse(window.enter_button.isEnabled())
self.assertEqual(window.server_list.count(), 0)
self.assertIsNone(window.password_login_result)
self.assertIn("serverName", window.log.toPlainText())
finally:
window.close()
def test_official_response_with_server_references_displays_both_characters(self):
from unittest.mock import Mock
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
client = Mock()
try:
self.wait(window)
response = {"servers": [{"id": 1, "serverName": "测试一区"}, {"id": 2, "serverName": "测试二区"},
{"$ref": "$.servers[0]"}, {"$ref": "$.servers[1]"}],
"masterInfos": [{"id": 1001, "serverId": 1, "masterName": "测试角色甲"},
{"id": 2002, "serverId": 2, "masterName": "测试角色乙"}]}
window.result("password", (client, response, {}))
self.assertEqual(window.server_list.count(), 2)
self.assertIn("测试角色甲", window.server_list.itemText(0))
self.assertIn("测试角色乙", window.server_list.itemText(1))
window.server_list.setCurrentIndex(1)
self.assertEqual(window.server_list.currentData()["id"], 2)
self.assertTrue(window.enter_button.isEnabled())
self.assertNotIn("操作失败", window.login_status.text())
finally:
window.close()
def test_local_server_error_is_labeled_and_not_logged_twice(self):
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
window.trace.emit("error", "本地区服整理", scope="local", message="测试区服整理错误")
window.error("测试区服整理错误")
self.app.processEvents()
self.assertEqual(len(window.trace.events), 1)
self.assertEqual(window.debug_window.rows.rowCount(), 1)
self.assertEqual(window.debug_window.rows.item(0, 2).text(), "本地错误")
finally:
window.close()
def test_password_is_retained_after_failure_and_restored_on_restart_with_debug_records(self):
from ranch_assistant.api import ApiError
class FailedLogin:
def __init__(self, *args, trace, **kwargs):
self.trace = trace
def authenticate(self, account, password):
request = self.trace.begin("渠道账号验证", body={"account": account, "password": password})
self.trace.emit("response", "渠道账号验证", request_id=request, http_status=200, body={"code": 407})
raise ApiError("测试登录失败")
with workspace_temp() as folder, patch.object(gui, "STATE", folder):
window = gui.Window()
window.timer.stop()
try:
self.wait(window)
window.account.setText("local-gui-account")
window.password.setText("local-gui-password")
with patch.object(gui, "PasswordLogin", FailedLogin), patch.object(window, "show_debug") as show:
window.password_login()
self.wait(window)
show.assert_not_called()
self.assertEqual(window.password.text(), "local-gui-password")
self.assertGreaterEqual(window.debug_window.rows.rowCount(), 3)
text = window.trace.path.read_text(encoding="utf-8")
self.assertIn('"code": 407', text)
self.assertNotIn("local-gui-password", text)
self.assertFalse(window.enter_button.isEnabled())
finally:
window.close()
restored = gui.Window()
restored.timer.stop()
try:
self.wait(restored)
self.assertEqual(restored.account.text(), "local-gui-account")
self.assertEqual(restored.password.text(), "local-gui-password")
restored.remember_password.setChecked(False)
finally:
restored.close()
self.assertEqual(gui.CredentialStore(folder).load(), (False, "", ""))
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,301 @@
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")}, 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, 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}})
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], [{"monsterId": [101]}, {"monsterIds": [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), "登录")
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())
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == "900")
window.monsters.cellWidget(row, 8).setChecked(True)
window.monsters.cellWidget(row, 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.execute.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):
row = next(i for i in range(window.monsters.rowCount()) if window.monsters.item(i, 0).text() == str(mid))
window.monsters.selectRow(row)
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()