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