kapitan 0.35.2.dev19__tar.gz → 0.35.2.dev20__tar.gz

{kapitan-0.35.2.dev19 → kapitan-0.35.2.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapitan
-Version: 0.35.2.dev19
+Version: 0.35.2.dev20
 Summary: Generic templated configuration management for Kubernetes, Terraform and other things
 Project-URL: Homepage, https://kapitan.dev
 Project-URL: Repository, https://github.com/kapicorp/kapitan

{kapitan-0.35.2.dev19 → kapitan-0.35.2.dev20}/kapitan/inventory/backends/omegaconf/__init__.py

@@ -125,28 +125,25 @@ class OmegaConfInventory(Inventory):
             class_path_base = self.classes_path
 
         # Now try to find the class file
-        extension = ".yml"
-
-        cases = [
-            # case components.kapicorp is absolute and a directory, look for components/kapicorp/init.yml
-            # case .components.kapicorp is relative and a directory, look for <class_parent_dir>/components/kapicorp/init.yml
-            os.path.join(class_path_base, *class_name.split("."), "init" + extension),
-            # case components.kapicorp is absolute and a file, look for components/kapicorp.yml
-            # case components.kapicorp is relative and a file, look for <class_parent_dir>/components/kapicorp.yml
-            os.path.join(class_path_base, *class_name.split(".")) + extension,
-            # Reclass compatibility mode
-            # case .components.kapicorp  points to <class_parent_dir>/kapicorp.yml
-            os.path.join(class_path_base, *class_name.split(".")[2:]) + extension,
-            # case components.kapicorp points to components/kapicorp/init.yml
-            os.path.join(
-                class_path_base, *class_name.split(".")[2:], "init" + extension
-            ),
-        ]
-
-        for case in cases:
-            if os.path.isfile(case):
-                class_file = case
-                return class_file
+        for ext in (".yml", ".yaml"):
+            cases = [
+                # case components.kapicorp is absolute and a directory, look for components/kapicorp/init.yml
+                # case .components.kapicorp is relative and a directory, look for <class_parent_dir>/components/kapicorp/init.yml
+                os.path.join(class_path_base, *class_name.split("."), "init" + ext),
+                # case components.kapicorp is absolute and a file, look for components/kapicorp.yml
+                # case components.kapicorp is relative and a file, look for <class_parent_dir>/components/kapicorp.yml
+                os.path.join(class_path_base, *class_name.split(".")) + ext,
+                # Reclass compatibility mode
+                # case .components.kapicorp  points to <class_parent_dir>/kapicorp.yml
+                os.path.join(class_path_base, *class_name.split(".")[2:]) + ext,
+                # case components.kapicorp points to components/kapicorp/init.yml
+                os.path.join(class_path_base, *class_name.split(".")[2:], "init" + ext),
+            ]
+
+            for case in cases:
+                if os.path.isfile(case):
+                    class_file = case
+                    return class_file
 
         logger.error(f"class file not found for class {class_name}, tried {cases}")
         return None

{kapitan-0.35.2.dev19 → kapitan-0.35.2.dev20}/kapitan/inventory/backends/omegaconf/migrate.py

@@ -34,7 +34,7 @@ def migrate_dir(path: str):
             try:
                 migrate_file(file)
             except Exception as e:
-                InventoryError(f"{file}: error with migration: {e}")
+                raise InventoryError(f"{file}: error with migration: {e}") from e
 
 
 def migrate_file(file: str):

{kapitan-0.35.2.dev19 → kapitan-0.35.2.dev20}/kapitan/resources.py

@@ -383,6 +383,13 @@ def get_inventory(inventory_path, ignore_class_not_found: bool = False) -> Inven
     )
     backend = get_inventory_backend(backend_id)
 
+    # migrate inventory to selected inventory backend BEFORE instantiating,
+    # because the constructor renders the inventory which would fail on
+    # un-migrated syntax.
+    if hasattr(cached.args, "migrate") and cached.args.migrate:
+        migrator = backend(inventory_path=inventory_path, initialise=False)
+        migrator.migrate()
+
     logger.debug(f"Using {backend.__name__} as inventory backend")
     try:
         inventory_backend = backend(
@@ -396,8 +403,4 @@ def get_inventory(inventory_path, ignore_class_not_found: bool = False) -> Inven
     cached.inv = inventory_backend
     cached.global_inv = cached.inv.inventory
 
-    # migrate inventory to selected inventory backend
-    if hasattr(cached.args, "migrate") and cached.args.migrate:
-        inventory_backend.migrate()
-
     return cached.inv

{kapitan-0.35.2.dev19 → kapitan-0.35.2.dev20}/tests/test_omegaconf.py

@@ -16,8 +16,14 @@ import unittest
 
 from omegaconf import OmegaConf
 
+from kapitan import cached
+from kapitan.cached import reset_cache
+from kapitan.errors import InventoryError
 from kapitan.inventory import get_inventory_backend
+from kapitan.inventory.backends.omegaconf import OmegaConfInventory
+from kapitan.inventory.backends.omegaconf.migrate import migrate_dir, migrate_str
 from kapitan.inventory.backends.omegaconf.resolvers import register_resolvers
+from kapitan.resources import get_inventory
 
 
 logger = logging.getLogger(__name__)
@@ -620,3 +626,127 @@ class InventoryTestOmegaConfDeferredResolvers(unittest.TestCase):
 
 
 # Compile tests for omegaconf are in test_compile.py (CompileTestResourcesOCOmegaconf)
+
+
+class TestOmegaConfMigrate(unittest.TestCase):
+    """Tests for the OmegaConf migration logic."""
+
+    def test_migrate_str_converts_colon_to_dot(self):
+        """Reclass ${foo:bar} becomes OmegaConf ${foo.bar}"""
+        self.assertEqual(migrate_str("${a:b}"), "${a.b}")
+        self.assertEqual(migrate_str("${a:b:c}"), "${a.b.c}")
+
+    def test_migrate_dir_raises_on_invalid_yaml(self):
+        """Migration errors must be raised, not swallowed."""
+        temp_dir = tempfile.mkdtemp()
+        bad_file = os.path.join(temp_dir, "bad.yml")
+        with open(bad_file, "w") as f:
+            f.write("parameters:\n  foo: bar\n")
+
+        # Make the file read-only so migrate_file can't write
+        os.chmod(bad_file, 0o444)
+
+        try:
+            with self.assertRaises(InventoryError):
+                migrate_dir(temp_dir)
+        finally:
+            os.chmod(bad_file, 0o644)
+            shutil.rmtree(temp_dir)
+
+
+class TestOmegaConfClassResolution(unittest.TestCase):
+    """Tests for OmegaConf class file resolution."""
+
+    def test_resolve_class_file_path_with_yaml_extension(self):
+        """Class files with .yaml extension must be discoverable."""
+        temp_dir = tempfile.mkdtemp()
+        classes_dir = os.path.join(temp_dir, "classes")
+        targets_dir = os.path.join(temp_dir, "targets")
+        os.makedirs(classes_dir)
+        os.makedirs(targets_dir)
+
+        # Create a .yaml class file
+        with open(os.path.join(classes_dir, "common.yaml"), "w") as f:
+            f.write("parameters:\n  foo: bar\n")
+
+        # Create a target that references the class
+        with open(os.path.join(targets_dir, "test.yml"), "w") as f:
+            f.write("classes:\n  - common\n")
+
+        inventory = OmegaConfInventory(inventory_path=temp_dir, initialise=False)
+        resolved = inventory.resolve_class_file_path("common")
+        self.assertEqual(resolved, os.path.join(classes_dir, "common.yaml"))
+
+        shutil.rmtree(temp_dir)
+
+    def test_resolve_class_file_path_prefers_yml_over_yaml(self):
+        """When both .yml and .yaml exist, .yml should take precedence."""
+        temp_dir = tempfile.mkdtemp()
+        classes_dir = os.path.join(temp_dir, "classes")
+        targets_dir = os.path.join(temp_dir, "targets")
+        os.makedirs(classes_dir)
+        os.makedirs(targets_dir)
+
+        with open(os.path.join(classes_dir, "common.yml"), "w") as f:
+            f.write("parameters:\n  from: yml\n")
+        with open(os.path.join(classes_dir, "common.yaml"), "w") as f:
+            f.write("parameters:\n  from: yaml\n")
+
+        inventory = OmegaConfInventory(inventory_path=temp_dir, initialise=False)
+        resolved = inventory.resolve_class_file_path("common")
+        self.assertEqual(resolved, os.path.join(classes_dir, "common.yml"))
+
+        shutil.rmtree(temp_dir)
+
+
+class TestOmegaConfInventoryMigrationTiming(unittest.TestCase):
+    """Tests that --migrate runs before inventory initialisation."""
+
+    def setUp(self):
+        reset_cache()
+        self.temp_dir = tempfile.mkdtemp()
+        inventory_dir = os.path.join(self.temp_dir, "inventory")
+        classes_dir = os.path.join(inventory_dir, "classes")
+        targets_dir = os.path.join(inventory_dir, "targets")
+        os.makedirs(classes_dir)
+        os.makedirs(targets_dir)
+
+        # Class with reclass-style interpolation
+        with open(os.path.join(classes_dir, "common.yml"), "w") as f:
+            f.write("parameters:\n  shared:\n    name: common\n")
+
+        with open(os.path.join(classes_dir, "app.yml"), "w") as f:
+            f.write(
+                "classes:\n  - common\nparameters:\n  app:\n    ref: ${shared:name}\n"
+            )
+
+        with open(os.path.join(targets_dir, "test.yml"), "w") as f:
+            f.write("classes:\n  - app\n")
+
+        self.inventory_path = inventory_dir
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+        reset_cache()
+
+    def test_migrate_runs_before_initialisation(self):
+        """When cached.args.migrate is True, get_inventory must migrate files
+        before the backend tries to render them."""
+        from argparse import Namespace
+
+        cached.args = Namespace(
+            migrate=True,
+            inventory_backend="omegaconf",
+            compose_target_name=False,
+            compose_node_name=False,
+        )
+
+        inventory = get_inventory(self.inventory_path)
+        self.assertIsInstance(inventory, OmegaConfInventory)
+        self.assertIn("test", inventory.targets)
+
+        # Verify the file was actually migrated
+        with open(os.path.join(self.inventory_path, "classes", "app.yml")) as f:
+            content = f.read()
+        self.assertIn("${shared.name}", content)
+        self.assertNotIn("${shared:name}", content)