"""Offline tests use synthetic ids/snapshots and public original static tables.""" from copy import deepcopy import hashlib import json from pathlib import Path import socket import subprocess import sys import threading from types import SimpleNamespace import unittest from unittest.mock import patch from ranch_assistant.battle_simulator import ( ExperimentalBattleRuntime, ORIGINAL_APK_SHA256, Stats, _offline_audit, _plain, combat_battles, combat_tables, damage_roll, simulate, ) def monster(mid=101, species=1001010, level=20, **changes): row = combat_tables()["monster_info"][str(species)] result = {"id": mid, "typeId": species, "level": level, "mode": 2, "tpLevel": 0, "feel": 0, "upStar": 0, "pAtk": 0, "pDef": 0, "pHp": 0, "pDex": 0} for name in ("Atk", "Def", "Hp", "Dex"): stat = name.lower() result["g" + name] = (row[stat + "_grow_min"] + row[stat + "_grow_max"]) / 2 result.update(changes) return result def enemy(**changes): result = {"type": "1001010", "team": 2, "mode": 2, "level": 1, "atk": 16, "def": 20, "hp": 101, "dex": 4, "spd_mov": .92, "spd_atk": 1595, "atk_dis": 100, "skill_1": 0, "skill_2": 0, "joinTime": -1, "wave": 1, "teamPos": 1, "ai": 0, "joinPoint": "point_team2_fore2", "controller": []} result.update(changes) return result def request(*, players=None, enemies=None, seconds=30, seed=0, master_level=43, **changes): players = players if players is not None else [monster()] result = {"context": "ordinary_stage", "seed": seed, "team": "teamA", "battle_position": {"battleType": "stage", "stageId": "fixture", "stageLevel": "1"}, "roster": {"master": {"level": master_level}, "monsters": players, "teams": [{"teamName": "teamA", "monsters": [m["id"] for m in players]}], "monsterAttributes": []}, "original_data": {"battle": {"time": seconds, "winType": ["1"], "loseType": ["1", "2"], "controller": [], "triggers": [], "teams": [{"team": 2, "numMax": 2, "ap": 80, "mons": enemies if enemies is not None else [enemy()]}], "battleField": {"fieldMode": True, "fieldName": "default", "mapAreas": [], "mapObjects": []}}}} result.update(changes) return result def battle_of(value): return value["original_data"]["battle"] class Midpoint: def uniform(self, low, high): return (low + high) / 2 class CombatDataTests(unittest.TestCase): def test_complete_original_data_is_cached_and_recursively_immutable(self): data = combat_tables() self.assertIs(data, combat_tables()) self.assertEqual(len(data["monster_info"]), 749) self.assertEqual(len(data["monster_skill"]), 266) self.assertEqual(len(combat_battles()["stage_info"]), 1178) self.assertEqual(len(combat_battles()["task_info"]), 1165) self.assertNotIn("stage_info", data) # Never decode the corpus in a battle worker. with self.assertRaises(TypeError): data["monster_info"]["1001010"]["atk"] = 999 self.assertEqual(data["game_setting"]["countDamagePerAtk"], .95) self.assertEqual(data["game_setting"]["critAdd"], 1.5) self.assertEqual(data["monster_skill"]["3"]["lv1"]["para"]["ability"], .4) self.assertEqual(data["attack_profiles"]["43"]["source_class"], "AttackType2") def test_manifest_identity_and_artifact_match(self): root = Path(__file__).resolve().parents[1] / "data" manifest = json.loads((root / "combat_manifest.json").read_text(encoding="utf-8")) self.assertEqual(manifest["source"]["apk_sha256"], ORIGINAL_APK_SHA256) for name, artifact in manifest["artifacts"].items(): self.assertEqual(hashlib.sha256((root / name).read_bytes()).hexdigest(), artifact["sha256"]) def test_damage_formula_uses_original_numbers_and_no_extra_multiplier(self): defender = Stats(100, 100, 20, 10, 1600, .9, 100, 5) # round(100*.95 - 20*(.25*.75 + .25*.125)) = 91. self.assertEqual(damage_roll(100, 10, defender, combat_tables()["game_setting"], Midpoint()), 91) self.assertEqual(damage_roll(1, 10, defender, combat_tables()["game_setting"], Midpoint()), 1) class SimulatorTests(unittest.TestCase): def test_snapshot_sanity_records_are_preserved_and_never_repaired(self): mon = monster(mid=100001, pAtk=200000, feel=201, potentialLevel=1) req = request(players=[mon]) inspected = ExperimentalBattleRuntime().inspect(req) codes = {a["code"] for a in inspected["anomalies"]} self.assertTrue({"+15overfeel", "+15overgrow", "+15overpoten", "+50overlv"}.issubset(codes)) result = simulate(req) for record in inspected["anomalies"]: self.assertIn(record, result["anomalies"]) self.assertGreater(result["units"][0]["stats"]["atk"], 200000) self.assertEqual(mon["feel"], 201) self.assertFalse(result["experimental_settlement_eligible"]) def test_authored_hidden_team_uses_only_original_configured_combatants(self): req = request(enemies=[enemy(hp=10), enemy(team=1, atk=10000)]) battle_of(req)["hideTeamMon"] = True result = simulate(req) self.assertEqual(result["outcome"], "win") self.assertTrue(all(not a["id"].startswith("player-") for a in result["units"])) self.assertTrue(any(a["team"] == 1 for a in result["units"])) self.assertEqual(result["battle_data"]["battleMonIds"], []) def test_three_routes_preserve_position_and_ordered_roster_ids_including_waiting(self): routes = { "ordinary_stage": {"battleType": "stage", "stageId": "fixture-stage", "stageLevel": "2", "taskTypeId": None, "taskStep": 0}, "task_battle": {"battleType": "task", "stageId": None, "stageLevel": None, "taskTypeId": "fixture-task", "taskStep": 1}, "task_pass_stage": {"battleType": "task", "stageId": None, "stageLevel": None, "taskTypeId": "fixture-pass", "taskStep": 2}, } expected_ids = [202, 105, 301, 101, 111] for context, position in routes.items(): req = request(context=context, battle_position=position, seconds=1, players=[monster(mid) for mid in expected_ids]) req["roster"]["monsters"].reverse() # Team order wins over inventory order. result = simulate(req) self.assertEqual(result["battle_data"]["battleMonIds"], expected_ids) self.assertEqual(result["battle_data"]["battlePosition"], {k: v for k, v in position.items() if v is not None}) self.assertEqual(sum(a["state"] == "waiting" and a["team"] == 1 for a in result["units"]), 1) self.assertNotIn(1001010, result["battle_data"]["battleMonIds"]) def test_source_boss_points_are_updated_by_actual_damage_and_deaths(self): for marker, expected in ((-1, 10), (7, 7)): result = simulate(request(enemies=[enemy(hp=10, bossPoint=marker)])) self.assertEqual(result["battle_data"]["bossDamage"], expected) self.assertEqual(result["battle_data"]["totalDamage"], 0) def test_cancellation_during_simulation_retains_partial_trace(self): class CancelAfterTicks: calls = 0 def is_set(self): self.calls += 1 return self.calls > 10 result = simulate(request(), cancel_event=CancelAfterTicks()) self.assertEqual(result["outcome"], "cancelled") self.assertGreater(result["elapsed_ms"], 0) self.assertTrue(result["events"]) self.assertIsNone(result["battle_data"]) def test_model_failure_keeps_detected_records(self): req = request(players=[monster(mid=100001, feel=201)]) with patch("ranch_assistant.battle_simulator._Battle.tick", side_effect=RuntimeError("fixture")): result = simulate(req) self.assertEqual(result["execution_status"], "error") self.assertTrue(result["anomalies"]) self.assertIsNone(result["battle_data"]) def test_known_copy_skills_use_original_factors_and_summons_count_alive(self): for species, skill_id, count, factor in ((1001010, 3, 1, .4), (1030010, 7, 3, .1)): req = request(players=[monster(species=species, pHp=100000)], enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=20) result = simulate(req) summons = [u for u in result["units"] if u["summon_of"]] self.assertEqual(len(summons), count) parent = result["units"][0] self.assertEqual(result["battle_data"]["aliveNum"], count + 1) self.assertEqual(result["battle_data"]["battleMonIds"], [101]) for child in summons: self.assertFalse(child["count_unit"]) self.assertFalse(child["skills"]) self.assertEqual(child["stats"]["atk"], int(parent["stats"]["atk"] * factor)) self.assertEqual(child["stats"]["defense"], int(parent["stats"]["defense"] * factor)) self.assertTrue(any(e["type"] == "skill" and e["skill"] == skill_id for e in result["events"])) ap = result["ap"]["1"] self.assertEqual(ap["current"], ap["initial"] - ap["spent"] + ap["recovered"]) self.assertEqual(ap["spent"], 18 if skill_id == 3 else 20) def test_area_hit_cleave_uses_original_skill9_and_spatial_neighbors(self): req = request(players=[monster(species=2004010, pHp=100000)], enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=20) result = simulate(req) area = [e for e in result["events"] if e.get("reason") == "skill9_area"] self.assertTrue(area) self.assertTrue(all(e["hp_lost"] > 0 for e in area)) stats = result["units"][0]["skills"][0] self.assertEqual(stats["id"], 9) self.assertEqual(stats["para"], {"areahurt": 1, "pow": 5}) def test_flash_move_and_four_hit_combo_are_executed(self): req = request(players=[monster(species=3010010, pHp=100000)], enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=30) battle_of(req)["battleField"]["fieldName"] = "longMapDefault" result = simulate(req) used = {e["skill"] for e in result["events"] if e["type"] == "skill"} self.assertTrue({5, 38}.issubset(used)) self.assertTrue(any(e["type"] == "dash" for e in result["events"])) casts = [e["at_ms"] for e in result["events"] if e["type"] == "skill" and e["skill"] == 38] attacks = [e for e in result["events"] if e["type"] == "attack" and e["actor"] == "player-1"] for start in casts: burst = [e for e in attacks if start <= e["at_ms"] < start + 1600] self.assertGreaterEqual(len(burst), 4) self.assertEqual(burst[0]["hit_delay_ms"], 100) def test_projectile_speed_and_launch_delay_produce_nonzero_travel(self): result = simulate(request(players=[monster(species=1001020)], enemies=[enemy(hp=1000000)], seconds=8)) projectiles = [e for e in result["events"] if e["type"] == "projectile" and e["actor"] == "player-1"] self.assertTrue(projectiles) self.assertGreater(projectiles[0]["travel_ms"], 0) attack = next(e for e in result["events"] if e["type"] == "attack" and e["actor"] == "player-1") self.assertEqual(attack["hit_delay_ms"], 100) self.assertGreaterEqual(projectiles[0]["at_ms"], attack["at_ms"] + 100) def test_status_effects_healing_and_thorns_are_real_trajectory_events(self): for attributes, event_type, reason in (({"atkStun": 100}, "stun", None), ({"atkPoi": 100, "atkPoiDmg": 15}, "damage", "poison"), ({"thorns": 100}, "damage", "thorns"), ({"atkVim": 50, "selfCure": 10}, "heal", None)): req = request(players=[monster(level=1, pHp=10000)], enemies=[enemy(hp=1000000)], seconds=20) req["roster"]["monsterAttributes"] = [dict(monsterId=101, **attributes)] result = simulate(req) self.assertTrue(any(e["type"] == event_type and (reason is None or e.get("reason") == reason) for e in result["events"]), attributes) if "atkVim" in attributes: self.assertGreater(result["units"][0]["healed"], 0) self.assertTrue(any(e.get("reason") == "selfCure" for e in result["events"])) def test_overcure_preserves_exact_source_score_even_when_effective_heal_is_small(self): req = request(seconds=6, trace_limit=0, enemies=[enemy(hp=1000000)]) req["roster"]["monsterAttributes"] = [{"monsterId": 101, "selfCure": 20001}] result = simulate(req) self.assertTrue(any(a["code"] == "+15overcure" and a["source_cheat_points"] == 19 for a in result["anomalies"])) self.assertEqual(result["battle_data"]["cheatNum"], 19) self.assertFalse(result["experimental_settlement_eligible"]) def test_experimental_eligibility_is_separate_and_requires_completed_clean_model(self): report = ExperimentalBattleRuntime().inspect(request()) self.assertFalse(report["experimental_settlement_eligible"]) result = simulate(request()) self.assertTrue(result["experimental_settlement_eligible"]) self.assertFalse(result["settlement_eligible"]) self.assertFalse(result["faithful"]) anomaly = simulate(request(players=[monster(pAtk=200000)])) self.assertFalse(anomaly["experimental_settlement_eligible"]) self.assertTrue(anomaly["experimental_eligibility_reasons"]) def test_original_stage_battle_executes_without_apk_or_network_reads(self): req = request() req["original_data"]["battle"] = combat_battles()["stage_info"]["0101"]["level"]["1"]["battle"] with patch("socket.socket", side_effect=AssertionError("No network")), \ patch("zipfile.ZipFile", side_effect=AssertionError("No APK access")): result = simulate(req) self.assertEqual(result["outcome"], "win") self.assertGreater(result["kills"], 1) self.assertEqual(result["kill_monster"], {}) # Original stage enemies are mode 1. self.assertTrue(any(e["type"] == "wave" for e in result["events"])) def test_task1002002_lianlake_admits_original_cosmetic_controllers(self): corpus = combat_battles() step = corpus["task_info"]["1002002"]["steps"][0] self.assertEqual(step["statusType"], "passStage") stage, level = step["statusValue"]["stage"], step["statusValue"]["level"] self.assertEqual((stage, level), ("0201", "1")) req = request(context="task_pass_stage", battle_position={ "battleType": "stage", "stageId": stage, "stageLevel": level, "taskTypeId": "1002002", "taskStep": 0}) req["original_data"]["battle"] = _plain(corpus["stage_info"][stage]["level"][level]["battle"]) before = deepcopy(req) baseline = deepcopy(req) for team in battle_of(baseline)["teams"]: for mon in team["mons"]: mon["controller"] = [] with patch("socket.socket", side_effect=AssertionError("No network")), \ patch("zipfile.ZipFile", side_effect=AssertionError("No APK access")): report = ExperimentalBattleRuntime().inspect(req) self.assertTrue(report["supported"], report["reasons"]) result, reference = simulate(req), simulate(baseline) self.assertEqual(result["execution_status"], "completed") self.assertTrue(result["requires_realtime_wait"]) self.assertTrue(any(d["code"] == "cosmetic_controller" for d in result["diagnostics"])) for key in ("events", "elapsed_ms", "units", "battle_data", "anomalies"): self.assertEqual(result[key], reference[key], key) self.assertEqual(report["units"][1]["stats"]["atk"], 80) self.assertEqual(report["units"][1]["stats"]["hp"], 1100) self.assertEqual(req, before) def test_buff_movie_cannot_bypass_substantive_or_unknown_controller_rejection(self): for controller in ( {"type": "buffMovie", "para": {"type": "none", "stopMove": True}}, {"type": "buffMovie", "para": {"type": "stun"}}, {"type": "buffMovie", "para": None}, {"type": "buffMovie"}, {"type": "buff", "para": {"type": "none"}}, {"type": "unknown", "para": {"type": "none"}}, ): with self.subTest(controller=controller): result = simulate(request(enemies=[enemy(controller=[controller])])) self.assertEqual(result["outcome"], "unsupported") self.assertIsNone(result["battle_data"]) self.assertIn("Unsupported monster controller: " + controller["type"], result["reasons"]) def test_full_snapshot_stats_follow_monster_vo_including_server_attributes(self): mon = monster(level=10, gAtk=3.125, gDef=2.5, gHp=30.25, gDex=1.25, tpLevel=2, pAtk=12, pDef=8, pHp=80, pDex=3, feel=120, upStar=1) req = request(players=[mon]) req["roster"]["master"].update(globalAtk=7, globalDef=4, globalHp=55, globalDex=2) req["roster"]["monsterAttributes"] = [{"monsterId": 101, "atk": 13, "def": 9, "hp": 45, "dex": 2, "atkSpd": 5, "crit": 4, "apCostSave": 1}] inspected = ExperimentalBattleRuntime().inspect(req) self.assertTrue(inspected["supported"], inspected["reasons"]) stats = inspected["units"][0]["stats"] original = combat_tables()["monster_info"]["1001010"] for stat, suffix in (("hp", "Hp"), ("atk", "Atk"), ("def", "Def"), ("dex", "Dex")): expected = int(1.21 * (original[stat] + mon["g" + suffix] * 11 + mon["p" + suffix] + req["roster"]["master"]["global" + suffix] + req["roster"]["monsterAttributes"][0][stat])) self.assertEqual(stats["defense" if stat == "def" else stat], expected) self.assertEqual(stats["attack_ms"], 1600 + int(-stats["dex"] * 3 / 4) - 80) self.assertEqual(stats["crit"], 4) self.assertEqual(inspected["units"][0]["ap_cost"], 0) def test_inspect_is_honest_and_does_not_mutate_inputs(self): req = request() before = deepcopy(req) result = ExperimentalBattleRuntime().inspect(req) self.assertTrue(result["supported"]) self.assertEqual(result["execution_mode"], "experimental") self.assertTrue(result["approximate"]) self.assertFalse(result["faithful"]) self.assertFalse(result["settlement_eligible"]) self.assertTrue(result["requires_realtime_wait"]) self.assertTrue(result["ignored_mechanics"]) self.assertEqual(req, before) def test_all_three_contexts_execute_deterministic_natural_win(self): first = None for context in ("ordinary_stage", "task_battle", "task_pass_stage"): result = simulate(request(context=context)) self.assertEqual(result["outcome"], "win") self.assertTrue(result["terminal"]) self.assertEqual(result["execution_status"], "completed") self.assertEqual(result["kills"], 1) self.assertEqual(result["battle_data"]["win"], True) if first: self.assertEqual(result["events"], first["events"]) first = result def test_natural_defeat_retains_actual_state_and_evidence(self): result = simulate(request(players=[monster(level=1)], enemies=[enemy(atk=10000, hp=10000)])) self.assertEqual(result["outcome"], "loss") self.assertEqual(result["terminal_reason"], "elimination") self.assertFalse(result["battle_data"]["win"]) self.assertEqual(result["alive_num"], 0) self.assertEqual(result["units"][0]["hp"], 0) self.assertTrue(any(e["type"] == "death" for e in result["events"])) def test_battle_clock_expiry_is_completed_loss_not_technical_timeout(self): req = request(seconds=1, enemies=[enemy(hp=100000, moveImmune=True, atk_dis=1)]) result = simulate(req) self.assertEqual(result["outcome"], "loss") self.assertEqual(result["execution_status"], "completed") self.assertEqual(result["terminal_reason"], "battle_time_limit") self.assertEqual(result["elapsed_ms"], 1000) self.assertEqual(result["battle_data"]["leftTime"], 0) self.assertFalse(result["battle_data"]["win"]) self.assertGreater(result["units"][0]["hp"], 0) def test_technical_timeout_and_cancellation_have_no_battle_data(self): event = threading.Event() event.set() for result in (simulate(request(), timeout=0), simulate(request(), cancel_event=event)): self.assertIn(result["execution_status"], ("timed_out", "cancelled")) self.assertFalse(result["terminal"]) self.assertIsNone(result["battle_data"]) def test_source_selective_kill_map_differs_from_all_kills(self): req = request(enemies=[enemy(hp=1, mode=1), enemy(hp=1, mode=2)]) result = simulate(req) self.assertEqual(result["outcome"], "win") self.assertEqual(result["kills"], 2) self.assertEqual(result["all_kills"], {"1001010": 2}) self.assertEqual(result["battle_data"]["killMonster"], {"1001010": 1}) self.assertEqual(result["battle_data"]["totalDamage"], 0) self.assertEqual(result["battle_data"]["killNum"], 0) self.assertEqual(result["battle_data"]["deadNum"], 0) self.assertGreater(result["damage_hp_lost"]["2"], 0) def test_waiting_roster_counts_alive_and_respects_source_capacity(self): players = [monster(i, level=1) for i in (101, 102, 103, 104, 105)] result = simulate(request(players=players, seconds=1, master_level=18)) player_units = [a for a in result["units"] if a["team"] == 1] self.assertEqual(sum(a["state"] == "active" for a in player_units), 4) self.assertEqual(sum(a["state"] == "waiting" for a in player_units), 1) self.assertEqual(result["battle_data"]["aliveNum"], 5) self.assertTrue(all(e["ap_charged"] == 0 for e in result["events"] if e["type"] == "deploy")) def test_order_reinforcements_and_wave_delay(self): req = request(enemies=[enemy(hp=1), enemy(hp=1, wave=2, joinTime=4)]) result = simulate(req) self.assertEqual(result["outcome"], "win") wave_wait = next(e for e in result["events"] if e["type"] == "wave_wait") wave = next(e for e in result["events"] if e["type"] == "wave") self.assertEqual(wave["at_ms"] - wave_wait["at_ms"], 700) second = next(e for e in result["events"] if e["type"] == "deploy" and e.get("wave") == 2) self.assertGreaterEqual(second["at_ms"], 4000) def test_unimplemented_skills_are_specific_and_explicit(self): req = request(players=[monster(species=1001020)]) # actual skill 10 report = ExperimentalBattleRuntime().inspect(req) self.assertTrue(report["supported"]) self.assertTrue(any(d["code"] == "unsupported_skill" and "10" in d["message"] for d in report["diagnostics"])) self.assertTrue(any("Skill 10" in x for x in report["ignored_mechanics"])) def test_controllers_triggers_and_non_elimination_are_rejected(self): for key, value in (("controller", [{"type": "monMaker"}]), ("triggers", [{"type": "dead"}]), ("winType", ["2"])): req = request() battle_of(req)[key] = value result = simulate(req) self.assertEqual(result["outcome"], "unsupported") self.assertFalse(result["supported"]) self.assertIsNone(result["battle_data"]) self.assertTrue(result["reasons"]) def test_missing_actual_growth_and_nonpositive_original_speed_are_rejected(self): req = request() req["roster"]["monsters"][0].pop("gAtk") self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"]) req = request() req["roster"]["monsterAttributes"] = [{"monsterId": 101, "atkSpd": 200}] report = ExperimentalBattleRuntime().inspect(req) self.assertFalse(report["supported"]) self.assertTrue(any("nonpositive" in x for x in report["reasons"])) def test_enemy_authored_stats_and_authored_scales_are_preserved(self): req = request(enemies=[enemy(atk=31, hp=101, dex=7, spd_atk=1595)]) battle_of(req).update(scaleAbility=1.2, scaleHp=1.5) stats = ExperimentalBattleRuntime().inspect(req)["units"][1]["stats"] self.assertEqual(stats["atk"], 37) self.assertEqual(stats["hp"], 151) self.assertEqual(stats["dex"], 8) self.assertEqual(stats["attack_ms"], 1595) def test_trace_limit_never_erases_overdamage_anomalies(self): req = request(players=[monster(pAtk=200000)], enemies=[enemy(hp=10)], trace_limit=1) result = simulate(req) self.assertEqual(result["outcome"], "win") self.assertEqual(len(result["events"]), 1) self.assertTrue(result["trace_truncated"]) records = [a for a in result["anomalies"] if a["code"] == "+10overdamage"] self.assertTrue(records) self.assertGreater(records[0]["damage"], 80000) self.assertEqual(result["battle_data"]["cheatNum"], 10) self.assertEqual(result["battle_data"]["cheatRecords"], result["anomalies"]) def test_stats_and_snapshot_never_mutate_across_runs(self): req = request() before = deepcopy(req) a, b = simulate(req), simulate(req) self.assertEqual(a, b) self.assertEqual(req, before) class WorkerTests(unittest.TestCase): def test_object_request_and_snapshot_raw_have_the_same_contract(self): req = request() req["snapshot"] = SimpleNamespace(raw=req.pop("roster")) result = ExperimentalBattleRuntime().run(SimpleNamespace(**req)) self.assertEqual(result["outcome"], "win") self.assertEqual(result["battle_data"]["battlePosition"], req["battle_position"]) def test_fixed_module_subprocess_equals_direct_model(self): req = request() with patch("socket.socket", side_effect=AssertionError("No network")): result = ExperimentalBattleRuntime().run(req) self.assertEqual(result, simulate(req)) def test_worker_entrypoint_does_not_import_gui_or_production_engine(self): completed = subprocess.run([sys.executable, "-c", "import sys; import ranch_assistant.battle_simulator; " "assert not any(n in sys.modules for n in " "('ranch_assistant.gui','ranch_assistant.engine','ranch_assistant.__main__'," "'ranch_assistant.battles','ranch_assistant.battle_runtime'))"], capture_output=True) self.assertEqual(completed.returncode, 0, completed.stderr) def test_worker_network_guard_rejects_socket_audit_events(self): for event in ("socket.__new__", "socket.connect", "socket.getaddrinfo", "urllib.Request"): with self.assertRaises(PermissionError): _offline_audit(event, ()) program = """import socket,sys from ranch_assistant.battle_simulator import _offline_audit sys.addaudithook(_offline_audit) try: socket.socket() except PermissionError: pass else: raise AssertionError('worker socket creation must fail') """ completed = subprocess.run([sys.executable, "-c", program], capture_output=True) self.assertEqual(completed.returncode, 0, completed.stderr) def test_cancel_and_wall_timeout_kill_and_reap_worker(self): for cancelled in (True, False): event = threading.Event() processes = [] real_popen = subprocess.Popen def observe(*args, **kwargs): self.assertEqual(args[0], [sys.executable, "-m", "ranch_assistant.battle_simulator", "--worker"]) self.assertNotIn("shell", kwargs) self.assertEqual(kwargs["creationflags"], getattr(subprocess, "CREATE_NO_WINDOW", 0)) process = real_popen(*args, **kwargs) processes.append(process) if cancelled: event.set() return process with patch("ranch_assistant.battle_simulator.subprocess.Popen", side_effect=observe): result = ExperimentalBattleRuntime().run(request(), cancel_event=event, timeout=10 if cancelled else .001) self.assertEqual(result["outcome"], "cancelled" if cancelled else "timeout") self.assertFalse(result["terminal"]) self.assertIsNone(result["battle_data"]) self.assertTrue(processes) self.assertIsNotNone(processes[0].poll()) def test_keyboard_interrupt_terminates_child(self): process = unittest.mock.MagicMock() process.communicate.side_effect = [KeyboardInterrupt, (b"", b"")] process.poll.return_value = None with patch("ranch_assistant.battle_simulator.subprocess.Popen", return_value=process): result = ExperimentalBattleRuntime().run(request()) self.assertEqual(result["outcome"], "cancelled") process.kill.assert_called_once() self.assertIsNone(result["battle_data"]) if __name__ == "__main__": unittest.main()