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