kapitan 0.35.2.dev27__tar.gz → 0.35.2.dev28__tar.gz

{kapitan-0.35.2.dev27 → kapitan-0.35.2.dev28}/.github/workflows/test-build-publish.yml

@@ -89,6 +89,8 @@ jobs:
     name: python ${{ matrix.python-version }} tests
     needs: [setup, check-changes]
     runs-on: ${{ needs.setup.outputs.runner }}
+    env:
+      VAULT_ADDR: http://localhost:8200
     strategy:
       fail-fast: false
       matrix:
@@ -119,6 +121,28 @@ jobs:
           mise exec -- kustomize version
           mise exec -- cue version
 
+      - name: Start Vault dev server for tests
+        if: needs.check-changes.outputs.has-code-changes == 'true'
+        run: |
+          docker run -d --name vault-ci \
+            --cap-add IPC_LOCK \
+            -e SKIP_SETCAP=1 \
+            -e VAULT_DEV_ROOT_TOKEN_ID=root \
+            -e VAULT_DEV_LISTEN_ADDRESS=0.0.0.0:8200 \
+            -p 8200:8200 \
+            hashicorp/vault server -dev
+          # Wait for Vault to be ready
+          for _ in $(seq 1 30); do
+            if curl -sf http://localhost:8200/v1/sys/health | grep -q '"initialized":true'; then
+              echo "Vault is ready"
+              exit 0
+            fi
+            sleep 1
+          done
+          echo "Vault failed to start"
+          docker logs vault-ci
+          exit 1
+
       - name: Run pytest
         if: needs.check-changes.outputs.has-code-changes == 'true'
         uses: pavelzw/pytest-action@510c5e90c360a185039bea56ce8b3e7e51a16507 # v2.2.0

{kapitan-0.35.2.dev27 → kapitan-0.35.2.dev28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapitan
-Version: 0.35.2.dev27
+Version: 0.35.2.dev28
 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.dev27 → kapitan-0.35.2.dev28}/tests/test_cli.py

@@ -19,7 +19,7 @@ import pytest
 from kapitan.cli import build_parser
 from kapitan.cli import main as kapitan
 from kapitan.refs.secrets.vaultkv import VaultSecret
-from tests.vault_server import VaultServer
+from tests.vault_server import get_shared_vault_server
 
 
 REFS_PATH = tempfile.mkdtemp()
@@ -60,7 +60,7 @@ class CliFuncsTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         # setup vault server (running in container)
-        cls.server = VaultServer()
+        cls.server = get_shared_vault_server()
 
     @classmethod
     def tearDownClass(cls):

kapitan-0.35.2.dev28/tests/test_inputs_base.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+
+# Copyright 2019 The Kapitan Authors
+# SPDX-FileCopyrightText: 2020 The Kapitan Authors <kapitan-admins@googlegroups.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for kapitan.inputs.base — to_file, CompiledFile, CompilingFile."""
+
+import json
+import os
+import tempfile
+import unittest
+from argparse import Namespace
+
+import pytest
+import toml
+import yaml
+
+from kapitan import cached
+from kapitan.cached import reset_cache
+from kapitan.errors import CompileError, KapitanError
+from kapitan.inputs.base import CompiledFile, InputType
+from kapitan.inventory.model.input_types import (
+    KapitanInputTypeCopyConfig,
+    OutputType,
+)
+
+
+class MockInputType(InputType):
+    """Mock InputType for testing base methods."""
+
+    def compile_file(self, config, input_path, compile_path):
+        pass
+
+    def inputs_hash(self, *inputs, **kwargs):
+        return ""
+
+
+@pytest.mark.usefixtures("reset_cached_args")
+class ToFileTest(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp(prefix="kapitan_base_test_")
+        self.compile_path = os.path.join(self.temp_dir, "compiled")
+        os.makedirs(self.compile_path, exist_ok=True)
+
+        cached.args = Namespace(
+            reveal=False,
+            indent=2,
+            yaml_use_rapidyaml=False,
+            yaml_dump_null_as_empty=False,
+        )
+        cached.inv = {"test-target": {"parameters": {}}}
+
+    def tearDown(self):
+        reset_cache()
+        import shutil
+
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def _make_compiler(self):
+        return MockInputType(
+            self.compile_path, [self.temp_dir], None, "test-target", cached.args
+        )
+
+    def test_to_file_plain(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.PLAIN
+        )
+        file_path = os.path.join(self.temp_dir, "output")
+        compiler.to_file(config, file_path, "hello world")
+
+        self.assertTrue(os.path.exists(file_path))
+        with open(file_path) as f:
+            self.assertEqual(f.read(), "hello world")
+
+    def test_to_file_json(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.JSON
+        )
+        file_path = os.path.join(self.temp_dir, "output")
+        compiler.to_file(config, file_path, {"key": "value"})
+
+        self.assertTrue(os.path.exists(file_path + ".json"))
+        with open(file_path + ".json") as f:
+            data = json.load(f)
+            self.assertEqual(data["key"], "value")
+
+    def test_to_file_yaml(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.YAML
+        )
+        file_path = os.path.join(self.temp_dir, "output")
+        compiler.to_file(config, file_path, {"key": "value"})
+
+        self.assertTrue(os.path.exists(file_path + ".yaml"))
+        with open(file_path + ".yaml") as f:
+            data = yaml.safe_load(f)
+            self.assertEqual(data["key"], "value")
+
+    def test_to_file_toml(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.TOML
+        )
+        file_path = os.path.join(self.temp_dir, "output")
+        compiler.to_file(config, file_path, {"section": {"key": "value"}})
+
+        self.assertTrue(os.path.exists(file_path + ".toml"))
+        with open(file_path + ".toml") as f:
+            data = toml.load(f)
+            self.assertEqual(data["section"]["key"], "value")
+
+    def test_to_file_auto_detects_json(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.AUTO
+        )
+        file_path = os.path.join(self.temp_dir, "output.json")
+        compiler.to_file(config, file_path, {"key": "value"})
+
+        with open(file_path) as f:
+            data = json.load(f)
+            self.assertEqual(data["key"], "value")
+
+    def test_to_file_auto_detects_yaml(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.AUTO
+        )
+        file_path = os.path.join(self.temp_dir, "output.yaml")
+        compiler.to_file(config, file_path, {"key": "value"})
+
+        with open(file_path) as f:
+            data = yaml.safe_load(f)
+            self.assertEqual(data["key"], "value")
+
+    def test_to_file_auto_fallback_to_default(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.AUTO
+        )
+        file_path = os.path.join(self.temp_dir, "output.unknown")
+        compiler.to_file(config, file_path, "plain text")
+
+        # Falls back to YAML (default for MockInputType since it inherits YAML)
+        self.assertTrue(os.path.exists(file_path + ".yaml"))
+
+    def test_to_file_prune_empty(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"],
+            output_path=".",
+            output_type=OutputType.YAML,
+            prune=True,
+        )
+        file_path = os.path.join(self.temp_dir, "output")
+        compiler.to_file(
+            config, file_path, {"keep": "this", "remove": {}, "also_remove": []}
+        )
+
+        with open(file_path + ".yaml") as f:
+            data = yaml.safe_load(f)
+            self.assertIn("keep", data)
+            self.assertNotIn("remove", data)
+            self.assertNotIn("also_remove", data)
+
+    def test_to_file_unsupported_output_type(self):
+        compiler = self._make_compiler()
+        config = KapitanInputTypeCopyConfig(
+            input_paths=["dummy"], output_path=".", output_type=OutputType.YAML
+        )
+        # Force an unsupported output_type after validation to trigger the ValueError
+        config.output_type = "UNSUPPORTED"
+        file_path = os.path.join(self.temp_dir, "output")
+
+        with self.assertRaises(ValueError) as ctx:
+            compiler.to_file(config, file_path, "data")
+        self.assertIn("not supported", str(ctx.exception))
+
+
+@pytest.mark.usefixtures("reset_cached_args")
+class CompiledFileTest(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp(prefix="kapitan_compiled_file_test_")
+        cached.args = Namespace(
+            reveal=False,
+            indent=2,
+            yaml_use_rapidyaml=False,
+            yaml_dump_null_as_empty=False,
+        )
+        cached.inv = {"test-target": {"parameters": {}}}
+
+    def tearDown(self):
+        reset_cache()
+        import shutil
+
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_compiled_file_context_manager(self):
+        file_path = os.path.join(self.temp_dir, "test.txt")
+        with CompiledFile(file_path, None, mode="w", target_name="test-target") as cf:
+            cf.write("hello")
+
+        with open(file_path) as f:
+            self.assertEqual(f.read(), "hello")
+
+    def test_compiling_file_write_yaml(self):
+        file_path = os.path.join(self.temp_dir, "test.yaml")
+        with CompiledFile(file_path, None, mode="w", target_name="test-target") as cf:
+            cf.write_yaml({"key": "value"})
+
+        with open(file_path) as f:
+            data = yaml.safe_load(f)
+            self.assertEqual(data["key"], "value")
+
+    def test_compiling_file_write_json(self):
+        file_path = os.path.join(self.temp_dir, "test.json")
+        with CompiledFile(file_path, None, mode="w", target_name="test-target") as cf:
+            cf.write_json({"key": "value"})
+
+        with open(file_path) as f:
+            data = json.load(f)
+            self.assertEqual(data["key"], "value")
+
+    def test_compiling_file_write_toml(self):
+        file_path = os.path.join(self.temp_dir, "test.toml")
+        with CompiledFile(file_path, None, mode="w", target_name="test-target") as cf:
+            cf.write_toml({"section": {"key": "value"}})
+
+        with open(file_path) as f:
+            data = toml.load(f)
+            self.assertEqual(data["section"]["key"], "value")
+
+    def test_compiling_file_skips_empty_yaml(self):
+        file_path = os.path.join(self.temp_dir, "test.yaml")
+        with CompiledFile(file_path, None, mode="w", target_name="test-target") as cf:
+            cf.write_yaml({})
+
+        # Empty YAML should be skipped (file created but empty)
+        self.assertTrue(os.path.exists(file_path))
+
+    def test_compile_input_path_wraps_kapitan_error(self):
+        class FailingInputType(InputType):
+            def compile_file(self, config, input_path, compile_path):
+                raise KapitanError("simulated failure")
+
+            def inputs_hash(self, *inputs, **kwargs):
+                return ""
+
+        compile_path = os.path.join(self.temp_dir, "compiled")
+        os.makedirs(compile_path, exist_ok=True)
+        compiler = FailingInputType(compile_path, [], None, "test-target", cached.args)
+        config = KapitanInputTypeCopyConfig(input_paths=["dummy"], output_path=".")
+
+        with self.assertRaises(CompileError) as ctx:
+            compiler.compile_input_path(config, "/some/path")
+        self.assertIn("test-target", str(ctx.exception))
+        self.assertIn("simulated failure", str(ctx.exception))

kapitan-0.35.2.dev28/tests/test_jinja2_input.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+
+# Copyright 2019 The Kapitan Authors
+# SPDX-FileCopyrightText: 2020 The Kapitan Authors <kapitan-admins@googlegroups.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for kapitan.inputs.jinja2 — the Jinja2 input compiler."""
+
+import os
+import tempfile
+import unittest
+from argparse import Namespace
+
+import pytest
+
+from kapitan import cached
+from kapitan.cached import reset_cache
+from kapitan.defaults import DEFAULT_JINJA2_FILTERS_PATH
+from kapitan.inputs.jinja2 import Jinja2
+from kapitan.inventory.model.input_types import KapitanInputTypeJinja2Config
+
+
+@pytest.mark.usefixtures("reset_cached_args")
+class Jinja2InputTest(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp(prefix="kapitan_jinja2_test_")
+        self.compile_path = os.path.join(self.temp_dir, "compiled")
+        os.makedirs(self.compile_path, exist_ok=True)
+
+        # Set up minimal global inventory for the target
+        cached.global_inv = {
+            "test-target": {
+                "parameters": {"kapitan": {"vars": {"my_var": "hello_world"}}}
+            }
+        }
+
+        # Set up cached args used by Jinja2 compiler
+        cached.args = Namespace(
+            reveal=False,
+            jinja2_filters=DEFAULT_JINJA2_FILTERS_PATH,
+            indent=2,
+            yaml_use_rapidyaml=False,
+            yaml_dump_null_as_empty=False,
+        )
+
+        # Set up cached.inv for CompiledFile multiline_string_style lookup
+        cached.inv = {"test-target": {"parameters": {}}}
+
+    def tearDown(self):
+        reset_cache()
+        import shutil
+
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def _make_template(self, name, content):
+        path = os.path.join(self.temp_dir, name)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as f:
+            f.write(content)
+        return path
+
+    def test_compile_single_file(self):
+        template_path = self._make_template("test.txt.j2", "{{ my_var }}")
+
+        compiler = Jinja2(
+            self.compile_path,
+            [self.temp_dir],
+            None,
+            "test-target",
+            cached.args,
+        )
+        config = KapitanInputTypeJinja2Config(
+            input_paths=[template_path],
+            output_path=".",
+        )
+        compiler.compile_file(config, template_path, self.compile_path)
+
+        output_path = os.path.join(self.compile_path, "test.txt.j2")
+        self.assertTrue(os.path.exists(output_path))
+        with open(output_path) as f:
+            self.assertEqual(f.read(), "hello_world")
+
+    def test_compile_directory(self):
+        subdir = os.path.join(self.temp_dir, "templates")
+        os.makedirs(subdir, exist_ok=True)
+        with open(os.path.join(subdir, "a.txt.j2"), "w") as f:
+            f.write("A: {{ my_var }}")
+        with open(os.path.join(subdir, "b.txt.j2"), "w") as f:
+            f.write("B: {{ my_var }}")
+
+        compiler = Jinja2(
+            self.compile_path,
+            [self.temp_dir],
+            None,
+            "test-target",
+            cached.args,
+        )
+        config = KapitanInputTypeJinja2Config(
+            input_paths=[subdir],
+            output_path=".",
+        )
+        compiler.compile_file(config, subdir, self.compile_path)
+
+        with open(os.path.join(self.compile_path, "a.txt.j2")) as f:
+            self.assertEqual(f.read(), "A: hello_world")
+        with open(os.path.join(self.compile_path, "b.txt.j2")) as f:
+            self.assertEqual(f.read(), "B: hello_world")
+
+    def test_suffix_remove(self):
+        template_path = self._make_template("config.txt.j2", "value: {{ my_var }}")
+
+        compiler = Jinja2(
+            self.compile_path,
+            [self.temp_dir],
+            None,
+            "test-target",
+            cached.args,
+        )
+        config = KapitanInputTypeJinja2Config(
+            input_paths=[template_path],
+            output_path=".",
+            suffix_remove=True,
+            suffix_stripped=".j2",
+        )
+        compiler.compile_file(config, template_path, self.compile_path)
+
+        # With suffix_remove=True, the output should be "config.txt" not "config.txt.j2"
+        output_path = os.path.join(self.compile_path, "config.txt")
+        self.assertTrue(os.path.exists(output_path), f"Expected {output_path} to exist")
+        with open(output_path) as f:
+            self.assertEqual(f.read(), "value: hello_world")
+
+    def test_input_params_injected(self):
+        template_path = self._make_template(
+            "params.txt.j2", "compile_path: {{ input_params.compile_path }}"
+        )
+
+        compiler = Jinja2(
+            self.compile_path,
+            [self.temp_dir],
+            None,
+            "test-target",
+            cached.args,
+        )
+        config = KapitanInputTypeJinja2Config(
+            input_paths=[template_path],
+            output_path=".",
+            input_params={"custom_key": "custom_value"},
+        )
+        compiler.compile_file(config, template_path, self.compile_path)
+
+        output_path = os.path.join(self.compile_path, "params.txt.j2")
+        with open(output_path) as f:
+            content = f.read()
+            self.assertIn("compile_path:", content)
+            self.assertIn(self.compile_path, content)
+
+    def test_inventory_context_available(self):
+        template_path = self._make_template("inv.txt.j2", "var: {{ my_var }}")
+
+        compiler = Jinja2(
+            self.compile_path,
+            [self.temp_dir],
+            None,
+            "test-target",
+            cached.args,
+        )
+        config = KapitanInputTypeJinja2Config(
+            input_paths=[template_path],
+            output_path=".",
+        )
+        compiler.compile_file(config, template_path, self.compile_path)
+
+        output_path = os.path.join(self.compile_path, "inv.txt.j2")
+        with open(output_path) as f:
+            self.assertEqual(f.read(), "var: hello_world")
+
+    def test_compiled_file_permissions_preserved(self):
+        template_path = self._make_template("perms.txt.j2", "content")
+        # Set a specific mode on the template
+        os.chmod(template_path, 0o640)
+
+        compiler = Jinja2(
+            self.compile_path,
+            [self.temp_dir],
+            None,
+            "test-target",
+            cached.args,
+        )
+        config = KapitanInputTypeJinja2Config(
+            input_paths=[template_path],
+            output_path=".",
+        )
+        compiler.compile_file(config, template_path, self.compile_path)
+
+        output_path = os.path.join(self.compile_path, "perms.txt.j2")
+        self.assertTrue(os.path.exists(output_path))
+        mode = os.stat(output_path).st_mode & 0o777
+        self.assertEqual(mode, 0o640)