Files

234 lines
13 KiB
Python

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 ranch_assistant.api import ApiError, Client, DEFAULT_KEY, Session, decode, encode, server_entries, server_id
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.debug import TraceLog
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))
if __name__ == "__main__":
unittest.main()