Files
myrzx_bot/ranch_assistant/tests/test_extensions.py
T

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