reexec: use blackbox testing

Try to use blackbox testing; add a internal/reexecoverride.OverrideArgv0
utility to override `os.Arg[0]` for testing, and to disable the
Linux "/proc/self/exe" fast-path to allow us to test the "naive"
path resolution.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

reexec/internal/reexecoverride/reexecoverride.go

@@ -0,0 +1,45 @@
+// Package reexecoverride provides test utilities for overriding argv0 as
+// observed by reexec.Self within the current process.
+
+package reexecoverride
+
+import "sync/atomic"
+
+// argv0Override holds an optional override for os.Args[0] used by reexec.Self.
+var argv0Override atomic.Pointer[string]
+
+// Argv0 returns the overridden argv0 if set.
+func Argv0() (string, bool) {
+	p := argv0Override.Load()
+	if p == nil {
+		return "", false
+	}
+	return *p, true
+}
+
+// TestingTB is the minimal subset of [testing.TB] used by this package.
+type TestingTB interface {
+	Helper()
+	Cleanup(func())
+}
+
+// OverrideArgv0 overrides the argv0 value observed by reexec.Self for the
+// lifetime of the calling test and restores it via [testing.TB.Cleanup].
+//
+// The override is process-global. Tests using OverrideArgv0 must not run in
+// parallel with other tests that call reexec.Self. OverrideArgv0 panics if an
+// override is already active.
+func OverrideArgv0(t TestingTB, argv0 string) {
+	t.Helper()
+
+	s := argv0
+	if !argv0Override.CompareAndSwap(nil, &s) {
+		panic("testing: test using reexecoverride.OverrideArgv0 cannot use t.Parallel")
+	}
+
+	t.Cleanup(func() {
+		if !argv0Override.CompareAndSwap(&s, nil) {
+			panic("testing: cleanup for reexecoverride.OverrideArgv0 detected parallel use of reexec.Self")
+		}
+	})
+}

reexec/reexec.go

@@ -13,6 +13,8 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+
+	"github.com/moby/sys/reexec/internal/reexecoverride"
 )
 
 var registeredInitializers = make(map[string]func())
@@ -78,6 +80,9 @@ func CommandContext(ctx context.Context, args ...string) *exec.Cmd {
 // "my-binary" at "/usr/bin/" (or "my-binary.exe" at "C:\" on Windows),
 // then it returns "/usr/bin/my-binary" and "C:\my-binary.exe" respectively.
 func Self() string {
+	if argv0, ok := reexecoverride.Argv0(); ok {
+		return naiveSelf(argv0)
+	}
 	if runtime.GOOS == "linux" {
 		return "/proc/self/exe"
 	}

reexec/reexec_test.go

@@ -1,17 +1,19 @@
-package reexec
+package reexec_test
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/moby/sys/reexec"
+	"github.com/moby/sys/reexec/internal/reexecoverride"
 )
 
 const (
@@ -21,23 +23,23 @@ const (
 )
 
 func init() {
-	Register(testReExec, func() {
+	reexec.Register(testReExec, func() {
 		panic("Return Error")
 	})
-	Register(testReExec2, func() {
+	reexec.Register(testReExec2, func() {
 		var args string
 		if len(os.Args) > 1 {
 			args = fmt.Sprintf("(args: %#v)", os.Args[1:])
 		}
 		fmt.Println("Hello", testReExec2, args)
 		os.Exit(0)
 	})
-	Register(testReExec3, func() {
+	reexec.Register(testReExec3, func() {
 		fmt.Println("Hello " + testReExec3)
 		time.Sleep(1 * time.Second)
 		os.Exit(0)
 	})
-	if Init() {
+	if reexec.Init() {
 		// Make sure we exit in case re-exec didn't os.Exit on its own.
 		os.Exit(0)
 	}
@@ -73,7 +75,7 @@ func TestRegister(t *testing.T) {
 					t.Errorf("got %q, want %q", r, tc.expectedErr)
 				}
 			}()
-			Register(tc.name, func() {})
+			reexec.Register(tc.name, func() {})
 		})
 	}
 }
@@ -102,7 +104,7 @@ func TestCommand(t *testing.T) {
 	}
 	for _, tc := range tests {
 		t.Run(tc.doc, func(t *testing.T) {
-			cmd := Command(tc.cmdAndArgs...)
+			cmd := reexec.Command(tc.cmdAndArgs...)
 			if !reflect.DeepEqual(cmd.Args, tc.cmdAndArgs) {
 				t.Fatalf("got %+v, want %+v", cmd.Args, tc.cmdAndArgs)
 			}
@@ -169,7 +171,7 @@ func TestCommandContext(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 			defer cancel()
 
-			cmd := CommandContext(ctx, tc.cmdAndArgs...)
+			cmd := reexec.CommandContext(ctx, tc.cmdAndArgs...)
 			if !reflect.DeepEqual(cmd.Args, tc.cmdAndArgs) {
 				t.Fatalf("got %+v, want %+v", cmd.Args, tc.cmdAndArgs)
 			}
@@ -202,18 +204,17 @@ func TestCommandContext(t *testing.T) {
 // can resolve a path that can be used to re-execute the current test binary
 // when it falls back to the argv[0]-based implementation.
 //
-// It invokes the binary via naiveSelf (intentionally bypassing the Linux
-// /proc/self/exe fast-path) so the fallback logic is exercised consistently
-// across platforms.
+// It forces Self() to bypass the Linux /proc/self/exe fast-path via
+// [reexecoverride.OverrideArgv0] so that the fallback logic is exercised
+// consistently across platforms.
 func TestRunNaiveSelf(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 	defer cancel()
 
-	// Similar to [rexec.CommandContext], but using naiveSelf to skip the
-	// optimized "/proc/self/exe" on Linux.
-	cmd := exec.CommandContext(ctx, naiveSelf(os.Args[0]), testReExec2)
-	cmd.Args = cmd.Args[1:]
+	// Force Self() to use naiveSelf(os.Args[0]), instead of "/proc/self/exe" on Linux.
+	reexecoverride.OverrideArgv0(t, os.Args[0])
 
+	cmd := reexec.CommandContext(ctx, testReExec2)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("Unable to start command: %v", err)
@@ -227,12 +228,23 @@ func TestRunNaiveSelf(t *testing.T) {
 }
 
 func TestNaiveSelfResolve(t *testing.T) {
+	t.Run("fast path on Linux", func(t *testing.T) {
+		if runtime.GOOS != "linux" {
+			t.Skip("only supported on Linux")
+		}
+		resolved := reexec.Self()
+		expected := "/proc/self/exe"
+		if resolved != expected {
+			t.Errorf("got %v, want %v", resolved, expected)
+		}
+	})
 	t.Run("resolve in PATH", func(t *testing.T) {
 		executable := "sh"
 		if runtime.GOOS == "windows" {
 			executable = "cmd"
 		}
-		resolved := naiveSelf(executable)
+		reexecoverride.OverrideArgv0(t, executable)
+		resolved := reexec.Self()
 		if resolved == executable {
 			t.Errorf("did not resolve via PATH; got %q", resolved)
 		}
@@ -246,7 +258,8 @@ func TestNaiveSelfResolve(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		resolved := naiveSelf(executable)
+		reexecoverride.OverrideArgv0(t, executable)
+		resolved := reexec.Self()
 		if resolved != want {
 			t.Errorf("expected absolute path; got %q, want %q", resolved, want)
 		}
@@ -257,14 +270,16 @@ func TestNaiveSelfResolve(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		resolved := naiveSelf(executable)
+		reexecoverride.OverrideArgv0(t, executable)
+		resolved := reexec.Self()
 		if resolved != want {
 			t.Errorf("expected absolute path; got %q, want %q", resolved, want)
 		}
 	})
 	t.Run("absolute path unchanged", func(t *testing.T) {
 		executable := filepath.Join(os.TempDir(), "some-executable")
-		resolved := naiveSelf(executable)
+		reexecoverride.OverrideArgv0(t, executable)
+		resolved := reexec.Self()
 		if resolved != executable {
 			t.Errorf("should not modify absolute paths; got %q, want %q", resolved, executable)
 		}