Refactor TestClosedLayers

Author: Peter554

tests/unit/adaptors/graph/test_layers.py

@@ -3,6 +3,7 @@
 import itertools
 import logging
 import re
+from collections.abc import Iterable
 
 import pytest  # type: ignore
 
@@ -964,17 +965,25 @@ class TestClosedLayers:
     @pytest.mark.parametrize(
         "importer, imported",
         [
-            ("mypackage.highest", "mypackage.low"),
-            ("mypackage.highest", "mypackage.lowest"),
-            ("mypackage.high", "mypackage.low"),
-            ("mypackage.high", "mypackage.lowest"),
+            ("highest", "low"),
+            ("highest", "lowest"),
+            ("high", "low"),
+            ("high", "lowest"),
         ],
     )
-    def test_cannot_import_through_closed_mid(self, importer, imported):
-        graph = self._build_legal_graph()
+    def test_one_closed_layer(self, importer, imported):
+        layers = [
+            Layer("highest"),
+            Layer("high"),
+            Layer("mid", closed=True),
+            Layer("low"),
+            Layer("lowest"),
+        ]
+        graph = self._build_layers(layers)
+
         graph.add_import(importer=importer, imported=imported)
 
-        result = self._analyze(graph)
+        result = graph.find_illegal_dependencies_for_layers(layers)
 
         assert result == {
             PackageDependency.new(
@@ -984,53 +993,40 @@ def test_cannot_import_through_closed_mid(self, importer, imported):
             ),
         }
 
-    def test_cannot_import_through_closed_mid_indirect(self):
-        graph = self._build_legal_graph()
-        graph.add_import(importer="mypackage.high", imported="mypackage.other")
-        graph.add_import(importer="mypackage.other", imported="mypackage.low")
+    def test_indirect_import_cannot_bypass_closed_layer(self):
+        layers = [
+            Layer("high"),
+            Layer("mid", closed=True),
+            Layer("low"),
+        ]
+        graph = self._build_layers(layers)
 
-        result = self._analyze(graph)
+        graph.add_module("other")
+        graph.add_import(importer="high", imported="other")
+        graph.add_import(importer="other", imported="low")
+
+        result = graph.find_illegal_dependencies_for_layers(layers)
 
         assert result == {
             PackageDependency.new(
-                importer="mypackage.high",
-                imported="mypackage.low",
-                routes={
-                    Route.single_chained("mypackage.high", "mypackage.other", "mypackage.low")
-                },
+                importer="high",
+                imported="low",
+                routes={Route.single_chained("high", "other", "low")},
             ),
         }
 
-    def _build_legal_graph(self):
+    def _build_layers(self, layers: Iterable[Layer]):
         graph = ImportGraph()
-        for module in (
-            "mypackage",
-            "mypackage.highest",
-            "mypackage.high",
-            "mypackage.mid",
-            "mypackage.low",
-            "mypackage.lowest",
-            "mypackage.other",
-        ):
+
+        modules = []
+        for layer in layers:
+            assert len(layer.module_tails) == 1
+            module = list(layer.module_tails)[0]
             graph.add_module(module)
+            modules.append(module)
 
-        # Add some 'legal' imports that respect the layering
-        graph.add_import(importer="mypackage.highest", imported="mypackage.high")
-        graph.add_import(importer="mypackage.high", imported="mypackage.mid")
-        graph.add_import(importer="mypackage.mid", imported="mypackage.low")
-        graph.add_import(importer="mypackage.low", imported="mypackage.lowest")
-        graph.add_import(importer="mypackage.highest", imported="mypackage.mid")
-        graph.add_import(importer="mypackage.mid", imported="mypackage.lowest")
+        # Legal imports, from higher layer to immediate lower layer
+        for higher_module, lower_module in zip(modules[:-1], modules[1:]):
+            graph.add_import(importer=higher_module, imported=lower_module)
 
         return graph
-
-    def _analyze(self, graph: ImportGraph) -> set[PackageDependency]:
-        return graph.find_illegal_dependencies_for_layers(
-            layers=(
-                Layer("mypackage.highest", closed=False),
-                Layer("mypackage.high", closed=False),
-                Layer("mypackage.mid", closed=True),  # Closed layer
-                Layer("mypackage.low", closed=False),
-                Layer("mypackage.lowest", closed=False),
-            ),
-        )