Merge pull request #467 from Caesarsage/feat/dry-run-podman

feat(test): podman driver support for microcks test --dry-run

Author: Harsh4902

cmd/test.go

@@ -44,6 +44,7 @@ func NewTestCommand(globalClientOpts *connectors.ClientOptions) *cobra.Command {
 		image              string
 		readyTimeout       time.Duration
 		watch              bool
+		driver             string
 	)
 	var testCmd = &cobra.Command{
 
@@ -131,6 +132,10 @@ func NewTestCommand(globalClientOpts *connectors.ClientOptions) *cobra.Command {
 					fmt.Println("--watch is only valid together with --dry-run")
 					os.Exit(1)
 				}
+				if driver != "" {
+					fmt.Println("--driver is only valid together with --dry-run")
+					os.Exit(1)
+				}
 			}
 
 			if dryRun {
@@ -140,6 +145,7 @@ func NewTestCommand(globalClientOpts *connectors.ClientOptions) *cobra.Command {
 					image:        image,
 					readyTimeout: readyTimeout,
 					watch:        watch,
+					driver:       driver,
 					params:       params,
 				}) {
 					os.Exit(1)
@@ -230,6 +236,7 @@ func NewTestCommand(globalClientOpts *connectors.ClientOptions) *cobra.Command {
 	testCmd.Flags().StringVar(&image, "image", defaultDryRunImage, "Microcks uber-native image used for --dry-run")
 	testCmd.Flags().DurationVar(&readyTimeout, "ready-timeout", 90*time.Second, "How long to wait for the ephemeral container to be ready (--dry-run only)")
 	testCmd.Flags().BoolVar(&watch, "watch", false, "Watch the artifact file and re-run the test on change (--dry-run only)")
+	testCmd.Flags().StringVar(&driver, "driver", "", "Container runtime for --dry-run: 'docker' or 'podman' (default: auto-detect)")
 
 	return testCmd
 }

cmd/testDryRun.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"net/url"
 	"os"
+	"os/exec"
 	"os/signal"
 	"path/filepath"
 	"strconv"
@@ -44,9 +45,58 @@ type dryRunOptions struct {
 	image        string
 	readyTimeout time.Duration
 	watch        bool
+	driver       string
 	params       testParams
 }
 
+// configureDriver points testcontainers-go at the right container runtime.
+// Docker is its default (honoring DOCKER_HOST); Podman needs its socket wired
+// into DOCKER_HOST and Ryuk disabled. An empty driver auto-detects.
+func configureDriver(driver string) error {
+	switch driver {
+	case "podman":
+		return setupPodman()
+	case "docker":
+		return nil // testcontainers-go's default, via DOCKER_HOST
+	case "":
+		if shouldUsePodman() {
+			return setupPodman()
+		}
+		return nil
+	default:
+		return fmt.Errorf("unsupported --driver %q (use 'docker' or 'podman')", driver)
+	}
+}
+
+// shouldUsePodman auto-detects podman only when it's clearly the intended
+// runtime: no explicit DOCKER_HOST, podman on PATH, and docker absent.
+func shouldUsePodman() bool {
+	if os.Getenv("DOCKER_HOST") != "" {
+		return false // respect an explicitly configured endpoint
+	}
+	_, podErr := exec.LookPath("podman")
+	_, dockErr := exec.LookPath("docker")
+	return podErr == nil && dockErr != nil
+}
+
+func setupPodman() error {
+	if err := connectors.ConfigurePodmanHost(); err != nil {
+		return err
+	}
+	// testcontainers-go silently falls back to Docker when the podman endpoint
+	// isn't reachable, which would make "--driver podman" a lie. Verify the
+	// connection now and fail loudly instead.
+	if err := connectors.PingDockerHost(); err != nil {
+		return fmt.Errorf("--driver podman selected but the podman endpoint is not reachable. "+
+			"Start it with 'podman machine start' (macOS/Windows) or "+
+			"'systemctl --user start podman.socket' (Linux). Underlying error: %w", err)
+	}
+	// Ryuk (Testcontainers' reaper) needs privileges rootless Podman doesn't
+	// grant; our signal-driven Terminate already guarantees cleanup, so disable
+	// it for the Podman path.
+	return os.Setenv("TESTCONTAINERS_RYUK_DISABLED", "true")
+}
+
 func validateDryRunOptions(opts dryRunOptions) error {
 	if opts.artifact == "" {
 		return fmt.Errorf("--artifact is required with --dry-run")
@@ -97,6 +147,12 @@ func runDryRunTest(opts dryRunOptions) bool {
 		return false
 	}
 
+	// Select the container runtime (docker default, podman wired via DOCKER_HOST).
+	if err := configureDriver(opts.driver); err != nil {
+		fmt.Println(err)
+		return false
+	}
+
 	// Ctrl+C / SIGTERM cancels the context so teardown still runs.
 	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 	defer cancel()

pkg/connectors/container_client.go

@@ -7,13 +7,13 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/image"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/jsonmessage"
 	"github.com/docker/go-connections/nat"
-	"github.com/microcks/microcks-cli/pkg/errors"
 	"github.com/moby/term"
 )
 
@@ -64,26 +64,52 @@ func NewDockerClient() (*containerClient, error) {
 	return &containerClient{cli: cli}, nil
 }
 
-func NewPodmanClient() (*containerClient, error) {
-	osName := runtime.GOOS
-	switch osName {
-	case "windows":
-		remoteSocket, err := exec.Command("podman", "machine", "inspect", "--format", "{{.ConnectionInfo.PodmanPipe.Path}}").Output()
-		errors.CheckError(err)
-		socketPath := strings.TrimSpace(string(remoteSocket))
-		err = os.Setenv("DOCKER_HOST", "npipe:////"+strings.TrimPrefix(socketPath, "\\\\"))
-		errors.CheckError(err)
+// PingDockerHost verifies the Docker-API endpoint at DOCKER_HOST actually
+// answers. The raw client honors DOCKER_HOST with no fallback, so this catches
+// an unreachable endpoint (e.g. a stopped Podman machine) before testcontainers-go
+// silently resolves to a different runtime.
+func PingDockerHost() error {
+	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	if err != nil {
+		return err
+	}
+	defer cli.Close()
 
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	_, err = cli.Ping(ctx)
+	return err
+}
+
+func ConfigurePodmanHost() error {
+	switch runtime.GOOS {
+	case "windows":
+		out, err := exec.Command("podman", "machine", "inspect", "--format", "{{.ConnectionInfo.PodmanPipe.Path}}").Output()
+		if err != nil {
+			return fmt.Errorf("resolving podman pipe path (is the podman machine running?): %w", err)
+		}
+		socketPath := strings.TrimSpace(string(out))
+		return os.Setenv("DOCKER_HOST", "npipe:////"+strings.TrimPrefix(socketPath, "\\\\"))
 	case "darwin":
-		remoteSocket, err := exec.Command("podman", "machine", "inspect", "--format", "{{.ConnectionInfo.PodmanSocket.Path}}").Output()
-		errors.CheckError(err)
-		err = os.Setenv("DOCKER_HOST", "unix://"+strings.TrimSpace(string(remoteSocket)))
-		errors.CheckError(err)
+		out, err := exec.Command("podman", "machine", "inspect", "--format", "{{.ConnectionInfo.PodmanSocket.Path}}").Output()
+		if err != nil {
+			return fmt.Errorf("resolving podman socket path (is the podman machine running?): %w", err)
+		}
+		return os.Setenv("DOCKER_HOST", "unix://"+strings.TrimSpace(string(out)))
 	case "linux":
-		remoteSocket, err := exec.Command("podman", "info", "--format", "{{.Host.RemoteSocket.Path}}").Output()
-		errors.CheckError(err)
-		err = os.Setenv("DOCKER_HOST", "unix://"+strings.TrimSpace(string(remoteSocket)))
-		errors.CheckError(err)
+		out, err := exec.Command("podman", "info", "--format", "{{.Host.RemoteSocket.Path}}").Output()
+		if err != nil {
+			return fmt.Errorf("resolving podman socket path: %w", err)
+		}
+		return os.Setenv("DOCKER_HOST", "unix://"+strings.TrimSpace(string(out)))
+	}
+	return nil
+}
+
+func NewPodmanClient() (*containerClient, error) {
+	if err := ConfigurePodmanHost(); err != nil {
+		return nil, err
 	}
 
 	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())