SoE: update to pyevermizer v0.48.0 (#3050)

worlds/soe/test/test_sniffamizer.py

@@ -0,0 +1,130 @@
+import typing
+from unittest import TestCase, skipUnless
+
+from . import SoETestBase
+from .. import pyevermizer
+from ..options import Sniffamizer
+
+
+class TestCount(TestCase):
+    """
+    Test that counts line up for sniff spots
+    """
+
+    def test_compare_counts(self) -> None:
+        self.assertEqual(len(pyevermizer.get_sniff_locations()), len(pyevermizer.get_sniff_items()),
+                         "Sniff locations and sniff items don't line up")
+
+
+class Bases:
+    # class in class to avoid running tests for helper class
+    class TestSniffamizerLocal(SoETestBase):
+        """
+        Test that provided options do not add sniff items or locations
+        """
+        def test_no_sniff_items(self) -> None:
+            self.assertLess(len(self.multiworld.itempool), 500,
+                            "Unexpected number of items")
+            for item in self.multiworld.itempool:
+                if item.code is not None:
+                    self.assertLess(item.code, 65000,
+                                    "Unexpected item type")
+
+        def test_no_sniff_locations(self) -> None:
+            location_count = sum(1 for location in self.multiworld.get_locations(self.player) if location.item is None)
+            self.assertLess(location_count, 500,
+                            "Unexpected number of locations")
+            for location in self.multiworld.get_locations(self.player):
+                if location.address is not None:
+                    self.assertLess(location.address, 65000,
+                                    "Unexpected location type")
+            self.assertEqual(location_count, len(self.multiworld.itempool),
+                             "Locations and item counts do not line up")
+
+    class TestSniffamizerPool(SoETestBase):
+        """
+        Test that provided options add sniff items and locations
+        """
+        def test_sniff_items(self) -> None:
+            self.assertGreater(len(self.multiworld.itempool), 500,
+                               "Unexpected number of items")
+
+        def test_sniff_locations(self) -> None:
+            location_count = sum(1 for location in self.multiworld.get_locations(self.player) if location.item is None)
+            self.assertGreater(location_count, 500,
+                               "Unexpected number of locations")
+            self.assertTrue(any(location.address is not None and location.address >= 65000
+                                for location in self.multiworld.get_locations(self.player)),
+                            "No sniff locations")
+            self.assertEqual(location_count, len(self.multiworld.itempool),
+                             "Locations and item counts do not line up")
+
+
+class TestSniffamizerShuffle(Bases.TestSniffamizerLocal):
+    """
+    Test that shuffle does not add extra items or locations
+    """
+    options: typing.Dict[str, typing.Any] = {
+        "sniffamizer": "shuffle"
+    }
+
+    def test_flags(self) -> None:
+        # default -> no flags
+        flags = self.world.options.flags
+        self.assertNotIn("s", flags)
+        self.assertNotIn("S", flags)
+        self.assertNotIn("v", flags)
+
+
+@skipUnless(hasattr(Sniffamizer, "option_everywhere"), "Feature disabled")
+class TestSniffamizerEverywhereVanilla(Bases.TestSniffamizerPool):
+    """
+    Test that everywhere + vanilla ingredients does add extra items and locations
+    """
+    options: typing.Dict[str, typing.Any] = {
+        "sniffamizer": "everywhere",
+        "sniff_ingredients": "vanilla_ingredients",
+    }
+
+    def test_flags(self) -> None:
+        flags = self.world.options.flags
+        self.assertIn("S", flags)
+        self.assertNotIn("v", flags)
+
+
+@skipUnless(hasattr(Sniffamizer, "option_everywhere"), "Feature disabled")
+class TestSniffamizerEverywhereRandom(Bases.TestSniffamizerPool):
+    """
+    Test that everywhere + random ingredients also adds extra items and locations
+    """
+    options: typing.Dict[str, typing.Any] = {
+        "sniffamizer": "everywhere",
+        "sniff_ingredients": "random_ingredients",
+    }
+
+    def test_flags(self) -> None:
+        flags = self.world.options.flags
+        self.assertIn("S", flags)
+        self.assertIn("v", flags)
+
+
+@skipUnless(hasattr(Sniffamizer, "option_everywhere"), "Feature disabled")
+class EverywhereAccessTest(SoETestBase):
+    """
+    Test that everywhere has certain rules
+    """
+    options: typing.Dict[str, typing.Any] = {
+        "sniffamizer": "everywhere",
+    }
+
+    @staticmethod
+    def _resolve_numbers(spots: typing.Mapping[str, typing.Iterable[int]]) -> typing.List[str]:
+        return [f"{name} #{number}" for name, numbers in spots.items() for number in numbers]
+
+    def test_knight_basher(self) -> None:
+        locations = ["Mungola", "Lightning Storm"] + self._resolve_numbers({
+            "Gomi's Tower Sniff": range(473, 491),
+            "Gomi's Tower": range(195, 199),
+        })
+        items = [["Knight Basher"]]
+        self.assertAccessDependency(locations, items)