feat: AMA-3307-fix-scan-usage-showing-on-error-vjeran

integration/flags/.snapshots/TestReportFlagsShouldFail-invalid-context-flag

@@ -0,0 +1 @@
+

integration/flags/.snapshots/TestReportFlagsShouldFail-invalid-format-flag

@@ -0,0 +1 @@
+

integration/flags/.snapshots/TestReportFlagsShouldFail-invalid-report-flag

@@ -0,0 +1 @@
+

integration/flags/report_flags_test.go

@@ -31,3 +31,18 @@ func TestReportFlags(t *testing.T) {
 
 	testhelper.RunTests(t, tests)
 }
+
+func TestReportFlagsShouldFail(t *testing.T) {
+	tests := []testhelper.TestCase{
+		newScanTest("invalid-report-flag", []string{"--report=testing"}, ""),
+		newScanTest("invalid-format-flag", []string{"--format=testing"}, ""),
+		newScanTest("invalid-context-flag", []string{"--format=testing"}, ""),
+	}
+
+	for i := range tests {
+		tests[i].ShouldSucceed = false
+	}
+
+	testhelper.RunTests(t, tests)
+
+}

integration/internal/testhelper/testhelper.go

@@ -17,7 +17,7 @@ var TestTimeout = 1 * time.Minute
 type TestCase struct {
 	name          string
 	arguments     []string
-	shouldSucceed bool
+	ShouldSucceed bool
 	options       TestCaseOptions
 	displayStdErr bool
 	ignoreForce   bool
@@ -32,7 +32,7 @@ func NewTestCase(name string, arguments []string, options TestCaseOptions) TestC
 	return TestCase{
 		name:          name,
 		arguments:     arguments,
-		shouldSucceed: true,
+		ShouldSucceed: true,
 		options:       options,
 		displayStdErr: options.DisplayStdErr,
 		ignoreForce:   options.IgnoreForce,
@@ -120,10 +120,10 @@ func RunTests(t *testing.T, tests []TestCase) {
 			cupaloy.SnapshotT(t, combinedOutput)
 
 			if err != nil {
-				if test.shouldSucceed {
+				if test.ShouldSucceed {
 					t.Errorf("Expected application to succeed, but it failed: %s", err)
 				}
-			} else if !test.shouldSucceed {
+			} else if !test.ShouldSucceed {
 				t.Error("Expected application to fail, but it did not")
 			}
 		})

pkg/commands/artifact/run.go

@@ -189,7 +189,7 @@ func (r *runner) Report(config settings.Config, report types.Report) (bool, erro
 		logger = outputhandler.PlainLogger(reportFile)
 	}
 
-	if config.Report.Report == flag.ReportPolicies && config.Report.Format == "" {
+	if config.Report.Report == flag.ReportPolicies && config.Report.Format == flag.FormatEmpty {
 		// for policy report, default report format is NOT JSON
 		reportPassed, err := reportoutput.ReportPolicies(report, logger, config)
 		if err != nil {
@@ -199,7 +199,7 @@ func (r *runner) Report(config settings.Config, report types.Report) (bool, erro
 	}
 
 	switch config.Report.Format {
-	case "", flag.FormatJSON:
+	case flag.FormatEmpty, flag.FormatJSON:
 		// default report format for is JSON
 		err := reportoutput.ReportJSON(report, logger, config)
 		if err != nil {

pkg/commands/scan.go

@@ -76,6 +76,8 @@ func NewScanCommand() *cobra.Command {
 				return cmd.Help()
 			}
 
+			cmd.SilenceUsage = true
+
 			return artifact.Run(cmd.Context(), options, artifact.TargetFilesystem)
 		},
 		SilenceErrors: false,

pkg/flag/options.go

@@ -245,7 +245,10 @@ func (f *Flags) ToOptions(args []string) (Options, error) {
 	}
 
 	if f.ReportFlagGroup != nil {
-		opts.ReportOptions = f.ReportFlagGroup.ToOptions()
+		opts.ReportOptions, err = f.ReportFlagGroup.ToOptions()
+		if err != nil {
+			return Options{}, fmt.Errorf("report flags error: %w", err)
+		}
 	}
 
 	if f.PolicyFlagGroup != nil {
@@ -259,7 +262,7 @@ func (f *Flags) ToOptions(args []string) (Options, error) {
 	if f.ScanFlagGroup != nil {
 		opts.ScanOptions, err = f.ScanFlagGroup.ToOptions(args)
 		if err != nil {
-			return Options{}, xerrors.Errorf("scan flag error: %w", err)
+			return Options{}, fmt.Errorf("scan flag error: %w", err)
 		}
 	}
 

pkg/flag/report_flags.go

@@ -1,23 +1,31 @@
 package flag
 
+import (
+	"errors"
+)
+
 type Severity int
 
 var (
-	FormatJSON = "json"
-	FormatYAML = "yaml"
+	FormatJSON  = "json"
+	FormatYAML  = "yaml"
+	FormatEmpty = ""
 
 	ReportDetectors = "detectors"
 	ReportDataFlow  = "dataflow"
 	ReportPolicies  = "policies"
 	ReportStats     = "stats"
 )
 
+var ErrInvalidFormat = errors.New("you've specified invalid format, valid ones are json,yaml")
+var ErrInvalidReport = errors.New("you've specified invalid report, valid ones are detectors, dataflow, policies, stats")
+
 var (
 	FormatFlag = Flag{
 		Name:       "format",
 		ConfigName: "report.format",
 		Shorthand:  "f",
-		Value:      "",
+		Value:      FormatEmpty,
 		Usage:      "Specify report format (json, yaml)",
 	}
 	ReportFlag = Flag{
@@ -66,10 +74,29 @@ func (f *ReportFlagGroup) Flags() []*Flag {
 	}
 }
 
-func (f *ReportFlagGroup) ToOptions() ReportOptions {
+func (f *ReportFlagGroup) ToOptions() (ReportOptions, error) {
+	format := getString(f.Format)
+	switch format {
+	case FormatYAML:
+	case FormatJSON:
+	case FormatEmpty:
+	default:
+		return ReportOptions{}, ErrInvalidFormat
+	}
+
+	report := getString(f.Report)
+	switch report {
+	case ReportDetectors:
+	case ReportDataFlow:
+	case ReportPolicies:
+	case ReportStats:
+	default:
+		return ReportOptions{}, ErrInvalidReport
+	}
+
 	return ReportOptions{
-		Format: getString(f.Format),
-		Report: getString(f.Report),
+		Format: format,
+		Report: report,
 		Output: getString(f.Output),
-	}
+	}, nil
 }

pkg/flag/scan_flags.go

@@ -1,6 +1,7 @@
 package flag
 
 import (
+	"errors"
 	"strings"
 	"time"
 )
@@ -9,8 +10,11 @@ type Context string
 
 const (
 	Health Context = "health"
+	Empty  Context = ""
 )
 
+var ErrInvalidContext = errors.New("you've specified invalid context, valid one is health")
+
 var (
 	SkipPathFlag = Flag{
 		Name:       "skip-path",
@@ -121,13 +125,20 @@ func (f *ScanFlagGroup) ToOptions(args []string) (ScanOptions, error) {
 		target = args[0]
 	}
 
+	context := getContext(f.ContextFlag)
+	switch context {
+	case Empty, Health:
+	default:
+		return ScanOptions{}, ErrInvalidContext
+	}
+
 	return ScanOptions{
 		SkipPath:                getStringSlice(f.SkipPathFlag),
 		Debug:                   getBool(f.DebugFlag),
 		DisableDomainResolution: getBool(f.DisableDomainResolutionFlag),
 		DomainResolutionTimeout: getDuration(f.DomainResolutionTimeoutFlag),
 		InternalDomains:         getStringSlice(f.InternalDomainsFlag),
-		Context:                 getContext(f.ContextFlag),
+		Context:                 context,
 		Quiet:                   getBool(f.QuietFlag),
 		Force:                   getBool(f.ForceFlag),
 		Target:                  target,