Improve ErrorWithExitCode

entrypoint/entrypoint.go

@@ -39,23 +39,38 @@ func RunApp(app *cli.App) {
 // If there is an error, display it in the console and exit with a non-zero exit code. Otherwise, exit 0.
 // Note that if the GRUNTWORK_DEBUG environment variable is set, this will print out the stack trace.
 func checkForErrorsAndExit(err error) {
-	exitCode := defaultSuccessExitCode
-	isDebugMode := os.Getenv(debugEnvironmentVarName) != ""
+	logError(err)
+	exitCode := getExitCode(err)
+	os.Exit(exitCode)
+}
 
+// logError will output an error message to stderr. This will output the stack trace if we are in debug mode.
+func logError(err error) {
+	isDebugMode := os.Getenv(debugEnvironmentVarName) != ""
 	if err != nil {
+		errWithoutStackTrace := errors.Unwrap(err)
 		if isDebugMode {
 			logging.GetLogger("").WithError(err).Error(errors.PrintErrorWithStackTrace(err))
 		} else {
-			fmt.Fprintf(os.Stderr, "ERROR: %s\n", errors.Unwrap(err))
+			fmt.Fprintf(os.Stderr, "ERROR: %s\n", errWithoutStackTrace)
 		}
+	}
+}
 
-		errorWithExitCode, isErrorWithExitCode := err.(errors.ErrorWithExitCode)
+// getExitCode will return an exit code to use for the CLI app. This will either be:
+// - defaultSuccessExitCode if there is no error.
+// - defaultErrorExitCode if there is a standard error.
+// - error exit code if there is an error that indicates an exit code.
+func getExitCode(err error) int {
+	exitCode := defaultSuccessExitCode
+	if err != nil {
+		errWithoutStackTrace := errors.Unwrap(err)
+		errorWithExitCode, isErrorWithExitCode := errWithoutStackTrace.(errors.ErrorWithExitCode)
 		if isErrorWithExitCode {
 			exitCode = errorWithExitCode.ExitCode
 		} else {
 			exitCode = defaultErrorExitCode
 		}
 	}
-
-	os.Exit(exitCode)
+	return exitCode
 }

entrypoint/entrypoint_test.go

@@ -2,11 +2,52 @@ package entrypoint
 
 import (
 	"bytes"
+	"fmt"
+	"testing"
+
+	"github.com/gruntwork-io/gruntwork-cli/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/urfave/cli"
-	"testing"
 )
 
+func TestEntrypointGetExitCode(t *testing.T) {
+	testCases := []struct {
+		name             string
+		err              error
+		expectedExitCode int
+	}{
+		{"TestNoError", nil, defaultSuccessExitCode},
+		{"TestNoErrorWithStackTrace", errors.WithStackTrace(nil), defaultSuccessExitCode},
+
+		{"TestBareError", fmt.Errorf("Broken"), defaultErrorExitCode},
+		{"TestBareErrorWithStackTrace", errors.WithStackTrace(fmt.Errorf("Broken")), defaultErrorExitCode},
+
+		{
+			"TestErrorWithExitCode",
+			errors.ErrorWithExitCode{
+				Err:      fmt.Errorf("Broken"),
+				ExitCode: 127,
+			},
+			127,
+		},
+		{
+			"TestErrorWithExitCodeWithStackTrace",
+			errors.WithStackTrace(
+				errors.ErrorWithExitCode{
+					Err:      fmt.Errorf("Broken"),
+					ExitCode: 127,
+				},
+			),
+			127,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			assert.Equal(t, getExitCode(testCase.err), testCase.expectedExitCode)
+		})
+	}
+}
+
 func TestEntrypointNewAppWrapsAppHelpPrinter(t *testing.T) {
 	app := createSampleApp()
 	fakeStdout := bytes.NewBufferString("")

errors/errors.go

@@ -2,6 +2,7 @@ package errors
 
 import (
 	"fmt"
+
 	goerrors "github.com/go-errors/errors"
 	"github.com/urfave/cli"
 )
@@ -13,7 +14,7 @@ type ErrorWithExitCode struct {
 }
 
 func (err ErrorWithExitCode) Error() string {
-	return fmt.Sprintf("ErrorWithExitCode{ Err = %v, ExitCode = %d }", err.Err, err.ExitCode)
+	return err.Err.Error()
 }
 
 // Wrap the given error in an Error type that contains the stack trace. If the given error already has a stack trace,