fixed test modules and files

Author: gcclinux

go.mod

@@ -7,6 +7,7 @@ require (
 	github.com/charmbracelet/bubbletea v1.3.10
 	github.com/charmbracelet/lipgloss v1.1.0
 	github.com/leanovate/gopter v0.2.11
+	pgregory.net/rapid v1.2.0
 )
 
 require (
@@ -27,5 +28,4 @@ require (
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/sys v0.36.0 // indirect
 	golang.org/x/text v0.8.0 // indirect
-	pgregory.net/rapid v1.2.0 // indirect
 )

internal/installer/installer_test.go

@@ -50,8 +50,8 @@ func TestGetGoInstallCommand(t *testing.T) {
 			t.Errorf("Unexpected command: %s", command)
 		}
 	case "linux":
-		if packageManager != "manual" {
-			t.Errorf("Expected manual on Linux, got %s", packageManager)
+		if packageManager != "direct" {
+			t.Errorf("Expected direct on Linux, got %s", packageManager)
 		}
 	default:
 		t.Logf("Unknown OS: %s", runtime.GOOS)

tests/property/command_execution_properties_test.go

@@ -170,9 +170,9 @@ func TestProperty_ScriptInterpreterSelection(t *testing.T) {
 		func(filename string) bool {
 			ce := executor.NewCommandExecutor()
 			scriptPath := filename + ".sh"
-			
+
 			interpreter := ce.GetInterpreter(scriptPath)
-			
+
 			// On Windows, .sh files should use "sh"
 			// On Unix systems, .sh files should use "bash"
 			if runtime.GOOS == "windows" {
@@ -187,9 +187,9 @@ func TestProperty_ScriptInterpreterSelection(t *testing.T) {
 		func(filename string) bool {
 			ce := executor.NewCommandExecutor()
 			scriptPath := filename + ".bash"
-			
+
 			interpreter := ce.GetInterpreter(scriptPath)
-			
+
 			return interpreter == "bash"
 		},
 		gen.Identifier(),
@@ -199,9 +199,9 @@ func TestProperty_ScriptInterpreterSelection(t *testing.T) {
 		func(filename string) bool {
 			ce := executor.NewCommandExecutor()
 			scriptPath := filename + ".ps1"
-			
+
 			interpreter := ce.GetInterpreter(scriptPath)
-			
+
 			// On Windows, .ps1 files should use "powershell"
 			// On Unix systems, .ps1 files should use "pwsh" (PowerShell Core)
 			if runtime.GOOS == "windows" {
@@ -215,22 +215,22 @@ func TestProperty_ScriptInterpreterSelection(t *testing.T) {
 	properties.Property("unsupported extensions return empty string", prop.ForAll(
 		func(filename string, ext string) bool {
 			ce := executor.NewCommandExecutor()
-			
-			// Use extensions that are not .sh, .bash, or .ps1
+
+			// Use extensions that are not supported script runners
 			scriptPath := filename + "." + ext
-			
+
 			interpreter := ce.GetInterpreter(scriptPath)
-			
+
 			return interpreter == ""
 		},
 		gen.Identifier(),
-		gen.OneConstOf("txt", "py", "js", "go", "md", "json", "xml"),
+		gen.OneConstOf("txt", "js", "md", "json", "xml", "html"),
 	))
 
 	properties.Property("case insensitive extension matching", prop.ForAll(
 		func(filename string, caseVariant int) bool {
 			ce := executor.NewCommandExecutor()
-			
+
 			// Test different case variants of .sh extension
 			var scriptPath string
 			switch caseVariant % 4 {
@@ -243,9 +243,9 @@ func TestProperty_ScriptInterpreterSelection(t *testing.T) {
 			case 3:
 				scriptPath = filename + ".sH"
 			}
-			
+
 			interpreter := ce.GetInterpreter(scriptPath)
-			
+
 			// Should still recognize the extension regardless of case
 			if runtime.GOOS == "windows" {
 				return interpreter == "sh"
@@ -259,12 +259,12 @@ func TestProperty_ScriptInterpreterSelection(t *testing.T) {
 	properties.Property("paths with directories handled correctly", prop.ForAll(
 		func(dir string, filename string, ext string) bool {
 			ce := executor.NewCommandExecutor()
-			
+
 			// Create a path with directory components
 			scriptPath := dir + "/" + filename + ext
-			
+
 			interpreter := ce.GetInterpreter(scriptPath)
-			
+
 			// Verify interpreter is selected based on extension, not path
 			switch ext {
 			case ".sh":
@@ -279,13 +279,17 @@ func TestProperty_ScriptInterpreterSelection(t *testing.T) {
 					return interpreter == "powershell"
 				}
 				return interpreter == "pwsh"
+			case ".py":
+				return interpreter == "python3"
+			case ".go":
+				return interpreter == "go"
 			default:
 				return interpreter == ""
 			}
 		},
 		gen.Identifier(),
 		gen.Identifier(),
-		gen.OneConstOf(".sh", ".bash", ".ps1", ".txt", ".py"),
+		gen.OneConstOf(".sh", ".bash", ".ps1", ".txt", ".py", ".go"),
 	))
 
 	properties.TestingRun(t, gopter.ConsoleReporter(false))

tests/unit/commandexecutor_test.go

@@ -14,19 +14,19 @@ func TestCommandExecutor_ExecuteCommand(t *testing.T) {
 	ce := executor.NewCommandExecutor()
 
 	tests := []struct {
-		name         string
-		command      string
-		cwd          string
-		expectError  bool
-		checkStdout  bool
+		name           string
+		command        string
+		cwd            string
+		expectError    bool
+		checkStdout    bool
 		stdoutContains string
 	}{
 		{
-			name:         "simple echo command",
-			command:      "echo hello",
-			cwd:          "",
-			expectError:  false,
-			checkStdout:  true,
+			name:           "simple echo command",
+			command:        "echo hello",
+			cwd:            "",
+			expectError:    false,
+			checkStdout:    true,
 			stdoutContains: "hello",
 		},
 		{
@@ -40,7 +40,7 @@ func TestCommandExecutor_ExecuteCommand(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result, err := ce.ExecuteCommand(tt.command, tt.cwd)
-			
+
 			if (err != nil) != tt.expectError {
 				t.Errorf("ExecuteCommand() error = %v, expectError %v", err, tt.expectError)
 				return
@@ -154,7 +154,7 @@ func TestCommandExecutor_ExecuteCommand_CommandNotFound(t *testing.T) {
 	ce := executor.NewCommandExecutor()
 
 	result, err := ce.ExecuteCommand("nonexistentcommand12345", "")
-	
+
 	// Should return an error because command doesn't exist
 	if err == nil && result != nil && result.ExitCode == 0 {
 		t.Errorf("Expected error or non-zero exit code for non-existent command")
@@ -165,13 +165,13 @@ func TestCommandExecutor_GetInterpreter(t *testing.T) {
 	ce := executor.NewCommandExecutor()
 
 	tests := []struct {
-		name           string
-		scriptPath     string
+		name                string
+		scriptPath          string
 		expectedInterpreter string
 	}{
 		{
-			name:           "bash script with .sh extension",
-			scriptPath:     "script.sh",
+			name:       "bash script with .sh extension",
+			scriptPath: "script.sh",
 			expectedInterpreter: func() string {
 				if runtime.GOOS == "windows" {
 					return "sh"
@@ -180,13 +180,13 @@ func TestCommandExecutor_GetInterpreter(t *testing.T) {
 			}(),
 		},
 		{
-			name:           "bash script with .bash extension",
-			scriptPath:     "script.bash",
+			name:                "bash script with .bash extension",
+			scriptPath:          "script.bash",
 			expectedInterpreter: "bash",
 		},
 		{
-			name:           "PowerShell script",
-			scriptPath:     "script.ps1",
+			name:       "PowerShell script",
+			scriptPath: "script.ps1",
 			expectedInterpreter: func() string {
 				if runtime.GOOS == "windows" {
 					return "powershell"
@@ -195,18 +195,18 @@ func TestCommandExecutor_GetInterpreter(t *testing.T) {
 			}(),
 		},
 		{
-			name:           "unsupported extension",
-			scriptPath:     "script.py",
+			name:                "unsupported extension",
+			scriptPath:          "script.txt",
 			expectedInterpreter: "",
 		},
 		{
-			name:           "no extension",
-			scriptPath:     "script",
+			name:                "no extension",
+			scriptPath:          "script",
 			expectedInterpreter: "",
 		},
 		{
-			name:           "uppercase extension",
-			scriptPath:     "SCRIPT.SH",
+			name:       "uppercase extension",
+			scriptPath: "SCRIPT.SH",
 			expectedInterpreter: func() string {
 				if runtime.GOOS == "windows" {
 					return "sh"
@@ -238,7 +238,7 @@ func TestCommandExecutor_ExecuteScript(t *testing.T) {
 
 		scriptPath := filepath.Join(tmpDir, "test.sh")
 		scriptContent := "#!/bin/bash\necho 'Hello from bash'\nexit 0"
-		
+
 		if err := os.WriteFile(scriptPath, []byte(scriptContent), 0755); err != nil {
 			t.Fatalf("Failed to create test script: %v", err)
 		}
@@ -266,7 +266,7 @@ func TestCommandExecutor_ExecuteScript(t *testing.T) {
 
 		scriptPath := filepath.Join(tmpDir, "fail.sh")
 		scriptContent := "#!/bin/bash\nexit 42"
-		
+
 		if err := os.WriteFile(scriptPath, []byte(scriptContent), 0755); err != nil {
 			t.Fatalf("Failed to create test script: %v", err)
 		}
@@ -283,9 +283,9 @@ func TestCommandExecutor_ExecuteScript(t *testing.T) {
 	})
 
 	t.Run("execute unsupported script type", func(t *testing.T) {
-		scriptPath := filepath.Join(tmpDir, "test.py")
+		scriptPath := filepath.Join(tmpDir, "test.txt")
 		scriptContent := "print('Hello')"
-		
+
 		if err := os.WriteFile(scriptPath, []byte(scriptContent), 0755); err != nil {
 			t.Fatalf("Failed to create test script: %v", err)
 		}
@@ -298,7 +298,7 @@ func TestCommandExecutor_ExecuteScript(t *testing.T) {
 
 	t.Run("execute non-existent script", func(t *testing.T) {
 		scriptPath := filepath.Join(tmpDir, "nonexistent.sh")
-		
+
 		result, err := ce.ExecuteScript(scriptPath)
 		// Either we get an error (script doesn't exist) or non-zero exit code
 		if err == nil && result != nil && result.ExitCode == 0 {
@@ -318,7 +318,7 @@ func TestCommandExecutor_ExecuteScript_StderrCapture(t *testing.T) {
 
 	scriptPath := filepath.Join(tmpDir, "stderr.sh")
 	scriptContent := "#!/bin/bash\necho 'error message' >&2\nexit 1"
-	
+
 	if err := os.WriteFile(scriptPath, []byte(scriptContent), 0755); err != nil {
 		t.Fatalf("Failed to create test script: %v", err)
 	}
@@ -395,7 +395,7 @@ func TestCommandExecutor_CommandNotFoundScenario(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result, err := ce.ExecuteCommand(tt.command, "")
-			
+
 			// Command not found should either return an error or non-zero exit code
 			if err == nil && result != nil {
 				if result.ExitCode == 0 {
@@ -421,12 +421,12 @@ func TestCommandExecutor_PermissionDeniedScenario(t *testing.T) {
 	}
 
 	tmpDir := t.TempDir()
-	
+
 	t.Run("execute non-executable script", func(t *testing.T) {
 		// Create a script without execute permissions
 		scriptPath := filepath.Join(tmpDir, "no_exec.sh")
 		scriptContent := "#!/bin/bash\necho 'This should not run'"
-		
+
 		if err := os.WriteFile(scriptPath, []byte(scriptContent), 0644); err != nil {
 			t.Fatalf("Failed to create test script: %v", err)
 		}
@@ -435,12 +435,12 @@ func TestCommandExecutor_PermissionDeniedScenario(t *testing.T) {
 		// This should fail because the file doesn't have execute permissions
 		cmd := scriptPath
 		result, err := ce.ExecuteCommand(cmd, "")
-		
+
 		// Should fail due to permission denied
 		if err == nil && result != nil && result.ExitCode == 0 {
 			t.Errorf("Expected error or non-zero exit code for non-executable script")
 		}
-		
+
 		// Note: ExecuteScript will still work because it calls bash with the script path
 		// which doesn't require execute permissions on the script file itself
 	})
@@ -456,7 +456,7 @@ func TestCommandExecutor_PermissionDeniedScenario(t *testing.T) {
 		// Try to write to the read-only directory
 		cmd := "touch " + filepath.Join(readOnlyDir, "test.txt")
 		result, err := ce.ExecuteCommand(cmd, "")
-		
+
 		// Should fail due to permission denied
 		if err == nil && result != nil && result.ExitCode == 0 {
 			t.Errorf("Expected error or non-zero exit code for writing to read-only directory")
@@ -474,7 +474,7 @@ func TestCommandExecutor_PermissionDeniedScenario(t *testing.T) {
 		// Try to read the protected file
 		cmd := "cat " + protectedFile
 		result, err := ce.ExecuteCommand(cmd, "")
-		
+
 		// Should fail due to permission denied
 		if err == nil && result != nil && result.ExitCode == 0 {
 			t.Errorf("Expected error or non-zero exit code for reading protected file")