Improve test coverage for error situations

Author: bep

README.md

@@ -3,7 +3,7 @@
 [![codecov](https://codecov.io/gh/bep/simplecobra/branch/master/graph/badge.svg)](https://codecov.io/gh/bep/simplecobra)
 [![GoDoc](https://godoc.org/github.com/bep/simplecobra?status.svg)](https://godoc.org/github.com/bep/simplecobra)
 
-So, [Cobra](https://github.com/spf13/cobra) is a Go CLI library with a feature set that's hard to resist for bigger applications (autocomplete, docs auto generation etc.). But it's also rather complex to use beyond the simplest of applications. This package is built to aid rewriting [Hugo's](https://github.com/gohugoio/hugo) commands package to something that's easier to understand and maintain.
+So, [Cobra](https://github.com/spf13/cobra) is a Go CLI library with a feature set that's hard to resist for bigger applications (autocompletion, docs and man pages auto generation etc.). But it's also complex to use beyond the simplest of applications. This package was built to help rewriting [Hugo's](https://github.com/gohugoio/hugo) commands package to something that's easier to understand and maintain.
 
 I welcome suggestions to improve/simplify this further, but the core idea is that the command graph gets built in one go with a tree of struct pointers implementing a simple `Commander` interface:
 
@@ -70,7 +70,7 @@ func main() {
 
 You have access to the `*cobra.Command` pointer so there's not much you cannot do with this project compared to the more low-level Cobra, but there's one small, but imortant difference:
 
-Cobra only treats the first level of misspelled commands as an `unknown command` with "Did you mean this?" suggestions, see [see this issue](https://github.com/spf13/cobra/pull/1500) for more context. The reason this is, is because of the ambiguity between sub command names and command arguments, but that is throwing away a very useful feature for not a very good reason. We recently rewrote [Hugo's CLI](https://github.com/gohugoio/hugo) using this poackage, and found only one sub command that needed to be adjusted to avoid this ambiguity.
+Cobra only treats the first level of misspelled commands as an `unknown command` with "Did you mean this?" suggestions, see [see this issue](https://github.com/spf13/cobra/pull/1500) for more context. The reason this is, is because of the ambiguity between sub command names and command arguments, but that is throwing away a very useful feature for a not very good reason. We recently rewrote [Hugo's CLI](https://github.com/gohugoio/hugo) using this poackage, and found only one sub command that needed to be adjusted to avoid this ambiguity.
 
 
 

simplecobra.go

@@ -99,11 +99,7 @@ func (c *Commandeer) init() error {
 }
 
 type runErr struct {
-	err error
-}
-
-func (r *runErr) Error() string {
-	return fmt.Sprintf("run error: %v", r.err)
+	error
 }
 
 func (c *Commandeer) compile() error {
@@ -115,7 +111,7 @@ func (c *Commandeer) compile() error {
 		Use: fmt.Sprintf("%s %s", c.Command.Name(), useCommandFlagsArgs),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if err := c.Command.Run(cmd.Context(), c, args); err != nil {
-				return &runErr{err: err}
+				return &runErr{error: err}
 			}
 			return nil
 		},
@@ -128,7 +124,9 @@ func (c *Commandeer) compile() error {
 	}
 
 	// This is where the flags, short and long description etc. are added
-	c.Command.WithCobraCommand(c.CobraCommand)
+	if err := c.Command.WithCobraCommand(c.CobraCommand); err != nil {
+		return err
+	}
 
 	// Add commands recursively.
 	for _, cc := range c.commandeers {
@@ -149,6 +147,10 @@ type Exec struct {
 // Execute executes the command tree starting from the root command.
 // The args are usually filled with os.Args[1:].
 func (r *Exec) Execute(ctx context.Context, args []string) (*Commandeer, error) {
+	if args == nil {
+		// Cobra falls back to os.Args[1:] if args is nil.
+		args = []string{}
+	}
 	r.c.CobraCommand.SetArgs(args)
 	cobraCommand, err := r.c.CobraCommand.ExecuteContextC(ctx)
 	var cd *Commandeer
@@ -177,20 +179,24 @@ func (r *Exec) Execute(ctx context.Context, args []string) (*Commandeer, error)
 }
 
 // CommandError is returned when a command fails because of a user error (unknown command, invalid flag etc.).
+// All other errors comes from the execution of the command.
 type CommandError struct {
 	Err error
 }
 
+// Error implements error.
 func (e *CommandError) Error() string {
 	return fmt.Sprintf("command error: %v", e.Err)
 }
 
+// Is reports whether e is of type *CommandError.
+func (*CommandError) Is(e error) bool {
+	_, ok := e.(*CommandError)
+	return ok
+}
+
 // IsCommandError  reports whether any error in err's tree matches CommandError.
 func IsCommandError(err error) bool {
-	switch err.(type) {
-	case *CommandError:
-		return true
-	}
 	return errors.Is(err, &CommandError{})
 }
 
@@ -200,7 +206,7 @@ func wrapErr(err error) error {
 	}
 
 	if rerr, ok := err.(*runErr); ok {
-		err = rerr.err
+		return rerr.error
 	}
 
 	// All other errors are coming from Cobra.
@@ -234,9 +240,6 @@ func findSuggestions(cmd *cobra.Command, arg string) string {
 	if cmd.DisableSuggestions {
 		return ""
 	}
-	if cmd.SuggestionsMinimumDistance <= 0 {
-		cmd.SuggestionsMinimumDistance = 2
-	}
 	suggestionsString := ""
 	if suggestions := cmd.SuggestionsFor(arg); len(suggestions) > 0 {
 		suggestionsString += "\n\nDid you mean this?\n"

simplecobra_test.go

@@ -2,8 +2,10 @@ package simplecobra_test
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log"
+	"os"
 	"testing"
 
 	"github.com/bep/simplecobra"
@@ -121,6 +123,24 @@ func TestErrors(t *testing.T) {
 		c.Assert(simplecobra.IsCommandError(err), qt.Equals, true)
 	})
 
+	c.Run("disable suggestions", func(c *qt.C) {
+		r := &rootCommand{name: "root",
+			commands: []simplecobra.Commander{
+				&lvl1Command{name: "foo", disableSuggestions: true,
+					commands: []simplecobra.Commander{
+						&lvl2Command{name: "bar"},
+					},
+				},
+			},
+		}
+		x, err := simplecobra.New(r)
+		c.Assert(err, qt.IsNil)
+		_, err = x.Execute(context.Background(), []string{"foo", "bars"})
+		c.Assert(err, qt.Not(qt.IsNil))
+		c.Assert(err.Error(), qt.Contains, "unknown")
+		c.Assert(err.Error(), qt.Not(qt.Contains), "Did you mean this?")
+	})
+
 	c.Run("unknown flag", func(c *qt.C) {
 		x, err := simplecobra.New(testCommands())
 		c.Assert(err, qt.IsNil)
@@ -130,6 +150,63 @@ func TestErrors(t *testing.T) {
 		c.Assert(simplecobra.IsCommandError(err), qt.Equals, true)
 	})
 
+	c.Run("fail New in root command", func(c *qt.C) {
+		r := &rootCommand{name: "root", failWithCobraCommand: true,
+			commands: []simplecobra.Commander{
+				&lvl1Command{name: "foo"},
+			},
+		}
+		_, err := simplecobra.New(r)
+		c.Assert(err, qt.IsNotNil)
+	})
+
+	c.Run("fail New in sub command", func(c *qt.C) {
+		r := &rootCommand{name: "root",
+			commands: []simplecobra.Commander{
+				&lvl1Command{name: "foo", failWithCobraCommand: true},
+			},
+		}
+		_, err := simplecobra.New(r)
+		c.Assert(err, qt.IsNotNil)
+	})
+
+	c.Run("fail run root command", func(c *qt.C) {
+		r := &rootCommand{name: "root", failRun: true,
+			commands: []simplecobra.Commander{
+				&lvl1Command{name: "foo"},
+			},
+		}
+		x, err := simplecobra.New(r)
+		c.Assert(err, qt.IsNil)
+		_, err = x.Execute(context.Background(), nil)
+		c.Assert(err, qt.IsNotNil)
+		c.Assert(err.Error(), qt.Equals, "failRun")
+	})
+
+	c.Run("fail init sub command", func(c *qt.C) {
+		r := &rootCommand{name: "root",
+			commands: []simplecobra.Commander{
+				&lvl1Command{name: "foo", failInit: true},
+			},
+		}
+		x, err := simplecobra.New(r)
+		c.Assert(err, qt.IsNil)
+		_, err = x.Execute(context.Background(), []string{"foo"})
+		c.Assert(err, qt.IsNotNil)
+
+	})
+
+}
+
+func TestIsCommandError(t *testing.T) {
+	c := qt.New(t)
+	cerr := &simplecobra.CommandError{Err: errors.New("foo")}
+	c.Assert(simplecobra.IsCommandError(os.ErrNotExist), qt.Equals, false)
+	c.Assert(simplecobra.IsCommandError(nil), qt.Equals, false)
+	c.Assert(simplecobra.IsCommandError(errors.New("foo")), qt.Equals, false)
+	c.Assert(simplecobra.IsCommandError(cerr), qt.Equals, true)
+	c.Assert(simplecobra.IsCommandError(fmt.Errorf("foo: %w", cerr)), qt.Equals, true)
+
 }
 
 func Example() {
@@ -176,9 +253,11 @@ type rootCommand struct {
 	localFlagNameC      string
 
 	// For testing.
-	ctx        context.Context
-	initThis   *simplecobra.Commandeer
-	initRunner *simplecobra.Commandeer
+	ctx                  context.Context
+	initThis             *simplecobra.Commandeer
+	initRunner           *simplecobra.Commandeer
+	failWithCobraCommand bool
+	failRun              bool
 
 	// Sub commands.
 	commands []simplecobra.Commander
@@ -202,11 +281,17 @@ func (c *rootCommand) Name() string {
 }
 
 func (c *rootCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
+	if c.failRun {
+		return errors.New("failRun")
+	}
 	c.ctx = ctx
 	return nil
 }
 
 func (c *rootCommand) WithCobraCommand(cmd *cobra.Command) error {
+	if c.failWithCobraCommand {
+		return errors.New("failWithCobraCommand")
+	}
 	localFlags := cmd.Flags()
 	persistentFlags := cmd.PersistentFlags()
 
@@ -223,6 +308,10 @@ type lvl1Command struct {
 	localFlagName  string
 	localFlagNameC string
 
+	failInit             bool
+	failWithCobraCommand bool
+	disableSuggestions   bool
+
 	rootCmd *rootCommand
 
 	commands []simplecobra.Commander
@@ -235,6 +324,9 @@ func (c *lvl1Command) Commands() []simplecobra.Commander {
 }
 
 func (c *lvl1Command) Init(this, runner *simplecobra.Commandeer) error {
+	if c.failInit {
+		return fmt.Errorf("failInit")
+	}
 	c.isInit = true
 	c.localFlagNameC = c.localFlagName + "_lvl1Command_compiled"
 	c.rootCmd = this.Root.Command.(*rootCommand)
@@ -251,6 +343,10 @@ func (c *lvl1Command) Run(ctx context.Context, cd *simplecobra.Commandeer, args
 }
 
 func (c *lvl1Command) WithCobraCommand(cmd *cobra.Command) error {
+	if c.failWithCobraCommand {
+		return errors.New("failWithCobraCommand")
+	}
+	cmd.DisableSuggestions = c.disableSuggestions
 	localFlags := cmd.Flags()
 	localFlags.StringVar(&c.localFlagName, "localFlagName", "", "set localFlagName for lvl1Command")
 	return nil