computer-playbook/tests/unit/python/plugins/lookup/test_nfs_lookups.py

import importlib.util
import unittest
import unittest.mock as mock

from ansible.parsing.dataloader import DataLoader
from ansible.template import Templar

from utils.storage.nfs import client_src, state_path


def _run(name, variables):
    """Lookups must read resolved values from `variables`; templar.template('{{..}}')
    no-ops on untrusted strings in ansible 2.19+ and emits literal Jinja into exports."""
    spec = importlib.util.spec_from_file_location(name, f"plugins/lookup/{name}.py")
    m = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(m)
    lm = m.LookupModule()
    lm._templar = Templar(loader=DataLoader(), variables=variables)
    return lm.run([], variables=variables)[0]


BASE = {
    "storage": {"nfs": {"server": "192.168.244.2"}},
    "RUNTIME": "github",
}


class TestNfsLookups(unittest.TestCase):
    def test_state_path_renders(self):
        self.assertEqual(_run("nfs_state_path", BASE), "/srv/nfs/infinito-state")

    def test_fstype_renders(self):
        self.assertEqual(_run("nfs_fstype", BASE), "nfs4")

    def test_mount_opts_github_soft(self):
        self.assertEqual(
            _run("nfs_mount_opts", BASE),
            "vers=4,rw,noresvport,soft,timeo=50,retrans=3",
        )

    def test_mount_opts_host_hard(self):
        self.assertEqual(
            _run("nfs_mount_opts", {**BASE, "RUNTIME": "host"}),
            "vers=4,rw,noresvport,hard,timeo=600",
        )

    def test_mount_opts_act_soft(self):
        self.assertEqual(
            _run("nfs_mount_opts", {**BASE, "RUNTIME": "act"}),
            "vers=4,rw,noresvport,soft,timeo=50,retrans=3",
        )


def _load(name, variables):
    spec = importlib.util.spec_from_file_location(name, f"plugins/lookup/{name}.py")
    m = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(m)
    lm = m.LookupModule()
    lm._templar = Templar(loader=DataLoader(), variables=variables)
    lm._loader = DataLoader()
    return m, lm


class TestNfsConfigBackedLookups(unittest.TestCase):
    """nfs_flavor / nfs_client_src reach the merged-config SPOT through
    lookup('config') via lookup_loader, NOT a utils.cache import."""

    def test_flavor_returns_config_lookup_result(self):
        m, lm = _load("nfs_flavor", {})
        with mock.patch.object(m, "lookup_loader") as loader:
            loader.get.return_value = mock.MagicMock(run=lambda *a, **k: ["ganesha"])
            self.assertEqual(lm.run([], variables={}), ["ganesha"])

    def test_flavor_config_call_shape(self):
        m, lm = _load("nfs_flavor", {})
        calls = []

        def _run(args, **kwargs):
            calls.append((tuple(args), kwargs))
            return ["kernel"]

        with mock.patch.object(m, "lookup_loader") as loader:
            loader.get.return_value = mock.MagicMock(run=_run)
            lm.run([], variables={"RUNTIME": "github"})
        (args, kwargs) = calls[0]
        self.assertEqual(
            args,
            ("svc-storage-nfs-server", "services.nfs-server.flavor", "kernel"),
        )
        self.assertEqual(kwargs.get("variables"), {"RUNTIME": "github"})

    def test_client_src_kernel_v4_uses_root_mount(self):
        nfs = {"server": "10.0.0.2"}
        vars_ = {"storage": {"nfs": nfs}}
        m, lm = _load("nfs_client_src", vars_)
        with mock.patch.object(m, "lookup_loader") as loader:
            loader.get.return_value = mock.MagicMock(run=lambda *a, **k: ["kernel"])
            result = lm.run([], variables=vars_)
        expected = client_src(
            "10.0.0.2",
            4,
            "kernel",
            state_path("/srv/nfs", "infinito-state"),
        )
        self.assertEqual(result, [expected])


class TestNfsTmpfsMountpointsLookup(unittest.TestCase):
    def test_only_nfs_backed_volumes_yield_octal_string_modes(self):
        vars_ = {"application_id": "web-app-demo"}
        applications = {
            "web-app-demo": {
                "volumes": {
                    "cache": {
                        "type": "volume",
                        "name": "demo_cache",
                        "mounts": [{"service": "app", "target": "/app/cache"}],
                    },
                    "local": {
                        "type": "volume",
                        "mounts": [{"service": "app", "target": "/app/local"}],
                    },
                    "static": {
                        "type": "tmpfs",
                        "mounts": [
                            {
                                "service": "app",
                                "target": "/app/cache/static",
                                "mode": "1777",
                            }
                        ],
                    },
                    "scratch": {
                        "type": "tmpfs",
                        "mounts": [{"service": "app", "target": "/app/local/tmp"}],
                    },
                }
            }
        }
        compose_volumes = {
            "cache": {
                "name": "demo_cache",
                "driver": "local",
                "driver_opts": {"type": "none", "o": "bind"},
            },
            "local": {},
        }
        m, lm = _load("nfs_tmpfs_mountpoints", vars_)
        with mock.patch.object(m, "lookup_loader") as loader:
            loader.get.return_value = mock.MagicMock(run=lambda *a, **k: [applications])
            result = lm.run([], variables=vars_, volumes=compose_volumes)
        self.assertEqual(result, [[{"path": "demo_cache/static", "mode": "01777"}]])


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