Files
myrzx_bot/ranch_assistant/tests/test_native_snapshot_bridge.py

261 lines
14 KiB
Python

"""Native AIR integration tests; fixtures contain no account data or networking.
The tests compile the actual bridge once, then run all cases in a child
ApplicationDomain with the pinned original SWFs. Missing local AIR assets skip
the suite; compilation/runtime failures with installed assets fail the suite.
"""
import copy
import unittest
from tools.battle_runtime.snapshot_bridge_check import (
dependencies_available, run_checks, synthetic_snapshot,
)
@unittest.skipUnless(dependencies_available(), "Prepared local Windows AIR SDK/original libraries required")
class NativeSnapshotBridgeTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
plain, rich = synthetic_snapshot(), synthetic_snapshot(rich=True)
cases = []
def case(name, source=plain, *, team="teamA", integrity=False):
snapshot = copy.deepcopy(source)
cases.append(dict(name=name, snapshot=snapshot, teamName=team, integrity=integrity))
return snapshot
case("plain", integrity=True)
case("rich", rich, integrity=True)
case("empty_attributes", integrity=True)["monsterAttributes"] = []
flat_skin = case("flat_skin_entry", rich, integrity=True)
flat_skin["items"] = []
flat_skin["monsters"][0].update(equip2=0, pAtk=0, pDef=0, pHp=0, pDex=0)
# Keep explicit server attributes independent of skin table abilities.
# The bridge must use the supplied values once, not recalculate them.
flat_skin["monsterAttributes"][0] = copy.deepcopy(plain["monsterAttributes"][0])
flat_skin["monsterAttributes"][1]["def"] = 7
case("shuffled_attributes", rich)["monsterAttributes"].reverse()
case("low_master_level")["master"]["level"] = 1
case("high_master_level")["master"]["level"] = 80
case("original_tp_clamp")["monsters"][0]["tpLevel"] = 9
case("original_skills")["monsters"][0].update(skill_1=999999, atk=999999, hp=999999)
alternate = case("alternate_team", team="teamB")
alternate["teams"].append(dict(teamName="teamB", teamType="pveBattleTeam",
monsters=[0, 100000002, 100000003, 100000001, 0, 0, 0]))
case("empty_padding")["teams"][0]["monsters"].append(0)
with_egg = case("unselected_incubator")
egg = copy.deepcopy(plain["monsters"][0])
egg.update(id=100000004, process=2, mode=0, level=0, potentialLevel=0)
with_egg["monsters"].append(egg)
case("bad_feel", integrity=True)["monsters"][0]["feel"] = 201
missing_global = case("missing_global")
del missing_global["master"]["globalAtk"]
missing_growth = case("missing_growth")
del missing_growth["monsters"][0]["gAtk"]
case("absent_attribute_row", integrity=True)["monsterAttributes"].pop(0)
missing_attribute_field = case("missing_attribute_field")
del missing_attribute_field["monsterAttributes"][0]["atk"]
missing_attributes = case("missing_attributes")
del missing_attributes["monsterAttributes"]
case("duplicate_attributes")["monsterAttributes"].append(copy.deepcopy(plain["monsterAttributes"][0]))
case("species_as_instance")["teams"][0]["monsters"][0] = 1001010
case("duplicate_member")["teams"][0]["monsters"][1] = 100000003
case("incubating_member")["monsters"][0]["process"] = 2
case("egg_member")["monsters"][0]["mode"] = 0
case("exploring_member")["monsters"][0]["inExploreTeam"] = 1
case("negative_member")["teams"][0]["monsters"][0] = -1
case("empty_team")["teams"][0]["monsters"] = [0] * 7
case("missing_team", team="absent")
case("occupied_padding")["teams"][0]["monsters"].append(100000002)
case("missing_equipment", rich)["items"] = []
missing_params = case("missing_equip_params", rich)
del missing_params["items"][0]["equipParams"]
case("bad_equip_params", rich)["items"][0]["equipParams"] = "{broken"
case("wrong_equipment_class", rich)["items"][0]["itemClass"] = 0
overflowing_equip = case("equipment_id_overflow", rich)
overflowing_equip["items"][0]["id"] = 2147483648
overflowing_equip["monsters"][0]["equip2"] = 2147483648
case("bad_entangle_json", rich)["monsters"][1]["entangleSkills"] = "null"
missing_history = case("missing_history")
del missing_history["history"]["monLib"]
case("string_stat")["monsters"][0]["gAtk"] = "4.9"
case("boolean_stat")["master"]["globalAtk"] = False
cls.evidence = run_checks(cases)
if not cls.evidence["result"].get("ok"):
raise AssertionError(cls.evidence["result"])
cls.results = {row["name"]: row for row in cls.evidence["result"]["cases"]}
def accepted(self, name):
result = self.results[name]
self.assertTrue(result["ok"], result.get("error"))
self.assertTrue(result["inputUnchanged"])
self.assertTrue(result["installed"])
self.assertTrue(result["contextUnchanged"])
return result
def rejected(self, name, code, path=None):
result = self.results[name]
self.assertFalse(result["ok"], name)
self.assertIn(f"SnapshotBridge[{code}]", result["error"], name)
if path:
self.assertIn(path, result["error"])
self.assertTrue(result["inputUnchanged"], name)
self.assertTrue(result["previousMasterRestored"], name)
def test_as3_compiles_and_runs_against_pinned_original_libraries(self):
self.assertEqual(self.evidence["compiler_exit_code"], 0)
self.assertEqual(self.evidence["process_exit_code"], 0)
self.assertEqual(len(self.evidence["source_sha256"]), 64)
def test_original_values_and_ordered_instance_ids_reach_native_team(self):
result = self.accepted("plain")
self.assertEqual(result["validation"]["selectedIds"], [100000003, 100000001, 100000002])
self.assertEqual(result["selectedSlots"], [100000003, 0, 100000001, 100000002, 0, 0, 0])
self.assertEqual(result["nativeMembers"], [dict(mid=100000003, teamPos=1),
dict(mid=100000001, teamPos=2),
dict(mid=100000002, teamPos=5)])
# Pinned original Lv1 slime values, independently of bridge mapping.
first = result["units"][0]
self.assertEqual(first["battle"], {"atk": 28, "def": 24, "hp": 335, "dex": 6})
self.assertEqual(first["skill_1"], 3)
def test_rich_snapshot_preserves_equipment_potential_skin_and_entangle(self):
result = self.accepted("rich")
first, second = result["units"][:2]
self.assertEqual(first["battle"], {"atk": 31, "def": 27, "hp": 393, "dex": 11})
self.assertEqual(first["potential"], 1)
self.assertEqual(first["equip2"], 100000101)
self.assertEqual(first["special"]["atkPoi"], 2)
self.assertEqual(first["special"]["atkPoiType"], 1)
self.assertEqual(second["skinVo"], 1003011)
self.assertEqual(second["entangleSkill"], {"1": 1001})
self.assertTrue(second["entangle"])
self.assertEqual(second["skill_1"], 6)
self.assertEqual(second["battle"], {"atk": 48, "def": 39, "hp": 209, "dex": 11})
self.assertEqual(result["inventory"], [dict(id=100000101, type=50001, num=1,
isUsed=True, atk=0, hp=50, atkPoiType=1)])
def test_attributes_join_by_instance_id_and_are_not_double_counted(self):
rich = self.accepted("rich")
reordered = self.accepted("shuffled_attributes")
self.assertEqual(rich["units"], reordered["units"])
# The two slime instances share a species, but only one has equipment.
self.assertEqual(rich["units"][0]["additions"]["hp"], 50)
self.assertEqual(rich["units"][2]["additions"]["hp"], 0)
def test_explicit_empty_and_absent_attribute_rows_preserve_original_defaults(self):
plain = self.accepted("plain")
for name, count in (("empty_attributes", 0), ("absent_attribute_row", 2)):
with self.subTest(name=name):
result = self.accepted(name)
self.assertEqual(result["validation"]["attributeCount"], count)
self.assertEqual(result["units"], plain["units"])
self.assertEqual(result["integrity"], plain["integrity"])
self.assertEqual(result["inventory"], [])
self.assertTrue(all(unit["skin"] == 0 for unit in result["units"]))
def test_flat_skin_table_resolves_original_entry_and_keeps_server_attributes(self):
result = self.accepted("flat_skin_entry")
skinned = result["units"][1]
self.assertEqual(skinned["skinVo"], 1003011)
self.assertEqual(skinned["skinEntry"], {"monType": "1003010",
"ability": {"def": 15, "atkVim": 2},
"sameOriginalEntry": True})
self.assertEqual(skinned["additions"]["def"], 7)
self.assertEqual(skinned["battle"]["def"], 31)
self.assertEqual(self.accepted("rich")["units"][1]["battle"]["def"], 39)
self.assertEqual(result["integrity"]["cheatNum"], 0)
self.assertEqual(len(result["integrity"]["records"]), 3)
def test_ap_and_tp_levels_use_original_source_semantics(self):
for name, level in (("low_master_level", 1), ("plain", 30), ("high_master_level", 80)):
with self.subTest(name=name):
result = self.accepted(name)
self.assertEqual(result["validation"]["masterLevel"], level)
self.assertEqual(result["nativeAP"], result["apFromRawLevel"])
self.assertEqual(result["validation"]["ap"], result["nativeAP"])
self.assertGreater(self.results["high_master_level"]["nativeAP"], self.results["plain"]["nativeAP"])
self.assertEqual(self.accepted("original_tp_clamp")["units"][0]["tplevel"], 4)
self.assertEqual(self.accepted("original_skills")["units"], self.accepted("plain")["units"])
def test_history_uses_original_flag_conversion_api(self):
history = self.accepted("rich")["history"]
self.assertEqual(history["guide_record"], {"firstOut": True})
self.assertEqual(history["unlockCity"], {"1": True})
self.assertEqual(history["passStage"], {"0101": {"1": True}})
self.assertEqual(history["unlockStage"], {"0101": {"1": True}})
self.assertEqual(history["monLib"], [1001010, 1003010])
self.assertEqual(self.results["rich"]["validation"]["historyLoader"], "HistoryVo.loadHistoryData")
def test_selected_team_and_original_loader_padding(self):
result = self.accepted("alternate_team")
self.assertEqual(result["validation"]["teamName"], "teamB")
self.assertEqual(result["validation"]["selectedIds"], [100000002, 100000003, 100000001])
padding = self.accepted("empty_padding")
self.assertEqual(padding["nativeMembers"], self.results["plain"]["nativeMembers"])
self.assertEqual(len(padding["validation"]["rawSlots"]), 8)
self.rejected("occupied_padding", "team_slot")
def test_unselected_incubation_does_not_change_selected_roster(self):
result = self.accepted("unselected_incubator")
self.assertEqual(result["loadedMonsterIds"], [100000001, 100000002, 100000003, 100000004])
self.assertEqual(result["validation"]["monsterCount"], 4)
self.assertEqual(result["validation"]["attributeCount"], 3)
self.assertEqual(result["units"], self.accepted("plain")["units"])
def test_real_integrity_checker_records_high_ids_and_detects_invalid_input(self):
for name in ("plain", "rich", "empty_attributes", "flat_skin_entry", "absent_attribute_row"):
integrity = self.accepted(name)["integrity"]
self.assertEqual(integrity["cheatNum"], 0)
ids = [int(record["mid"]) for record in integrity["records"]]
self.assertEqual(ids, [100000003, 100000001, 100000002])
self.assertTrue(all(mid > 100000000 for mid in ids))
self.assertIn("+0uneqmon100000001", integrity["text"])
self.assertIsNotNone(integrity["records"][0]["skillLevel1"])
invalid = self.accepted("bad_feel")
self.assertEqual(invalid["units"][0]["feel"], 201)
self.assertGreater(invalid["integrity"]["cheatNum"], 0)
self.assertIn("overfeel", invalid["integrity"]["text"])
self.assertEqual(len(invalid["integrity"]["records"]), 3)
self.assertIsNotNone(invalid["integrity"]["master"])
def test_missing_stats_fail_with_paths_without_zero_defaults(self):
for name, code, path in (
("missing_global", "missing_number", "master.globalAtk"),
("missing_growth", "missing_number", "monsters[0].gAtk"),
("missing_attribute_field", "missing_number", "monsterAttributes[0].atk"),
("missing_attributes", "missing_array", "monsterAttributes"),
("string_stat", "missing_number", "monsters[0].gAtk"),
("boolean_stat", "missing_number", "master.globalAtk"),
("missing_history", "missing_array", "history.monLib"),
):
with self.subTest(name=name):
self.rejected(name, code, path)
def test_selected_members_must_exist_and_be_available(self):
for name, code in (
("species_as_instance", "missing_team_member"), ("duplicate_member", "duplicate_member"),
("incubating_member", "incubating_member"), ("egg_member", "incubating_member"),
("exploring_member", "exploring_member"), ("negative_member", "team_member_id"),
("empty_team", "empty_team"), ("missing_team", "team_missing"),
("duplicate_attributes", "duplicate_attributes"),
):
with self.subTest(name=name):
self.rejected(name, code)
def test_incomplete_equipment_and_entangle_cannot_enter_original_error_fallbacks(self):
for name, code in (
("missing_equipment", "missing_equipment"), ("missing_equip_params", "json_string"),
("bad_equip_params", "json_string"), ("wrong_equipment_class", "equipment_class"),
("equipment_id_overflow", "equipment_id"),
("bad_entangle_json", "missing_object"),
):
with self.subTest(name=name):
self.rejected(name, code)
if __name__ == "__main__":
unittest.main()