feat(engine): podman native — auto-detect runtime (docker→podman), compose mengikuti engine, doctor engine-agnostic

internal/docker/engine_test.go

@@ -0,0 +1,99 @@
+package docker
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestEngineCandidates(t *testing.T) {
+	t.Setenv("DOCKER_HOST", "")
+	t.Setenv("XDG_RUNTIME_DIR", "/run/user/1000")
+	cands := engineCandidates("")
+	if len(cands) != 3 {
+		t.Fatalf("harusnya 3 kandidat: %+v", cands)
+	}
+	if cands[0].name != "docker" || cands[0].host != "" {
+		t.Fatalf("kandidat pertama harus docker default: %+v", cands[0])
+	}
+	if cands[1].name != "podman" || cands[1].host != "unix:///run/user/1000/podman/podman.sock" {
+		t.Fatalf("kandidat kedua harus podman rootless: %+v", cands[1])
+	}
+	if cands[2].host != "unix:///run/podman/podman.sock" {
+		t.Fatalf("kandidat ketiga harus podman rootful: %+v", cands[2])
+	}
+
+	// override menang dan namanya mengikuti isi host
+	cands = engineCandidates("unix:///run/user/1000/podman/podman.sock")
+	if len(cands) != 1 || cands[0].name != "podman" {
+		t.Fatalf("override podman salah: %+v", cands)
+	}
+	cands = engineCandidates("tcp://192.168.1.5:2375")
+	if len(cands) != 1 || cands[0].name != "docker" {
+		t.Fatalf("override tcp harus docker: %+v", cands)
+	}
+
+	// DOCKER_HOST diset → satu kandidat, host dibiarkan kosong (FromEnv)
+	t.Setenv("DOCKER_HOST", "unix:///custom.sock")
+	cands = engineCandidates("")
+	if len(cands) != 1 || cands[0].host != "" || cands[0].name != "docker" {
+		t.Fatalf("DOCKER_HOST salah: %+v", cands)
+	}
+}
+
+func TestDetectWith(t *testing.T) {
+	cands := []candidate{{name: "docker", host: "d1"}, {name: "podman", host: "p1"}}
+
+	// docker mati → jatuh ke podman
+	connect := func(host string) (*Client, error) {
+		if host == "p1" {
+			return &Client{}, nil
+		}
+		return nil, fmt.Errorf("connection refused")
+	}
+	cl, info, err := detectWith(cands, connect)
+	if err != nil || cl == nil || info.Name != "podman" || info.Host != "p1" {
+		t.Fatalf("fallback salah: cl=%v info=%+v err=%v", cl, info, err)
+	}
+
+	// semua mati → error jelas
+	connect = func(host string) (*Client, error) { return nil, fmt.Errorf("matilah") }
+	if _, _, err := detectWith(cands, connect); err == nil {
+		t.Fatal("semua gagal harus error")
+	}
+}
+
+func TestPickCompose(t *testing.T) {
+	have := func(bins ...string) func(string) (string, error) {
+		m := map[string]bool{}
+		for _, b := range bins {
+			m[b] = true
+		}
+		return func(b string) (string, error) {
+			if m[b] {
+				return "/usr/bin/" + b, nil
+			}
+			return "", fmt.Errorf("tidak ada")
+		}
+	}
+
+	// podman engine: binary podman ada → `podman compose` (subcommand bawaan)
+	if got := pickCompose("auto", "podman", have("docker", "podman")); got[0] != "podman" || got[1] != "compose" {
+		t.Fatalf("podman engine: %v", got)
+	}
+	// podman engine tanpa binary podman → jatuh ke podman-compose
+	if got := pickCompose("auto", "podman", have("podman-compose")); got[0] != "podman-compose" {
+		t.Fatalf("fallback podman-compose: %v", got)
+	}
+	// engine docker
+	if got := pickCompose("auto", "docker", have("docker")); got[0] != "docker" || got[1] != "compose" {
+		t.Fatalf("docker engine: %v", got)
+	}
+	// docker engine, tapi hanya podman yang ada → tetap pakai podman
+	if got := pickCompose("auto", "docker", have("podman")); got[0] != "podman" {
+		t.Fatalf("degradasi ke podman: %v", got)
+	}
+	// spec eksplisit selalu menang
+	if got := pickCompose("docker-compose", "podman", have("docker-compose")); got[0] != "docker-compose" {
+		t.Fatalf("eksplisit: %v", got)
+	}
+}