diff --git a/cmd/cli/kubectl-kyverno/commands/apply/command.go b/cmd/cli/kubectl-kyverno/commands/apply/command.go
index c7c776d893..c4bda7964a 100644
--- a/cmd/cli/kubectl-kyverno/commands/apply/command.go
+++ b/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
diff --git a/cmd/cli/kubectl-kyverno/commands/apply/command_test.go b/cmd/cli/kubectl-kyverno/commands/apply/command_test.go
index c94635c353..aef0ae54fb 100644
--- a/cmd/cli/kubectl-kyverno/commands/apply/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/command.go b/cmd/cli/kubectl-kyverno/commands/command.go
index 4b433ee3f1..1ce5947a6d 100644
--- a/cmd/cli/kubectl-kyverno/commands/command.go
+++ b/cmd/cli/kubectl-kyverno/commands/command.go
@@ -15,12 +15,10 @@ import (
 
 func RootCommand(experimental bool) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "kyverno",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "kyverno",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return cmd.Help()
 		},
diff --git a/cmd/cli/kubectl-kyverno/commands/command_test.go b/cmd/cli/kubectl-kyverno/commands/command_test.go
index 59bb29e6e1..a5bb71e116 100644
--- a/cmd/cli/kubectl-kyverno/commands/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/create/command.go b/cmd/cli/kubectl-kyverno/commands/create/command.go
index 5de86353ee..68aa2025a9 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/command.go
+++ b/cmd/cli/kubectl-kyverno/commands/create/command.go
@@ -12,13 +12,12 @@ import (
 
 func Command() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "create",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "create",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return cmd.Help()
 		},
diff --git a/cmd/cli/kubectl-kyverno/commands/create/command_test.go b/cmd/cli/kubectl-kyverno/commands/create/command_test.go
index d58fe4bdd5..8ee8d4f7b8 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/create/exception/command.go b/cmd/cli/kubectl-kyverno/commands/create/exception/command.go
index c110601867..7d20311cbb 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/exception/command.go
+++ b/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]",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.ExactArgs(1),
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "exception [name]",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.ExactArgs(1),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			tmpl, err := template.New("exception").Parse(templates.ExceptionTemplate)
 			if err != nil {
diff --git a/cmd/cli/kubectl-kyverno/commands/create/exception/command_test.go b/cmd/cli/kubectl-kyverno/commands/create/exception/command_test.go
index 9eccbbde9a..deed709e95 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/exception/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/create/metrics-config/command.go b/cmd/cli/kubectl-kyverno/commands/create/metrics-config/command.go
index c93e96e7dd..0003e18986 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/metrics-config/command.go
+++ b/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",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "metrics-config",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("metricsconfig").Funcs(sprig.HermeticTxtFuncMap()).Parse(templates.MetricsConfigTemplate)
 			if err != nil {
diff --git a/cmd/cli/kubectl-kyverno/commands/create/metrics-config/command_test.go b/cmd/cli/kubectl-kyverno/commands/create/metrics-config/command_test.go
index 3a7645d679..67896e0af1 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/metrics-config/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/create/test/command.go b/cmd/cli/kubectl-kyverno/commands/create/test/command.go
index e49b6466e9..91ec76dd2c 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/test/command.go
+++ b/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",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "test",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("test").Parse(templates.TestTemplate)
 			if err != nil {
diff --git a/cmd/cli/kubectl-kyverno/commands/create/test/command_test.go b/cmd/cli/kubectl-kyverno/commands/create/test/command_test.go
index ff87af915f..36049077a1 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/test/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/create/user-info/command.go b/cmd/cli/kubectl-kyverno/commands/create/user-info/command.go
index 0fcc11fbe6..05490f0fb2 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/user-info/command.go
+++ b/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",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "user-info",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("userinfo").Parse(templates.UserInfoTemplate)
 			if err != nil {
diff --git a/cmd/cli/kubectl-kyverno/commands/create/user-info/command_test.go b/cmd/cli/kubectl-kyverno/commands/create/user-info/command_test.go
index 4167790899..3ab9541742 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/user-info/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/create/values/command.go b/cmd/cli/kubectl-kyverno/commands/create/values/command.go
index d769b00184..c5c86e9f60 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/values/command.go
+++ b/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",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "values",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			tmpl, err := template.New("values").Parse(templates.ValuesTemplate)
 			if err != nil {
diff --git a/cmd/cli/kubectl-kyverno/commands/create/values/command_test.go b/cmd/cli/kubectl-kyverno/commands/create/values/command_test.go
index 8cfd463f74..47c7ca5cfe 100644
--- a/cmd/cli/kubectl-kyverno/commands/create/values/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/docs/command.go b/cmd/cli/kubectl-kyverno/commands/docs/command.go
index d51c21c2eb..699f3c20b0 100644
--- a/cmd/cli/kubectl-kyverno/commands/docs/command.go
+++ b/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",
-		Short:   command.FormatDescription(true, websiteUrl, false, description...),
-		Long:    command.FormatDescription(false, websiteUrl, false, description...),
-		Example: command.FormatExamples(examples...),
-		Args:    cobra.NoArgs,
+		Use:          "docs",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		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)
 		},
 	}
diff --git a/cmd/cli/kubectl-kyverno/commands/docs/command_test.go b/cmd/cli/kubectl-kyverno/commands/docs/command_test.go
index 4b714eaf0d..d0eca2ceaf 100644
--- a/cmd/cli/kubectl-kyverno/commands/docs/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/fix/command.go b/cmd/cli/kubectl-kyverno/commands/fix/command.go
index 392745cf1b..fee3f9ebf3 100644
--- a/cmd/cli/kubectl-kyverno/commands/fix/command.go
+++ b/cmd/cli/kubectl-kyverno/commands/fix/command.go
@@ -8,13 +8,12 @@ import (
 
 func Command() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "fix",
-		Short:         command.FormatDescription(true, websiteUrl, true, description...),
-		Long:          command.FormatDescription(false, websiteUrl, true, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "fix",
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return cmd.Help()
 		},
diff --git a/cmd/cli/kubectl-kyverno/commands/fix/command_test.go b/cmd/cli/kubectl-kyverno/commands/fix/command_test.go
index ed81523f55..13c2996bf8 100644
--- a/cmd/cli/kubectl-kyverno/commands/fix/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/fix/test/command.go b/cmd/cli/kubectl-kyverno/commands/fix/test/command.go
index e847bb03cf..dbd5aaa69e 100644
--- a/cmd/cli/kubectl-kyverno/commands/fix/test/command.go
+++ b/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]...",
-		Short:   command.FormatDescription(true, websiteUrl, true, description...),
-		Long:    command.FormatDescription(false, websiteUrl, true, description...),
-		Example: command.FormatExamples(examples...),
-		Args:    cobra.MinimumNArgs(1),
+		Use:          "test [dir]...",
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
+		Example:      command.FormatExamples(examples...),
+		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...)
 		},
 	}
diff --git a/cmd/cli/kubectl-kyverno/commands/fix/test/command_test.go b/cmd/cli/kubectl-kyverno/commands/fix/test/command_test.go
index 2224fd8582..934a083481 100644
--- a/cmd/cli/kubectl-kyverno/commands/fix/test/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/command.go b/cmd/cli/kubectl-kyverno/commands/jp/command.go
index 7dce3a8107..c14c64857c 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/command.go
+++ b/cmd/cli/kubectl-kyverno/commands/jp/command.go
@@ -10,13 +10,12 @@ import (
 
 func Command() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "jp",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "jp",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return cmd.Help()
 		},
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/command_test.go b/cmd/cli/kubectl-kyverno/commands/jp/command_test.go
index ddfda04df5..dce9dfc03c 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/function/command.go b/cmd/cli/kubectl-kyverno/commands/jp/function/command.go
index 981c8b9ec0..86db9d9384 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/function/command.go
+++ b/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]...",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "function [function_name]...",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		SilenceUsage: true,
 		Run: func(cmd *cobra.Command, args []string) {
 			printFunctions(cmd.OutOrStdout(), args...)
 		},
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/function/command_test.go b/cmd/cli/kubectl-kyverno/commands/jp/function/command_test.go
index efafa96037..2ad46cb7b0 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/function/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/parse/command.go b/cmd/cli/kubectl-kyverno/commands/jp/parse/command.go
index ad64005afd..fd468c1d4d 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/parse/command.go
+++ b/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]...",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "parse [-f file|expression]...",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			expressions, err := loadExpressions(cmd, args, files)
 			if err != nil {
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/parse/command_test.go b/cmd/cli/kubectl-kyverno/commands/jp/parse/command_test.go
index 5dede0c42c..c355ebb34a 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/parse/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/query/command.go b/cmd/cli/kubectl-kyverno/commands/jp/query/command.go
index 53d1d6fcd7..f2547742fe 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/query/command.go
+++ b/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]...",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "query [-i input] [-q query|query]...",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			queries, err := loadQueries(cmd, args, queries)
 			if err != nil {
diff --git a/cmd/cli/kubectl-kyverno/commands/jp/query/command_test.go b/cmd/cli/kubectl-kyverno/commands/jp/query/command_test.go
index cfbf9f68dd..a4cbd1d62c 100644
--- a/cmd/cli/kubectl-kyverno/commands/jp/query/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/oci/command.go b/cmd/cli/kubectl-kyverno/commands/oci/command.go
index 5ee3491ac5..11c4c1b000 100644
--- a/cmd/cli/kubectl-kyverno/commands/oci/command.go
+++ b/cmd/cli/kubectl-kyverno/commands/oci/command.go
@@ -19,13 +19,12 @@ func Command() *cobra.Command {
 		registryclient.AzureKeychain,
 	)
 	cmd := &cobra.Command{
-		Use:           "oci",
-		Short:         command.FormatDescription(true, websiteUrl, true, description...),
-		Long:          command.FormatDescription(false, websiteUrl, true, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "oci",
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return cmd.Help()
 		},
diff --git a/cmd/cli/kubectl-kyverno/commands/oci/command_test.go b/cmd/cli/kubectl-kyverno/commands/oci/command_test.go
index 506e0e0fe2..e238c08679 100644
--- a/cmd/cli/kubectl-kyverno/commands/oci/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/oci/pull/command.go b/cmd/cli/kubectl-kyverno/commands/oci/pull/command.go
index c7c8bcfe9c..89295f7d58 100644
--- a/cmd/cli/kubectl-kyverno/commands/oci/pull/command.go
+++ b/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]",
-		Short:   command.FormatDescription(true, websiteUrl, true, description...),
-		Long:    command.FormatDescription(false, websiteUrl, true, description...),
-		Example: command.FormatExamples(examples...),
-		Args:    cobra.ExactArgs(1),
+		Use:          "pull [dir]",
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
+		Example:      command.FormatExamples(examples...),
+		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)
 		},
 	}
diff --git a/cmd/cli/kubectl-kyverno/commands/oci/pull/command_test.go b/cmd/cli/kubectl-kyverno/commands/oci/pull/command_test.go
index 4ad2d94861..056d4ea395 100644
--- a/cmd/cli/kubectl-kyverno/commands/oci/pull/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/oci/push/command.go b/cmd/cli/kubectl-kyverno/commands/oci/push/command.go
index 42c0257b3b..55531ade5e 100644
--- a/cmd/cli/kubectl-kyverno/commands/oci/push/command.go
+++ b/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",
-		Short:   command.FormatDescription(true, websiteUrl, true, description...),
-		Long:    command.FormatDescription(false, websiteUrl, true, description...),
-		Example: command.FormatExamples(examples...),
-		Args:    cobra.ExactArgs(1),
+		Use:          "push [dir or file]",
+		Short:        command.FormatDescription(true, websiteUrl, true, description...),
+		Long:         command.FormatDescription(false, websiteUrl, true, description...),
+		Example:      command.FormatExamples(examples...),
+		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)
 		},
 	}
diff --git a/cmd/cli/kubectl-kyverno/commands/oci/push/command_test.go b/cmd/cli/kubectl-kyverno/commands/oci/push/command_test.go
index fb97f2d196..bf08d09c3e 100644
--- a/cmd/cli/kubectl-kyverno/commands/oci/push/command_test.go
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/test/command.go b/cmd/cli/kubectl-kyverno/commands/test/command.go
index ffef6ebb99..7e52527f4e 100644
--- a/cmd/cli/kubectl-kyverno/commands/test/command.go
+++ b/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]...",
-		Args:    cobra.MinimumNArgs(1),
-		Short:   command.FormatDescription(true, websiteUrl, false, description...),
-		Long:    command.FormatDescription(false, websiteUrl, false, description...),
-		Example: command.FormatExamples(examples...),
+		Use:          "test [local folder or git repository]...",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		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)
diff --git a/cmd/cli/kubectl-kyverno/commands/test/command_test.go b/cmd/cli/kubectl-kyverno/commands/test/command_test.go
new file mode 100644
index 0000000000..7fe8b83424
--- /dev/null
+++ b/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))
+}
diff --git a/cmd/cli/kubectl-kyverno/commands/version/command.go b/cmd/cli/kubectl-kyverno/commands/version/command.go
index d1e1fda6a1..34a5e0eb5e 100644
--- a/cmd/cli/kubectl-kyverno/commands/version/command.go
+++ b/cmd/cli/kubectl-kyverno/commands/version/command.go
@@ -10,13 +10,12 @@ import (
 
 func Command() *cobra.Command {
 	return &cobra.Command{
-		Use:           "version",
-		Short:         command.FormatDescription(true, websiteUrl, false, description...),
-		Long:          command.FormatDescription(false, websiteUrl, false, description...),
-		Example:       command.FormatExamples(examples...),
-		Args:          cobra.NoArgs,
-		SilenceErrors: true,
-		SilenceUsage:  true,
+		Use:          "version",
+		Short:        command.FormatDescription(true, websiteUrl, false, description...),
+		Long:         command.FormatDescription(false, websiteUrl, false, description...),
+		Example:      command.FormatExamples(examples...),
+		Args:         cobra.NoArgs,
+		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())
diff --git a/cmd/cli/kubectl-kyverno/commands/version/command_test.go b/cmd/cli/kubectl-kyverno/commands/version/command_test.go
index d4920720a6..6205bad4ab 100644
--- a/cmd/cli/kubectl-kyverno/commands/version/command_test.go
+++ b/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))
 }
diff --git a/cmd/cli/kubectl-kyverno/main.go b/cmd/cli/kubectl-kyverno/main.go
index a7a02df1e7..81f9558a83 100644
--- a/cmd/cli/kubectl-kyverno/main.go
+++ b/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 fmt.Errorf("Failed to execute command (%w)", err)
-	}
-	return nil
+	return cmd, nil
 }
 
 func configureLogs(cli *cobra.Command) error {
diff --git a/docs/user/cli/kyverno_oci_push.md b/docs/user/cli/kyverno_oci_push.md
index c36e944fac..3d03131a86 100644
--- a/docs/user/cli/kyverno_oci_push.md
+++ b/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