Add offline battle estimates and passive phone sample analysis
This commit is contained in:
@@ -0,0 +1,205 @@
|
||||
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()
|
||||
@@ -0,0 +1,129 @@
|
||||
from contextlib import redirect_stdout
|
||||
from dataclasses import asdict, replace
|
||||
import io
|
||||
import json
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from tools.battle_estimate_v12 import Fighter, Rules, demo_player, hit_damage, main, simulate
|
||||
from ranch_assistant.tests.test_core import workspace_temp
|
||||
|
||||
|
||||
class MidpointRandom:
|
||||
def __init__(self, critical=False):
|
||||
self.critical = critical
|
||||
|
||||
def random(self):
|
||||
return 0 if self.critical else .99
|
||||
|
||||
def uniform(self, low, high):
|
||||
return (low + high) / 2
|
||||
|
||||
|
||||
def fighter(**changes):
|
||||
return replace(Fighter(1001010, "fixture", 100, 100, 20, 10, 1000), **changes)
|
||||
|
||||
|
||||
RULES = Rules(.95, .25, 1.5, 1.15, {1: 2, 2: 4, 3: 1, 4: 3, 5: 0})
|
||||
|
||||
|
||||
class BattleEstimateTests(unittest.TestCase):
|
||||
def test_base_damage_matches_source_formula_at_midpoint(self):
|
||||
# 100 * .95 - 20 * (.25 * .75 + .25 * .125) = 90.625.
|
||||
self.assertEqual(hit_damage(fighter(), fighter(), RULES, MidpointRandom()), 91)
|
||||
|
||||
def test_critical_attack_is_applied_before_the_defense_roll(self):
|
||||
self.assertEqual(hit_damage(fighter(), fighter(), RULES, MidpointRandom(True)), 138)
|
||||
|
||||
def test_dex_advantage_and_disadvantage_change_the_damage_range(self):
|
||||
self.assertEqual(hit_damage(fighter(dex=50), fighter(), RULES, MidpointRandom()), 98)
|
||||
self.assertEqual(hit_damage(fighter(dex=0), fighter(dex=40), RULES, MidpointRandom()), 84)
|
||||
|
||||
def test_extreme_dex_difference_is_capped(self):
|
||||
rng = MidpointRandom()
|
||||
self.assertEqual(hit_damage(fighter(dex=90), fighter(), RULES, rng),
|
||||
hit_damage(fighter(dex=900), fighter(), RULES, rng))
|
||||
|
||||
def test_high_defense_cannot_reduce_base_damage_below_one(self):
|
||||
self.assertEqual(hit_damage(fighter(atk=1), fighter(defense=100000), RULES, MidpointRandom()), 1)
|
||||
|
||||
def test_element_counter_uses_the_attacker_element(self):
|
||||
attack = fighter(element=1)
|
||||
self.assertGreater(hit_damage(attack, fighter(element=2), RULES, MidpointRandom()),
|
||||
hit_damage(attack, fighter(element=3), RULES, MidpointRandom()))
|
||||
|
||||
def test_win_is_derived_from_kills_and_credits_only_actual_hp_lost(self):
|
||||
strong = fighter(hp=10000, atk=10000, attack_ms=100)
|
||||
result = simulate([strong], [fighter()], RULES, seed=1, timeout_ms=10000, enemy_capacity=1)
|
||||
self.assertEqual(result["predicted_outcome"], "win")
|
||||
self.assertEqual(result["enemy_kills"], 1)
|
||||
self.assertEqual(result["player_damage"], 100)
|
||||
self.assertEqual(result["model_duration_seconds"], .1)
|
||||
|
||||
def test_a_weak_roster_can_lose(self):
|
||||
result = simulate([fighter(hp=1, atk=1)], [fighter(hp=10000)], RULES,
|
||||
seed=1, timeout_ms=10000, enemy_capacity=1)
|
||||
self.assertEqual(result["predicted_outcome"], "loss")
|
||||
self.assertEqual(result["player_survivors"], 0)
|
||||
|
||||
def test_timeout_happens_before_an_attack_at_the_same_deadline(self):
|
||||
result = simulate([fighter(atk=100000)], [fighter()], RULES,
|
||||
seed=1, timeout_ms=1000, enemy_capacity=1)
|
||||
self.assertEqual(result["predicted_outcome"], "timeout")
|
||||
self.assertEqual(result["resolved_hits"], 0)
|
||||
|
||||
def test_wave_gap_and_enemy_capacity_are_respected(self):
|
||||
result = simulate([fighter(hp=10000, atk=10000, attack_ms=100)],
|
||||
[fighter(), fighter(), fighter(wave=2)], RULES, seed=1, timeout_ms=10000, enemy_capacity=1)
|
||||
self.assertEqual(result["enemy_kills"], 3)
|
||||
self.assertEqual(result["model_duration_seconds"], 1.0)
|
||||
|
||||
def test_fixed_seed_is_reproducible_and_does_not_mutate_roster(self):
|
||||
team, enemies = [fighter()], [fighter()]
|
||||
before = [asdict(x) for x in team + enemies]
|
||||
first = simulate(team, enemies, RULES, seed=12, timeout_ms=10000, enemy_capacity=1)
|
||||
self.assertEqual(first, simulate(team, enemies, RULES, seed=12, timeout_ms=10000, enemy_capacity=1))
|
||||
self.assertEqual([asdict(x) for x in team + enemies], before)
|
||||
|
||||
def test_invalid_units_and_empty_teams_are_rejected(self):
|
||||
for field, value in (("hp", 0), ("attack_ms", 0), ("atk", float("nan")), ("crit", float("inf"))):
|
||||
with self.assertRaises(ValueError):
|
||||
fighter(**{field: value})
|
||||
with self.assertRaises(ValueError):
|
||||
simulate([], [fighter()], RULES, seed=1, timeout_ms=1000, enemy_capacity=1)
|
||||
|
||||
def test_catalog_example_uses_mean_growth_without_changing_source(self):
|
||||
row = {"type": 1, "name": "fixture", "element": 5, "spd_atk": 1600,
|
||||
**{key: 10 for key in ("atk", "def", "hp", "dex")},
|
||||
**{key + suffix: value for key in ("atk", "def", "hp", "dex")
|
||||
for suffix, value in (("_grow_min", 2), ("_grow_max", 4))}}
|
||||
before = dict(row)
|
||||
unit = demo_player(row, 3)
|
||||
self.assertEqual((unit.atk, unit.defense, unit.hp, unit.dex), (16, 16, 16, 16))
|
||||
self.assertEqual(unit.attack_ms, 1588)
|
||||
self.assertEqual(row, before)
|
||||
|
||||
def test_cli_cannot_call_network_and_labels_results_as_uncalibrated_estimates(self):
|
||||
tables = {"monster_info": {"1": {"type": 1, "name": "fixture", "element": 5, "spd_atk": 1000, "skill_1": 3,
|
||||
**{key: 100 for key in ("atk", "def", "hp", "dex")},
|
||||
**{key + suffix: 1 for key in ("atk", "def", "hp", "dex") for suffix in ("_grow_min", "_grow_max")}}}}
|
||||
scenario = (tables, {}, {"name": "fixture"}, [fighter()], RULES, 10000, 1, set())
|
||||
with workspace_temp() as folder, patch("tools.battle_estimate_v12.load_scenario", return_value=scenario), \
|
||||
patch("socket.socket", side_effect=AssertionError("Offline model attempted a socket")), redirect_stdout(io.StringIO()):
|
||||
output = folder / "estimate.json"
|
||||
self.assertEqual(main(["--apk", "fixture.apk", "--species", "1", "--trials", "2", "--output", str(output)]), 0)
|
||||
report = json.loads(output.read_text(encoding="utf-8"))
|
||||
self.assertTrue(report["approximate"])
|
||||
self.assertFalse(report["calibrated_against_original_runtime"])
|
||||
self.assertNotIn("battleData", report)
|
||||
self.assertNotIn("token", report)
|
||||
self.assertEqual(sum(v["count"] for v in report["duration_seconds_by_predicted_outcome"].values()), 2)
|
||||
team = folder / "team.json"
|
||||
team.write_text(json.dumps([asdict(fighter(species=1))]), encoding="utf-8")
|
||||
self.assertEqual(main(["--apk", "fixture.apk", "--team", str(team), "--trials", "2", "--output", str(output)]), 0)
|
||||
report = json.loads(output.read_text(encoding="utf-8"))
|
||||
self.assertEqual(report["ignored_skill_ids_from_catalog"], [3])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user