Add v1.2 development quest progression and experimental battle runtime
This commit is contained in:
@@ -0,0 +1,260 @@
|
||||
"""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()
|
||||
Reference in New Issue
Block a user