Improve code coverage for cli/cmd package

Signed-off-by: Meghna Singh <[email protected]>

Author: singhmeghna79

cli/cmd/check_operator_test.go

@@ -3,7 +3,6 @@
 package cmd
 
 import (
-	"io"
 	"os"
 	"testing"
 
@@ -32,7 +31,6 @@ func TestCheckOperatorStatusRunE(t *testing.T) {
 
 	command = mockCommand
 
-	// Test for ModeDirect where pod namespace is not set.
 	OperatingMode = ModeDirect
 	_ = os.Unsetenv(podNamespace)
 	err := checkOperatorStatusRunE(&cobra.Command{}, nil)
@@ -174,14 +172,12 @@ func TestWriteStatus(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			OutputFormat = test.outputFormat
 
-			changeSTDOUT()
-			writeStatus(test.status)
-			restoreSTDOUT()
-
-			o, _ := io.ReadAll(r)
+			output := captureOutput(t, func() {
+				writeStatus(test.status)
+			})
 
 			for _, c := range test.contains {
-				assert.Contains(t, string(o), c, "unexpected output")
+				assert.Contains(t, output, c, "unexpected output")
 			}
 		})
 	}

cli/cmd/check_test.go

@@ -0,0 +1,19 @@
+// Copyright 2024 NetApp, Inc. All Rights Reserved.
+
+package cmd
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCheckCmd_PersistentPreRunE(t *testing.T) {
+	cmd := &cobra.Command{}
+	args := []string{}
+
+	assert.NotPanics(t, func() {
+		_ = checkCmd.PersistentPreRunE(cmd, args)
+	})
+}

cli/cmd/completion_test.go

@@ -1,11 +1,52 @@
 package cmd
 
 import (
+	"sync"
 	"testing"
 
+	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 )
 
+var testStateMutex sync.RWMutex
+
+func withTestState(t *testing.T, skipDetection bool, plugins map[string]struct{}, fn func()) {
+	t.Helper()
+
+	testStateMutex.Lock()
+	defer testStateMutex.Unlock()
+
+	originalSkip := skipPluginDetection
+	originalPlugins := pluginsFound
+
+	defer func() {
+		skipPluginDetection = originalSkip
+		pluginsFound = originalPlugins
+	}()
+
+	skipPluginDetection = skipDetection
+	pluginsFound = plugins
+
+	fn()
+}
+
+func setupCompletionCommand(t *testing.T, cmdType string, runE func(*cobra.Command, []string) error) *cobra.Command {
+	t.Helper()
+
+	rootCmd := &cobra.Command{Use: "tridentctl"}
+	completionCmd := &cobra.Command{Use: "completion"}
+	targetCmd := &cobra.Command{
+		Use:   cmdType,
+		Short: "Generate the autocompletion script for " + cmdType,
+		RunE:  runE,
+	}
+
+	rootCmd.AddCommand(completionCmd)
+	completionCmd.AddCommand(targetCmd)
+
+	return targetCmd
+}
+
 func TestGenPatchedBashCompletionScript(t *testing.T) {
 	dummyOriginalScript := `    args=("${words[@]:1}")
     requestComp="${words[0]} __complete ${args[*]}"
@@ -55,3 +96,131 @@ func TestGenPatchedZshCompletionScript(t *testing.T) {
 
 	assert.Equal(t, expectedResult, result)
 }
+
+type completionTestCase struct {
+	name                string
+	skipPluginDetection bool
+	pluginsFound        map[string]struct{}
+	description         string
+}
+
+func TestCompletionBashCmd(t *testing.T) {
+	testCases := []completionTestCase{
+		{
+			name:                "basic_bash_completion",
+			skipPluginDetection: true,
+			pluginsFound:        map[string]struct{}{},
+			description:         "Should generate bash completion successfully",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			withTestState(t, tc.skipPluginDetection, tc.pluginsFound, func() {
+				cmd := setupCompletionCommand(t, "bash", completionBashCmd.RunE)
+
+				output := captureOutput(t, func() {
+					err := cmd.RunE(cmd, []string{})
+					assert.NoError(t, err, tc.description)
+				})
+
+				assert.NotEmpty(t, output, "Should generate some completion output")
+			})
+		})
+	}
+}
+
+func TestCompletionZshCmd(t *testing.T) {
+	testCases := []completionTestCase{
+		{
+			name:                "basic_zsh_completion",
+			skipPluginDetection: true,
+			pluginsFound:        map[string]struct{}{},
+			description:         "Should generate zsh completion successfully",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			withTestState(t, tc.skipPluginDetection, tc.pluginsFound, func() {
+				cmd := setupCompletionCommand(t, "zsh", completionZshCmd.RunE)
+
+				output := captureOutput(t, func() {
+					err := cmd.RunE(cmd, []string{})
+					assert.NoError(t, err, tc.description)
+				})
+
+				assert.NotEmpty(t, output, "Should generate completion output")
+			})
+		})
+	}
+}
+
+func TestCompletionFishCmd(t *testing.T) {
+	cmd := setupCompletionCommand(t, "fish", completionFishCmd.RunE)
+
+	output := captureOutput(t, func() {
+		err := cmd.RunE(cmd, []string{})
+		assert.NoError(t, err, "Should call cmd.Root().GenFishCompletion successfully")
+	})
+
+	assert.NotEmpty(t, output, "Should generate fish completion output")
+}
+
+func TestCompletionPowershellCmd(t *testing.T) {
+	cmd := setupCompletionCommand(t, "powershell", completionPowershellCmd.RunE)
+
+	output := captureOutput(t, func() {
+		err := cmd.RunE(cmd, []string{})
+		assert.NoError(t, err, "Should call cmd.Root().GenPowerShellCompletionWithDesc successfully")
+	})
+
+	assert.NotEmpty(t, output, "Should generate powershell completion output")
+}
+
+func TestGetCobraPoweredPlugins(t *testing.T) {
+	testCases := []struct {
+		name                string
+		skipPluginDetection bool
+		pluginsFound        map[string]struct{}
+		expectNil           bool
+		description         string
+	}{
+		{
+			name:                "skip_detection_returns_nil",
+			skipPluginDetection: true,
+			pluginsFound:        map[string]struct{}{"plugin1": {}, "plugin2": {}},
+			expectNil:           true,
+			description:         "Should return nil when skipPluginDetection is true",
+		},
+		{
+			name:                "no_plugins_found_empty_slice",
+			skipPluginDetection: false,
+			pluginsFound:        map[string]struct{}{},
+			expectNil:           false,
+			description:         "Should return empty slice when no plugins in pluginsFound map",
+		},
+		{
+			name:                "plugins_found_cobra_detection_process",
+			skipPluginDetection: false,
+			pluginsFound:        map[string]struct{}{"plugin1": {}, "plugin2": {}},
+			expectNil:           true,
+			description:         "Should process plugins and return slice (may be empty if plugins fail cobra detection)",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			withTestState(t, tc.skipPluginDetection, tc.pluginsFound, func() {
+				result := GetCobraPoweredPlugins()
+
+				if tc.expectNil {
+					assert.Nil(t, result, tc.description)
+				} else {
+					assert.NotNil(t, result, tc.description)
+					assert.IsType(t, []string{}, result, "Should return string slice type")
+				}
+			})
+		})
+	}
+}