551 lines
29 KiB
Python
551 lines
29 KiB
Python
"""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"] == "aggregate_skill" and "10" in d["message"] for d in report["diagnostics"]))
|
|
self.assertTrue(any("bounded expected" in x for x in report["assumptions"]))
|
|
self.assertTrue(any(d["code"] == "unsupported_skill" for d in simulate(req)["diagnostics"]))
|
|
|
|
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_uses_quick_model_by_default(self):
|
|
from ranch_assistant.battle_quick import simulate_quick
|
|
req = request()
|
|
with patch("socket.socket", side_effect=AssertionError("No network")):
|
|
result = ExperimentalBattleRuntime().run(req)
|
|
self.assertEqual(result, simulate_quick(req))
|
|
self.assertEqual(result["simulation_method"], "aggregate_hp_dps")
|
|
|
|
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()
|