main_test.go

// Copyright 2022 NetApp, Inc. All Rights Reserved.

package main

import (
	"context"
	"flag"
	"io"
	"math"
	"math/rand"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"
	"syscall"
	"testing"
	"time"

	log "github.com/sirupsen/logrus"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"k8s.io/utils/pointer"

	"github.com/netapp/trident/config"
)

func TestMain(m *testing.M) {
	// Disable any standard log output
	log.SetOutput(io.Discard)
	os.Exit(m.Run())
}

func TestControllerRestURL(t *testing.T) {
	testCases := []struct {
		name     string
		host     string
		port     string
		expected string
	}{
		{
			name:     "IPv6 address",
			host:     "2001:db8::1",
			port:     "34571",
			expected: "https://[2001:db8::1]:34571",
		},
		{
			name:     "IPv4 address",
			host:     "192.0.2.10",
			port:     "34571",
			expected: "https://192.0.2.10:34571",
		},
		{
			name:     "DNS name",
			host:     "trident-csi",
			port:     "34571",
			expected: "https://trident-csi:34571",
		},
		{
			name:     "defaults",
			expected: "https://trident-csi:34571",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Setenv("TRIDENT_CSI_SERVICE_HOST", tc.host)
			t.Setenv("TRIDENT_CSI_SERVICE_PORT", tc.port)
			assert.Equal(t, tc.expected, controllerRestURL())
		})
	}
}

func TestMain_processCommandLineArgs_QPS(t *testing.T) {
	type parameters struct {
		k8sApiQPS         float64
		expectedK8sApiQPS float32
	}

	tests := map[string]parameters{
		"QPS is set to 100.0": {
			k8sApiQPS:         100.0,
			expectedK8sApiQPS: 100.0,
		},
		"QPS is set to maxFloat32": {
			k8sApiQPS:         math.MaxFloat32,
			expectedK8sApiQPS: math.MaxFloat32,
		},
		"QPS is set to maxFloat64 + 1": {
			k8sApiQPS:         math.MaxFloat64 + 1,
			expectedK8sApiQPS: config.DefaultK8sAPIQPS,
		},
	}

	for name, params := range tests {
		t.Run(name, func(t *testing.T) {
			csiEndpoint = pointer.String("true")
			useInMemory = pointer.Bool(true)
			k8sApiQPS = &params.k8sApiQPS
			processCmdLineArgs(context.TODO())

			assert.Equal(t, params.expectedK8sApiQPS, config.K8sAPIQPS)
		})
	}
}

func TestMain_processCommandLineArgs_TagriTimeout(t *testing.T) {
	originalTagriTimeout := tagriTimeout
	originalConfigTagriTimeout := config.TagriTimeout
	defer func() {
		tagriTimeout = originalTagriTimeout
		config.TagriTimeout = originalConfigTagriTimeout
	}()

	tests := []struct {
		name             string
		tagriTimeoutSecs int
		expectedDuration time.Duration
	}{
		{
			name:             "default tagri_timeout (5 minutes)",
			tagriTimeoutSecs: 300,
			expectedDuration: 300 * time.Second,
		},
		{
			name:             "custom tagri_timeout (10 minutes)",
			tagriTimeoutSecs: 600,
			expectedDuration: 600 * time.Second,
		},
		{
			name:             "custom tagri_timeout (1 minute)",
			tagriTimeoutSecs: 60,
			expectedDuration: 60 * time.Second,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tagriTimeout = new(time.Duration(tt.tagriTimeoutSecs) * time.Second)
			csiEndpoint = pointer.String("true")
			useInMemory = pointer.Bool(true)
			k8sApiQPS = pointer.Float64(config.DefaultK8sAPIQPS)
			k8sApiBurst = pointer.Int(config.DefaultK8sAPIBurst)

			processCmdLineArgs(context.TODO())

			assert.Equal(t, tt.expectedDuration, config.TagriTimeout,
				"config.TagriTimeout should be set from --tagri_timeout flag")
		})
	}
}

func TestGetenvAsPointerToBool(t *testing.T) {
	ctx := context.Background()
	testKey := "TEST_BOOL_VAR"

	// Clean up environment variable before and after test
	defer func() {
		os.Unsetenv(testKey)
	}()

	tests := []struct {
		name        string
		envValue    string
		setEnv      bool
		expected    bool
		description string
	}{
		{
			name:        "Environment variable not set",
			setEnv:      false,
			expected:    false,
			description: "Should return false when environment variable is not set",
		},
		{
			name:        "Environment variable set to empty string",
			envValue:    "",
			setEnv:      true,
			expected:    false,
			description: "Should return false when environment variable is empty",
		},
		{
			name:        "Environment variable set to 'true'",
			envValue:    "true",
			setEnv:      true,
			expected:    true,
			description: "Should return true when environment variable is 'true'",
		},
		{
			name:        "Environment variable set to 'TRUE'",
			envValue:    "TRUE",
			setEnv:      true,
			expected:    true,
			description: "Should return true when environment variable is 'TRUE' (case insensitive)",
		},
		{
			name:        "Environment variable set to 'True'",
			envValue:    "True",
			setEnv:      true,
			expected:    true,
			description: "Should return true when environment variable is 'True' (mixed case)",
		},
		{
			name:        "Environment variable set to 'false'",
			envValue:    "false",
			setEnv:      true,
			expected:    false,
			description: "Should return false when environment variable is 'false'",
		},
		{
			name:        "Environment variable set to 'FALSE'",
			envValue:    "FALSE",
			setEnv:      true,
			expected:    false,
			description: "Should return false when environment variable is 'FALSE'",
		},
		{
			name:        "Environment variable set to random string",
			envValue:    "random",
			setEnv:      true,
			expected:    false,
			description: "Should return false when environment variable is not 'true'",
		},
		{
			name:        "Environment variable set to '1'",
			envValue:    "1",
			setEnv:      true,
			expected:    false,
			description: "Should return false when environment variable is '1' (not 'true')",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Clean up before each test
			os.Unsetenv(testKey)

			if tt.setEnv {
				os.Setenv(testKey, tt.envValue)
			}

			result := getenvAsPointerToBool(ctx, testKey)
			require.NotNil(t, result, "Result should not be nil")
			assert.Equal(t, tt.expected, *result, tt.description)
		})
	}
}

func TestEnsureDockerPluginExecPath(t *testing.T) {
	ctx := context.Background()
	originalPath := os.Getenv("PATH")

	// Restore original PATH after test
	defer func() {
		os.Setenv("PATH", originalPath)
	}()

	tests := []struct {
		name        string
		initialPath string
		expected    string
		description string
	}{
		{
			name:        "PATH does not contain /netapp",
			initialPath: "/usr/bin:/bin:/usr/local/bin",
			expected:    "/netapp:/usr/bin:/bin:/usr/local/bin",
			description: "Should prepend /netapp to PATH when not present",
		},
		{
			name:        "PATH already contains /netapp at the beginning",
			initialPath: "/netapp:/usr/bin:/bin",
			expected:    "/netapp:/usr/bin:/bin",
			description: "Should not modify PATH when /netapp is already present",
		},
		{
			name:        "PATH contains /netapp in the middle",
			initialPath: "/usr/bin:/netapp:/bin",
			expected:    "/usr/bin:/netapp:/bin",
			description: "Should not modify PATH when /netapp is already present in middle",
		},
		{
			name:        "PATH contains /netapp at the end",
			initialPath: "/usr/bin:/bin:/netapp",
			expected:    "/usr/bin:/bin:/netapp",
			description: "Should not modify PATH when /netapp is already present at end",
		},
		{
			name:        "Empty PATH",
			initialPath: "",
			expected:    "/netapp:",
			description: "Should prepend /netapp to empty PATH",
		},
		{
			name:        "PATH with similar but different paths",
			initialPath: "/usr/bin:/bin:/opt/netapp/bin",
			expected:    "/usr/bin:/bin:/opt/netapp/bin",
			description: "Should not modify PATH when /netapp is already present in another path",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set initial PATH
			os.Setenv("PATH", tt.initialPath)

			// Call the function
			ensureDockerPluginExecPath(ctx)

			// Check the result
			actualPath := os.Getenv("PATH")
			assert.Equal(t, tt.expected, actualPath, tt.description)
		})
	}
}

func TestProcessDockerPluginArgs(t *testing.T) {
	ctx := context.Background()

	// Save original values
	originalEnableREST := enableREST
	originalConfigPath := configPath
	originalPath := os.Getenv("PATH")

	defer func() {
		// Restore original values
		enableREST = originalEnableREST
		configPath = originalConfigPath
		os.Setenv("PATH", originalPath)
		os.Unsetenv(config.DockerPluginModeEnvVariable)
		os.Unsetenv("rest")
		os.Unsetenv("config")
	}()

	t.Run("Not in docker plugin mode", func(t *testing.T) {
		// Ensure we're not in docker plugin mode
		os.Unsetenv(config.DockerPluginModeEnvVariable)

		err := processDockerPluginArgs(ctx)
		assert.NoError(t, err, "Should return no error when not in docker plugin mode")
	})

	t.Run("Docker plugin mode with rest environment variable true", func(t *testing.T) {
		os.Setenv(config.DockerPluginModeEnvVariable, "1")
		os.Setenv("rest", "true")

		err := processDockerPluginArgs(ctx)
		assert.NoError(t, err, "Should return no error when processing valid docker plugin args")
		assert.True(t, *enableREST, "enableREST should be set to true")
	})

	t.Run("Docker plugin mode with rest environment variable false", func(t *testing.T) {
		os.Setenv(config.DockerPluginModeEnvVariable, "1")
		os.Setenv("rest", "false")

		err := processDockerPluginArgs(ctx)
		assert.NoError(t, err, "Should return no error when processing valid docker plugin args")
		assert.False(t, *enableREST, "enableREST should be set to false")
	})

	t.Run("Docker plugin mode with rest environment variable empty", func(t *testing.T) {
		os.Setenv(config.DockerPluginModeEnvVariable, "1")
		os.Setenv("rest", "")

		err := processDockerPluginArgs(ctx)
		assert.NoError(t, err, "Should return no error when processing valid docker plugin args")
		assert.False(t, *enableREST, "enableREST should be set to false when rest env var is empty")
	})

	t.Run("Docker plugin mode with non-existent config file", func(t *testing.T) {
		os.Setenv(config.DockerPluginModeEnvVariable, "1")
		os.Setenv("config", "/non/existent/config.json")

		err := processDockerPluginArgs(ctx)
		assert.Error(t, err, "Should return error when config file does not exist")
		assert.Contains(t, err.Error(), "does not exist", "Error should mention file does not exist")
	})

	t.Run("Docker plugin mode ensures PATH contains /netapp", func(t *testing.T) {
		// Set a PATH that doesn't contain /netapp
		initialPath := "/usr/bin:/bin"
		os.Setenv("PATH", initialPath)
		os.Setenv(config.DockerPluginModeEnvVariable, "1")
		// Explicitly unset config env var to avoid config file validation
		os.Unsetenv("config")

		err := processDockerPluginArgs(ctx)
		assert.NoError(t, err, "Should return no error")

		updatedPath := os.Getenv("PATH")
		assert.True(t, strings.Contains(updatedPath, "/netapp"), "PATH should contain /netapp after processing docker plugin args")
	})
}

func TestProcessDockerPluginArgsWithMocking(t *testing.T) {
	ctx := context.Background()

	// Save original values
	originalEnableREST := enableREST
	originalConfigPath := configPath
	originalPath := os.Getenv("PATH")

	defer func() {
		// Restore original values
		enableREST = originalEnableREST
		configPath = originalConfigPath
		os.Setenv("PATH", originalPath)
		os.Unsetenv(config.DockerPluginModeEnvVariable)
		os.Unsetenv("rest")
		os.Unsetenv("config")
	}()

	t.Run("Docker plugin mode with config file in plugin location", func(t *testing.T) {
		os.Setenv(config.DockerPluginModeEnvVariable, "1")

		// Create a config file with absolute path that starts with the plugin location
		tempConfig := filepath.Join(config.DockerPluginConfigLocation, "test-config.json")
		// Set config env to absolute path that includes plugin location
		os.Setenv("config", tempConfig)

		err := processDockerPluginArgs(ctx)
		// This will fail because the file doesn't actually exist, but we'll get the right error
		assert.Error(t, err, "Should return error for non-existent file")
		assert.Contains(t, err.Error(), "does not exist", "Should be 'does not exist' error")
	})

	t.Run("Docker plugin mode with permission denied error", func(t *testing.T) {
		os.Setenv(config.DockerPluginModeEnvVariable, "1")

		// Just test with a nonexistent file path that doesn't trigger the specific "does not exist" logic
		// The function checks !strings.HasPrefix(configFile, config.DockerPluginConfigLocation)
		// So we'll use an absolute path to bypass that logic and test the stat error path
		nonExistentFile := "/tmp/nonexistent_test_config_dir_12345/config.json"
		os.Setenv("config", nonExistentFile)

		err := processDockerPluginArgs(ctx)
		assert.Error(t, err, "Should return error for nonexistent file")
		assert.Contains(t, err.Error(), "does not exist", "Should be 'does not exist' error for this path")
	})
}

func TestPrintFlag(t *testing.T) {
	tests := []struct {
		name        string
		flagName    string
		flagValue   string
		description string
	}{
		{
			name:        "String flag",
			flagName:    "test-string",
			flagValue:   "test-value",
			description: "Should call printFlag without error",
		},
		{
			name:        "Boolean flag",
			flagName:    "test-bool",
			flagValue:   "true",
			description: "Should call printFlag without error",
		},
		{
			name:        "Empty value flag",
			flagName:    "test-empty",
			flagValue:   "",
			description: "Should call printFlag without error",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Create a flag for testing
			testFlag := &flag.Flag{
				Name:  tt.flagName,
				Value: &testFlagValue{value: tt.flagValue},
			}

			// Call printFlag - this should not panic or error
			assert.NotPanics(t, func() {
				printFlag(testFlag)
			}, "printFlag should not panic")
		})
	}
}

// testFlagValue is a helper struct to mock flag.Value interface for testing
type testFlagValue struct {
	value string
}

func (t *testFlagValue) String() string {
	return t.value
}

func (t *testFlagValue) Set(s string) error {
	t.value = s
	return nil
}

func TestMain_processCommandLineArgs_Comprehensive(t *testing.T) {
	// Save original values
	originalStoreClient := storeClient
	originalUseInMemory := useInMemory
	originalUsePassthrough := usePassthrough
	originalUseCRD := useCRD
	originalCsiEndpoint := csiEndpoint
	originalConfigPath := configPath
	originalDockerPluginMode := dockerPluginMode
	originalK8sApiQPS := k8sApiQPS
	originalK8sApiBurst := k8sApiBurst

	defer func() {
		// Restore original values
		storeClient = originalStoreClient
		useInMemory = originalUseInMemory
		usePassthrough = originalUsePassthrough
		useCRD = originalUseCRD
		csiEndpoint = originalCsiEndpoint
		configPath = originalConfigPath
		dockerPluginMode = originalDockerPluginMode
		k8sApiQPS = originalK8sApiQPS
		k8sApiBurst = originalK8sApiBurst
	}()

	tests := []struct {
		name                 string
		setupFunc            func()
		expectedK8sQPS       float32
		expectedK8sBurst     int
		expectedEnableCSI    bool
		expectedEnableDocker bool
		description          string
	}{
		{
			name: "CSI frontend with in-memory store",
			setupFunc: func() {
				csiEndpoint = pointer.String("/tmp/csi.sock")
				useInMemory = pointer.Bool(true)
				usePassthrough = pointer.Bool(false)
				useCRD = pointer.Bool(false)
				k8sApiQPS = pointer.Float64(50.0)
				k8sApiBurst = pointer.Int(100)
			},
			expectedK8sQPS:       50.0,
			expectedK8sBurst:     100,
			expectedEnableCSI:    true,
			expectedEnableDocker: false,
			description:          "Should configure CSI frontend with in-memory store",
		},
		{
			name: "In-memory store only (for testing)",
			setupFunc: func() {
				csiEndpoint = pointer.String("")
				dockerPluginMode = pointer.Bool(false)
				configPath = pointer.String("")
				useInMemory = pointer.Bool(true)
				usePassthrough = pointer.Bool(false)
				useCRD = pointer.Bool(false)
				k8sApiQPS = pointer.Float64(config.DefaultK8sAPIQPS)
				k8sApiBurst = pointer.Int(config.DefaultK8sAPIBurst)
			},
			expectedK8sQPS:       config.DefaultK8sAPIQPS,
			expectedK8sBurst:     config.DefaultK8sAPIBurst,
			expectedEnableCSI:    false,
			expectedEnableDocker: false,
			description:          "Should configure in-memory store for testing",
		},
		{
			name: "K8s API Burst configuration",
			setupFunc: func() {
				csiEndpoint = pointer.String("/tmp/csi.sock")
				useInMemory = pointer.Bool(true)
				k8sApiQPS = pointer.Float64(75.5)
				k8sApiBurst = pointer.Int(150)
			},
			expectedK8sQPS:       75.5,
			expectedK8sBurst:     150,
			expectedEnableCSI:    true,
			expectedEnableDocker: false,
			description:          "Should properly configure K8s API burst settings",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Reset to defaults
			config.K8sAPIQPS = config.DefaultK8sAPIQPS
			config.K8sAPIBurst = config.DefaultK8sAPIBurst
			storeClient = nil

			// Setup test conditions
			tt.setupFunc()

			// Call the function
			processCmdLineArgs(context.Background())

			// Verify K8s API settings
			assert.Equal(t, tt.expectedK8sQPS, config.K8sAPIQPS, "K8s API QPS should match expected value")
			assert.Equal(t, tt.expectedK8sBurst, config.K8sAPIBurst, "K8s API Burst should match expected value")

			// Verify frontend configuration
			actualEnableCSI := *csiEndpoint != ""
			actualEnableDocker := (*dockerPluginMode || *configPath != "") && !actualEnableCSI
			assert.Equal(t, tt.expectedEnableCSI, actualEnableCSI, "CSI enablement should match expected")
			assert.Equal(t, tt.expectedEnableDocker, actualEnableDocker, "Docker enablement should match expected")

			// Verify store client is created
			assert.NotNil(t, storeClient, "Store client should be created")

			// For in-memory store, we can verify UsingPassthroughStore is false
			assert.False(t, config.UsingPassthroughStore, "Should not be using passthrough store for in-memory")
		})
	}
}

func TestMainFunction(t *testing.T) {
	// Test the main function by running it as a subprocess
	// This is the standard way to test main functions that call os.Exit()

	if os.Getenv("TEST_MAIN_FUNCTION") == "1" {
		// This block runs in the subprocess
		// Set up minimal valid configuration to avoid immediate exit

		// Reset command line args to minimal set
		os.Args = []string{"trident", "--no_persistence", "--csi_endpoint=/tmp/test.sock", "--csi_node_name=test-node", "--csi_role=node"}

		// Set required environment to avoid early exits
		os.Setenv("PATH", "/usr/bin:/bin")

		// Override global variables for testing
		useInMemory = pointer.Bool(true)
		csiEndpoint = pointer.String("/tmp/test.sock")
		csiNodeName = pointer.String("test-node")
		csiRole = pointer.String("node")
		enableREST = pointer.Bool(false)
		enableHTTPSREST = pointer.Bool(false)
		enableMetrics = pointer.Bool(false)

		// Call main - this will eventually exit, but we want to test the early initialization
		main()
		return
	}

	tests := []struct {
		name         string
		args         []string
		env          map[string]string
		expectExit   bool
		expectedCode int
		description  string
	}{
		{
			name:         "Invalid log level",
			args:         []string{"trident", "--log_level=invalid", "--no_persistence"},
			env:          map[string]string{},
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 for invalid log level",
		},
		{
			name:         "Invalid log format",
			args:         []string{"trident", "--log_format=invalid", "--no_persistence"},
			env:          map[string]string{},
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 for invalid log format",
		},
		{
			name:         "Help flag",
			args:         []string{"trident", "--help"},
			env:          map[string]string{},
			expectExit:   true,
			expectedCode: 2, // flag package exits with 2 for help
			description:  "Should exit with code 2 for help flag",
		},
		{
			name:         "Version info with minimal config",
			args:         []string{"trident", "--no_persistence"},
			env:          map[string]string{"TEST_MAIN_FUNCTION": "1"},
			expectExit:   true,
			expectedCode: 1, // Will eventually fail trying to create orchestrator, but tests early init
			description:  "Should run early initialization before failing on orchestrator creation",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := exec.Command(os.Args[0], "-test.run=TestMainFunction")
			cmd.Env = append(os.Environ(), "TEST_MAIN_FUNCTION=1")

			// Set custom args through environment
			for k, v := range tt.env {
				cmd.Env = append(cmd.Env, k+"="+v)
			}

			// Set the args for the subprocess
			if len(tt.args) > 1 {
				cmd.Args = append(cmd.Args, tt.args[1:]...)
			}

			err := cmd.Run()

			if tt.expectExit {
				// Check that the process exited with expected code
				if exitError, ok := err.(*exec.ExitError); ok {
					if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
						actualCode := status.ExitStatus()
						if tt.expectedCode != 0 {
							assert.Equal(t, tt.expectedCode, actualCode, tt.description)
						} else {
							assert.NotEqual(t, 0, actualCode, "Process should have exited with non-zero code")
						}
					}
				} else if err == nil && tt.expectedCode == 0 {
					// Process exited successfully
					assert.NoError(t, err, "Process should have exited successfully")
				} else if err != nil {
					// Some other error occurred
					t.Logf("Process exited with error: %v", err)
				}
			} else {
				assert.NoError(t, err, "Process should not have failed")
			}
		})
	}
}

// TestMainFunctionInitialization tests the early initialization parts of main
func TestMainFunctionInitialization(t *testing.T) {
	// Test aspects of main function that can be tested without running the full function

	t.Run("GOMAXPROCS behavior", func(t *testing.T) {
		originalMaxProcs := runtime.GOMAXPROCS(0)  // Get current value
		defer runtime.GOMAXPROCS(originalMaxProcs) // Restore after test

		// Test that GOMAXPROCS is set to number of CPUs
		expectedProcs := runtime.NumCPU()
		actualProcs := runtime.GOMAXPROCS(expectedProcs)

		assert.Equal(t, expectedProcs, runtime.GOMAXPROCS(0), "GOMAXPROCS should be set to number of CPUs")

		// Restore the previous value
		runtime.GOMAXPROCS(actualProcs)
	})

	t.Run("Force detach flag creation on Linux", func(t *testing.T) {
		// This test verifies the OS-specific flag creation logic
		if runtime.GOOS == "linux" {
			// On Linux, enableForceDetach should be available
			assert.NotNil(t, enableForceDetach, "enableForceDetach flag should be created on Linux")
		} else {
			// On non-Linux platforms, enableForceDetach might not be initialized in tests
			// but the logic should handle this gracefully
			t.Logf("Running on %s, force detach flag is Linux-specific", runtime.GOOS)
		}
	})

	t.Run("Docker plugin mode environment setup", func(t *testing.T) {
		originalMode := dockerPluginMode
		originalEnv := os.Getenv("DOCKER_PLUGIN_MODE")

		defer func() {
			dockerPluginMode = originalMode
			if originalEnv == "" {
				os.Unsetenv("DOCKER_PLUGIN_MODE")
			} else {
				os.Setenv("DOCKER_PLUGIN_MODE", originalEnv)
			}
		}()

		// Test docker plugin mode environment variable setting
		dockerPluginMode = pointer.Bool(true)

		// Simulate the logic from main function
		if *dockerPluginMode {
			os.Setenv("DOCKER_PLUGIN_MODE", "1")
		}

		assert.Equal(t, "1", os.Getenv("DOCKER_PLUGIN_MODE"), "Docker plugin mode environment should be set")
	})

	t.Run("Random seed initialization", func(t *testing.T) {
		// Test that random seed can be set without error
		// This simulates the rand.Seed(time.Now().UnixNano()) call in main
		beforeTime := time.Now().UnixNano()
		time.Sleep(1 * time.Millisecond) // Ensure time difference
		afterTime := time.Now().UnixNano()

		assert.True(t, afterTime > beforeTime, "Time should advance for random seed")

		// Test that we can set the seed (this is what main does)
		assert.NotPanics(t, func() {
			rand.Seed(time.Now().UnixNano())
		}, "Setting random seed should not panic")
	})
}

func TestProcessCmdLineArgsErrorPaths(t *testing.T) {
	// Test the error paths in processCmdLineArgs using subprocess testing
	// since the function calls Fatal which exits the process

	if os.Getenv("TEST_PROCESSCMDLINEARGS_ERRORS") == "1" {
		// This block runs in the subprocess
		ctx := context.Background()

		// Set up conditions based on environment variables
		testCase := os.Getenv("TEST_CASE")

		switch testCase {
		case "insufficient_args":
			// No frontends and no in-memory
			csiEndpoint = pointer.String("")
			dockerPluginMode = pointer.Bool(false)
			configPath = pointer.String("")
			useInMemory = pointer.Bool(false)
		case "multiple_stores":
			// Multiple store types
			csiEndpoint = pointer.String("/tmp/csi.sock")
			useInMemory = pointer.Bool(true)
			usePassthrough = pointer.Bool(true)
			useCRD = pointer.Bool(false)
		case "passthrough_error":
			// Docker mode with invalid config path for passthrough store
			csiEndpoint = pointer.String("")
			dockerPluginMode = pointer.Bool(true)
			configPath = pointer.String("/invalid/path/config.json")
			useInMemory = pointer.Bool(false)
			usePassthrough = pointer.Bool(false) // Will be inferred to true
			useCRD = pointer.Bool(false)
		}

		// Call processCmdLineArgs - this will eventually call Fatal and exit
		processCmdLineArgs(ctx)
		return
	}

	tests := []struct {
		name         string
		testCase     string
		expectExit   bool
		expectedCode int
		description  string
	}{
		{
			name:         "Insufficient arguments",
			testCase:     "insufficient_args",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when no frontends and no in-memory mode",
		},
		{
			name:         "Multiple store types",
			testCase:     "multiple_stores",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when multiple store types configured",
		},
		{
			name:         "Passthrough store creation error",
			testCase:     "passthrough_error",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when passthrough store creation fails",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := exec.Command(os.Args[0], "-test.run=TestProcessCmdLineArgsErrorPaths")
			cmd.Env = append(os.Environ(),
				"TEST_PROCESSCMDLINEARGS_ERRORS=1",
				"TEST_CASE="+tt.testCase,
			)

			err := cmd.Run()

			if tt.expectExit {
				// Check that the process exited with expected code
				if exitError, ok := err.(*exec.ExitError); ok {
					if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
						actualCode := status.ExitStatus()
						assert.Equal(t, tt.expectedCode, actualCode, tt.description)
					}
				} else if err != nil {
					// Some other error occurred - still indicates Fatal was called
					t.Logf("Process exited with error (expected): %v", err)
				}
			} else {
				assert.NoError(t, err, "Process should not have failed")
			}
		})
	}
}

func TestProcessCmdLineArgsAdvancedCoverage(t *testing.T) {
	// Test additional paths in processCmdLineArgs for better coverage

	// Save original values
	originalStoreClient := storeClient
	originalUseInMemory := useInMemory
	originalConfigPath := configPath

	defer func() {
		// Restore original values
		storeClient = originalStoreClient
		useInMemory = originalUseInMemory
		configPath = originalConfigPath
	}()

	t.Run("In-memory store simple test", func(t *testing.T) {
		// Reset state
		storeClient = nil
		useInMemory = pointer.Bool(true)

		// This should complete successfully
		assert.NotPanics(t, func() {
			processCmdLineArgs(context.Background())
		}, "Should complete successfully with in-memory store")

		assert.NotNil(t, storeClient, "Store client should be created")
	})
}

func TestMainFunctionAdditionalPaths(t *testing.T) {
	// Test additional paths in main function using subprocess testing

	if os.Getenv("TEST_MAIN_ADDITIONAL") == "1" {
		// This block runs in the subprocess
		testCase := os.Getenv("TEST_CASE")

		switch testCase {
		case "docker_plugin_args_error":
			// Set up a condition that will cause processDockerPluginArgs to fail
			os.Setenv(config.DockerPluginModeEnvVariable, "1")
			os.Setenv("config", "/invalid/nonexistent/config.json")
			dockerPluginMode = pointer.Bool(true)
		case "init_log_level_error":
			// Set up invalid log level
			debug = pointer.Bool(false)
			logLevel = pointer.String("invalid-level")
		case "init_log_format_error":
			// Set up invalid log format
			logFormat = pointer.String("invalid-format")
		}

		// Call main - this will exit with an error
		main()
		return
	}

	tests := []struct {
		name         string
		testCase     string
		expectExit   bool
		expectedCode int
		description  string
	}{
		{
			name:         "Docker plugin args error",
			testCase:     "docker_plugin_args_error",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when processDockerPluginArgs fails",
		},
		{
			name:         "Init log level error",
			testCase:     "init_log_level_error",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when InitLogLevel fails",
		},
		{
			name:         "Init log format error",
			testCase:     "init_log_format_error",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when InitLogFormat fails",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := exec.Command(os.Args[0], "-test.run=TestMainFunctionAdditionalPaths")
			cmd.Env = append(os.Environ(),
				"TEST_MAIN_ADDITIONAL=1",
				"TEST_CASE="+tt.testCase,
			)

			err := cmd.Run()

			if tt.expectExit {
				// Check that the process exited with expected code
				if exitError, ok := err.(*exec.ExitError); ok {
					if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
						actualCode := status.ExitStatus()
						assert.Equal(t, tt.expectedCode, actualCode, tt.description)
					}
				} else if err != nil {
					// Some other error occurred - still indicates exit was called
					t.Logf("Process exited with error (expected): %v", err)
				}
			} else {
				assert.NoError(t, err, "Process should not have failed")
			}
		})
	}
}

func TestMainFunctionAdvancedPaths(t *testing.T) {
	// Test additional main function paths using subprocess testing

	if os.Getenv("TEST_MAIN_ADVANCED") == "1" {
		// This block runs in the subprocess
		testCase := os.Getenv("TEST_CASE")

		switch testCase {
		case "debug_flag_coverage":
			// Test debug flag path - but fail early to avoid long initialization
			debug = pointer.Bool(true)
			logLevel = pointer.String("info") // Will be overridden to debug
			// Don't use in-memory store to force early exit due to missing k8s config

		case "concurrency_enabled":
			// Test concurrency path - but fail early
			enableConcurrency = pointer.Bool(true)
			// Don't use in-memory store to force early exit due to missing k8s config

		case "metrics_enabled_with_port":
			// Test metrics enabled with port - but fail early
			enableMetrics = pointer.Bool(true)
			metricsPort = pointer.String("8080")
			metricsAddress = pointer.String("localhost")
			// Don't use in-memory store to force early exit due to missing k8s config

		case "metrics_enabled_no_port":
			// Test metrics enabled without port (should warn) - but fail early
			enableMetrics = pointer.Bool(true)
			metricsPort = pointer.String("")
			// Don't use in-memory store to force early exit due to missing k8s config

		case "rest_enabled":
			// Test REST frontend enabled - but fail early
			enableREST = pointer.Bool(true)
			httpRequestTimeout = pointer.Duration(30 * time.Second)
			// Don't use in-memory store to force early exit due to missing k8s config

		case "workflow_error":
			// Test workflow setting error
			logWorkflows = pointer.String("invalid-workflow")
			// No need for any store config - this will fail during workflow setup

		case "log_layers_error":
			// Test log layers setting error
			logLayers = pointer.String("invalid-layer")
			// No need for any store config - this will fail during log layers setup
		}

		// Call main - this will exit with an error for invalid cases
		main()
		return
	}

	tests := []struct {
		name         string
		testCase     string
		expectExit   bool
		expectedCode int
		description  string
	}{
		{
			name:         "Debug flag coverage",
			testCase:     "debug_flag_coverage",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating orchestrator
			description:  "Should set log level to debug when debug flag is true",
		},
		{
			name:         "Concurrency enabled",
			testCase:     "concurrency_enabled",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating orchestrator
			description:  "Should create concurrent orchestrator when concurrency is enabled",
		},
		{
			name:         "Metrics enabled with port",
			testCase:     "metrics_enabled_with_port",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating orchestrator
			description:  "Should create metrics server when metrics enabled with port",
		},
		{
			name:         "Metrics enabled no port",
			testCase:     "metrics_enabled_no_port",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating orchestrator
			description:  "Should warn about missing port when metrics enabled without port",
		},
		{
			name:         "REST enabled",
			testCase:     "rest_enabled",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating orchestrator
			description:  "Should enable REST frontend when enableREST is true",
		},
		{
			name:         "Workflow error",
			testCase:     "workflow_error",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when SetWorkflows fails",
		},
		{
			name:         "Log layers error",
			testCase:     "log_layers_error",
			expectExit:   true,
			expectedCode: 1,
			description:  "Should exit with code 1 when SetLogLayers fails",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set a timeout for subprocess tests
			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
			defer cancel()
			cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestMainFunctionAdvancedPaths")
			cmd.Env = append(os.Environ(),
				"TEST_MAIN_ADVANCED=1",
				"TEST_CASE="+tt.testCase,
			)

			err := cmd.Run()

			if tt.expectExit {
				// Check that the process exited with expected code
				if exitError, ok := err.(*exec.ExitError); ok {
					if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
						actualCode := status.ExitStatus()
						assert.Equal(t, tt.expectedCode, actualCode, tt.description)
					}
				} else if err != nil {
					// Some other error occurred - still indicates exit was called
					t.Logf("Process exited with error (expected): %v", err)
				}
			} else {
				assert.NoError(t, err, "Process should not have failed")
			}
		})
	}
}

func TestMainFunctionCSIPaths(t *testing.T) {
	// Test CSI-specific paths in main function

	if os.Getenv("TEST_MAIN_CSI") == "1" {
		// This block runs in the subprocess
		testCase := os.Getenv("TEST_CASE")

		// Set up basic CSI configuration
		csiEndpoint = pointer.String("/tmp/csi.sock")
		csiNodeName = pointer.String("test-node")
		useCRD = pointer.Bool(true)
		k8sAPIServer = pointer.String("https://test:6443")
		k8sConfigPath = pointer.String("/tmp/kubeconfig")

		switch testCase {
		case "csi_controller":
			csiRole = pointer.String("controller")
		case "csi_node":
			csiRole = pointer.String("node")
		case "csi_all_in_one":
			csiRole = pointer.String("allInOne")
		case "csi_invalid_role":
			csiRole = pointer.String("invalid-role")
		case "csi_no_endpoint":
			csiEndpoint = pointer.String("")
		case "csi_no_node_name":
			csiNodeName = pointer.String("")
		case "csi_node_no_crd":
			csiRole = pointer.String("node")
			useCRD = pointer.Bool(false)
		case "csi_all_in_one_no_crd":
			csiRole = pointer.String("allInOne")
			useCRD = pointer.Bool(false)
		}

		// Call main - this will exit with various error conditions
		main()
		return
	}

	tests := []struct {
		name         string
		testCase     string
		expectExit   bool
		expectedCode int
		description  string
	}{
		{
			name:         "CSI Controller role",
			testCase:     "csi_controller",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating CSI frontend
			description:  "Should configure CSI controller role",
		},
		{
			name:         "CSI Node role",
			testCase:     "csi_node",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating CSI frontend
			description:  "Should configure CSI node role",
		},
		{
			name:         "CSI All-in-One role",
			testCase:     "csi_all_in_one",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating CSI frontend
			description:  "Should configure CSI all-in-one role",
		},
		{
			name:         "CSI Invalid role",
			testCase:     "csi_invalid_role",
			expectExit:   true,
			expectedCode: 1, // Should fatal on invalid role
			description:  "Should exit with code 1 for invalid CSI role",
		},
		{
			name:         "CSI No endpoint",
			testCase:     "csi_no_endpoint",
			expectExit:   true,
			expectedCode: 1, // Should fatal on missing endpoint
			description:  "Should exit with code 1 when CSI endpoint missing",
		},
		{
			name:         "CSI No node name",
			testCase:     "csi_no_node_name",
			expectExit:   true,
			expectedCode: 1, // Should fatal on missing node name
			description:  "Should exit with code 1 when CSI node name missing",
		},
		{
			name:         "CSI Node role without CRD persistence",
			testCase:     "csi_node_no_crd",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating CSI frontend
			description:  "Should configure CSI node role without creating Node CRD controller when CRD persistence is disabled",
		},
		{
			name:         "CSI All-in-One role without CRD persistence",
			testCase:     "csi_all_in_one_no_crd",
			expectExit:   true,
			expectedCode: 1, // Will eventually fail creating CSI frontend
			description:  "Should configure CSI all-in-one role without creating Node CRD controller when CRD persistence is disabled",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set a timeout for subprocess tests
			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
			defer cancel()
			cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=TestMainFunctionCSIPaths")
			cmd.Env = append(os.Environ(),
				"TEST_MAIN_CSI=1",
				"TEST_CASE="+tt.testCase,
			)

			err := cmd.Run()

			if tt.expectExit {
				// Check that the process exited with expected code
				if exitError, ok := err.(*exec.ExitError); ok {
					if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
						actualCode := status.ExitStatus()
						assert.Equal(t, tt.expectedCode, actualCode, tt.description)
					}
				} else if err != nil {
					// Some other error occurred - still indicates exit was called
					t.Logf("Process exited with error (expected): %v", err)
				}
			} else {
				assert.NoError(t, err, "Process should not have failed")
			}
		})
	}
}