Windows test fixes

Author: AdamDrewsTR

cmd/meta/getstarted_test.go

@@ -161,6 +161,12 @@ func TestGetStartedCommand_FishShell(t *testing.T) {
 }
 
 func TestGetStartedCommand_UnknownShell(t *testing.T) {
+	// On Windows, shell detection always defaults to PowerShell
+	// This test is for Unix where unknown shells fall back to bash
+	if utils.IsWindows() {
+		t.Skip("Skipping unknown shell test on Windows - defaults to PowerShell")
+	}
+
 	tmpDir := t.TempDir()
 	t.Setenv(utils.GoenvEnvVarRoot.String(), tmpDir)
 	t.Setenv(utils.GoenvEnvVarShell.String(), "")

cmd/tools/list_tools_test.go

@@ -3,10 +3,11 @@ package tools
 import (
 	"bytes"
 	"encoding/json"
-	"github.com/go-nv/goenv/internal/utils"
 	"path/filepath"
 	"testing"
 
+	"github.com/go-nv/goenv/internal/utils"
+
 	"github.com/go-nv/goenv/internal/cmdtest"
 	"github.com/go-nv/goenv/internal/config"
 	"github.com/go-nv/goenv/internal/manager"
@@ -32,13 +33,12 @@ func TestListCommand_AllFlag(t *testing.T) {
 		// Create version with tool directory
 		cmdtest.CreateMockGoVersionWithTools(t, tmpDir, version)
 
-		// Create individual tool binaries
+		// Create individual tool binaries using helper (handles .bat on Windows)
 		cfg := &config.Config{Root: tmpDir}
 		binPath := cfg.VersionGopathBin(version)
 
 		for _, tool := range tools {
-			toolPath := filepath.Join(binPath, tool)
-			testutil.WriteTestFile(t, toolPath, []byte("fake"), utils.PermFileExecutable)
+			cmdtest.CreateToolExecutable(t, binPath, tool)
 		}
 	}
 
@@ -104,8 +104,7 @@ func TestListCommand_JSONOutput(t *testing.T) {
 
 	tools := []string{"gopls", "staticcheck"}
 	for _, tool := range tools {
-		toolPath := filepath.Join(binPath, tool)
-		testutil.WriteTestFile(t, toolPath, []byte("fake"), utils.PermFileExecutable)
+		cmdtest.CreateToolExecutable(t, binPath, tool)
 	}
 
 	// Enable JSON output
@@ -205,8 +204,8 @@ func TestListCommand_HiddenFiles(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	// Create regular and hidden files
-	testutil.WriteTestFile(t, filepath.Join(binPath, "gopls"), []byte("fake"), utils.PermFileExecutable)
+	// Create regular and hidden files (use helper for gopls to handle .bat on Windows)
+	cmdtest.CreateToolExecutable(t, binPath, "gopls")
 	testutil.WriteTestFile(t, filepath.Join(binPath, ".hidden"), []byte("fake"), utils.PermFileExecutable)
 
 	toolList, err := toolspkg.ListForVersion(cfg, version)
@@ -282,8 +281,7 @@ func TestListCommand_RunE(t *testing.T) {
 
 	tools := []string{"gopls", "staticcheck"}
 	for _, tool := range tools {
-		toolPath := filepath.Join(binPath, tool)
-		testutil.WriteTestFile(t, toolPath, []byte("fake"), utils.PermFileExecutable)
+		cmdtest.CreateToolExecutable(t, binPath, tool)
 	}
 
 	// Create .go-version to set current version
@@ -322,22 +320,16 @@ func TestListCommand_MultipleVersions(t *testing.T) {
 	// Create multiple versions
 	versions := []string{"1.21.0", "1.22.0", "1.23.0"}
 	for _, v := range versions {
-		// Create Go binary for version (required by ListInstalledVersions)
+		// Create Go binary for version using helper (handles .bat on Windows)
 		goBinDir := filepath.Join(tmpDir, "versions", v, "bin")
-		if err := utils.EnsureDirWithContext(goBinDir, "create test directory"); err != nil {
-			t.Fatal(err)
-		}
-		goBin := filepath.Join(goBinDir, "go")
-		testutil.WriteTestFile(t, goBin, []byte("#!/bin/sh\necho go version"), utils.PermFileExecutable)
+		cmdtest.CreateTestBinary(t, tmpDir, v, "go")
 
-		// Create tools
+		// Create tools using helper (handles .bat on Windows)
 		binPath := filepath.Join(tmpDir, "versions", v, "gopath", "bin")
 		if err := utils.EnsureDirWithContext(binPath, "create test directory"); err != nil {
 			t.Fatal(err)
 		}
-
-		// Each version has gopls
-		testutil.WriteTestFile(t, filepath.Join(binPath, "gopls"), []byte("fake"), utils.PermFileExecutable)
+		cmdtest.CreateToolExecutable(t, binPath, "gopls")
 	}
 
 	// Get all versions

cmd/tools/status_test.go

@@ -166,11 +166,10 @@ func TestStatusCommand_Categorization(t *testing.T) {
 		// Create version with tool directory
 		cmdtest.CreateMockGoVersionWithTools(t, tmpDir, version)
 
-		// Create individual tool binaries
+		// Create individual tool binaries using helper (handles .bat on Windows)
 		binPath := cfg.VersionGopathBin(version)
 		for _, tool := range tools {
-			toolPath := filepath.Join(binPath, tool)
-			testutil.WriteTestFile(t, toolPath, []byte("fake"), utils.PermFileExecutable)
+			cmdtest.CreateToolExecutable(t, binPath, tool)
 		}
 	}
 

cmd/tools/sync_tools_test.go

@@ -47,16 +47,10 @@ func setupSyncTestEnv(t *testing.T, versions []string, tools map[string][]string
 			t.Fatalf("Failed to create GOPATH/bin: %v", err)
 		}
 
-		// Create tools for this version
+		// Create tools for this version using helper (handles .bat on Windows)
 		if versionTools, ok := tools[version]; ok {
 			for _, tool := range versionTools {
-				toolPath := filepath.Join(gopathBin, tool)
-				content := "mock tool"
-				if utils.IsWindows() {
-					toolPath += ".bat"
-					content = "@echo off\necho mock tool\n"
-				}
-				testutil.WriteTestFile(t, toolPath, []byte(content), utils.PermFileExecutable)
+				cmdtest.CreateToolExecutable(t, gopathBin, tool)
 			}
 		}
 	}

cmd/tools/uninstall_tools_test.go

@@ -115,11 +115,10 @@ func TestFindCurrentVersionToolTargets(t *testing.T) {
 	cmdtest.CreateMockGoVersionWithTools(t, tmpDir, version)
 	binPath := cfg.VersionGopathBin(version)
 
-	// Create test tools
+	// Create test tools using helper (handles .bat on Windows)
 	tools := []string{"gopls", "staticcheck"}
 	for _, tool := range tools {
-		toolPath := filepath.Join(binPath, tool)
-		testutil.WriteTestFile(t, toolPath, []byte("fake"), utils.PermFileExecutable)
+		cmdtest.CreateToolExecutable(t, binPath, tool)
 	}
 
 	// Set current version

cmd/tools/update_tools_test.go

@@ -56,14 +56,7 @@ func setupUpdateTestEnv(t *testing.T, version string, tools []testToolInfo, shou
 		}
 
 		for _, tool := range tools {
-			toolPath := filepath.Join(gopathBin, tool.name)
-			mockContent := "mock tool binary"
-			if utils.IsWindows() {
-				toolPath += ".bat"
-				mockContent = "@echo off\necho mock tool binary\n"
-			}
-
-			testutil.WriteTestFile(t, toolPath, []byte(mockContent), utils.PermFileExecutable)
+			cmdtest.CreateToolExecutable(t, gopathBin, tool.name)
 		}
 	}
 

internal/cmdtest/fixtures_test.go

@@ -39,17 +39,30 @@ func TestFixtureWithVersions(t *testing.T) {
 	defer f.Cleanup()
 
 	// Add versions using method chaining
-	f.WithVersions("1.21.0", "1.22.0")
+	f.WithVersions("1.21.0", "1.22.0", "1.23.0")
 
-	// Verify versions were created
-	v1Path := filepath.Join(f.Root, "versions", "1.21.0", "bin", "go")
-	v2Path := filepath.Join(f.Root, "versions", "1.22.0", "bin", "go")
+	// Verify versions were created using ListInstalledVersions
+	versions, err := f.Manager.ListInstalledVersions()
+	if err != nil {
+		t.Fatalf("Failed to list installed versions: %v", err)
+	}
 
-	if utils.FileNotExists(v1Path) {
-		t.Errorf("Version 1.21.0 binary not created at %s", v1Path)
+	expectedVersions := []string{"1.21.0", "1.22.0", "1.23.0"}
+	if len(versions) != len(expectedVersions) {
+		t.Errorf("Expected %d versions, got %d", len(expectedVersions), len(versions))
 	}
-	if utils.FileNotExists(v2Path) {
-		t.Errorf("Version 1.22.0 binary not created at %s", v2Path)
+
+	for _, expected := range expectedVersions {
+		found := false
+		for _, v := range versions {
+			if v == expected {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("Expected version %s not found in installed versions", expected)
+		}
 	}
 }
 
@@ -60,16 +73,16 @@ func TestFixtureWithTools(t *testing.T) {
 	f.WithVersions("1.21.0").
 		WithTools("1.21.0", "gopls", "staticcheck")
 
-	// Verify tools were created
+	// Verify tools were created using FindExecutable (handles .bat/.exe on Windows)
 	toolDir := filepath.Join(f.Root, "versions", "1.21.0", "gopath", "bin")
-	goplsPath := filepath.Join(toolDir, "gopls")
-	staticcheckPath := filepath.Join(toolDir, "staticcheck")
 
-	if utils.FileNotExists(goplsPath) {
-		t.Errorf("gopls not created at %s", goplsPath)
+	goplsPath := filepath.Join(toolDir, "gopls")
+	if _, err := utils.FindExecutable(toolDir, "gopls"); err != nil {
+		t.Errorf("gopls not found in %s: %v", toolDir, err)
 	}
-	if utils.FileNotExists(staticcheckPath) {
-		t.Errorf("staticcheck not created at %s", staticcheckPath)
+
+	if _, err := utils.FindExecutable(toolDir, "staticcheck"); err != nil {
+		t.Errorf("staticcheck not found in %s: %v", toolDir, err)
 	}
 }
 
@@ -184,12 +197,13 @@ func TestToolScenario(t *testing.T) {
 	// Verify version and tools
 	f.AssertVersionInstalled("1.21.0")
 
+	// Verify tools were created using FindExecutable (handles .bat/.exe on Windows)
 	toolDir := filepath.Join(f.Root, "versions", "1.21.0", "gopath", "bin")
-	if utils.FileNotExists(filepath.Join(toolDir, "gopls")) {
-		t.Error("gopls not created in ToolScenario")
+	if _, err := utils.FindExecutable(toolDir, "gopls"); err != nil {
+		t.Errorf("gopls not created in ToolScenario: %v", err)
 	}
-	if utils.FileNotExists(filepath.Join(toolDir, "staticcheck")) {
-		t.Error("staticcheck not created in ToolScenario")
+	if _, err := utils.FindExecutable(toolDir, "staticcheck"); err != nil {
+		t.Errorf("staticcheck not created in ToolScenario: %v", err)
 	}
 }
 
@@ -247,19 +261,19 @@ func TestVersionBuilder(t *testing.T) {
 		WithGoMod().
 		Build()
 
-	// Verify binaries
+	// Verify binaries using FindExecutable (handles .bat/.exe on Windows)
 	binDir := filepath.Join(f.Root, "versions", "1.21.0", "bin")
-	if utils.FileNotExists(filepath.Join(binDir, "go")) {
-		t.Error("go binary not created")
+	if _, err := utils.FindExecutable(binDir, "go"); err != nil {
+		t.Errorf("go binary not created: %v", err)
 	}
-	if utils.FileNotExists(filepath.Join(binDir, "gofmt")) {
-		t.Error("gofmt binary not created")
+	if _, err := utils.FindExecutable(binDir, "gofmt"); err != nil {
+		t.Errorf("gofmt binary not created: %v", err)
 	}
 
-	// Verify tools
+	// Verify tools using FindExecutable (handles .bat/.exe on Windows)
 	toolDir := filepath.Join(f.Root, "versions", "1.21.0", "gopath", "bin")
-	if utils.FileNotExists(filepath.Join(toolDir, "gopls")) {
-		t.Error("gopls tool not created")
+	if _, err := utils.FindExecutable(toolDir, "gopls"); err != nil {
+		t.Errorf("gopls tool not created: %v", err)
 	}
 
 	// Verify pkg directory
@@ -291,14 +305,14 @@ func TestScenarioBuilder(t *testing.T) {
 	// Local should override global
 	f.AssertCurrentVersion("1.22.0")
 
-	// Verify tools
+	// Verify tools using FindExecutable (handles .bat/.exe on Windows)
 	toolDir1 := filepath.Join(f.Root, "versions", "1.21.0", "gopath", "bin")
-	if utils.FileNotExists(filepath.Join(toolDir1, "gopls")) {
-		t.Error("gopls not created for 1.21.0")
+	if _, err := utils.FindExecutable(toolDir1, "gopls"); err != nil {
+		t.Errorf("gopls not created for 1.21.0: %v", err)
 	}
 
 	toolDir2 := filepath.Join(f.Root, "versions", "1.22.0", "gopath", "bin")
-	if utils.FileNotExists(filepath.Join(toolDir2, "staticcheck")) {
-		t.Error("staticcheck not created for 1.22.0")
+	if _, err := utils.FindExecutable(toolDir2, "staticcheck"); err != nil {
+		t.Errorf("staticcheck not created for 1.22.0: %v", err)
 	}
 }

internal/shell/profile/profile_test.go

@@ -58,6 +58,11 @@ func TestHasGoenvInit(t *testing.T) {
 }
 
 func TestGetProfile(t *testing.T) {
+	// This test is Unix-specific (tests .bashrc)
+	if utils.IsWindows() {
+		t.Skip("Skipping Unix shell profile test on Windows")
+	}
+
 	// Create temporary test directory
 	tmpDir := t.TempDir()
 	home := filepath.Join(tmpDir, "home")
@@ -147,6 +152,11 @@ func TestDetectPathResets(t *testing.T) {
 }
 
 func TestGetAllProfiles(t *testing.T) {
+	// This test is Unix-specific (tests .zshrc, .zprofile)
+	if utils.IsWindows() {
+		t.Skip("Skipping Unix shell profile test on Windows")
+	}
+
 	// Create temporary test directory
 	tmpDir := t.TempDir()
 	home := filepath.Join(tmpDir, "home")