Add --debug flag to return full stack trace on error

cli/setup.go

@@ -16,25 +16,36 @@ import (
 const (
 	RootFlag     = "root"
 	HomeFlag     = "home"
+	DebugFlag    = "debug"
 	OutputFlag   = "output"
 	EncodingFlag = "encoding"
 )
 
+// Executable is the minimal interface to *corba.Command, so we can
+// wrap if desired before the test
+type Executable interface {
+	Execute() error
+}
+
 // PrepareBaseCmd is meant for tendermint and other servers
-func PrepareBaseCmd(cmd *cobra.Command, envPrefix, defautRoot string) func() {
+func PrepareBaseCmd(cmd *cobra.Command, envPrefix, defautRoot string) Executor {
 	cobra.OnInitialize(func() { initEnv(envPrefix) })
 	cmd.PersistentFlags().StringP(RootFlag, "r", defautRoot, "DEPRECATED. Use --home")
 	// -h is already reserved for --help as part of the cobra framework
+	// do you want to try something else??
+	// also, default must be empty, so we can detect this unset and fall back
+	// to --root / TM_ROOT / TMROOT
 	cmd.PersistentFlags().String(HomeFlag, "", "root directory for config and data")
+	cmd.PersistentFlags().Bool(DebugFlag, false, "print out full stack trace on errors")
 	cmd.PersistentPreRunE = concatCobraCmdFuncs(bindFlagsLoadViper, cmd.PersistentPreRunE)
-	return func() { execute(cmd) }
+	return Executor{cmd}
 }
 
 // PrepareMainCmd is meant for client side libs that want some more flags
 //
 // This adds --encoding (hex, btc, base64) and --output (text, json) to
 // the command.  These only really make sense in interactive commands.
-func PrepareMainCmd(cmd *cobra.Command, envPrefix, defautRoot string) func() {
+func PrepareMainCmd(cmd *cobra.Command, envPrefix, defautRoot string) Executor {
 	cmd.PersistentFlags().StringP(EncodingFlag, "e", "hex", "Binary encoding (hex|b64|btc)")
 	cmd.PersistentFlags().StringP(OutputFlag, "o", "text", "Output format (text|json)")
 	cmd.PersistentPreRunE = concatCobraCmdFuncs(setEncoding, validateOutput, cmd.PersistentPreRunE)
@@ -68,15 +79,27 @@ func copyEnvVars(prefix string) {
 	}
 }
 
+// Executor wraps the cobra Command with a nicer Execute method
+type Executor struct {
+	*cobra.Command
+}
+
 // execute adds all child commands to the root command sets flags appropriately.
 // This is called by main.main(). It only needs to happen once to the rootCmd.
-func execute(cmd *cobra.Command) {
+func (e Executor) Execute() error {
-	// TODO: this can do something cooler with debug and log-levels
+	e.SilenceUsage = true
-	if err := cmd.Execute(); err != nil {
+	e.SilenceErrors = true
-		fmt.Println(err)
+	err := e.Command.Execute()
-		os.Exit(-1)
+	if err != nil {
+		// TODO: something cooler with log-levels
+		if viper.GetBool(DebugFlag) {
+			fmt.Printf("ERROR: %+v\n", err)
+		} else {
+			fmt.Println("ERROR:", err.Error())
 		}
 	}
+	return err
+}
 
 type cobraCmdFunc func(cmd *cobra.Command, args []string) error
 

cli/setup_test.go

@@ -8,20 +8,16 @@ import (
 	"os"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"testing"
 
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-// Executable is the minimal interface to *corba.Command, so we can
-// wrap if desired before the test
-type Executable interface {
-	Execute() error
-}
-
 func TestSetupEnv(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
 
@@ -46,15 +42,15 @@ func TestSetupEnv(t *testing.T) {
 		i := strconv.Itoa(idx)
 		// test command that store value of foobar in local variable
 		var foo string
-		cmd := &cobra.Command{
+		demo := &cobra.Command{
 			Use: "demo",
 			RunE: func(cmd *cobra.Command, args []string) error {
 				foo = viper.GetString("foobar")
 				return nil
 			},
 		}
-		cmd.Flags().String("foobar", "", "Some test value from config")
+		demo.Flags().String("foobar", "", "Some test value from config")
-		PrepareBaseCmd(cmd, "DEMO", "/qwerty/asdfgh") // some missing dir..
+		cmd := PrepareBaseCmd(demo, "DEMO", "/qwerty/asdfgh") // some missing dir..
 
 		viper.Reset()
 		args := append([]string{cmd.Use}, tc.args...)
@@ -112,15 +108,15 @@ func TestSetupConfig(t *testing.T) {
 		i := strconv.Itoa(idx)
 		// test command that store value of foobar in local variable
 		var foo string
-		cmd := &cobra.Command{
+		boo := &cobra.Command{
 			Use: "reader",
 			RunE: func(cmd *cobra.Command, args []string) error {
 				foo = viper.GetString("boo")
 				return nil
 			},
 		}
-		cmd.Flags().String("boo", "", "Some test value from config")
+		boo.Flags().String("boo", "", "Some test value from config")
-		PrepareBaseCmd(cmd, "RD", "/qwerty/asdfgh") // some missing dir...
+		cmd := PrepareBaseCmd(boo, "RD", "/qwerty/asdfgh") // some missing dir...
 
 		viper.Reset()
 		args := append([]string{cmd.Use}, tc.args...)
@@ -130,6 +126,47 @@ func TestSetupConfig(t *testing.T) {
 	}
 }
 
+func TestSetupDebug(t *testing.T) {
+	assert, require := assert.New(t), require.New(t)
+
+	cases := []struct {
+		args     []string
+		env      map[string]string
+		long     bool
+		expected string
+	}{
+		{nil, nil, false, "Debug flag = false"},
+		{[]string{"--debug"}, nil, true, "Debug flag = true"},
+		{[]string{"--no-such-flag"}, nil, false, "unknown flag: --no-such-flag"},
+		{nil, map[string]string{"DBG_DEBUG": "true"}, true, "Debug flag = true"},
+	}
+
+	for idx, tc := range cases {
+		i := strconv.Itoa(idx)
+		// test command that store value of foobar in local variable
+		debug := &cobra.Command{
+			Use: "debug",
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return errors.Errorf("Debug flag = %t", viper.GetBool(DebugFlag))
+			},
+		}
+		cmd := PrepareBaseCmd(debug, "DBG", "/qwerty/asdfgh") // some missing dir..
+
+		viper.Reset()
+		args := append([]string{cmd.Use}, tc.args...)
+		out, err := runCaptureWithArgs(cmd, args, tc.env)
+		require.NotNil(err, i)
+		msg := strings.Split(out, "\n")
+		desired := fmt.Sprintf("ERROR: %s", tc.expected)
+		assert.Equal(desired, msg[0], i)
+		if tc.long && assert.True(len(msg) > 2, i) {
+			// the next line starts the stack trace...
+			assert.Contains(msg[1], "TestSetupDebug", i)
+			assert.Contains(msg[2], "setup_test.go", i)
+		}
+	}
+}
+
 // runWithArgs executes the given command with the specified command line args
 // and environmental variables set. It returns any error returned from cmd.Execute()
 func runWithArgs(cmd Executable, args []string, env map[string]string) error {