convert windows paths to wsl2 paths

Signed-off-by: Swapnanil-Gupta <swpnlg@amazon.com>

Author: Swapnanil-Gupta

option/modifier.go

@@ -49,3 +49,16 @@ func WithNerdctlVersion(version string) Modifier {
 		o.features[nerdctlVersion] = version
 	})
 }
+
+// WithWindowsHostPathTranslation makes the option rewrite Windows drive-letter
+// paths (e.g. `C:\Users\foo`) in command arguments to their WSL2 equivalents
+// (e.g. `/mnt/c/Users/foo`) before executing.
+//
+// This is done in the Finch CLI too.
+// See (https://github.com/runfinch/finch/blob/ff1346b1d76f083ba86433e4501cbb5e5ce29634/cmd/finch/nerdctl_windows.go#L72),
+// But since common-tests is meant to be executed outside of Finch CLI (e.g Finch Core), we need this as an option.
+func WithWindowsHostPathTranslation() Modifier {
+	return newFuncModifier(func(o *Option) {
+		o.features[windowsHostPathTranslation] = true
+	})
+}

option/option.go

@@ -19,6 +19,7 @@ type feature int
 const (
 	environmentVariablePassthrough feature = iota
 	nerdctlVersion                 feature = iota
+	windowsHostPathTranslation     feature = iota
 )
 
 var (
@@ -68,6 +69,9 @@ func New(subject []string, modifiers ...Modifier) (*Option, error) {
 // NewCmd creates a command using the stored option and the provided args.
 func (o *Option) NewCmd(args ...string) *exec.Cmd {
 	cmdName := o.subject[0]
+	if o.supportsWindowsHostPathTranslation() {
+		args = translateWindowsHostPaths(args)
+	}
 	cmdArgs := append(o.subject[1:], args...) //nolint:gocritic // appendAssign does not apply to our case.
 	cmd := exec.Command(cmdName, cmdArgs...)  //nolint:gosec // G204 is not an issue because cmdName is fully controlled by the user.
 	cmd.Env = append(os.Environ(), o.env...)
@@ -113,6 +117,17 @@ func (o *Option) SupportsEnvVarPassthrough() bool {
 	return false
 }
 
+// supportsWindowsHostPathTranslation reports whether command arguments should
+// have Windows host paths rewritten to their WSL2 equivalents before execution.
+func (o *Option) supportsWindowsHostPathTranslation() bool {
+	if value, exists := o.features[windowsHostPathTranslation]; exists {
+		if boolValue, ok := value.(bool); ok {
+			return boolValue
+		}
+	}
+	return false
+}
+
 // IsNerdctlV1 is used by tests to check if the option supports [feature.nerdctlVersion] == nerdctl1xx.
 func (o *Option) IsNerdctlV1() bool {
 	return o.isNerdctlVersion(isNerdctl1xx)
@@ -159,13 +174,25 @@ func (o *Option) GetNerdctlVersion() (string, error) {
 		//nolint:gosec // G204 is not an issue because subject is fully controlled by the user.
 		versionBytes, err := exec.Command(o.subject[0], "version").Output()
 		if err != nil {
-			return "", fmt.Errorf("failed to run nerdctl --version: %w", err)
+			return "", fmt.Errorf("failed to run finch version: %w", err)
 		}
 		version, err := getNerdctlVersionMatch(finchNerdctlVersionRegex, string(versionBytes))
 		if err != nil {
 			return "", err
 		}
 		return version, nil
+	case "limactl":
+		// Assumes that "finch" is the vm name
+		//nolint:gosec // G204 is not an issue because subject is fully controlled by the user.
+		versionBytes, err := exec.Command(o.subject[0], "shell", "finch", "nerdctl", "--version").Output()
+		if err != nil {
+			return "", fmt.Errorf("failed to run nerdctl --version with limactl: %w", err)
+		}
+		version, err := getNerdctlVersionMatch(nerdctlVersionRegex, string(versionBytes))
+		if err != nil {
+			return "", err
+		}
+		return version, nil
 	default:
 		return "", fmt.Errorf("unsupported subject %s", execName)
 	}

option/option_test.go

@@ -49,6 +49,116 @@ func TestSupportsEnvVarPassthrough(t *testing.T) {
 	}
 }
 
+func TestTranslateWindowsHostPaths(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		in   []string
+		want []string
+	}{
+		{
+			name: "BuildContextPositional",
+			in:   []string{"build", "-t", "foo", `C:\Users\foo\finch-test123`},
+			want: []string{"build", "-t", "foo", "/mnt/c/Users/foo/finch-test123"},
+		},
+		{
+			name: "BuildDockerfileAndContext",
+			in:   []string{"build", "-f", `D:\a\Dockerfile`, "--no-cache", `D:\a`},
+			want: []string{"build", "-f", "/mnt/d/a/Dockerfile", "--no-cache", "/mnt/d/a"},
+		},
+		{
+			name: "BuildOutputDest",
+			in:   []string{"build", "-t", "output:tag", "--output", `type=tar,dest=C:\Users\foo\out.tar`, `C:\ctx`},
+			want: []string{"build", "-t", "output:tag", "--output", "type=tar,dest=/mnt/c/Users/foo/out.tar", "/mnt/c/ctx"},
+		},
+		{
+			name: "BuildOutputEqualsForm",
+			in:   []string{"build", `--output=type=docker`, `C:\ctx`},
+			want: []string{"build", "--output=type=docker", "/mnt/c/ctx"},
+		},
+		{
+			name: "BuildSecretSrc",
+			in:   []string{"build", "--secret", `id=mysecret,src=C:\Users\foo\secret.txt`, "-f", `C:\Users\foo\Dockerfile`, `C:\Users\foo`},
+			want: []string{
+				"build", "--secret", "id=mysecret,src=/mnt/c/Users/foo/secret.txt",
+				"-f", "/mnt/c/Users/foo/Dockerfile", "/mnt/c/Users/foo",
+			},
+		},
+		{
+			name: "SaveOutputFlag",
+			in:   []string{"save", "-o", `C:\Users\foo\test.tar`, "alpine:latest"},
+			want: []string{"save", "-o", "/mnt/c/Users/foo/test.tar", "alpine:latest"},
+		},
+		{
+			name: "SaveOutputFlagBeforeImages",
+			in:   []string{"save", "--output", `C:\Users\foo\test.tar`, "alpine:latest", "alpine:3.13"},
+			want: []string{"save", "--output", "/mnt/c/Users/foo/test.tar", "alpine:latest", "alpine:3.13"},
+		},
+		{
+			name: "LoadInputFlag",
+			in:   []string{"load", "-i", `C:\Users\foo\test.tar`},
+			want: []string{"load", "-i", "/mnt/c/Users/foo/test.tar"},
+		},
+		{
+			name: "ComposeFileFlag",
+			in:   []string{"compose", "up", "--file", `C:\Users\foo\docker-compose.yml`},
+			want: []string{"compose", "up", "--file", "/mnt/c/Users/foo/docker-compose.yml"},
+		},
+		{
+			name: "CpHostToContainer",
+			in:   []string{"cp", `C:\Users\foo\test-file`, "finch-test-ctr:/tmp/test-file"},
+			want: []string{"cp", "/mnt/c/Users/foo/test-file", "finch-test-ctr:/tmp/test-file"},
+		},
+		{
+			name: "CpContainerToHost",
+			in:   []string{"cp", "finch-test-ctr:/tmp/test-file", `C:\Users\foo\test-file`},
+			want: []string{"cp", "finch-test-ctr:/tmp/test-file", "/mnt/c/Users/foo/test-file"},
+		},
+		{
+			name: "CpWithFollowLinkFlagAndContainerSpec",
+			in:   []string{"cp", "-L", `C:\Users\foo\symlink`, "finch-test-ctr:/tmp/test-file"},
+			want: []string{"cp", "-L", "/mnt/c/Users/foo/symlink", "finch-test-ctr:/tmp/test-file"},
+		},
+		{
+			name: "RunBindMountHostPathOnly",
+			in:   []string{"run", "-v", `C:\host:/container`, "alpine:3.13"},
+			want: []string{"run", "-v", "/mnt/c/host:/container", "alpine:3.13"},
+		},
+		{
+			name: "RunNamedVolumeUntouched",
+			in:   []string{"run", "-v", "foo:/usr/share", "--name", "ctr", "alpine:3.13"},
+			want: []string{"run", "-v", "foo:/usr/share", "--name", "ctr", "alpine:3.13"},
+		},
+		{
+			name: "RunAnonymousVolumeUntouched",
+			in:   []string{"run", "-v", "/usr/share", "--name", "ctr", "alpine:3.13"},
+			want: []string{"run", "-v", "/usr/share", "--name", "ctr", "alpine:3.13"},
+		},
+		{
+			name: "PullImageTagAndFlagsUntouched",
+			in:   []string{"pull", "alpine:3.13", "--platform", "linux/amd64"},
+			want: []string{"pull", "alpine:3.13", "--platform", "linux/amd64"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			got := translateWindowsHostPaths(test.in)
+			if len(got) != len(test.want) {
+				t.Fatalf("length mismatch: got %v, want %v", got, test.want)
+			}
+			for i := range got {
+				if got[i] != test.want[i] {
+					t.Errorf("arg %d: got %q, want %q", i, got[i], test.want[i])
+				}
+			}
+		})
+	}
+}
+
 func TestNerdctlVersion(t *testing.T) {
 	t.Parallel()