DLC Quest: Fix code structure, typos, poor code quality (#2066)

"Added a bunch of tests to make sure I don't break anything during refactoring
Huge cleanup in the Regions file, extract methods, remove code duplicate, fix typos, fix variable naming conventions, etc.
Small cleanup in other places, minor stuff just what was needed for Regions"

Author: agilbert1412

worlds/dlcquest/Regions.py

@@ -0,0 +1,130 @@
+from . import DLCQuestTestBase
+from .. import Options
+
+sword = "Sword"
+gun = "Gun"
+wooden_sword = "Wooden Sword"
+pickaxe = "Pickaxe"
+humble_bindle = "Humble Indie Bindle"
+box_supplies = "Box of Various Supplies"
+items = [sword, gun, wooden_sword, pickaxe, humble_bindle, box_supplies]
+
+important_pack = "Incredibly Important Pack"
+
+
+class TestItemShuffle(DLCQuestTestBase):
+    options = {Options.ItemShuffle.internal_name: Options.ItemShuffle.option_shuffled,
+               Options.Campaign.internal_name: Options.Campaign.option_both}
+
+    def test_items_in_pool(self):
+        item_names = {item.name for item in self.multiworld.get_items()}
+        for item in items:
+            with self.subTest(f"{item}"):
+                self.assertIn(item, item_names)
+
+    def test_item_locations_in_pool(self):
+        location_names = {location.name for location in self.multiworld.get_locations()}
+        for item_location in items:
+            with self.subTest(f"{item_location}"):
+                self.assertIn(item_location, location_names)
+
+    def test_sword_location_has_correct_rules(self):
+        self.assertFalse(self.can_reach_location(sword))
+        movement_pack = self.multiworld.create_item("Movement Pack", self.player)
+        self.collect(movement_pack)
+        self.assertFalse(self.can_reach_location(sword))
+        time_pack = self.multiworld.create_item("Time is Money Pack", self.player)
+        self.collect(time_pack)
+        self.assertTrue(self.can_reach_location(sword))
+
+    def test_gun_location_has_correct_rules(self):
+        self.assertFalse(self.can_reach_location(gun))
+        movement_pack = self.multiworld.create_item("Movement Pack", self.player)
+        self.collect(movement_pack)
+        self.assertFalse(self.can_reach_location(gun))
+        sword_item = self.multiworld.create_item(sword, self.player)
+        self.collect(sword_item)
+        self.assertFalse(self.can_reach_location(gun))
+        gun_pack = self.multiworld.create_item("Gun Pack", self.player)
+        self.collect(gun_pack)
+        self.assertTrue(self.can_reach_location(gun))
+
+    def test_wooden_sword_location_has_correct_rules(self):
+        self.assertFalse(self.can_reach_location(wooden_sword))
+        important_pack_item = self.multiworld.create_item(important_pack, self.player)
+        self.collect(important_pack_item)
+        self.assertTrue(self.can_reach_location(wooden_sword))
+
+    def test_bindle_location_has_correct_rules(self):
+        self.assertFalse(self.can_reach_location(humble_bindle))
+        wooden_sword_item = self.multiworld.create_item(wooden_sword, self.player)
+        self.collect(wooden_sword_item)
+        self.assertFalse(self.can_reach_location(humble_bindle))
+        plants_pack = self.multiworld.create_item("Harmless Plants Pack", self.player)
+        self.collect(plants_pack)
+        self.assertFalse(self.can_reach_location(humble_bindle))
+        wall_jump_pack = self.multiworld.create_item("Wall Jump Pack", self.player)
+        self.collect(wall_jump_pack)
+        self.assertFalse(self.can_reach_location(humble_bindle))
+        name_change_pack = self.multiworld.create_item("Name Change Pack", self.player)
+        self.collect(name_change_pack)
+        self.assertFalse(self.can_reach_location(humble_bindle))
+        cut_content_pack = self.multiworld.create_item("Cut Content Pack", self.player)
+        self.collect(cut_content_pack)
+        self.assertFalse(self.can_reach_location(humble_bindle))
+        box_supplies_item = self.multiworld.create_item(box_supplies, self.player)
+        self.collect(box_supplies_item)
+        self.assertTrue(self.can_reach_location(humble_bindle))
+
+    def test_box_supplies_location_has_correct_rules(self):
+        self.assertFalse(self.can_reach_location(box_supplies))
+        wooden_sword_item = self.multiworld.create_item(wooden_sword, self.player)
+        self.collect(wooden_sword_item)
+        self.assertFalse(self.can_reach_location(box_supplies))
+        plants_pack = self.multiworld.create_item("Harmless Plants Pack", self.player)
+        self.collect(plants_pack)
+        self.assertFalse(self.can_reach_location(box_supplies))
+        wall_jump_pack = self.multiworld.create_item("Wall Jump Pack", self.player)
+        self.collect(wall_jump_pack)
+        self.assertFalse(self.can_reach_location(box_supplies))
+        name_change_pack = self.multiworld.create_item("Name Change Pack", self.player)
+        self.collect(name_change_pack)
+        self.assertFalse(self.can_reach_location(box_supplies))
+        cut_content_pack = self.multiworld.create_item("Cut Content Pack", self.player)
+        self.collect(cut_content_pack)
+        self.assertTrue(self.can_reach_location(box_supplies))
+
+    def test_pickaxe_location_has_correct_rules(self):
+        self.assertFalse(self.can_reach_location(pickaxe))
+        wooden_sword_item = self.multiworld.create_item(wooden_sword, self.player)
+        self.collect(wooden_sword_item)
+        self.assertFalse(self.can_reach_location(pickaxe))
+        plants_pack = self.multiworld.create_item("Harmless Plants Pack", self.player)
+        self.collect(plants_pack)
+        self.assertFalse(self.can_reach_location(pickaxe))
+        wall_jump_pack = self.multiworld.create_item("Wall Jump Pack", self.player)
+        self.collect(wall_jump_pack)
+        self.assertFalse(self.can_reach_location(pickaxe))
+        name_change_pack = self.multiworld.create_item("Name Change Pack", self.player)
+        self.collect(name_change_pack)
+        self.assertFalse(self.can_reach_location(pickaxe))
+        bindle_item = self.multiworld.create_item("Humble Indie Bindle", self.player)
+        self.collect(bindle_item)
+        self.assertTrue(self.can_reach_location(pickaxe))
+
+
+class TestNoItemShuffle(DLCQuestTestBase):
+    options = {Options.ItemShuffle.internal_name: Options.ItemShuffle.option_disabled,
+               Options.Campaign.internal_name: Options.Campaign.option_both}
+
+    def test_items_not_in_pool(self):
+        item_names = {item.name for item in self.multiworld.get_items()}
+        for item in items:
+            with self.subTest(f"{item}"):
+                self.assertNotIn(item, item_names)
+
+    def test_item_locations_not_in_pool(self):
+        location_names = {location.name for location in self.multiworld.get_locations()}
+        for item_location in items:
+            with self.subTest(f"{item_location}"):
+                self.assertNotIn(item_location, location_names)

worlds/dlcquest/test/TestItemShuffle.py

@@ -0,0 +1,87 @@
+from typing import Dict
+
+from BaseClasses import MultiWorld
+from Options import SpecialRange
+from .option_names import options_to_include
+from .checks.world_checks import assert_can_win, assert_same_number_items_locations
+from . import DLCQuestTestBase, setup_dlc_quest_solo_multiworld
+from ... import AutoWorldRegister
+
+
+def basic_checks(tester: DLCQuestTestBase, multiworld: MultiWorld):
+    assert_can_win(tester, multiworld)
+    assert_same_number_items_locations(tester, multiworld)
+
+
+def get_option_choices(option) -> Dict[str, int]:
+    if issubclass(option, SpecialRange):
+        return option.special_range_names
+    elif option.options:
+        return option.options
+    return {}
+
+
+class TestGenerateDynamicOptions(DLCQuestTestBase):
+    def test_given_option_pair_when_generate_then_basic_checks(self):
+        num_options = len(options_to_include)
+        for option1_index in range(0, num_options):
+            for option2_index in range(option1_index + 1, num_options):
+                option1 = options_to_include[option1_index]
+                option2 = options_to_include[option2_index]
+                option1_choices = get_option_choices(option1)
+                option2_choices = get_option_choices(option2)
+                for key1 in option1_choices:
+                    for key2 in option2_choices:
+                        with self.subTest(f"{option1.internal_name}: {key1}, {option2.internal_name}: {key2}"):
+                            choices = {option1.internal_name: option1_choices[key1],
+                                       option2.internal_name: option2_choices[key2]}
+                            multiworld = setup_dlc_quest_solo_multiworld(choices)
+                            basic_checks(self, multiworld)
+
+    def test_given_option_truple_when_generate_then_basic_checks(self):
+        num_options = len(options_to_include)
+        for option1_index in range(0, num_options):
+            for option2_index in range(option1_index + 1, num_options):
+                for option3_index in range(option2_index + 1, num_options):
+                    option1 = options_to_include[option1_index]
+                    option2 = options_to_include[option2_index]
+                    option3 = options_to_include[option3_index]
+                    option1_choices = get_option_choices(option1)
+                    option2_choices = get_option_choices(option2)
+                    option3_choices = get_option_choices(option3)
+                    for key1 in option1_choices:
+                        for key2 in option2_choices:
+                            for key3 in option3_choices:
+                                with self.subTest(f"{option1.internal_name}: {key1}, {option2.internal_name}: {key2}, {option3.internal_name}: {key3}"):
+                                    choices = {option1.internal_name: option1_choices[key1],
+                                               option2.internal_name: option2_choices[key2],
+                                               option3.internal_name: option3_choices[key3]}
+                                    multiworld = setup_dlc_quest_solo_multiworld(choices)
+                                    basic_checks(self, multiworld)
+
+    def test_given_option_quartet_when_generate_then_basic_checks(self):
+        num_options = len(options_to_include)
+        for option1_index in range(0, num_options):
+            for option2_index in range(option1_index + 1, num_options):
+                for option3_index in range(option2_index + 1, num_options):
+                    for option4_index in range(option3_index + 1, num_options):
+                        option1 = options_to_include[option1_index]
+                        option2 = options_to_include[option2_index]
+                        option3 = options_to_include[option3_index]
+                        option4 = options_to_include[option4_index]
+                        option1_choices = get_option_choices(option1)
+                        option2_choices = get_option_choices(option2)
+                        option3_choices = get_option_choices(option3)
+                        option4_choices = get_option_choices(option4)
+                        for key1 in option1_choices:
+                            for key2 in option2_choices:
+                                for key3 in option3_choices:
+                                    for key4 in option4_choices:
+                                        with self.subTest(
+                                                f"{option1.internal_name}: {key1}, {option2.internal_name}: {key2}, {option3.internal_name}: {key3}, {option4.internal_name}: {key4}"):
+                                            choices = {option1.internal_name: option1_choices[key1],
+                                                       option2.internal_name: option2_choices[key2],
+                                                       option3.internal_name: option3_choices[key3],
+                                                       option4.internal_name: option4_choices[key4]}
+                                            multiworld = setup_dlc_quest_solo_multiworld(choices)
+                                            basic_checks(self, multiworld)

worlds/dlcquest/test/TestOptionsLong.py

@@ -0,0 +1,53 @@
+from typing import ClassVar
+
+from typing import Dict, FrozenSet, Tuple, Any
+from argparse import Namespace
+
+from BaseClasses import MultiWorld
+from test.TestBase import WorldTestBase
+from .. import DLCqworld
+from test.general import gen_steps, setup_solo_multiworld as setup_base_solo_multiworld
+from worlds.AutoWorld import call_all
+
+
+class DLCQuestTestBase(WorldTestBase):
+    game = "DLCQuest"
+    world: DLCqworld
+    player: ClassVar[int] = 1
+
+    def world_setup(self, *args, **kwargs):
+        super().world_setup(*args, **kwargs)
+        if self.constructed:
+            self.world = self.multiworld.worlds[self.player]  # noqa
+
+    @property
+    def run_default_tests(self) -> bool:
+        # world_setup is overridden, so it'd always run default tests when importing DLCQuestTestBase
+        is_not_dlc_test = type(self) is not DLCQuestTestBase
+        should_run_default_tests = is_not_dlc_test and super().run_default_tests
+        return should_run_default_tests
+
+
+def setup_dlc_quest_solo_multiworld(test_options=None, seed=None, _cache: Dict[FrozenSet[Tuple[str, Any]], MultiWorld] = {}) -> MultiWorld: #noqa
+    if test_options is None:
+        test_options = {}
+
+    # Yes I reuse the worlds generated between tests, its speeds the execution by a couple seconds
+    frozen_options = frozenset(test_options.items()).union({seed})
+    if frozen_options in _cache:
+        return _cache[frozen_options]
+
+    multiworld = setup_base_solo_multiworld(DLCqworld, ())
+    multiworld.set_seed(seed)
+    # print(f"Seed: {multiworld.seed}") # Uncomment to print the seed for every test
+    args = Namespace()
+    for name, option in DLCqworld.options_dataclass.type_hints.items():
+        value = option(test_options[name]) if name in test_options else option.from_any(option.default)
+        setattr(args, name, {1: value})
+    multiworld.set_options(args)
+    for step in gen_steps:
+        call_all(multiworld, step)
+
+    _cache[frozen_options] = multiworld
+
+    return multiworld

worlds/dlcquest/test/__init__.py

@@ -0,0 +1,42 @@
+from typing import List
+
+from BaseClasses import MultiWorld, ItemClassification
+from .. import DLCQuestTestBase
+from ... import Options
+
+
+def get_all_item_names(multiworld: MultiWorld) -> List[str]:
+    return [item.name for item in multiworld.itempool]
+
+
+def get_all_location_names(multiworld: MultiWorld) -> List[str]:
+    return [location.name for location in multiworld.get_locations() if not location.event]
+
+
+def assert_victory_exists(tester: DLCQuestTestBase, multiworld: MultiWorld):
+    campaign = multiworld.campaign[1]
+    all_items = [item.name for item in multiworld.get_items()]
+    if campaign == Options.Campaign.option_basic or campaign == Options.Campaign.option_both:
+        tester.assertIn("Victory Basic", all_items)
+    if campaign == Options.Campaign.option_live_freemium_or_die or campaign == Options.Campaign.option_both:
+        tester.assertIn("Victory Freemium", all_items)
+
+
+def collect_all_then_assert_can_win(tester: DLCQuestTestBase, multiworld: MultiWorld):
+    for item in multiworld.get_items():
+        multiworld.state.collect(item)
+    campaign = multiworld.campaign[1]
+    if campaign == Options.Campaign.option_basic or campaign == Options.Campaign.option_both:
+        tester.assertTrue(multiworld.find_item("Victory Basic", 1).can_reach(multiworld.state))
+    if campaign == Options.Campaign.option_live_freemium_or_die or campaign == Options.Campaign.option_both:
+        tester.assertTrue(multiworld.find_item("Victory Freemium", 1).can_reach(multiworld.state))
+
+
+def assert_can_win(tester: DLCQuestTestBase, multiworld: MultiWorld):
+    assert_victory_exists(tester, multiworld)
+    collect_all_then_assert_can_win(tester, multiworld)
+
+
+def assert_same_number_items_locations(tester: DLCQuestTestBase, multiworld: MultiWorld):
+    non_event_locations = [location for location in multiworld.get_locations() if not location.event]
+    tester.assertEqual(len(multiworld.itempool), len(non_event_locations))

worlds/dlcquest/test/checks/__init__.py

@@ -0,0 +1,5 @@
+from .. import DLCqworld
+
+options_to_exclude = ["progression_balancing", "accessibility", "start_inventory", "start_hints", "death_link"]
+options_to_include = [option for option_name, option in DLCqworld.options_dataclass.type_hints.items()
+                      if option_name not in options_to_exclude]