computer-playbook/tests/unit/utils/test_templating.py

# tests/unit/utils/test_templating.py
import os
import unittest
from pathlib import Path
from unittest.mock import patch

from ansible.errors import AnsibleError


def _repo_root() -> Path:
    # __file__ = tests/unit/utils/test_templating.py
    return Path(__file__).resolve().parents[3]


# Ensure repo root is importable so `utils.*` resolves in all runners
import sys  # noqa: E402

sys.path.insert(0, str(_repo_root()))  # noqa: E402


from utils.templating import (  # noqa: E402
    render_ansible_strict,
)


class _FakeTemplarLookupUndefined:
    """
    Simulates the earlier failure:
      - templar exists
      - but cannot evaluate lookup()
      - returns string unchanged => must trigger fallback evaluator
    """

    def __init__(self):
        self.available_variables = {}

    def template(self, s, *args, **kwargs):
        # behave like templar that doesn't expand anything
        return s


class _FakeTemplarRejectsVariablesKwarg:
    """
    Simulates the earlier failure:
      Templar.template() got an unexpected keyword argument 'variables'
    We ensure our helper does NOT pass variables kwarg.
    """

    def __init__(self):
        self.available_variables = {}

    def template(self, s, fail_on_undefined=False):  # supports only these args
        # return something simple if variables were set via available_variables
        # We mimic minimal Jinja for a very specific case:
        if s.strip() == "{{ CA_ROOT.cert_host }}":
            ca_root = self.available_variables.get("CA_ROOT", {})
            return ca_root.get("cert_host", s)
        return s


class TestTemplatingRenderStrict(unittest.TestCase):
    def test_plain_string_passthrough(self):
        out = render_ansible_strict(
            templar=None,
            raw="/etc/infinito/ca/root-ca.crt",
            var_name="x",
            err_prefix="t",
            variables={},
        )
        self.assertEqual(out, "/etc/infinito/ca/root-ca.crt")

    def test_none_hard_fails(self):
        with self.assertRaises(AnsibleError):
            render_ansible_strict(
                templar=None,
                raw=None,
                var_name="x",
                err_prefix="t",
                variables={},
            )

    def test_empty_after_render_hard_fails(self):
        with self.assertRaises(AnsibleError):
            render_ansible_strict(
                templar=None,
                raw="  ",
                var_name="x",
                err_prefix="t",
                variables={},
            )

    def test_env_lookup_fallback_when_lookup_undefined_like(self):
        # Previously: 'lookup' is undefined -> string remained unchanged.
        # Now: fallback must resolve lookup('env', 'domain') (case-insensitive quoting)
        with patch.dict(os.environ, {"domain": "infinito.localhost"}, clear=False):
            out = render_ansible_strict(
                templar=_FakeTemplarLookupUndefined(),
                raw="{{ lookup('env', 'domain') | default('infinito.localhost', true) }}",
                var_name="CA_TRUST.trust_name",
                err_prefix="compose_ca_inject_cmd",
                variables={},
            )
        self.assertEqual(out, "infinito.localhost")

    def test_env_lookup_default_when_env_missing(self):
        with patch.dict(os.environ, {}, clear=True):
            out = render_ansible_strict(
                templar=_FakeTemplarLookupUndefined(),
                raw="{{ lookup('env', 'DOMAIN') | default('infinito.localhost', true) }}",
                var_name="CA_TRUST.trust_name",
                err_prefix="compose_ca_inject_cmd",
                variables={},
            )
        self.assertEqual(out, "infinito.localhost")

    def test_ca_root_nested_var_resolves_without_templar(self):
        # This is the scenario that kept failing:
        # Rendered: /etc/{{ SOFTWARE_DOMAIN }}/ca/root-ca.crt
        # Raw: {{ CA_ROOT.cert_host }}
        #
        # We simulate CA_ROOT.cert_host itself being a Jinja string that requires another variable.
        variables = {
            "SOFTWARE_DOMAIN": "infinito.nexus",
            "CA_ROOT": {
                "cert_host": "/etc/{{ SOFTWARE_DOMAIN }}/ca/root-ca.crt",
            },
        }
        out = render_ansible_strict(
            templar=None,  # no templar available -> must still resolve via fallback
            raw="{{ CA_ROOT.cert_host }}",
            var_name="CA_TRUST.cert_host",
            err_prefix="compose_ca_inject_cmd",
            variables=variables,
        )
        self.assertEqual(out, "/etc/infinito.nexus/ca/root-ca.crt")

    def test_templar_available_variables_is_used_no_variables_kwarg(self):
        # This covers the earlier crash:
        #   Templar.template() got an unexpected keyword argument 'variables'
        #
        # Our helper must not pass variables=..., but instead set available_variables.
        variables = {"CA_ROOT": {"cert_host": "/etc/infinito/ca/root-ca.crt"}}
        out = render_ansible_strict(
            templar=_FakeTemplarRejectsVariablesKwarg(),
            raw="{{ CA_ROOT.cert_host }}",
            var_name="CA_TRUST.cert_host",
            err_prefix="compose_ca_inject_cmd",
            variables=variables,
        )
        self.assertEqual(out, "/etc/infinito/ca/root-ca.crt")

    def test_unresolved_jinja_hard_fails(self):
        # If we cannot resolve, strict mode must hard fail (this matches your runtime failures).
        with self.assertRaises(AnsibleError):
            render_ansible_strict(
                templar=_FakeTemplarLookupUndefined(),
                raw="{{ DOES_NOT_EXIST }}",
                var_name="x",
                err_prefix="t",
                variables={},
            )

    def test_multi_round_rendering(self):
        # Ensure multi-pass rendering works:
        #   raw -> "{{ CA_ROOT.cert_host }}"
        #   CA_ROOT.cert_host -> "/etc/{{ SOFTWARE_DOMAIN }}/ca/root-ca.crt"
        variables = {
            "SOFTWARE_DOMAIN": "infinito.nexus",
            "CA_ROOT": {"cert_host": "/etc/{{ SOFTWARE_DOMAIN }}/ca/root-ca.crt"},
        }
        out = render_ansible_strict(
            templar=_FakeTemplarLookupUndefined(),  # returns unchanged => fallback kicks in
            raw="{{ CA_ROOT.cert_host }}",
            var_name="x",
            err_prefix="t",
            variables=variables,
        )
        self.assertEqual(out, "/etc/infinito.nexus/ca/root-ca.crt")

    def test_embedded_expression_in_string(self):
        # Make sure embedded {{ ... }} inside a larger string is handled.
        variables = {"SOFTWARE_DOMAIN": "infinito.nexus"}
        out = render_ansible_strict(
            templar=None,
            raw="/etc/{{ SOFTWARE_DOMAIN }}/ca/root-ca.crt",
            var_name="x",
            err_prefix="t",
            variables=variables,
        )
        self.assertEqual(out, "/etc/infinito.nexus/ca/root-ca.crt")

    def test_filters_lower_upper_default(self):
        variables = {"NAME": "MiXeD", "EMPTY": ""}
        out1 = render_ansible_strict(
            templar=None,
            raw="{{ NAME | lower }}",
            var_name="x",
            err_prefix="t",
            variables=variables,
        )
        self.assertEqual(out1, "mixed")

        out2 = render_ansible_strict(
            templar=None,
            raw="{{ NAME | upper }}",
            var_name="x",
            err_prefix="t",
            variables=variables,
        )
        self.assertEqual(out2, "MIXED")

        out3 = render_ansible_strict(
            templar=None,
            raw="{{ EMPTY | default('fallback', true) }}",
            var_name="x",
            err_prefix="t",
            variables=variables,
        )
        self.assertEqual(out3, "fallback")


if __name__ == "__main__":
    unittest.main()