**Commit message:**

Fix Docker CLI install, switch test runners to bash, and stabilize unit tests for compose/seed mocks

https://chatgpt.com/share/697e68cd-d22c-800f-9b2e-47ef231b6502

Dockerfile

@@ -16,7 +16,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     make \
     rsync \
     ca-certificates \
-    docker-cli \
+    docker.io \
+    bash \
   && rm -rf /var/lib/apt/lists/*
 
 # Fail fast if docker client is missing

Makefile

@@ -49,9 +49,9 @@ test: test-unit test-integration test-e2e
 test-unit: clean build
 	@echo ">> Running unit tests"
 	@docker run --rm -t $(IMAGE) \
-	  sh -lc 'python -m unittest discover -t . -s tests/unit -p "test_*.py" -v'
+	  bash -lc 'python -m unittest discover -t . -s tests/unit -p "test_*.py" -v'
 
 test-integration: clean build
 	@echo ">> Running integration tests"
 	@docker run --rm -t $(IMAGE) \
-	  sh -lc 'python -m unittest discover -t . -s tests/integration -p "test_*.py" -v'
+	  bash -lc 'python -m unittest discover -t . -s tests/integration -p "test_*.py" -v'

scripts/test-e2e.sh

@@ -83,7 +83,7 @@ dump_debug() {
   docker -H "${DIND_HOST}" run --rm \
     -v "${E2E_TMP_VOL}:/tmp" \
     alpine:3.20 \
-    sh -lc 'cd /tmp && tar -czf /out.tar.gz . || true' \
+    bash -lc 'cd /tmp && tar -czf /out.tar.gz . || true' \
     >/dev/null 2>&1 || true
 
   # The above writes inside the container FS, not to host. So do it properly:
@@ -91,7 +91,7 @@ dump_debug() {
   local tmpc="baudolo-e2e-tmpdump-${TS}"
   docker -H "${DIND_HOST}" rm -f "${tmpc}" >/dev/null 2>&1 || true
   docker -H "${DIND_HOST}" create --name "${tmpc}" -v "${E2E_TMP_VOL}:/tmp" alpine:3.20 \
-    sh -lc 'cd /tmp && tar -czf /tmpdump.tar.gz . || true' >/dev/null
+    bash -lc 'cd /tmp && tar -czf /tmpdump.tar.gz . || true' >/dev/null
   docker -H "${DIND_HOST}" start -a "${tmpc}" >/dev/null 2>&1 || true
   docker -H "${DIND_HOST}" cp "${tmpc}:/tmpdump.tar.gz" "${ARTIFACTS_DIR}/e2e-tmp-${TS}.tar.gz" >/dev/null 2>&1 || true
   docker -H "${DIND_HOST}" rm -f "${tmpc}" >/dev/null 2>&1 || true
@@ -187,7 +187,7 @@ if [ "${DEBUG_SHELL}" = "1" ]; then
     -v "${DIND_VOL}:/var/lib/docker:ro" \
     -v "${E2E_TMP_VOL}:/tmp" \
     "${IMG}" \
-    sh -lc '
+    bash -lc '
       set -e
       if [ ! -f /etc/machine-id ]; then
         mkdir -p /etc
@@ -195,7 +195,7 @@ if [ "${DEBUG_SHELL}" = "1" ]; then
       fi
       echo ">> DOCKER_HOST=${DOCKER_HOST}"
       docker ps -a || true
-      exec sh
+      exec bash
     '
   rc=$?
 else
@@ -206,7 +206,7 @@ else
     -v "${DIND_VOL}:/var/lib/docker:ro" \
     -v "${E2E_TMP_VOL}:/tmp" \
     "${IMG}" \
-    sh -lc '
+    bash -lc '
     set -euo pipefail
     set -x
     export PYTHONUNBUFFERED=1

tests/unit/backup/test_compose.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+from typing import List
+from unittest.mock import patch
+
+
+def _touch(p: Path) -> None:
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+    # If the path already exists as a directory (e.g. ".env" created by ".env/env"),
+    # remove it so we can create a file with the same name.
+    if p.exists() and p.is_dir():
+        shutil.rmtree(p)
+
+    p.write_text("x", encoding="utf-8")
+
+
+def _setup_compose_dir(
+    tmp_path: Path,
+    name: str = "mailu",
+    *,
+    with_override: bool = False,
+    with_ca_override: bool = False,
+    env_layout: str | None = None,  # None | ".env" | ".env/env"
+) -> Path:
+    d = tmp_path / name
+    d.mkdir(parents=True, exist_ok=True)
+
+    _touch(d / "docker-compose.yml")
+
+    if with_override:
+        _touch(d / "docker-compose.override.yml")
+
+    if with_ca_override:
+        _touch(d / "docker-compose.ca.override.yml")
+
+    if env_layout == ".env":
+        _touch(d / ".env")
+    elif env_layout == ".env/env":
+        _touch(d / ".env" / "env")
+
+    return d
+
+
+class TestCompose(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        from baudolo.backup import compose as mod
+
+        cls.compose_mod = mod
+
+    def test_detect_env_file_prefers_dotenv_over_legacy(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = _setup_compose_dir(tmp_path, env_layout=".env/env")
+            # Also create .env file -> should be preferred
+            _touch(d / ".env")
+
+            env_file = self.compose_mod._detect_env_file(d)
+            self.assertEqual(env_file, d / ".env")
+
+    def test_detect_env_file_uses_legacy_if_no_dotenv(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = _setup_compose_dir(tmp_path, env_layout=".env/env")
+
+            env_file = self.compose_mod._detect_env_file(d)
+            self.assertEqual(env_file, d / ".env" / "env")
+
+    def test_detect_compose_files_requires_base(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = tmp_path / "stack"
+            d.mkdir()
+
+            with self.assertRaises(FileNotFoundError):
+                self.compose_mod._detect_compose_files(d)
+
+    def test_detect_compose_files_includes_optional_overrides(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = _setup_compose_dir(
+                tmp_path,
+                with_override=True,
+                with_ca_override=True,
+            )
+
+            files = self.compose_mod._detect_compose_files(d)
+            self.assertEqual(
+                files,
+                [
+                    d / "docker-compose.yml",
+                    d / "docker-compose.override.yml",
+                    d / "docker-compose.ca.override.yml",
+                ],
+            )
+
+    def test_build_cmd_uses_wrapper_when_present(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = _setup_compose_dir(
+                tmp_path, with_override=True, with_ca_override=True, env_layout=".env"
+            )
+
+            with patch.object(
+                self.compose_mod.shutil, "which", lambda name: "/usr/local/bin/compose"
+            ):
+                cmd = self.compose_mod._build_compose_cmd(str(d), ["up", "-d"])
+
+            self.assertEqual(
+                cmd,
+                [
+                    "/usr/local/bin/compose",
+                    "--chdir",
+                    str(d.resolve()),
+                    "--",
+                    "up",
+                    "-d",
+                ],
+            )
+
+    def test_build_cmd_fallback_docker_compose_with_all_files_and_env(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = _setup_compose_dir(
+                tmp_path,
+                with_override=True,
+                with_ca_override=True,
+                env_layout=".env",
+            )
+
+            with patch.object(self.compose_mod.shutil, "which", lambda name: None):
+                cmd = self.compose_mod._build_compose_cmd(
+                    str(d), ["up", "-d", "--force-recreate"]
+                )
+
+            expected: List[str] = [
+                "docker",
+                "compose",
+                "-f",
+                str((d / "docker-compose.yml").resolve()),
+                "-f",
+                str((d / "docker-compose.override.yml").resolve()),
+                "-f",
+                str((d / "docker-compose.ca.override.yml").resolve()),
+                "--env-file",
+                str((d / ".env").resolve()),
+                "up",
+                "-d",
+                "--force-recreate",
+            ]
+            self.assertEqual(cmd, expected)
+
+    def test_hard_restart_calls_run_twice_with_correct_cmds_wrapper(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = _setup_compose_dir(tmp_path, name="mailu", env_layout=".env")
+
+            with patch.object(
+                self.compose_mod.shutil, "which", lambda name: "/usr/local/bin/compose"
+            ):
+                calls = []
+
+                def fake_run(cmd, check: bool):
+                    calls.append((cmd, check))
+                    return 0
+
+                with patch.object(self.compose_mod.subprocess, "run", fake_run):
+                    self.compose_mod.hard_restart_docker_services(str(d))
+
+            self.assertEqual(
+                calls,
+                [
+                    (
+                        [
+                            "/usr/local/bin/compose",
+                            "--chdir",
+                            str(d.resolve()),
+                            "--",
+                            "down",
+                        ],
+                        True,
+                    ),
+                    (
+                        [
+                            "/usr/local/bin/compose",
+                            "--chdir",
+                            str(d.resolve()),
+                            "--",
+                            "up",
+                            "-d",
+                        ],
+                        True,
+                    ),
+                ],
+            )
+
+    def test_hard_restart_calls_run_twice_with_correct_cmds_fallback(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            tmp_path = Path(td)
+            d = _setup_compose_dir(
+                tmp_path,
+                name="mailu",
+                with_override=True,
+                with_ca_override=True,
+                env_layout=".env/env",
+            )
+
+            with patch.object(self.compose_mod.shutil, "which", lambda name: None):
+                calls = []
+
+                def fake_run(cmd, check: bool):
+                    calls.append((cmd, check))
+                    return 0
+
+                with patch.object(self.compose_mod.subprocess, "run", fake_run):
+                    self.compose_mod.hard_restart_docker_services(str(d))
+
+            down_cmd = calls[0][0]
+            up_cmd = calls[1][0]
+
+            self.assertTrue(calls[0][1] is True)
+            self.assertTrue(calls[1][1] is True)
+
+            self.assertEqual(down_cmd[0:2], ["docker", "compose"])
+            self.assertEqual(down_cmd[-1], "down")
+            self.assertIn("--env-file", down_cmd)
+
+            self.assertEqual(up_cmd[0:2], ["docker", "compose"])
+            self.assertTrue(up_cmd[-2:] == ["up", "-d"] or up_cmd[-3:] == ["up", "-d"])
+            self.assertIn("--env-file", up_cmd)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

tests/unit/seed/test_main.py

@@ -1,4 +1,3 @@
-# tests/unit/src/baudolo/seed/test_main.py
 from __future__ import annotations
 
 import unittest
@@ -33,6 +32,30 @@ class TestSeedMain(unittest.TestCase):
         with self.assertRaises(ValueError):
             seed_main._validate_database_value("bad name", instance="x")
 
+    def _mock_df_mask_any(self, *, any_value: bool) -> MagicMock:
+        """
+        Build a DataFrame-like mock such that:
+          mask = (df["instance"] == instance) & (df["database"] == database)
+          mask.any() returns any_value
+        """
+        df = MagicMock(spec=pd.DataFrame)
+
+        left = MagicMock()
+        right = MagicMock()
+
+        mask = MagicMock()
+        mask.any.return_value = any_value
+
+        # (left & right) => mask
+        left.__and__.return_value = mask
+
+        # df["instance"] / df["database"] => return objects whose == produces left/right
+        col = MagicMock()
+        col.__eq__.side_effect = [left, right]
+        df.__getitem__.return_value = col
+
+        return df
+
     @patch("baudolo.seed.__main__.os.path.exists", return_value=False)
     @patch("baudolo.seed.__main__.pd.read_csv")
     @patch("baudolo.seed.__main__._empty_df")
@@ -44,11 +67,7 @@ class TestSeedMain(unittest.TestCase):
         read_csv: MagicMock,
         exists: MagicMock,
     ) -> None:
-        df_existing = MagicMock(spec=pd.DataFrame)
+        df_existing = self._mock_df_mask_any(any_value=False)
-        series_mask = MagicMock()
-        series_mask.any.return_value = False
-
-        df_existing.__getitem__.return_value = series_mask  # for df["instance"] etc.
         empty_df.return_value = df_existing
 
         df_out = MagicMock(spec=pd.DataFrame)
@@ -65,9 +84,7 @@ class TestSeedMain(unittest.TestCase):
         read_csv.assert_not_called()
         empty_df.assert_called_once()
         concat.assert_called_once()
-        df_out.to_csv.assert_called_once_with(
+        df_out.to_csv.assert_called_once_with("/tmp/databases.csv", sep=";", index=False)
-            "/tmp/databases.csv", sep=";", index=False
-        )
 
     @patch("baudolo.seed.__main__.os.path.exists", return_value=True)
     @patch("baudolo.seed.__main__.pd.read_csv", side_effect=EmptyDataError("empty"))
@@ -82,16 +99,7 @@ class TestSeedMain(unittest.TestCase):
         read_csv: MagicMock,
         exists: MagicMock,
     ) -> None:
-        """
+        df_existing = self._mock_df_mask_any(any_value=False)
-        Key regression test:
-        If file exists but is empty => warn, create header columns, then proceed.
-        """
-        df_existing = MagicMock(spec=pd.DataFrame)
-        series_mask = MagicMock()
-        series_mask.any.return_value = False
-
-        # emulate df["instance"] and df["database"] usage
-        df_existing.__getitem__.return_value = series_mask
         empty_df.return_value = df_existing
 
         df_out = MagicMock(spec=pd.DataFrame)
@@ -109,17 +117,15 @@ class TestSeedMain(unittest.TestCase):
         read_csv.assert_called_once()
         empty_df.assert_called_once()
 
-        # warning was printed to stderr
+        # warning printed to stderr
         self.assertTrue(print_.called)
         args, kwargs = print_.call_args
         self.assertIn("WARNING: databases.csv exists but is empty", args[0])
-        self.assertIn("file", kwargs)
+        self.assertEqual(kwargs.get("file"), seed_main.sys.stderr)
-        self.assertEqual(kwargs["file"], seed_main.sys.stderr)
 
         concat.assert_called_once()
-        df_out.to_csv.assert_called_once_with(
+        df_out.toF.to_csv.assert_not_called()  # keep lint happy if you use it
-            "/tmp/databases.csv", sep=";", index=False
+        df_out.to_csv.assert_called_once_with("/tmp/databases.csv", sep=";", index=False)
-        )
 
     @patch("baudolo.seed.__main__.os.path.exists", return_value=True)
     @patch("baudolo.seed.__main__.pd.read_csv")
@@ -128,22 +134,7 @@ class TestSeedMain(unittest.TestCase):
         read_csv: MagicMock,
         exists: MagicMock,
     ) -> None:
-        df = MagicMock(spec=pd.DataFrame)
+        df = self._mock_df_mask_any(any_value=True)
-
-        # mask.any() => True triggers update branch
-        mask = MagicMock()
-        mask.any.return_value = True
-
-        # df["instance"] etc => return something that supports comparisons;
-        # simplest: just return an object that makes mask flow work.
-        df.__getitem__.return_value = MagicMock()
-        # Force the computed mask to be our mask
-        # by making (df["instance"] == instance) & (df["database"] == database) return `mask`
-        left = MagicMock()
-        right = MagicMock()
-        left.__and__.return_value = mask
-        df.__getitem__.return_value.__eq__.side_effect = [left, right]  # two == calls
-
         read_csv.return_value = df
 
         seed_main.check_and_add_entry(
@@ -154,9 +145,6 @@ class TestSeedMain(unittest.TestCase):
             password="pass",
         )
 
-        # update branch: df.loc[mask, ["username","password"]] = ...
-        # we can't easily assert the assignment, but we can assert .loc was accessed
-        self.assertTrue(hasattr(df, "loc"))
         df.to_csv.assert_called_once_with("/tmp/databases.csv", sep=";", index=False)
 
     @patch("baudolo.seed.__main__.check_and_add_entry")
@@ -184,9 +172,7 @@ class TestSeedMain(unittest.TestCase):
 
     @patch("baudolo.seed.__main__.sys.exit")
     @patch("baudolo.seed.__main__.print")
-    @patch(
+    @patch("baudolo.seed.__main__.check_and_add_entry", side_effect=RuntimeError("boom"))
-        "baudolo.seed.__main__.check_and_add_entry", side_effect=RuntimeError("boom")
-    )
     @patch("baudolo.seed.__main__.argparse.ArgumentParser.parse_args")
     def test_main_exits_nonzero_on_error(
         self,
@@ -205,7 +191,6 @@ class TestSeedMain(unittest.TestCase):
 
         seed_main.main()
 
-        # prints error to stderr and exits with 1
         self.assertTrue(print_.called)
         _, kwargs = print_.call_args
         self.assertEqual(kwargs.get("file"), seed_main.sys.stderr)
@@ -213,4 +198,4 @@ class TestSeedMain(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main(verbosity=2)

tests/unit/src/baudolo/backup/test_compose.py

@@ -1,215 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import List
-
-import pytest
-
-
-@pytest.fixture
-def compose_mod():
-    """
-    Import the module under test.
-    Adjust the import path if your package layout differs.
-    """
-    from baudolo.backup import compose as mod
-
-    return mod
-
-
-def _touch(p: Path) -> None:
-    p.parent.mkdir(parents=True, exist_ok=True)
-    p.write_text("x", encoding="utf-8")
-
-
-def _setup_compose_dir(
-    tmp_path: Path,
-    name: str = "mailu",
-    *,
-    with_override: bool = False,
-    with_ca_override: bool = False,
-    env_layout: str | None = None,  # None | ".env" | ".env/env"
-) -> Path:
-    d = tmp_path / name
-    d.mkdir(parents=True, exist_ok=True)
-
-    _touch(d / "docker-compose.yml")
-
-    if with_override:
-        _touch(d / "docker-compose.override.yml")
-
-    if with_ca_override:
-        _touch(d / "docker-compose.ca.override.yml")
-
-    if env_layout == ".env":
-        _touch(d / ".env")
-    elif env_layout == ".env/env":
-        _touch(d / ".env" / "env")
-
-    return d
-
-
-def test_detect_env_file_prefers_dotenv_over_legacy(tmp_path: Path, compose_mod):
-    d = _setup_compose_dir(tmp_path, env_layout=".env/env")
-    # Also create .env file -> should be preferred
-    _touch(d / ".env")
-
-    env_file = compose_mod._detect_env_file(d)
-    assert env_file == d / ".env"
-
-
-def test_detect_env_file_uses_legacy_if_no_dotenv(tmp_path: Path, compose_mod):
-    d = _setup_compose_dir(tmp_path, env_layout=".env/env")
-    env_file = compose_mod._detect_env_file(d)
-    assert env_file == d / ".env" / "env"
-
-
-def test_detect_compose_files_requires_base(tmp_path: Path, compose_mod):
-    d = tmp_path / "stack"
-    d.mkdir()
-
-    with pytest.raises(FileNotFoundError):
-        compose_mod._detect_compose_files(d)
-
-
-def test_detect_compose_files_includes_optional_overrides(tmp_path: Path, compose_mod):
-    d = _setup_compose_dir(
-        tmp_path,
-        with_override=True,
-        with_ca_override=True,
-    )
-
-    files = compose_mod._detect_compose_files(d)
-    assert files == [
-        d / "docker-compose.yml",
-        d / "docker-compose.override.yml",
-        d / "docker-compose.ca.override.yml",
-    ]
-
-
-def test_build_cmd_uses_wrapper_when_present(monkeypatch, tmp_path: Path, compose_mod):
-    d = _setup_compose_dir(
-        tmp_path, with_override=True, with_ca_override=True, env_layout=".env"
-    )
-
-    # Pretend "which compose" finds a wrapper.
-    monkeypatch.setattr(
-        compose_mod.shutil, "which", lambda name: "/usr/local/bin/compose"
-    )
-
-    cmd = compose_mod._build_compose_cmd(str(d), ["up", "-d"])
-
-    # Wrapper should be used, and wrapper itself resolves -f / --env-file.
-    assert cmd == [
-        "/usr/local/bin/compose",
-        "--chdir",
-        str(d.resolve()),
-        "--",
-        "up",
-        "-d",
-    ]
-
-
-def test_build_cmd_fallback_docker_compose_with_all_files_and_env(
-    monkeypatch, tmp_path: Path, compose_mod
-):
-    d = _setup_compose_dir(
-        tmp_path,
-        with_override=True,
-        with_ca_override=True,
-        env_layout=".env",
-    )
-
-    # No wrapper found.
-    monkeypatch.setattr(compose_mod.shutil, "which", lambda name: None)
-
-    cmd = compose_mod._build_compose_cmd(str(d), ["up", "-d", "--force-recreate"])
-
-    # Fallback should replicate the wrapper resolution logic.
-    expected: List[str] = [
-        "docker",
-        "compose",
-        "-f",
-        str((d / "docker-compose.yml").resolve()),
-        "-f",
-        str((d / "docker-compose.override.yml").resolve()),
-        "-f",
-        str((d / "docker-compose.ca.override.yml").resolve()),
-        "--env-file",
-        str((d / ".env").resolve()),
-        "up",
-        "-d",
-        "--force-recreate",
-    ]
-    assert cmd == expected
-
-
-def test_hard_restart_calls_run_twice_with_correct_cmds_wrapper(
-    monkeypatch, tmp_path: Path, compose_mod
-):
-    d = _setup_compose_dir(tmp_path, name="mailu", env_layout=".env")
-
-    # Wrapper exists
-    monkeypatch.setattr(
-        compose_mod.shutil, "which", lambda name: "/usr/local/bin/compose"
-    )
-
-    calls = []
-
-    def fake_run(cmd, check: bool):
-        calls.append((cmd, check))
-        return 0
-
-    monkeypatch.setattr(compose_mod.subprocess, "run", fake_run)
-
-    compose_mod.hard_restart_docker_services(str(d))
-
-    assert calls == [
-        (["/usr/local/bin/compose", "--chdir", str(d.resolve()), "--", "down"], True),
-        (
-            ["/usr/local/bin/compose", "--chdir", str(d.resolve()), "--", "up", "-d"],
-            True,
-        ),
-    ]
-
-
-def test_hard_restart_calls_run_twice_with_correct_cmds_fallback(
-    monkeypatch, tmp_path: Path, compose_mod
-):
-    d = _setup_compose_dir(
-        tmp_path,
-        name="mailu",
-        with_override=True,
-        with_ca_override=True,
-        env_layout=".env/env",
-    )
-
-    # No wrapper exists
-    monkeypatch.setattr(compose_mod.shutil, "which", lambda name: None)
-
-    calls = []
-
-    def fake_run(cmd, check: bool):
-        calls.append((cmd, check))
-        return 0
-
-    monkeypatch.setattr(compose_mod.subprocess, "run", fake_run)
-
-    compose_mod.hard_restart_docker_services(str(d))
-
-    # We assert only key structure + ordering to keep it robust.
-    down_cmd = calls[0][0]
-    up_cmd = calls[1][0]
-
-    assert calls[0][1] is True
-    assert calls[1][1] is True
-
-    # down: docker compose -f ... --env-file ... down
-    assert down_cmd[0:2] == ["docker", "compose"]
-    assert down_cmd[-1] == "down"
-    assert "--env-file" in down_cmd
-
-    # up: docker compose ... up -d
-    assert up_cmd[0:2] == ["docker", "compose"]
-    assert up_cmd[-2:] == ["up", "-d"] or up_cmd[-3:] == ["up", "-d"]  # tolerance
-    assert "--env-file" in up_cmd