Initialize local project and fix ranch growth synchronization
This commit is contained in:
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user