260 lines
12 KiB
Python
260 lines
12 KiB
Python
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()
|