Add unit test cases for pkg/cmd/util/flag package

Add unit test cases for pkg/cmd/util/flag package

Fixes #6253

Signed-off-by: Wenkai Yin(尹文开) <yinw@vmware.com>

pkg/cmd/util/flag/accessors_test.go

@@ -0,0 +1,45 @@
+package flag
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetOptionalStringFlag(t *testing.T) {
+	flagName := "flag"
+
+	// not specified
+	cmd := &cobra.Command{}
+	assert.Equal(t, "", GetOptionalStringFlag(cmd, flagName))
+
+	// specified
+	cmd.Flags().String(flagName, "value", "")
+	assert.Equal(t, "value", GetOptionalStringFlag(cmd, flagName))
+}
+
+func TestGetOptionalBoolFlag(t *testing.T) {
+	flagName := "flag"
+
+	// not specified
+	cmd := &cobra.Command{}
+	assert.False(t, GetOptionalBoolFlag(cmd, flagName))
+
+	// specified
+	cmd.Flags().Bool(flagName, true, "")
+	assert.True(t, GetOptionalBoolFlag(cmd, flagName))
+}
+
+func TestGetOptionalStringArrayFlag(t *testing.T) {
+	flagName := "flag"
+
+	// not specified
+	cmd := &cobra.Command{}
+	assert.Equal(t, []string{}, GetOptionalStringArrayFlag(cmd, flagName))
+
+	// specified
+	values := NewStringArray("value")
+	cmd.Flags().Var(&values, flagName, "")
+	assert.Equal(t, []string{"value"}, GetOptionalStringArrayFlag(cmd, flagName))
+}

pkg/cmd/util/flag/array_test.go

@@ -0,0 +1,24 @@
+package flag
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStringOfStringArray(t *testing.T) {
+	array := NewStringArray("a", "b")
+	assert.Equal(t, "a,b", array.String())
+}
+
+func TestSetOfStringArray(t *testing.T) {
+	array := NewStringArray()
+	require.Nil(t, array.Set("a,b"))
+	assert.Equal(t, "a,b", array.String())
+}
+
+func TestTypeOfStringArray(t *testing.T) {
+	array := NewStringArray()
+	assert.Equal(t, "stringArray", array.Type())
+}

pkg/cmd/util/flag/enum_test.go

@@ -0,0 +1,31 @@
+package flag
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStringOfEnum(t *testing.T) {
+	enum := NewEnum("a", "a", "b", "c")
+	assert.Equal(t, "a", enum.String())
+}
+
+func TestSetOfEnum(t *testing.T) {
+	enum := NewEnum("a", "a", "b", "c")
+	assert.NotNil(t, enum.Set("d"))
+
+	require.Nil(t, enum.Set("b"))
+	assert.Equal(t, "b", enum.String())
+}
+
+func TestTypeOfEnum(t *testing.T) {
+	enum := NewEnum("a", "a", "b", "c")
+	assert.Equal(t, "", enum.Type())
+}
+
+func TestAllowedValuesOfEnum(t *testing.T) {
+	enum := NewEnum("a", "a", "b", "c")
+	assert.Equal(t, []string{"a", "b", "c"}, enum.AllowedValues())
+}

pkg/cmd/util/flag/label_selector_test.go

@@ -0,0 +1,30 @@
+package flag
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TestStringOfLabelSelector(t *testing.T) {
+	ls, err := metav1.ParseToLabelSelector("k1=v1,k2=v2")
+	require.Nil(t, err)
+	selector := &LabelSelector{
+		LabelSelector: ls,
+	}
+	assert.Equal(t, "k1=v1,k2=v2", selector.String())
+}
+
+func TestSetOfLabelSelector(t *testing.T) {
+	selector := &LabelSelector{}
+	require.Nil(t, selector.Set("k1=v1,k2=v2"))
+	str := selector.String()
+	assert.True(t, str == "k1=v1,k2=v2" || str == "k2=v2,k2=v2")
+}
+
+func TestTypeOfLabelSelector(t *testing.T) {
+	selector := &LabelSelector{}
+	assert.Equal(t, "labelSelector", selector.Type())
+}

pkg/cmd/util/flag/map_test.go

@@ -68,8 +68,20 @@ func TestSetOfMap(t *testing.T) {
 				require.NotNil(t, err)
 				return
 			}
-			assert.EqualValues(t, c.expected, m.data)
+			assert.EqualValues(t, c.expected, m.Data())
 		})
 	}
 
 }
+
+func TestStringOfMap(t *testing.T) {
+	m := NewMap()
+	require.Nil(t, m.Set("k1=v1,k2=v2"))
+	str := m.String()
+	assert.True(t, str == "k1=v1,k2=v2" || str == "k2=v2,k1=v1")
+}
+
+func TestTypeOfMap(t *testing.T) {
+	m := NewMap()
+	assert.Equal(t, "mapStringString", m.Type())
+}

pkg/cmd/util/flag/optional_bool_test.go

@@ -0,0 +1,44 @@
+package flag
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStringOfOptionalBool(t *testing.T) {
+	// nil
+	ob := NewOptionalBool(nil)
+	assert.Equal(t, "<nil>", ob.String())
+
+	// true
+	b := true
+	ob = NewOptionalBool(&b)
+	assert.Equal(t, "true", ob.String())
+
+	// false
+	b = false
+	ob = NewOptionalBool(&b)
+	assert.Equal(t, "false", ob.String())
+}
+
+func TestSetOfOptionalBool(t *testing.T) {
+	// error
+	ob := NewOptionalBool(nil)
+	assert.NotNil(t, ob.Set("invalid"))
+
+	// nil
+	ob = NewOptionalBool(nil)
+	assert.Nil(t, ob.Set(""))
+	assert.Nil(t, ob.Value)
+
+	// true
+	ob = NewOptionalBool(nil)
+	assert.Nil(t, ob.Set("true"))
+	assert.True(t, *ob.Value)
+}
+
+func TestTypeOfOptionalBool(t *testing.T) {
+	ob := NewOptionalBool(nil)
+	assert.Equal(t, "optionalBool", ob.Type())
+}