Files

206 lines
10 KiB
Python

import copy
from contextlib import redirect_stdout
import io
import json
from types import SimpleNamespace
import unittest
from unittest.mock import patch
from ranch_assistant.api import DEFAULT_KEY, encode
from ranch_assistant.tests.test_core import workspace_temp
from tools.capture_battle_proxy import BattleCapture
from tools.compare_battle_v12 import compare, main, observations
END = "battleService/battleEnd"
def battle():
return {"battlePosition": {"battleType": "stage", "stageId": "0101", "stageLevel": "1"},
"battleMonIds": [11, 12], "win": True, "leftTime": 275000, "aliveNum": 2,
"apLeft": 5, "killMonster": {"1001010": 5}, "cheatNum": 0}
def events(value=None, code=0):
return [{"kind": "request", "operation": END, "request_id": "fixture-1", "capture_origin": "phone_proxy",
"body": {"battleData": battle() if value is None else value, "token": "sensitive-token"}},
{"kind": "response", "operation": END, "request_id": "fixture-1", "body": {"resCode": code, "costTi": 10}}]
def estimate(ids=(11, 12)):
return {"format": "myrzx-offline-basic-attack-estimate", "stage": {"id": "0101", "difficulty": "1"},
"players": [{"instance_id": mid} for mid in ids], "configured_time_limit_seconds": 300,
"duration_seconds_by_predicted_outcome": {"win": {"median": 20, "p10": 18, "p90": 23}}}
class Message:
def __init__(self, content):
self.content = content
def get_content(self):
return self.content
def flow(request, response, url="https://prod-dyd-1.dydab.com:9091/" + END):
req = Message(request)
req.pretty_url = url
res = Message(response)
res.status_code = 200
return SimpleNamespace(id="fixture-flow", request=req, response=res)
class BattleCaptureTests(unittest.TestCase):
def test_encrypted_capture_decodes_redacts_and_never_changes_or_sends_the_flow(self):
with workspace_temp() as folder, patch("socket.socket", side_effect=AssertionError("Unexpected network")):
capture = BattleCapture(folder, DEFAULT_KEY)
exchange = flow(encode({"token": "capture-private-token", "battleData": battle()}, DEFAULT_KEY),
encode({"resCode": 0, "reward": {}}, DEFAULT_KEY))
before = (exchange.request.content, exchange.response.content)
capture.request(exchange)
capture.response(exchange)
self.assertEqual((exchange.request.content, exchange.response.content), before)
text = capture.trace.path.read_text(encoding="utf-8")
self.assertNotIn("capture-private-token", text)
self.assertNotIn(DEFAULT_KEY, text)
rows = [json.loads(line) for line in text.splitlines()]
self.assertEqual(rows[0]["body"]["battleData"], battle())
samples, diagnostics = observations(rows)
self.assertEqual(len(samples), 1)
self.assertEqual(diagnostics, {})
def test_plain_json_is_supported_and_query_strings_are_not_saved(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
exchange = flow(json.dumps({"battleData": battle()}).encode(), b'{"resCode":0}',
url="https://prod-dyd-1.dydab.com:9091/" + END + "?token=query-secret")
capture.request(exchange)
self.assertNotIn("query-secret", capture.trace.path.read_text(encoding="utf-8"))
def test_other_hosts_login_and_payment_paths_are_ignored(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
for url in ("https://prod-dyd-1.dydab.com.evil.test/" + END,
"https://unrelated.test/" + END,
"https://prod-dyd-1.dydab.com:9091/userServerService/loginUser",
"https://prod-dyd-1.dydab.com:9091/paymentService/pay"):
exchange = flow(b'{"token":"secret"}', b'{}', url)
capture.request(exchange)
capture.response(exchange)
self.assertFalse(capture.trace.events)
self.assertFalse(capture.trace.path.exists())
def test_decode_failure_does_not_retain_raw_body(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
capture.request(flow(b"raw-private-body", b"{}"))
text = capture.trace.path.read_text(encoding="utf-8")
self.assertNotIn("raw-private-body", text)
self.assertEqual(capture.trace.events[0]["kind"], "error")
def test_pause_marker_stops_recording_without_modifying_the_flow(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
exchange = flow(b'{"battleData":{}}', b'{"resCode":0}')
capture.trace.path.with_name("capture.paused").touch()
capture.request(exchange)
capture.response(exchange)
self.assertFalse(capture.trace.events)
self.assertEqual(exchange.request.content, b'{"battleData":{}}')
def test_readiness_probe_decodes_but_retains_no_game_or_account_body(self):
with workspace_temp() as folder:
capture = BattleCapture(folder)
exchange = flow(encode({"token": "probe-token", "masterId": 1234567}, DEFAULT_KEY),
encode({"resCode": 0, "private": "probe-private-data"}, DEFAULT_KEY),
url="https://prod-dyd-1.dydab.com:9091/heartBeatService/keepAlive")
capture.request(exchange)
capture.response(exchange)
rows = list(capture.trace.events)
self.assertTrue(all(row["kind"] == "diagnostic" and row["decoded"] for row in rows))
self.assertEqual(rows[1]["resCode"], 0)
text = capture.trace.path.read_text(encoding="utf-8")
for value in ("probe-token", "1234567", "probe-private-data", '"body"'):
self.assertNotIn(value, text)
class BattleComparisonTests(unittest.TestCase):
def test_successful_request_and_response_are_paired_without_mutation_or_secrets(self):
source = events()
before = copy.deepcopy(source)
samples, diagnostics = observations(source)
self.assertEqual(source, before)
self.assertEqual(diagnostics, {})
self.assertEqual(len(samples), 1)
self.assertNotIn("sensitive-token", json.dumps(samples))
def test_missing_or_failed_response_is_not_a_confirmed_sample(self):
self.assertEqual(observations(events()[:1])[0], [])
self.assertEqual(observations(events(code=997))[0], [])
def test_sweep_shaped_data_cannot_be_used_as_a_real_battle_sample(self):
value = battle()
value.update(leftTime=0, aliveNum=0, apLeft=0, killMonster={})
samples, diagnostics = observations(events(value))
self.assertEqual(samples, [])
self.assertEqual(diagnostics["sweep_or_ambiguous_empty_result"], 1)
def test_duplicate_flow_is_not_counted_twice(self):
source = events()
samples, diagnostics = observations(source + source)
self.assertEqual(len(samples), 1)
self.assertEqual(diagnostics["duplicate_request"], 1)
def test_elapsed_time_is_derived_from_millisecond_combat_clock(self):
sample = observations(events())[0][0]
result = compare(estimate(), sample, client_variant="original")
self.assertEqual(result["status"], "compared")
self.assertEqual(result["observed_clock_elapsed_seconds"], 25)
self.assertEqual(result["absolute_time_error_seconds"], 5)
self.assertAlmostEqual(result["relative_time_error"], .2)
self.assertFalse(result["same_attributes_and_resource_version_verified"])
def test_other_rosters_stages_and_task_contexts_are_not_mixed(self):
sample = observations(events())[0][0]
self.assertEqual(compare(estimate((99,)), sample)["status"], "different_roster")
other = estimate()
other["stage"]["difficulty"] = "2"
self.assertEqual(compare(other, sample)["status"], "different_stage_or_difficulty")
sample["position"]["battleType"] = "task"
self.assertEqual(compare(estimate(), sample)["status"], "task_context_requires_separate_mapping")
def test_missing_roster_identity_is_only_an_exploratory_comparison(self):
result = compare(estimate((None, None)), observations(events())[0][0], client_variant="original")
self.assertEqual(result["status"], "exploratory_roster_unverified")
def test_missing_and_out_of_range_timing_is_rejected(self):
sample = observations(events())[0][0]
for remaining in (None, -1, 300001, float("nan")):
sample["reported"]["leftTime"] = remaining
self.assertEqual(compare(estimate(), sample)["status"], "invalid_or_missing_timing")
def test_modified_client_is_retained_as_protocol_evidence_without_timing_comparison(self):
sample = observations(events())[0][0]
result = compare(estimate(), sample, client_variant="modified")
self.assertEqual(result["status"], "modified_client_not_calibratable")
self.assertNotIn("relative_time_error", result)
def test_unverified_client_is_not_counted_as_an_aligned_comparison(self):
result = compare(estimate(), observations(events())[0][0])
self.assertEqual(result["status"], "exploratory_client_unverified")
def test_protocol_only_cli_keeps_variant_and_samples_without_network_or_model(self):
with workspace_temp() as folder, patch("socket.socket", side_effect=AssertionError("Unexpected network")):
capture, output = folder / "capture.jsonl", folder / "report.json"
capture.write_text("\n".join(json.dumps(row) for row in events()), encoding="utf-8")
with redirect_stdout(io.StringIO()):
code = main(["--capture", str(capture), "--client-variant", "modified", "--output", str(output)])
report = json.loads(output.read_text(encoding="utf-8"))
self.assertEqual(code, 0)
self.assertEqual(report["capture_client_variant"], "modified")
self.assertEqual(report["accepted_settlement_sample_count"], 1)
self.assertEqual(report["aligned_roster_comparison_count"], 0)
self.assertIsNone(report["median_relative_time_error"])
if __name__ == "__main__":
unittest.main()