feat(core): add option to return specific error codes

internal/core/bootstrap.go

@@ -125,11 +125,15 @@ func Bootstrap(config *BootstrapConfig) (exitCode int, result interface{}, err e
 		if _, ok := err.(*interactive.InterruptError); ok {
 			return 130, nil, err
 		}
+		errorCode := 1
+		if cliErr, ok := err.(*CliError); ok && cliErr.Code != 0 {
+			errorCode = cliErr.Code
+		}
 		printErr := meta.Printer.Print(err, nil)
 		if printErr != nil {
 			_, _ = fmt.Fprintln(os.Stderr, err)
 		}
-		return 1, nil, err
+		return errorCode, nil, err
 	}
 	return 0, meta.result, nil
 }

internal/core/bootstrap_test.go

@@ -27,4 +27,108 @@ func TestInterruptError(t *testing.T) {
 		Cmd:             "scw test interrupt error",
 		Check:           TestCheckExitCode(130),
 	}))
+	t.Run("exit-code", Test(&TestConfig{
+		Commands: NewCommands(
+			&Command{
+				Namespace: "test",
+				Resource:  "code",
+				Verb:      "error",
+				ArgsType:  reflect.TypeOf(args.RawArgs{}),
+				Run: func(ctx context.Context, argsI interface{}) (i interface{}, e error) {
+					return nil, &CliError{Code: 99}
+				},
+			},
+		),
+		UseE2EClient:    true,
+		DisableParallel: true, // because e2e client is used
+		Cmd:             "scw test code error",
+		Check:           TestCheckExitCode(99),
+	}))
+	t.Run("emtpy-error", Test(&TestConfig{
+		Commands: NewCommands(
+			&Command{
+				Namespace: "test",
+				Resource:  "empty",
+				Verb:      "error",
+				ArgsType:  reflect.TypeOf(args.RawArgs{}),
+				Run: func(ctx context.Context, argsI interface{}) (i interface{}, e error) {
+					return nil, &CliError{Code: 99, Empty: true}
+				},
+			},
+		),
+		UseE2EClient:    true,
+		DisableParallel: true, // because e2e client is used
+		Cmd:             "scw test empty error",
+		Check: TestCheckCombine(
+			TestCheckExitCode(99),
+			TestCheckStderrGolden(),
+		),
+	}))
+	t.Run("emtpy-error-json", Test(&TestConfig{
+		Commands: NewCommands(
+			&Command{
+				Namespace: "test",
+				Resource:  "empty",
+				Verb:      "error",
+				ArgsType:  reflect.TypeOf(args.RawArgs{}),
+				Run: func(ctx context.Context, argsI interface{}) (i interface{}, e error) {
+					return nil, &CliError{Code: 99, Empty: true}
+				},
+			},
+		),
+		UseE2EClient:    true,
+		DisableParallel: true, // because e2e client is used
+		Cmd:             "scw -o json test empty error",
+		Check: TestCheckCombine(
+			TestCheckExitCode(99),
+			TestCheckStderrGolden(),
+		),
+	}))
+	t.Run("emtpy-success", Test(&TestConfig{
+		Commands: NewCommands(
+			&Command{
+				Namespace: "test",
+				Resource:  "empty",
+				Verb:      "success",
+				ArgsType:  reflect.TypeOf(args.RawArgs{}),
+				Run: func(ctx context.Context, argsI interface{}) (i interface{}, e error) {
+					return &SuccessResult{
+						Empty:    true,
+						Message:  "dummy",
+						Details:  "dummy",
+						Resource: "dummy",
+						Verb:     "dummy",
+					}, nil
+				},
+			},
+		),
+		UseE2EClient:    true,
+		DisableParallel: true, // because e2e client is used
+		Cmd:             "scw test empty success",
+		Check:           TestCheckStdoutGolden(),
+	}))
+	t.Run("emtpy-success-json", Test(&TestConfig{
+		Commands: NewCommands(
+			&Command{
+				Namespace: "test",
+				Resource:  "empty",
+				Verb:      "success",
+				ArgsType:  reflect.TypeOf(args.RawArgs{}),
+				Run: func(ctx context.Context, argsI interface{}) (i interface{}, e error) {
+					return &SuccessResult{
+						Empty:    true,
+						Message:  "dummy",
+						Details:  "dummy",
+						Resource: "dummy",
+						Verb:     "dummy",
+					}, nil
+
+				},
+			},
+		),
+		UseE2EClient:    true,
+		DisableParallel: true, // because e2e client is used
+		Cmd:             "scw -o json test empty success",
+		Check:           TestCheckStdoutGolden(),
+	}))
 }

internal/core/error.go

@@ -23,13 +23,22 @@ type CliError struct {
 
 	Details string
 	Hint    string
+
+	// Code allows to return a sepcific error code from the main binary.
+	Code int
+
+	// Empty tells the marshaler to not print any message for the error
+	Empty bool
 }
 
 func (s *CliError) Error() string {
 	return s.Err.Error()
 }
 
 func (s *CliError) MarshalHuman() (string, error) {
+	if s.Empty {
+		return "", nil
+	}
 	sections := []string(nil)
 	if s.Err != nil {
 		humanError := s.Err
@@ -63,6 +72,10 @@ func (s *CliError) MarshalHuman() (string, error) {
 }
 
 func (s *CliError) MarshalJSON() ([]byte, error) {
+	if s.Empty {
+		type emptyRes struct{}
+		return json.Marshal(&emptyRes{})
+	}
 	type tmpRes struct {
 		Message string `json:"message"`
 		Error   error  `json:"error"`

internal/core/testdata/test-interrupt-error-emtpy-error-json.stderr.golden

@@ -0,0 +1 @@
+{}

internal/core/testdata/test-interrupt-error-emtpy-success-json.stdout.golden

@@ -0,0 +1 @@
+{}

internal/printer/human.go

@@ -21,6 +21,10 @@ func (o *humanPrinter) Print(data interface{}, opt *human.MarshalOpt) error {
 		return err
 	}
 
+	if str == "" {
+		return nil
+	}
+
 	if _, isError := data.(error); isError {
 		_, err = fmt.Fprintln(o.ErrorWriter, str)
 		return err