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()