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