ceph-devstack 0.1.0__py3-none-any.whl

tests/resources/test_container.py

@@ -0,0 +1,247 @@
+import json
+import os
+import pytest
+
+from pathlib import Path
+from unittest.mock import patch, AsyncMock
+
+from ceph_devstack import config
+from ceph_devstack.resources.container import Container
+from .test_podmanresource import (
+    TestPodmanResource as _TestPodmanResource,
+)
+
+
+class _TestContainerBase:
+    @pytest.fixture
+    def cls(self):
+        return Container
+
+    def setup_method(self):
+        config["containers"]["container"] = {"image": "example.com/image:latest"}
+
+
+class TestContainerResource(_TestPodmanResource, _TestContainerBase):
+    @pytest.fixture
+    def cls(self):
+        return Container
+
+    @pytest.fixture(
+        scope="class", params=["build", "create", "start", "stop", "remove"]
+    )
+    def action(self, request):
+        return request.param
+
+    async def test_action_calls_cmd_with_correct_args(self, cls, action):
+        if action == "build":
+            config["containers"][cls.__name__.lower()]["repo"] = "/repo_path"
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc = AsyncMock()
+            mock_cmd.return_value = mock_proc
+            action_cmd = "rm" if action == "remove" else action
+            await getattr(obj, action)()
+            if action == "create":
+                assert len(mock_cmd.call_args_list) == 2
+                assert "inspect" in mock_cmd.call_args_list[0][0][0]
+                assert action_cmd in mock_cmd.call_args_list[-1][0][0]
+            else:
+                mock_cmd.assert_called_once()
+                call_args = mock_cmd.call_args[0][0]
+                assert action_cmd in call_args
+
+    async def test_empty_cmd_skips_action(self, cls, action):
+        with patch.object(cls, "cmd"):
+            obj = cls()
+            setattr(obj, f"{action}_cmd", [])
+            await getattr(obj, action)()
+            obj.cmd.assert_not_awaited()
+
+    async def test_action_cmd_called_with_stream_output(self, cls, action):
+        if action == "remove":
+            pytest.skip("remove action doesn't stream output")
+        if action == "build":
+            config["containers"][cls.__name__.lower()]["repo"] = "/repo_path"
+        with patch.object(cls, "cmd") as mock_cmd:
+            obj = cls()
+            await getattr(obj, action)()
+            _, kwargs = mock_cmd.call_args
+            assert kwargs.get("stream_output") is True
+
+    async def test_build_action_skips_when_no_repo(self, cls):
+        config["containers"][cls.__name__.lower()]["repo"] = ""
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            await obj.build()
+            mock_cmd.assert_not_called()
+
+    async def test_pull_action_skips_localhost_images(self, cls):
+        config["containers"]["container"]["image"] = "localhost/image:latest"
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            await obj.pull()
+            mock_cmd.assert_not_called()
+
+    @pytest.mark.parametrize(
+        "output,rc,expected", ([b"12345", 0, 12345], [b"error", 1, 1])
+    )
+    async def test_wait_returns_output_on_success(self, cls, output, rc, expected):
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc = AsyncMock()
+            mock_proc.communicate = AsyncMock(return_value=(output, b""))
+            mock_proc.returncode = rc
+            mock_cmd.return_value = mock_proc
+            result = await obj.wait()
+            assert expected == result
+
+    async def test_wait_action_returns_error_code_on_failure(self, cls):
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc = AsyncMock()
+            mock_proc.communicate = AsyncMock(return_value=(b"", b"error occurred"))
+            mock_proc.returncode = 130
+            mock_cmd.return_value = mock_proc
+            result = await obj.wait()
+            assert result == 130
+
+
+class TestContainerInit(_TestContainerBase):
+    def test_init_sets_env_vars_from_class(self, cls):
+        Container.env_vars = {"TEST_VAR": "default_value"}
+        obj = cls()
+        assert "TEST_VAR" in obj.env_vars
+        assert obj.env_vars["TEST_VAR"] == "default_value"
+
+    def test_init_overrides_env_vars_from_environment(self, cls):
+        Container.env_vars = {"TEST_VAR": "default"}
+        with patch.dict(os.environ, {"TEST_VAR": "env_value"}):
+            obj = cls()
+        assert obj.env_vars["TEST_VAR"] == "env_value"
+
+    def test_init_does_not_override_missing_env_vars(self, cls):
+        Container.env_vars = {"TEST_VAR": "default"}
+        with patch.dict(os.environ, {}, clear=False):
+            if "TEST_VAR" in os.environ:
+                del os.environ["TEST_VAR"]
+            obj = cls()
+        assert obj.env_vars["TEST_VAR"] == "default"
+
+
+class TestContainerExists(_TestContainerBase):
+    @pytest.mark.parametrize("rc,res", ([0, True], [1, False]))
+    async def test_exists(self, cls, rc, res):
+        with patch.object(cls, "cmd"):
+            obj = cls()
+            obj.cmd.return_value = AsyncMock()
+            obj.cmd.return_value.wait.return_value = rc
+            assert await obj.exists() == res
+
+
+class TestContainerRunning(_TestContainerBase):
+    async def test_is_running_yes(self, cls):
+        with patch.object(cls, "cmd"):
+            obj = cls()
+            output_obj = [{"State": {"Status": "running"}}]
+            m_read = AsyncMock(return_value=json.dumps(output_obj))
+            m_stdout = AsyncMock(read=m_read)
+            obj.cmd.return_value = AsyncMock(
+                stdout=m_stdout,
+                returncode=0,
+            )
+            obj.cmd.return_value.wait.return_value = 0
+            assert await obj.is_running() is True
+
+    async def test_is_running_no_bc_status(self, cls):
+        with patch.object(cls, "cmd"):
+            obj = cls()
+            output_obj = [{"State": {"Status": "crashed"}}]
+            m_read = AsyncMock(return_value=json.dumps(output_obj))
+            m_stdout = AsyncMock(read=m_read)
+            obj.cmd.return_value = AsyncMock(
+                stdout=m_stdout,
+                returncode=0,
+            )
+            obj.cmd.return_value.wait.return_value = 0
+            assert await obj.is_running() is False
+
+    async def test_is_running_no_bc_dne(self, cls):
+        with patch.object(cls, "cmd"):
+            obj = cls()
+            obj.cmd.return_value = AsyncMock(returncode=1)
+            assert await obj.is_running() is False
+
+
+class TestContainerImageName(_TestContainerBase):
+    def test_image_name_default_returns_class_name(self, cls):
+        obj = cls()
+        assert obj.image_name == "container"
+
+    def test_image_name_returns_custom_when_set(self, cls):
+        obj = cls()
+        obj._image_name = "custom-image"
+        assert obj.image_name == "custom-image"
+
+
+class TestContainerImageTag(_TestContainerBase):
+    def test_image_tag_with_colon(self, cls):
+        obj = cls()
+        config["containers"]["container"] = {"image": "example.com/image:v1.0"}
+        assert obj.image_tag == "v1.0"
+
+    def test_image_tag_without_colon(self, cls):
+        obj = cls()
+        config["containers"]["container"] = {"image": "example.com/image"}
+        assert obj.image_tag == "latest"
+
+
+class TestContainerImage(_TestContainerBase):
+    def test_image_returns_config_image_when_no_repo(self, cls):
+        obj = cls()
+        assert obj.image == "example.com/image:latest"
+
+    def test_image_returns_localhost_when_repo_exists(self, cls):
+        config["containers"]["container"]["repo"] = "/path/to/repo"
+        obj = cls()
+        obj._image_name = "my-image"
+        assert obj.image == "localhost/my-image"
+
+
+class TestContainerCwd(_TestContainerBase):
+    def test_cwd_returns_repo_when_exists(self, cls):
+        obj = cls()
+        with patch.object(type(obj), "repo", Path("/path/to/repo")):
+            assert obj.cwd == Path("/path/to/repo")
+
+    def test_cwd_returns_dot_when_no_repo(self, cls):
+        obj = cls()
+        assert obj.cwd == "."
+
+
+class TestContainerAddEnvToArgs(_TestContainerBase):
+    def test_add_env_to_args_inserts_env_vars(self, cls):
+        obj = cls()
+        obj.env_vars = {"KEY1": "value1", "KEY2": "value2"}
+        args = ["podman", "run", "image"]
+        result = obj.add_env_to_args(args)
+        assert result[-1] == "image"  # last element is preserved
+        assert "-e" in result
+        assert "KEY1=value1" in result
+        assert "KEY2=value2" in result
+
+    def test_add_env_to_args_skips_empty_values(self, cls):
+        obj = cls()
+        obj.env_vars = {"KEY1": "value1", "KEY2": None, "KEY3": ""}
+        args = ["podman", "run", "image"]
+        result = obj.add_env_to_args(args)
+        assert "KEY1=value1" in result
+        assert "KEY2=" not in result
+        assert "KEY3=" not in result
+
+    def test_add_env_to_args_preserves_order(self, cls):
+        obj = cls()
+        obj.env_vars = {"KEY": "value"}
+        args = ["podman", "run", "image"]
+        result = obj.add_env_to_args(args)
+        assert result[-1] == "image"
+        assert result.index("-e") < result.index("image")

tests/resources/test_misc.py

@@ -0,0 +1,46 @@
+import pytest
+
+from unittest.mock import patch, AsyncMock
+
+from ceph_devstack.resources.misc import Network, Secret
+
+from .test_podmanresource import (
+    TestPodmanResource as _TestPodmanResource,
+)
+
+
+class TestMiscResource(_TestPodmanResource):
+    @pytest.fixture(scope="class", params=[Network, Secret])
+    def cls(self, request):
+        return request.param
+
+    @pytest.fixture(scope="class", params=["create", "exists", "remove"])
+    def action(self, request):
+        return request.param
+
+    async def test_exists_means_inspect(self, cls):
+        obj = cls()
+        assert "inspect" in obj.exists_cmd
+
+    @pytest.mark.parametrize("rc,expected", [[0, True], [1, False]])
+    async def test_exists(self, cls, rc, expected):
+        obj = cls()
+        with patch.object(obj, "cmd") as mock_cmd:
+            mock_proc = AsyncMock()
+            mock_proc.wait = AsyncMock(return_value=rc)
+            mock_cmd.return_value = mock_proc
+            result = await obj.exists()
+            assert result is expected
+
+    @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 1)

tests/resources/test_podmanresource.py

@@ -0,0 +1,59 @@
+import pytest
+
+from pathlib import Path
+from subprocess import CalledProcessError
+from unittest.mock import patch
+
+
+from ceph_devstack.resources import PodmanResource
+
+
+class TestPodmanResource:
+    @pytest.fixture(scope="class")
+    def cls(self):
+        return PodmanResource
+
+    @pytest.fixture(scope="class", params=["create", "remove"])
+    def action(self, request):
+        return request.param
+
+    def test_name(self, cls):
+        obj = cls()
+        assert obj.name == cls.__name__.lower()
+        obj = cls(name="foo")
+        assert obj.name == "foo"
+
+    def test_format_cmd(self, cls):
+        obj = cls(name="pr")
+        assert "name" in obj.cmd_vars
+        res = obj.format_cmd(["foo", "{name}", "bar", "x{name}x"])
+        assert res == ["foo", "pr", "bar", "xprx"]
+
+    def test_cmd_vars_contains_name(self, cls):
+        assert "name" in cls.cmd_vars
+
+    def test_repr(self, cls):
+        obj = cls()
+        class_name = cls.__name__
+        assert repr(obj) == f"{class_name}()"
+        obj = cls(name="foo")
+        assert repr(obj) == f'{class_name}(name="foo")'
+
+    async def test_apply(self, cls, action):
+        with patch.object(cls, action):
+            obj = cls()
+            await obj.apply(action)
+            method = getattr(obj, action)
+            method.assert_awaited_once()
+
+    async def test_cmd(self, cls):
+        with patch("ceph_devstack.host.host.arun") as m_arun:
+            obj = cls()
+            await obj.cmd(["0"])
+            print(m_arun.await_args_list)
+            m_arun.assert_awaited_once_with(["0"], cwd=Path("."), stream_output=False)
+
+    async def test_cmd_failed(self, cls):
+        obj = cls()
+        with pytest.raises(CalledProcessError):
+            await obj.cmd(["false"], check=True)

tests/test_config.py

@@ -0,0 +1,120 @@
+import tomlkit
+
+from ceph_devstack import config, Config
+
+
+class TestConfigDump:
+    def test_config_dump_returns_string(self):
+        result = config.dump()
+        assert isinstance(result, str)
+
+    def test_config_dump_is_valid_toml(self):
+        result = config.dump()
+        parsed = tomlkit.parse(result)
+        assert isinstance(parsed, tomlkit.TOMLDocument)
+
+    def test_config_contents_basic(self):
+        result = config.dump()
+        requires = [
+            "containers",
+            "data_dir",
+            "postgres",
+            "beanstalk",
+            "paddles",
+            "pulpito",
+            "testnode",
+            "teuthology",
+            "archive",
+        ]
+        for item in requires:
+            assert item in result
+
+
+class TestConfigGetValue:
+    def test_get_value_simple_key(self):
+        result = config.get_value("data_dir")
+        assert isinstance(result, str)
+
+    def test_get_value_nested_count(self):
+        result = config.get_value("containers.testnode.count")
+        assert result == "3"
+
+    def test_get_value_nested_loop_device_size(self):
+        result = config.get_value("containers.testnode.loop_device_size")
+        assert result == "5G"
+
+    def test_get_value_nested_image(self):
+        result = config.get_value("containers.testnode.image")
+        assert "quay.io/ceph-infra/teuthology-testnode:main" in result
+
+    def test_get_value_returns_string_for_int(self):
+        result = config.get_value("containers.testnode.count")
+        assert result == "3"
+        assert isinstance(result, str)
+
+
+class TestConfigSet:
+    def test_set_value_simple_key(self, tmp_path):
+        test_config = Config()
+        config_file = tmp_path / "test_config.toml"
+        config_file.write_text("")
+        test_config.load(config_file)
+        test_config.set_value("test_key", "test_value")
+        assert test_config["test_key"] == "test_value"
+
+    def test_set_value_nested_key(self, tmp_path):
+        test_config = Config()
+        config_file = tmp_path / "test_config.toml"
+        config_file.write_text("")
+        test_config.load(config_file)
+        test_config.set_value("test_section.test_key", "test_value")
+        assert test_config["test_section"]["test_key"] == "test_value"
+
+    def test_set_value_updates_user_obj(self, tmp_path):
+        test_config = Config()
+        config_file = tmp_path / "test_config.toml"
+        config_file.write_text("")
+        test_config.load(config_file)
+        test_config.set_value("new_key", "new_value")
+        assert "new_key" in test_config.user_obj
+
+    def test_set_value_creates_intermediate_sections(self, tmp_path):
+        test_config = Config()
+        config_file = tmp_path / "test_config.toml"
+        config_file.write_text("")
+        test_config.load(config_file)
+        test_config.set_value("deep.nested.key", "value")
+        assert test_config.user_obj["deep"]["nested"]["key"] == "value"
+
+    def test_set_value_overrides_existing(self, tmp_path):
+        test_config = Config()
+        config_file = tmp_path / "test_config.toml"
+        config_file.write_text("")
+        test_config.load(config_file)
+        original_count = test_config["containers"]["testnode"]["count"]
+        new_count = original_count + 2
+        test_config.set_value("containers.testnode.count", str(new_count))
+        assert test_config["containers"]["testnode"]["count"] != original_count
+        assert test_config["containers"]["testnode"]["count"] == new_count
+
+
+class TestConfigDefaults:
+    def test_config_defaults(self):
+        assert config == {
+            "data_dir": "~/.local/share/ceph-devstack",
+            "containers": {
+                "archive": {"image": "python:alpine"},
+                "beanstalk": {"image": "quay.io/ceph-infra/teuthology-beanstalkd:main"},
+                "paddles": {"image": "quay.io/ceph-infra/paddles:main"},
+                "postgres": {
+                    "image": "quay.io/ceph-infra/teuthology-postgresql:latest"
+                },
+                "pulpito": {"image": "quay.io/ceph-infra/pulpito:main"},
+                "testnode": {
+                    "count": 3,
+                    "loop_device_size": "5G",
+                    "image": "quay.io/ceph-infra/teuthology-testnode:main",
+                },
+                "teuthology": {"image": "quay.io/ceph-infra/teuthology-dev:main"},
+            },
+        }

tests/test_deep_merge.py

@@ -0,0 +1,71 @@
+from ceph_devstack import deep_merge
+
+
+class TestDeepMerge:
+    def test_deep_merge_empty_maps(self):
+        result = deep_merge()
+        assert result == {}
+
+    def test_deep_merge_single_map(self):
+        m = {"a": 1, "b": 2}
+        result = deep_merge(m)
+        assert result == m
+
+    def test_deep_merge_two_maps_no_overlap(self):
+        m1 = {"a": 1}
+        m2 = {"b": 2}
+        result = deep_merge(m1, m2)
+        assert result == {"a": 1, "b": 2}
+
+    def test_deep_merge_two_maps_with_overlap(self):
+        m1 = {"a": 1, "b": 2}
+        m2 = {"b": 3, "c": 4}
+        result = deep_merge(m1, m2)
+        assert result == {"a": 1, "b": 3, "c": 4}
+
+    def test_deep_merge_nested_dicts(self):
+        m1 = {"a": {"x": 1, "y": 2}}
+        m2 = {"a": {"y": 3, "z": 4}}
+        result = deep_merge(m1, m2)
+        assert result == {"a": {"x": 1, "y": 3, "z": 4}}
+
+    def test_deep_merge_three_maps(self):
+        m1 = {"a": 1}
+        m2 = {"b": 2}
+        m3 = {"c": 3}
+        result = deep_merge(m1, m2, m3)
+        assert result == {"a": 1, "b": 2, "c": 3}
+
+    def test_deep_merge_nested_override(self):
+        m1 = {"outer": {"inner": "default", "keep": "value"}}
+        m2 = {"outer": {"inner": "override"}}
+        result = deep_merge(m1, m2)
+        assert result["outer"]["inner"] == "override"
+        assert result["outer"]["keep"] == "value"
+
+    def test_deep_merge_with_none_value(self):
+        m1 = {"a": 1}
+        m2 = {"b": None}
+        result = deep_merge(m1, m2)
+        assert result == {"a": 1, "b": None}
+
+    def test_deep_merge_with_list_values(self):
+        m1 = {"a": [1, 2, 3]}
+        m2 = {"a": [4, 5]}
+        result = deep_merge(m1, m2)
+        assert result["a"] == [4, 5]
+
+    def test_deep_merge_does_not_modify_original_maps(self):
+        m1 = {"a": {"x": 1}}
+        m2 = {"a": {"y": 2}}
+        m1_copy = {"a": {"x": 1}}
+        m2_copy = {"a": {"y": 2}}
+        deep_merge(m1, m2)
+        assert m1 == m1_copy
+        assert m2 == m2_copy
+
+    def test_deep_merge_with_different_types(self):
+        m1 = {"a": 1}
+        m2 = {"a": "string"}
+        result = deep_merge(m1, m2)
+        assert result["a"] == "string"