ceph-devstack 0.1.0__py3-none-any.whl

tests/resources/ceph/test_env_vars.py

@@ -0,0 +1,110 @@
+import pytest
+
+from ceph_devstack.resources.ceph import containers
+
+
+ANY_VALUE = "ANY_VALUE"
+
+
+class _TestContainerEnvVars:
+    @pytest.fixture(scope="class")
+    def cls(self):
+        raise NotImplementedError
+
+    @pytest.fixture(scope="class")
+    def env_vars(self):
+        # return {}
+        raise NotImplementedError
+
+    def test_env_vars(self, cls, env_vars):
+        obj = cls()
+        if env_vars == {}:
+            assert obj.env_vars == env_vars
+        else:
+            for env_var, value in env_vars.items():
+                assert env_var in obj.env_vars
+                assert obj.env_vars[env_var] == value
+
+
+class TestPostgres(_TestContainerEnvVars):
+    @pytest.fixture(scope="class")
+    def cls(self):
+        return containers.Postgres
+
+    @pytest.fixture(scope="class")
+    def env_vars(self):
+        return {
+            "POSTGRES_USER": "root",
+            "POSTGRES_PASSWORD": "password",
+            "APP_DB_USER": "admin",
+            "APP_DB_PASS": "password",
+            "APP_DB_NAME": "paddles",
+        }
+
+
+class TestPaddles(_TestContainerEnvVars):
+    @pytest.fixture(scope="class")
+    def cls(self):
+        return containers.Paddles
+
+    @pytest.fixture(scope="class")
+    def env_vars(self):
+        return {
+            "PADDLES_SERVER_HOST": "0.0.0.0",
+        }
+
+
+class TestPulpito(_TestContainerEnvVars):
+    @pytest.fixture(scope="class")
+    def cls(self):
+        return containers.Pulpito
+
+    @pytest.fixture(scope="class")
+    def env_vars(self):
+        return {
+            "PULPITO_PADDLES_ADDRESS": "http://paddles:8080",
+        }
+
+
+class TestTestNode(_TestContainerEnvVars):
+    @pytest.fixture(scope="class")
+    def cls(self):
+        return containers.TestNode
+
+    @pytest.fixture(scope="class")
+    def env_vars(self):
+        return {
+            "CEPH_VOLUME_ALLOW_LOOP_DEVICES": "true",
+        }
+
+
+class TestTeuthology(_TestContainerEnvVars):
+    @pytest.fixture(scope="class")
+    def cls(self):
+        return containers.Teuthology
+
+    @pytest.fixture(scope="class")
+    def env_vars(self):
+        return {
+            "SSH_PRIVKEY": "",
+            "SSH_PRIVKEY_FILE": "",
+            "TEUTHOLOGY_MACHINE_TYPE": "",
+            "TEUTHOLOGY_TESTNODES": "",
+            "TEUTHOLOGY_BRANCH": "",
+            "TEUTHOLOGY_CEPH_BRANCH": "",
+            "TEUTHOLOGY_CEPH_REPO": "",
+            "TEUTHOLOGY_SUITE": "",
+            "TEUTHOLOGY_SUITE_BRANCH": "",
+            "TEUTHOLOGY_SUITE_REPO": "",
+            "TEUTHOLOGY_SUITE_EXTRA_ARGS": "",
+        }
+
+
+class TestBeanstalk(_TestContainerEnvVars):
+    @pytest.fixture(scope="class")
+    def cls(self):
+        return containers.Beanstalk
+
+    @pytest.fixture(scope="class")
+    def env_vars(self):
+        return {}

tests/resources/ceph/test_requirements_ceph.py

@@ -0,0 +1,262 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from ceph_devstack import config
+from ceph_devstack.resources.ceph import CephDevStack
+
+from ceph_devstack.resources.ceph.requirements import (
+    HasSudo,
+    LoopControlDeviceExists,
+    LoopControlDeviceWriteable,
+    SELinuxModule,
+)
+
+
+class TestHasSudo:
+    def setup_method(self):
+        self.req = HasSudo()
+
+    async def test_has_sudo_check_true(self):
+        mock_proc = AsyncMock()
+        mock_proc.wait = AsyncMock(return_value=0)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is True
+
+    async def test_has_sudo_check_false(self):
+        mock_proc = AsyncMock()
+        mock_proc.wait = AsyncMock(return_value=1)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is False
+
+    def test_has_sudo_check_cmd(self):
+        assert self.req.check_cmd == ["sudo", "true"]
+
+    def test_has_sudo_suggest_msg(self):
+        assert self.req.suggest_msg == "sudo access is required"
+
+
+class TestLoopControlDeviceExists:
+    def setup_method(self):
+        self.req = LoopControlDeviceExists()
+
+    async def test_loop_control_exists_true(self):
+        mock_proc = AsyncMock()
+        mock_proc.wait = AsyncMock(return_value=0)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is True
+
+    async def test_loop_control_exists_false(self):
+        mock_proc = AsyncMock()
+        mock_proc.wait = AsyncMock(return_value=1)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is False
+
+    def test_loop_control_exists_check_cmd(self):
+        assert self.req.check_cmd == ["test", "-e", "/dev/loop-control"]
+
+    def test_loop_control_exists_fix_cmd(self):
+        assert self.req.fix_cmd == ["sudo", "modprobe", "loop"]
+
+    def test_loop_control_exists_suggest_msg(self):
+        assert self.req.suggest_msg == "/dev/loop-control does not exist"
+
+
+class TestLoopControlDeviceWriteable:
+    def setup_method(self):
+        self.req = LoopControlDeviceWriteable()
+
+    async def test_loop_control_writeable_check_true(self):
+        mock_proc = AsyncMock()
+        mock_proc.wait = AsyncMock(return_value=0)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is True
+
+    async def test_loop_control_writeable_check_false_local(self):
+        mock_check_proc = AsyncMock()
+        mock_check_proc.wait = AsyncMock(return_value=1)
+
+        mock_stat_proc = MagicMock()
+        mock_stat_proc.communicate = MagicMock(return_value=(b"disk", 0))
+
+        mock_whoami_proc = MagicMock()
+        mock_whoami_proc.communicate = MagicMock(return_value=(b"testuser", 0))
+
+        async def side_effect_arun(args):
+            if "stat" in args:
+                return mock_stat_proc
+            if "whoami" in args:
+                return mock_whoami_proc
+            return mock_check_proc
+
+        with (
+            patch.object(self.req.host, "arun", side_effect=side_effect_arun),
+            patch.object(self.req.host, "type", "local"),
+        ):
+            result = await self.req.check()
+            assert result is False
+            assert "usermod" in " ".join(self.req.fix_cmd)
+
+    async def test_loop_control_writeable_check_false_remote(self):
+        mock_check_proc = AsyncMock()
+        mock_check_proc.wait = AsyncMock(return_value=1)
+
+        mock_stat_proc = MagicMock()
+        mock_stat_proc.communicate = MagicMock(return_value=(b"disk", 0))
+
+        mock_whoami_proc = MagicMock()
+        mock_whoami_proc.communicate = MagicMock(return_value=(b"testuser", 0))
+
+        async def side_effect_arun(args):
+            if "stat" in args:
+                return mock_stat_proc
+            if "whoami" in args:
+                return mock_whoami_proc
+            return mock_check_proc
+
+        with (
+            patch.object(self.req.host, "arun", side_effect=side_effect_arun),
+            patch.object(self.req.host, "type", "remote"),
+        ):
+            result = await self.req.check()
+            assert result is False
+            assert "chgrp" in " ".join(self.req.fix_cmd)
+
+
+class TestSELinuxModule:
+    def setup_method(self):
+        self.req = SELinuxModule()
+
+    async def test_selinux_module_check_true(self):
+        mock_proc = AsyncMock()
+        mock_proc.stdout = AsyncMock()
+        mock_proc.stdout.read = AsyncMock(return_value=b"ceph_devstack\nother_module\n")
+        mock_proc.wait = AsyncMock(return_value=0)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is True
+
+    async def test_selinux_module_check_false(self):
+        mock_proc = AsyncMock()
+        mock_proc.stdout = AsyncMock()
+        mock_proc.stdout.read = AsyncMock(
+            return_value=b"other_module\nanother_module\n"
+        )
+        mock_proc.wait = AsyncMock(return_value=0)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is False
+
+    async def test_selinux_module_check_empty_output(self):
+        mock_proc = AsyncMock()
+        mock_proc.stdout = AsyncMock()
+        mock_proc.stdout.read = AsyncMock(return_value=b"")
+        mock_proc.wait = AsyncMock(return_value=0)
+        with patch.object(self.req.host, "arun", return_value=mock_proc):
+            result = await self.req.check()
+            assert result is False
+
+
+class TestSELinuxModuleFixCmd:
+    def test_selinux_module_fix_cmd_local(self):
+        class MockLocalHost:
+            type = "local"
+
+        with patch.object(
+            SELinuxModule,
+            "host",
+            MockLocalHost(),
+        ):
+            req = SELinuxModule()
+            assert req.fix_cmd[:3] == [
+                "sudo",
+                "semodule",
+                "-i",
+            ]
+            assert req.fix_cmd[3].endswith("ceph_devstack.pp")
+
+    def test_selinux_module_fix_cmd_remote(self):
+        class MockRemoteHost:
+            type = "remote"
+
+        with patch.object(
+            SELinuxModule,
+            "host",
+            MockRemoteHost(),
+        ):
+            req = SELinuxModule()
+            assert req.fix_cmd[:7] == [
+                "podman",
+                "machine",
+                "ssh",
+                "--",
+                "sudo",
+                "semodule",
+                "-i",
+            ]
+            assert req.fix_cmd[7].endswith("ceph_devstack.pp")
+
+
+class TestCephDevStackCheckRequirements:
+    async def test_check_requirements_returns_true_when_all_pass(self):
+        devstack = CephDevStack()
+        devstack.service_specs = {}
+        config["containers"] = {}
+
+        with (
+            patch("ceph_devstack.resources.ceph.HasSudo") as MockHasSudo,
+            patch(
+                "ceph_devstack.resources.ceph.LoopControlDeviceExists"
+            ) as MockLoopCtrl,
+            patch(
+                "ceph_devstack.resources.ceph.LoopControlDeviceWriteable"
+            ) as MockLoopCtrlWrite,
+            patch("ceph_devstack.host.host.selinux_enforcing") as mock_selinux,
+        ):
+            mock_has_sudo = AsyncMock()
+            mock_has_sudo.evaluate = AsyncMock(return_value=True)
+            MockHasSudo.return_value = mock_has_sudo
+            mock_loop_ctrl = AsyncMock()
+            mock_loop_ctrl.evaluate = AsyncMock(return_value=True)
+            MockLoopCtrl.return_value = mock_loop_ctrl
+            mock_loop_ctrl_write = AsyncMock()
+            mock_loop_ctrl_write.evaluate = AsyncMock(return_value=True)
+            MockLoopCtrlWrite.return_value = mock_loop_ctrl_write
+            mock_selinux.return_value = False
+            result = await devstack.check_requirements()
+            assert result is True
+
+    async def test_check_requirements_returns_false_when_repo_missing(self):
+        devstack = CephDevStack()
+        devstack.service_specs = {}
+        config["containers"] = {
+            "custom": {"repo": "/nonexistent/path"},
+        }
+
+        with (
+            patch("ceph_devstack.resources.ceph.HasSudo") as MockHasSudo,
+            patch(
+                "ceph_devstack.resources.ceph.LoopControlDeviceExists"
+            ) as MockLoopCtrl,
+            patch(
+                "ceph_devstack.resources.ceph.LoopControlDeviceWriteable"
+            ) as MockLoopCtrlWrite,
+            patch("ceph_devstack.host.host.selinux_enforcing") as mock_selinux,
+            patch("ceph_devstack.host.host.path_exists") as mock_path_exists,
+        ):
+            mock_has_sudo = AsyncMock()
+            mock_has_sudo.evaluate = AsyncMock(return_value=True)
+            MockHasSudo.return_value = mock_has_sudo
+            mock_loop_ctrl = AsyncMock()
+            mock_loop_ctrl.evaluate = AsyncMock(return_value=True)
+            MockLoopCtrl.return_value = mock_loop_ctrl
+            mock_loop_ctrl_write = AsyncMock()
+            mock_loop_ctrl_write.evaluate = AsyncMock(return_value=True)
+            MockLoopCtrlWrite.return_value = mock_loop_ctrl_write
+            mock_selinux.return_value = False
+            mock_path_exists.return_value = False
+            result = await devstack.check_requirements()
+            assert result is False

tests/resources/ceph/test_ssh_keypair.py

@@ -0,0 +1,109 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+
+
+from ceph_devstack.resources.ceph import SSHKeyPair
+from tests.resources.test_misc import TestMiscResource as _TestMiscResource
+
+
+class TestSSHKeyPair(_TestMiscResource):
+    @pytest.fixture
+    def cls(self):
+        return SSHKeyPair
+
+    def test_name(self, cls):
+        obj = cls()
+        assert obj.name == "id_rsa"
+
+    def test_repr(self, cls):
+        obj = cls()
+        class_name = cls.__name__
+        assert repr(obj) == f'{class_name}(name="id_rsa")'
+        obj = cls(name="foo")
+        assert repr(obj) == f'{class_name}(name="foo")'
+
+    def test_ssh_key_pair_default_paths(self, cls):
+        pair = SSHKeyPair()
+        assert pair.privkey_path == "id_rsa"
+        assert pair.pubkey_path == "id_rsa.pub"
+
+    async def test_action_for_each_key(self, cls, action):
+        with patch.object(cls, "cmd"):
+            obj = cls()
+            cmds = getattr(obj, f"{action}_cmds")
+            assert len(cmds) == 2
+            assert obj.format_cmd(cmds[0])[-1] == obj.privkey_path
+            assert obj.format_cmd(cmds[1])[-1] == obj.pubkey_path
+
+    def test_ssh_key_pair_cmd_vars(self, cls):
+        obj = cls()
+        assert "name" in obj.cmd_vars
+        assert "privkey_path" in obj.cmd_vars
+        assert "pubkey_path" in obj.cmd_vars
+
+    @pytest.mark.parametrize("exists", [True, False])
+    async def test_create_when_not_exists(self, cls, exists):
+        obj = cls()
+        with (
+            patch.object(obj, "exists", return_value=exists),
+            patch.object(obj, "cmd") as mock_cmd,
+        ):
+            mock_proc = AsyncMock()
+            mock_proc.wait = AsyncMock(return_value=(0 if exists else 1))
+            mock_cmd.return_value = mock_proc
+            await obj.create()
+            assert len(mock_cmd.call_args_list) == (0 if exists else 3)
+
+    async def test_ssh_key_pair_exists_both_present(self, cls):
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc1 = AsyncMock()
+            mock_proc1.wait = AsyncMock(return_value=0)
+            mock_proc2 = AsyncMock()
+            mock_proc2.wait = AsyncMock(return_value=0)
+            mock_cmd.side_effect = [mock_proc1, mock_proc2]
+            result = await obj.exists()
+            assert result is True
+            assert mock_cmd.call_count == 2
+
+    async def test_ssh_key_pair_exists_first_missing(self, cls):
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc1 = AsyncMock()
+            mock_proc1.wait = AsyncMock(return_value=1)
+            mock_cmd.return_value = mock_proc1
+            result = await obj.exists()
+            assert result is False
+
+    async def test_ssh_key_pair_exists_second_missing(self, cls):
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc1 = AsyncMock()
+            mock_proc1.wait = AsyncMock(return_value=0)
+            mock_proc2 = AsyncMock()
+            mock_proc2.wait = AsyncMock(return_value=1)
+            mock_cmd.side_effect = [mock_proc1, mock_proc2]
+            result = await obj.exists()
+            assert result is False
+
+    async def test_ssh_key_pair_exists_when_already_exists(self, cls):
+        obj = cls()
+        with (
+            patch.object(obj, "exists") as mock_exists,
+            patch.object(obj, "_get_ssh_keys") as mock_get_keys,
+            patch.object(obj, "cmd") as mock_cmd,
+        ):
+            mock_exists.return_value = True
+            await obj.create()
+            mock_exists.assert_called_once()
+            mock_get_keys.assert_not_called()
+            mock_cmd.assert_not_called()
+
+    async def test_ssh_key_pair_remove_calls_both_commands(self, cls):
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc = AsyncMock()
+            mock_proc.wait = AsyncMock(return_value=0)
+            mock_cmd.return_value = mock_proc
+            await obj.remove()
+            assert mock_cmd.call_count == 2

tests/resources/ceph/test_testnode.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import pytest
+
+from ceph_devstack.resources.ceph import TestNode as _TestNode
+from ceph_devstack import config
+
+
+class TestTestnode:
+    @pytest.fixture(scope="class")
+    def cls(self) -> type[_TestNode]:
+        return _TestNode
+
+    def test_testnode_loop_device_count_default_to_one(self, cls):
+        testnode = cls("testnode_1")
+        assert testnode.loop_device_count == 1
+
+    def test_testnode_create_cmd_includes_related_devices(self, cls):
+        config.load(Path(__file__).parent.joinpath("fixtures", "testnode-config.toml"))
+        testnode = cls("testnode_1")
+        create_cmd = testnode.create_cmd
+        assert "--device=/dev/loop4" in create_cmd
+        assert "--device=/dev/loop5" in create_cmd
+        assert "--device=/dev/loop6" in create_cmd
+        assert "--device=/dev/loop7" in create_cmd
+
+    def test_testnode_devices_is_based_on_loop_device_count_config(self, cls):
+        config.load(Path(__file__).parent.joinpath("fixtures", "testnode-config.toml"))
+        testnode = cls("testnode_1")
+        assert testnode.loop_device_count == 4
+        assert testnode.devices == [
+            "/dev/loop4",
+            "/dev/loop5",
+            "/dev/loop6",
+            "/dev/loop7",
+        ]