reexec: use blackbox testing

Try to use blackbox testing; add a internal/reexectest.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/reexectest/reexectest.go

@@ -0,0 +1,42 @@
+// Package reexectest provides utilities for user in tests.
+
+package reexectest
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+var (
+	// argv0Override holds an optional override for os.Args[0] used by reexec.Self.
+	argv0Override atomic.Pointer[string]
+
+	// overrideMu serializes setting/clearing the override so tests don't trample
+	// each other if multiple tests try to override at the same time.
+	overrideMu sync.Mutex
+)
+
+// Argv0 returns the overridden argv0 if set.
+func Argv0() (string, bool) {
+	p := argv0Override.Load()
+	if p == nil {
+		return "", false
+	}
+	return *p, true
+}
+
+// OverrideArgv0 overrides os.Arg[0] with argv0 and returns a restore function.
+// Call the restore function (typically via t.Cleanup) to clear the override.
+//
+// While the override is active, any concurrent call to reexec.Self() in the
+// same process will observe the override. So tests that use this should not
+// run in parallel with other tests that call reexec.Self().
+func OverrideArgv0(argv0 string) (restore func()) {
+	overrideMu.Lock()
+	s := argv0
+	argv0Override.Store(&s)
+	return func() {
+		argv0Override.Store(nil)
+		overrideMu.Unlock()
+	}
+}

reexec/reexec.go

@@ -13,6 +13,8 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+
+	"github.com/moby/sys/reexec/internal/reexectest"
 )
 
 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 := reexectest.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/reexectest"
 )
 
 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(t.Context(), 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)
 			}
@@ -208,11 +210,11 @@ func TestRunNaiveSelf(t *testing.T) {
 	ctx, cancel := context.WithTimeout(t.Context(), 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.
+	restore := reexectest.OverrideArgv0(os.Args[0])
+	t.Cleanup(restore)
 
+	cmd := reexec.CommandContext(ctx, testReExec2)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("Unable to start command: %v", err)
@@ -226,12 +228,24 @@ 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)
+		restore := reexectest.OverrideArgv0(executable)
+		t.Cleanup(restore)
+		resolved := reexec.Self()
 		if resolved == executable {
 			t.Errorf("did not resolve via PATH; got %q", resolved)
 		}
@@ -241,23 +255,29 @@ func TestNaiveSelfResolve(t *testing.T) {
 	})
 	t.Run("not in PATH", func(t *testing.T) {
 		const executable = "some-nonexistent-executable"
-		resolved := naiveSelf(executable)
+		restore := reexectest.OverrideArgv0(executable)
+		t.Cleanup(restore)
+		resolved := reexec.Self()
 		want, _ := filepath.Abs(executable)
 		if resolved != want {
 			t.Errorf("expected absolute path; got %q, want %q", resolved, want)
 		}
 	})
 	t.Run("relative path", func(t *testing.T) {
 		executable := filepath.Join(".", "some-executable")
-		resolved := naiveSelf(executable)
+		restore := reexectest.OverrideArgv0(executable)
+		t.Cleanup(restore)
+		resolved := reexec.Self()
 		want, _ := filepath.Abs(executable)
 		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)
+		restore := reexectest.OverrideArgv0(executable)
+		resolved := reexec.Self()
+		restore()
 		if resolved != executable {
 			t.Errorf("should not modify absolute paths; got %q, want %q", resolved, executable)
 		}