refactor: cli commands tests and error handling (#8367)

Signed-off-by: Charles-Edouard Brétéché <charles.edouard@nirmata.com>

cmd/cli/kubectl-kyverno/commands/apply/command.go

@@ -74,9 +74,9 @@ func Command() *cobra.Command {
 		Long:         command.FormatDescription(false, websiteUrl, false, description...),
 		Example:      command.FormatExamples(examples...),
 		SilenceUsage: true,
-		RunE: func(cmd *cobra.Command, policyPaths []string) (err error) {
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
 			color.InitColors(removeColor)
-			applyCommandConfig.PolicyPaths = policyPaths
+			applyCommandConfig.PolicyPaths = args
 			rc, _, skipInvalidPolicies, responses, err := applyCommandConfig.applyCommandHelper()
 			if err != nil {
 				return err

cmd/cli/kubectl-kyverno/commands/apply/command_test.go

@@ -1,7 +1,9 @@
 package apply
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"strings"
@@ -372,3 +374,43 @@ func TestCommand(t *testing.T) {
 	err := cmd.Execute()
 	assert.NoError(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: require policy`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/command.go

@@ -15,12 +15,10 @@ import (
 
 func RootCommand(experimental bool) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "kyverno",
+		Use:          "kyverno",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Args:          cobra.NoArgs,
+		SilenceUsage: true,
-		SilenceErrors: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return cmd.Help()
 		},

cmd/cli/kubectl-kyverno/commands/command_test.go

@@ -1,6 +1,9 @@
 package commands
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -21,3 +24,46 @@ func TestRootCommandExperimental(t *testing.T) {
 	err := cmd.Execute()
 	assert.NoError(t, err)
 }
+
+func TestRootCommandWithInvalidArg(t *testing.T) {
+	cmd := RootCommand(false)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `
+Error: unknown command "foo" for "kyverno"
+Run 'kyverno --help' for usage.`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestRootCommandWithInvalidFlag(t *testing.T) {
+	cmd := RootCommand(false)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestRootCommandHelp(t *testing.T) {
+	cmd := RootCommand(false)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/create/command.go

@@ -12,13 +12,12 @@ import (
 
 func Command() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "create",
+		Use:          "create",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return cmd.Help()
 		},

cmd/cli/kubectl-kyverno/commands/create/command_test.go

@@ -1,6 +1,9 @@
 package create
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "create"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/create/exception/command.go

@@ -27,13 +27,12 @@ func Command() *cobra.Command {
 	var rules, any, all []string
 	var options options
 	cmd := &cobra.Command{
-		Use:           "exception [name]",
+		Use:          "exception [name]",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.ExactArgs(1),
+		Args:         cobra.ExactArgs(1),
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			tmpl, err := template.New("exception").Parse(templates.ExceptionTemplate)
 			if err != nil {

cmd/cli/kubectl-kyverno/commands/create/exception/command_test.go

@@ -99,3 +99,43 @@ spec:
         - rule-2`
 	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: accepts 1 arg(s), received 0`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/create/metrics-config/command.go

@@ -25,13 +25,12 @@ func Command() *cobra.Command {
 	var path string
 	var options options
 	cmd := &cobra.Command{
-		Use:           "metrics-config",
+		Use:          "metrics-config",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("metricsconfig").Funcs(sprig.HermeticTxtFuncMap()).Parse(templates.MetricsConfigTemplate)
 			if err != nil {

cmd/cli/kubectl-kyverno/commands/create/metrics-config/command_test.go

@@ -1,6 +1,9 @@
 package metricsconfig
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "metrics-config"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/create/test/command.go

@@ -33,13 +33,12 @@ func Command() *cobra.Command {
 	var options options
 	var pass, fail, skip []string
 	cmd := &cobra.Command{
-		Use:           "test",
+		Use:          "test",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("test").Parse(templates.TestTemplate)
 			if err != nil {

cmd/cli/kubectl-kyverno/commands/create/test/command_test.go

@@ -1,6 +1,9 @@
 package test
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "test"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/create/user-info/command.go

@@ -16,13 +16,12 @@ func Command() *cobra.Command {
 	var username string
 	var roles, clusterRoles, groups []string
 	cmd := &cobra.Command{
-		Use:           "user-info",
+		Use:          "user-info",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("userinfo").Parse(templates.UserInfoTemplate)
 			if err != nil {

cmd/cli/kubectl-kyverno/commands/create/user-info/command_test.go

@@ -1,6 +1,9 @@
 package userinfo
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "user-info"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/create/values/command.go

@@ -15,13 +15,12 @@ func Command() *cobra.Command {
 	var path string
 	var globalValues, namespaceSelector, rules, resources []string
 	cmd := &cobra.Command{
-		Use:           "values",
+		Use:          "values",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("values").Parse(templates.ValuesTemplate)
 			if err != nil {

cmd/cli/kubectl-kyverno/commands/create/values/command_test.go

@@ -1,6 +1,9 @@
 package values
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "values"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/docs/command.go

@@ -10,17 +10,16 @@ import (
 func Command(root *cobra.Command) *cobra.Command {
 	var options options
 	cmd := &cobra.Command{
-		Use:     "docs",
+		Use:          "docs",
-		Short:   command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:    command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example: command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:    cobra.NoArgs,
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			if err := options.validate(root); err != nil {
 				return err
 			}
-			cmd.SilenceUsage = true
-			cmd.SilenceErrors = true
 			return options.execute(root)
 		},
 	}

cmd/cli/kubectl-kyverno/commands/docs/command_test.go

@@ -1,6 +1,9 @@
 package docs
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/spf13/cobra"
@@ -21,3 +24,44 @@ func TestCommandWithoutArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command(&cobra.Command{})
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "docs"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command(&cobra.Command{})
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command(&cobra.Command{})
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/fix/command.go

@@ -8,13 +8,12 @@ import (
 
 func Command() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "fix",
+		Use:          "fix",
-		Short:         command.FormatDescription(true, websiteUrl, true, description...),
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
-		Long:          command.FormatDescription(false, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return cmd.Help()
 		},

cmd/cli/kubectl-kyverno/commands/fix/command_test.go

@@ -1,6 +1,9 @@
 package fix
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "fix"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/fix/test/command.go

@@ -8,17 +8,16 @@ import (
 func Command() *cobra.Command {
 	var options options
 	cmd := &cobra.Command{
-		Use:     "test [dir]...",
+		Use:          "test [dir]...",
-		Short:   command.FormatDescription(true, websiteUrl, true, description...),
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
-		Long:    command.FormatDescription(false, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
-		Example: command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:    cobra.MinimumNArgs(1),
+		Args:         cobra.MinimumNArgs(1),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if err := options.validate(args...); err != nil {
 				return err
 			}
-			cmd.SilenceUsage = true
-			cmd.SilenceErrors = true
 			return options.execute(cmd.OutOrStdout(), args...)
 		},
 	}

cmd/cli/kubectl-kyverno/commands/fix/test/command_test.go

@@ -1,6 +1,9 @@
 package test
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,43 @@ func TestCommandInvalidFileName(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: requires at least 1 arg(s), only received 0`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/jp/command.go

@@ -10,13 +10,12 @@ import (
 
 func Command() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "jp",
+		Use:          "jp",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return cmd.Help()
 		},

cmd/cli/kubectl-kyverno/commands/jp/command_test.go

@@ -1,6 +1,9 @@
 package jp
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "jp"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/jp/function/command.go

@@ -14,12 +14,11 @@ import (
 
 func Command() *cobra.Command {
 	return &cobra.Command{
-		Use:           "function [function_name]...",
+		Use:          "function [function_name]...",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		Run: func(cmd *cobra.Command, args []string) {
 			printFunctions(cmd.OutOrStdout(), args...)
 		},

cmd/cli/kubectl-kyverno/commands/jp/function/command_test.go

@@ -1,6 +1,9 @@
 package function
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -28,3 +31,30 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.NoError(t, err)
 }
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/jp/parse/command.go

@@ -14,12 +14,11 @@ import (
 func Command() *cobra.Command {
 	var files []string
 	cmd := &cobra.Command{
-		Use:           "parse [-f file|expression]...",
+		Use:          "parse [-f file|expression]...",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			expressions, err := loadExpressions(cmd, args, files)
 			if err != nil {

cmd/cli/kubectl-kyverno/commands/jp/parse/command_test.go

@@ -1,6 +1,9 @@
 package parse
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -13,3 +16,43 @@ func TestCommand(t *testing.T) {
 	err := cmd.Execute()
 	assert.NoError(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := "Error: SyntaxError: Incomplete expression\n\n^"
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/jp/query/command.go

@@ -21,12 +21,11 @@ func Command() *cobra.Command {
 	var input string
 	var queries []string
 	cmd := &cobra.Command{
-		Use:           "query [-i input] [-q query|query]...",
+		Use:          "query [-i input] [-q query|query]...",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			queries, err := loadQueries(cmd, args, queries)
 			if err != nil {

cmd/cli/kubectl-kyverno/commands/jp/query/command_test.go

@@ -1,6 +1,9 @@
 package query
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -13,3 +16,43 @@ func TestCommand(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: at least one query or input object is required`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/oci/command.go

@@ -19,13 +19,12 @@ func Command() *cobra.Command {
 		registryclient.AzureKeychain,
 	)
 	cmd := &cobra.Command{
-		Use:           "oci",
+		Use:          "oci",
-		Short:         command.FormatDescription(true, websiteUrl, true, description...),
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
-		Long:          command.FormatDescription(false, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return cmd.Help()
 		},

cmd/cli/kubectl-kyverno/commands/oci/command_test.go

@@ -1,6 +1,9 @@
 package oci
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -20,3 +23,44 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "oci"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/oci/pull/command.go

@@ -11,18 +11,17 @@ import (
 func Command(keychain authn.Keychain) *cobra.Command {
 	var options options
 	cmd := &cobra.Command{
-		Use:     "pull [dir]",
+		Use:          "pull [dir]",
-		Short:   command.FormatDescription(true, websiteUrl, true, description...),
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
-		Long:    command.FormatDescription(false, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
-		Example: command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:    cobra.ExactArgs(1),
+		Args:         cobra.ExactArgs(1),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			dir := args[0]
 			if err := options.validate(dir); err != nil {
 				return err
 			}
-			cmd.SilenceUsage = true
-			cmd.SilenceErrors = true
 			return options.execute(cmd.Context(), dir, keychain)
 		},
 	}

cmd/cli/kubectl-kyverno/commands/oci/pull/command_test.go

@@ -1,6 +1,9 @@
 package pull
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/google/go-containerregistry/pkg/authn"
@@ -31,3 +34,43 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command(keychain)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: accepts 1 arg(s), received 0`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command(keychain)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command(keychain)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/oci/push/command.go

@@ -11,18 +11,17 @@ import (
 func Command(keychain authn.Keychain) *cobra.Command {
 	var options options
 	cmd := &cobra.Command{
-		Use:     "push",
+		Use:          "push [dir or file]",
-		Short:   command.FormatDescription(true, websiteUrl, true, description...),
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
-		Long:    command.FormatDescription(false, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
-		Example: command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:    cobra.ExactArgs(1),
+		Args:         cobra.ExactArgs(1),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			dir := args[0]
 			if err := options.validate(dir); err != nil {
 				return err
 			}
-			cmd.SilenceUsage = true
-			cmd.SilenceErrors = true
 			return options.execute(cmd.Context(), dir, keychain)
 		},
 	}

cmd/cli/kubectl-kyverno/commands/oci/push/command_test.go

@@ -1,6 +1,9 @@
 package push
 
 import (
+	"bytes"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/google/go-containerregistry/pkg/authn"
@@ -31,3 +34,43 @@ func TestCommandWithArgs(t *testing.T) {
 	err := cmd.Execute()
 	assert.Error(t, err)
 }
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command(keychain)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: accepts 1 arg(s), received 0`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command(keychain)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command(keychain)
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/test/command.go

@@ -24,11 +24,12 @@ func Command() *cobra.Command {
 	var fileName, gitBranch string
 	var registryAccess, failOnly, removeColor, detailedResults bool
 	cmd := &cobra.Command{
-		Use:     "test [local folder or git repository]...",
+		Use:          "test [local folder or git repository]...",
-		Args:    cobra.MinimumNArgs(1),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Short:   command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Long:    command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
-		Example: command.FormatExamples(examples...),
+		Args:         cobra.MinimumNArgs(1),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, dirPath []string) (err error) {
 			color.InitColors(removeColor)
 			store.SetRegistryAccess(registryAccess)

cmd/cli/kubectl-kyverno/commands/test/command_test.go

@@ -0,0 +1,50 @@
+package test
+
+import (
+	"bytes"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCommandWithInvalidArg(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: requires at least 1 arg(s), only received 0`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
+}

cmd/cli/kubectl-kyverno/commands/version/command.go

@@ -10,13 +10,12 @@ import (
 
 func Command() *cobra.Command {
 	return &cobra.Command{
-		Use:           "version",
+		Use:          "version",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
+		Example:      command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
+		Args:         cobra.NoArgs,
-		SilenceErrors: true,
+		SilenceUsage: true,
-		SilenceUsage:  true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			fmt.Fprintf(cmd.OutOrStdout(), "Version: %s\n", version.Version())
 			fmt.Fprintf(cmd.OutOrStdout(), "Time: %s\n", version.Time())

cmd/cli/kubectl-kyverno/commands/version/command_test.go

@@ -27,10 +27,43 @@ Git commit ID: ---`
 	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
 }
 
-func TestCommandWithArgs(t *testing.T) {
+func TestCommandWithInvalidArg(t *testing.T) {
 	cmd := Command()
 	assert.NotNil(t, cmd)
-	cmd.SetArgs([]string{"test"})
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"foo"})
 	err := cmd.Execute()
 	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown command "foo" for "version"`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandWithInvalidFlag(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetErr(b)
+	cmd.SetArgs([]string{"--xxx"})
+	err := cmd.Execute()
+	assert.Error(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	expected := `Error: unknown flag: --xxx`
+	assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(out)))
+}
+
+func TestCommandHelp(t *testing.T) {
+	cmd := Command()
+	assert.NotNil(t, cmd)
+	b := bytes.NewBufferString("")
+	cmd.SetOut(b)
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	assert.NoError(t, err)
+	out, err := io.ReadAll(b)
+	assert.NoError(t, err)
+	assert.True(t, strings.HasPrefix(string(out), cmd.Long))
 }

cmd/cli/kubectl-kyverno/main.go

@@ -12,21 +12,22 @@ import (
 )
 
 func main() {
-	if err := run(); err != nil {
+	cmd, err := setup()
+	if err != nil {
 		fmt.Println("Error:", err)
 		os.Exit(1)
 	}
+	if err := cmd.Execute(); err != nil {
+		os.Exit(1)
+	}
 }
 
-func run() error {
+func setup() (*cobra.Command, error) {
 	cmd := commands.RootCommand(experimental.IsEnabled())
 	if err := configureLogs(cmd); err != nil {
-		return fmt.Errorf("Failed to setup logging (%w)", err)
+		return nil, fmt.Errorf("Failed to setup logging (%w)", err)
 	}
-	if err := cmd.Execute(); err != nil {
+	return cmd, nil
-		return fmt.Errorf("Failed to execute command (%w)", err)
-	}
-	return nil
 }
 
 func configureLogs(cli *cobra.Command) error {

docs/user/cli/kyverno_oci_push.md

@@ -11,7 +11,7 @@ Push policie(s) that are included in an OCI image to OCI registry.
   For more information visit https://kyverno.io/docs/kyverno-cli/#pushing
 
 ```
-kyverno oci push [flags]
+kyverno oci push [dir or file] [flags]
 ```
 
 ### Examples