fix(backup): match the engine on the image name

has_image tested the pattern against the raw .Config.Image, so anything in the reference could decide which dump tool runs -- including the registry host and the tag. A swarm node that hosts the local registry prefixes every pull with its own name, and that node is named after the app under test, so a Postgres container reads as svc-db-mariadb-swarm-mgr-01:5000/postgres_custom:17-3.5. dumps.py tries mariadb before postgres, matched on the hostname, and dumped Postgres with mariadb-dump: exit 127, the image does not ship it. The BackupException took the backup unit down with it.

image_name strips digest, tag and registry host and matches on the repository path, so the decision rests on the image alone. Same intent as the exact --images-* matching from f9776ac, applied to the one place that commit did not reach. Tags stop deciding too: xwiki_custom:lts-postgres-tomcat no longer reads as Postgres.

The e2e reproduces the shape without a registry -- a docker tag is enough for .Config.Image to carry the reference verbatim -- and asserts a real pg_dump lands. Under the old code mariadb-dump aborts and no dump file exists.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/e2e/test_e2e_engine_detection_registry_prefix.py

@@ -0,0 +1,105 @@
+import unittest
+
+from .helpers import (
+    POSTGRES_IMAGE,
+    POSTGRES_DATA_DIR,
+    backup_run,
+    backup_path,
+    cleanup_docker,
+    create_minimal_compose_dir,
+    ensure_empty_dir,
+    latest_version_dir,
+    require_docker,
+    unique,
+    write_databases_csv,
+    run,
+    wait_for_postgres,
+)
+
+REGISTRY_HOST = "svc-db-mariadb-swarm-mgr-01:5000"
+
+
+class TestE2EEngineDetectionRegistryPrefix(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        require_docker()
+        cls.prefix = unique("baudolo-e2e-registry-prefix")
+        cls.backups_dir = f"/tmp/{cls.prefix}/Backups"
+        ensure_empty_dir(cls.backups_dir)
+        cls.compose_dir = create_minimal_compose_dir(f"/tmp/{cls.prefix}")
+        cls.repo_name = cls.prefix
+
+        cls.image = f"{REGISTRY_HOST}/postgres_custom:17-3.5"
+        cls.pg_container = f"{cls.prefix}-pg"
+        cls.pg_volume = f"{cls.prefix}-pg-vol"
+        cls.containers = [cls.pg_container]
+        cls.volumes = [cls.pg_volume]
+
+        run(["docker", "pull", POSTGRES_IMAGE])
+        run(["docker", "tag", POSTGRES_IMAGE, cls.image])
+        run(["docker", "volume", "create", cls.pg_volume])
+
+        run(
+            [
+                "docker",
+                "run",
+                "-d",
+                "--name",
+                cls.pg_container,
+                "-e",
+                "POSTGRES_PASSWORD=pgpw",
+                "-e",
+                "POSTGRES_DB=appdb",
+                "-e",
+                "POSTGRES_USER=postgres",
+                "-v",
+                f"{cls.pg_volume}:{POSTGRES_DATA_DIR}",
+                cls.image,
+            ]
+        )
+        wait_for_postgres(cls.pg_container, user="postgres", timeout_s=90)
+
+        run(
+            [
+                "docker",
+                "exec",
+                cls.pg_container,
+                "sh",
+                "-lc",
+                "psql -U postgres -d appdb -c \"CREATE TABLE t (id int primary key, v text); INSERT INTO t VALUES (1,'ok');\"",
+            ]
+        )
+
+        cls.databases_csv = f"/tmp/{cls.prefix}/databases.csv"
+        write_databases_csv(
+            cls.databases_csv, [(cls.pg_container, "appdb", "postgres", "pgpw")]
+        )
+
+        backup_run(
+            backups_dir=cls.backups_dir,
+            repo_name=cls.repo_name,
+            compose_dir=cls.compose_dir,
+            databases_csv=cls.databases_csv,
+            database_containers=[cls.pg_container],
+            images_no_stop_required=[cls.image],
+        )
+
+        cls.hash, cls.version = latest_version_dir(cls.backups_dir, cls.repo_name)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cleanup_docker(containers=cls.containers, volumes=cls.volumes)
+        run(["docker", "rmi", cls.image], check=False)
+
+    def test_the_registry_host_does_not_pick_the_engine(self) -> None:
+        p = (
+            backup_path(self.backups_dir, self.repo_name, self.version, self.pg_volume)
+            / "sql"
+            / "appdb.backup.sql"
+        )
+        self.assertTrue(p.is_file(), f"Expected a pg_dump at: {p}")
+        self.assertIn("Dumped by pg_dump", p.read_text(encoding="utf-8"))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/backup/test_docker_image_name.py

@@ -0,0 +1,50 @@
+import unittest
+from unittest.mock import patch
+
+from baudolo.backup import docker as docker_mod
+
+
+def _with_image(reference: str):
+    return patch.object(docker_mod, "execute_shell_command", return_value=[reference])
+
+
+class TestImageName(unittest.TestCase):
+    def test_plain_reference(self) -> None:
+        with _with_image("postgres:16"):
+            self.assertEqual(docker_mod.image_name("c1"), "postgres")
+
+    def test_registry_host_is_dropped(self) -> None:
+        with _with_image("svc-db-mariadb-swarm-mgr-01:5000/postgres_custom:17-3.5"):
+            self.assertEqual(docker_mod.image_name("c1"), "postgres_custom")
+
+    def test_pull_through_path_is_kept(self) -> None:
+        with _with_image(
+            "svc-db-mariadb-swarm-mgr-01:5000/ghcr.io/x/mirror/docker.io/postgres:16"
+        ):
+            self.assertEqual(
+                docker_mod.image_name("c1"), "ghcr.io/x/mirror/docker.io/postgres"
+            )
+
+    def test_digest_is_dropped(self) -> None:
+        with _with_image("registry:5000/postgres@sha256:" + "0" * 64):
+            self.assertEqual(docker_mod.image_name("c1"), "postgres")
+
+
+class TestHasImage(unittest.TestCase):
+    def test_registry_hostname_does_not_decide_the_engine(self) -> None:
+        with _with_image("svc-db-mariadb-swarm-mgr-01:5000/postgres_custom:17-3.5"):
+            self.assertFalse(docker_mod.has_image("c1", "mariadb"))
+        with _with_image("svc-db-mariadb-swarm-mgr-01:5000/postgres_custom:17-3.5"):
+            self.assertTrue(docker_mod.has_image("c1", "postgres"))
+
+    def test_tag_does_not_decide_the_engine(self) -> None:
+        with _with_image("registry:5000/xwiki_custom:lts-postgres-tomcat"):
+            self.assertFalse(docker_mod.has_image("c1", "postgres"))
+
+    def test_mirrored_mariadb_still_matches(self) -> None:
+        with _with_image("registry:5000/ghcr.io/x/mirror/docker.io/mariadb:11"):
+            self.assertTrue(docker_mod.has_image("c1", "mariadb"))
+
+
+if __name__ == "__main__":
+    unittest.main()