Enhance macOS support in createCommandWithEnhancedPath and add related tests

Author: cx-amol-mane

internal/services/realtimeengine/iacrealtime/constants.go

@@ -15,6 +15,9 @@ const (
 
 	// engineVerifyTimeout is the timeout in seconds for verifying container engine availability
 	engineVerifyTimeout = 5
+
+	// OS constants
+	osLinux = "linux"
 )
 
 // macOSDockerFallbackPaths contains additional paths to check for Docker on macOS

internal/services/realtimeengine/iacrealtime/container-manager.go

@@ -4,7 +4,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
 	"strings"
 
 	"github.com/checkmarx/ast-cli/internal/commands/util"
@@ -44,7 +43,7 @@ func createCommandWithEnhancedPath(enginePath string, args ...string) *exec.Cmd
 	cmd := exec.Command(enginePath, args...)
 
 	// Only enhance PATH on macOS
-	if runtime.GOOS != osDarwin {
+	if getOS() != osDarwin {
 		return cmd
 	}
 

internal/services/realtimeengine/iacrealtime/container-manager_test.go

@@ -1,7 +1,9 @@
 package iacrealtime
 
 import (
+	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -544,3 +546,133 @@ func TestCreateCommandWithEnhancedPath_EnvIsSet(t *testing.T) {
 		}
 	}
 }
+
+// ============================================================================
+// Tests for createCommandWithEnhancedPath on macOS (mocked)
+// ============================================================================
+
+func TestCreateCommandWithEnhancedPath_MacOS_EnhancesPath(t *testing.T) {
+	// Mock OS to be macOS
+	origGOOS := getOS
+	defer func() { getOS = origGOOS }()
+	getOS = func() string { return osDarwin }
+
+	// Create a temp directory that exists (to be added to PATH)
+	tempDir := t.TempDir()
+	enginePath := filepath.Join(tempDir, "docker")
+
+	cmd := createCommandWithEnhancedPath(enginePath, "run", "--rm")
+
+	if cmd == nil {
+		t.Fatal("createCommandWithEnhancedPath should not return nil")
+	}
+
+	// On macOS, Env should be set
+	if cmd.Env == nil {
+		t.Error("On macOS, cmd.Env should be set with enhanced PATH")
+	}
+
+	// Verify PATH is in the environment
+	foundPath := false
+	for _, e := range cmd.Env {
+		if strings.HasPrefix(e, "PATH=") {
+			foundPath = true
+			// Verify the engine directory is in the PATH
+			if !strings.Contains(e, tempDir) {
+				t.Errorf("Enhanced PATH should contain engine directory %s, got %s", tempDir, e)
+			}
+			break
+		}
+	}
+	if !foundPath {
+		t.Error("Enhanced PATH should contain PATH= entry")
+	}
+}
+
+func TestCreateCommandWithEnhancedPath_MacOS_AddsDockerPaths(t *testing.T) {
+	// Mock OS to be macOS
+	origGOOS := getOS
+	defer func() { getOS = origGOOS }()
+	getOS = func() string { return osDarwin }
+
+	cmd := createCommandWithEnhancedPath("/usr/local/bin/docker", "--version")
+
+	if cmd == nil {
+		t.Fatal("createCommandWithEnhancedPath should not return nil")
+	}
+
+	// On macOS, Env should be set
+	if cmd.Env == nil {
+		t.Error("On macOS, cmd.Env should be set")
+	}
+}
+
+func TestCreateCommandWithEnhancedPath_MacOS_DeduplicatesPaths(t *testing.T) {
+	// Mock OS to be macOS
+	origGOOS := getOS
+	defer func() { getOS = origGOOS }()
+	getOS = func() string { return osDarwin }
+
+	// Set PATH to include one of the fallback paths
+	oldPath := os.Getenv("PATH")
+	defer func() { _ = os.Setenv("PATH", oldPath) }()
+	_ = os.Setenv("PATH", "/usr/local/bin:/usr/bin")
+
+	cmd := createCommandWithEnhancedPath("/usr/local/bin/docker", "--version")
+
+	if cmd == nil {
+		t.Fatal("createCommandWithEnhancedPath should not return nil")
+	}
+
+	// Verify PATH doesn't have duplicates
+	for _, e := range cmd.Env {
+		if strings.HasPrefix(e, "PATH=") {
+			pathValue := strings.TrimPrefix(e, "PATH=")
+			parts := strings.Split(pathValue, string(os.PathListSeparator))
+			seen := make(map[string]int)
+			for _, p := range parts {
+				seen[p]++
+				if seen[p] > 1 {
+					t.Errorf("PATH contains duplicate entry: %s", p)
+				}
+			}
+			break
+		}
+	}
+}
+
+func TestCreateCommandWithEnhancedPath_NonMacOS_NoEnhancement(t *testing.T) {
+	// Mock OS to be Linux
+	origGOOS := getOS
+	defer func() { getOS = origGOOS }()
+	getOS = func() string { return osLinux }
+
+	cmd := createCommandWithEnhancedPath("/usr/bin/docker", "run")
+
+	if cmd == nil {
+		t.Fatal("createCommandWithEnhancedPath should not return nil")
+	}
+
+	// On non-macOS, Env should be nil (uses parent environment)
+	if cmd.Env != nil {
+		t.Error("On non-macOS, cmd.Env should be nil")
+	}
+}
+
+func TestCreateCommandWithEnhancedPath_Windows_NoEnhancement(t *testing.T) {
+	// Mock OS to be Windows
+	origGOOS := getOS
+	defer func() { getOS = origGOOS }()
+	getOS = func() string { return osWindows }
+
+	cmd := createCommandWithEnhancedPath("C:\\Program Files\\Docker\\docker.exe", "run")
+
+	if cmd == nil {
+		t.Fatal("createCommandWithEnhancedPath should not return nil")
+	}
+
+	// On Windows, Env should be nil (uses parent environment)
+	if cmd.Env != nil {
+		t.Error("On Windows, cmd.Env should be nil")
+	}
+}

internal/services/realtimeengine/iacrealtime/iac-realtime_test.go

@@ -600,7 +600,7 @@ func TestGetFallbackPaths_Podman_Darwin(t *testing.T) {
 func TestGetFallbackPaths_NonDarwin(t *testing.T) {
 	origGOOS := getOS
 	defer func() { getOS = origGOOS }()
-	getOS = func() string { return "linux" }
+	getOS = func() string { return osLinux }
 
 	fallbackDir := testFallbackDir
 	paths := getFallbackPaths(engineDocker, fallbackDir)
@@ -778,7 +778,7 @@ func TestGetFallbackPaths_PrimaryPathFirst(t *testing.T) {
 func TestGetFallbackPaths_EmptyFallbackDir(t *testing.T) {
 	origGOOS := getOS
 	defer func() { getOS = origGOOS }()
-	getOS = func() string { return "linux" }
+	getOS = func() string { return osLinux }
 
 	paths := getFallbackPaths(engineDocker, "")
 
@@ -876,7 +876,7 @@ func TestEngineNameResolution_FallbackPathsChecked(t *testing.T) {
 
 	origGOOS := getOS
 	defer func() { getOS = origGOOS }()
-	getOS = func() string { return "linux" }
+	getOS = func() string { return osLinux }
 
 	// Save and clear PATH
 	oldPath := os.Getenv("PATH")
@@ -899,7 +899,7 @@ func TestEngineNameResolution_FallbackPathsChecked(t *testing.T) {
 func TestEngineNameResolution_EmptyEngineName(t *testing.T) {
 	origGOOS := getOS
 	defer func() { getOS = origGOOS }()
-	getOS = func() string { return "linux" }
+	getOS = func() string { return osLinux }
 
 	// Save and clear PATH
 	oldPath := os.Getenv("PATH")
@@ -1079,3 +1079,129 @@ func TestFilterIgnoredFindings_PreservesOrder(t *testing.T) {
 		}
 	}
 }
+
+// ============================================================================
+// Tests for loadIgnoredIacFindings function
+// ============================================================================
+
+func TestLoadIgnoredIacFindings_ValidFile(t *testing.T) {
+	tempDir := t.TempDir()
+	testFile := filepath.Join(tempDir, "ignored.json")
+
+	// Create valid JSON file
+	content := `[
+		{"title": "Finding1", "similarityId": "id1"},
+		{"title": "Finding2", "similarityId": "id2"}
+	]`
+	err := os.WriteFile(testFile, []byte(content), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	findings, err := loadIgnoredIacFindings(testFile)
+
+	if err != nil {
+		t.Errorf("Expected no error, got %v", err)
+	}
+
+	if len(findings) != 2 {
+		t.Errorf("Expected 2 findings, got %d", len(findings))
+	}
+
+	if findings[0].Title != "Finding1" || findings[0].SimilarityID != "id1" {
+		t.Errorf("First finding mismatch: %+v", findings[0])
+	}
+}
+
+func TestLoadIgnoredIacFindings_EmptyArray(t *testing.T) {
+	tempDir := t.TempDir()
+	testFile := filepath.Join(tempDir, "ignored.json")
+
+	err := os.WriteFile(testFile, []byte("[]"), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	findings, err := loadIgnoredIacFindings(testFile)
+
+	if err != nil {
+		t.Errorf("Expected no error, got %v", err)
+	}
+
+	if len(findings) != 0 {
+		t.Errorf("Expected 0 findings, got %d", len(findings))
+	}
+}
+
+func TestLoadIgnoredIacFindings_InvalidJSON(t *testing.T) {
+	tempDir := t.TempDir()
+	testFile := filepath.Join(tempDir, "ignored.json")
+
+	err := os.WriteFile(testFile, []byte("not valid json"), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	_, err = loadIgnoredIacFindings(testFile)
+
+	if err == nil {
+		t.Error("Expected error for invalid JSON, got nil")
+	}
+}
+
+func TestLoadIgnoredIacFindings_FileNotFound(t *testing.T) {
+	_, err := loadIgnoredIacFindings("/non/existent/file.json")
+
+	if err == nil {
+		t.Error("Expected error for non-existent file, got nil")
+	}
+}
+
+func TestLoadIgnoredIacFindings_EmptyFile(t *testing.T) {
+	tempDir := t.TempDir()
+	testFile := filepath.Join(tempDir, "ignored.json")
+
+	err := os.WriteFile(testFile, []byte(""), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	_, err = loadIgnoredIacFindings(testFile)
+
+	if err == nil {
+		t.Error("Expected error for empty file, got nil")
+	}
+}
+
+// ============================================================================
+// Additional tests for verifyEnginePath function - testing with real executable
+// ============================================================================
+
+func TestVerifyEnginePath_DirectoryInsteadOfFile(t *testing.T) {
+	tempDir := t.TempDir()
+
+	result := verifyEnginePath(tempDir)
+	if result {
+		t.Error("verifyEnginePath should return false for directory path")
+	}
+}
+
+func TestVerifyEnginePath_ValidSystemExecutable(t *testing.T) {
+	// Test with a known system executable
+	var execPath string
+	if runtime.GOOS == osWindows {
+		execPath = "C:\\Windows\\System32\\cmd.exe"
+	} else {
+		execPath = "/bin/sh"
+	}
+
+	// Check if the executable exists first
+	if _, err := os.Stat(execPath); err != nil {
+		t.Skipf("System executable not found: %s", execPath)
+	}
+
+	result := verifyEnginePath(execPath)
+	if !result {
+		t.Errorf("verifyEnginePath should return true for valid executable: %s", execPath)
+	}
+}