tests for CmdFlags

commands.go

@@ -442,14 +442,16 @@ func IsHelp(err error) bool {
 
 type CmdFlags struct {
 	*flag.FlagSet
+	w       io.Writer
 	name    string
 	args    []string
 	argsets [][]string
 }
 
 func Flags(name string, args []string) *CmdFlags {
-	set := flag.NewFlagSet(name, flag.PanicOnError)
-	f := &CmdFlags{set, name, args, nil}
+	set := flag.NewFlagSet(name, flag.ContinueOnError)
+	f := &CmdFlags{set, nil, name, args, nil}
+	f.SetOutput(os.Stderr)
 	set.Usage = f.usage
 	return f
 }
@@ -459,7 +461,11 @@ func (f *CmdFlags) ArgSet(args ...string) {
 }
 
 func (f *CmdFlags) usage() {
-	w := tabwriter.NewWriter(os.Stdout, 5, 2, 2, ' ', 0)
+	fw := f.w
+	if fw == nil {
+		fw = ioutil.Discard
+	}
+	w := tabwriter.NewWriter(fw, 5, 2, 2, ' ', 0)
 	fmt.Fprintf(w, "usage:\t")
 	if len(f.argsets) == 0 {
 		fmt.Fprintln(w, f.name)
@@ -474,20 +480,14 @@ func (f *CmdFlags) usage() {
 	f.PrintDefaults()
 }
 
+func (f *CmdFlags) SetOutput(w io.Writer) {
+	f.w = w
+	f.FlagSet.SetOutput(w)
+}
+
 func (f *CmdFlags) Parse(args *[]string) (err error) {
-	defer func() {
-		if e := recover(); e != nil {
-			var iserr bool
-			err, iserr = e.(error)
-			if iserr {
-				return
-			}
-			err = fmt.Errorf("%v", e)
-		}
-	}()
 	if args == nil {
 		args = &f.args
 	}
-	f.FlagSet.Parse(*args)
-	return nil
+	return f.FlagSet.Parse(*args)
 }

commands_test.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"testing"
+)
+
+func testFlags(name string, args []string) (*CmdFlags, *bytes.Buffer) {
+	buf := new(bytes.Buffer)
+	flags := Flags(name, args)
+	flags.SetOutput(buf)
+	return flags, buf
+}
+
+func TestCmdFlags(t *testing.T) {
+	// parses good flags correctly
+	rawargs := []string{"-a", "b", "-c", "d"}
+	flags, _ := testFlags("test", rawargs)
+	a := flags.String("a", "", "a string")
+	c := flags.Bool("c", false, "a bool")
+	err := flags.Parse(nil)
+	if err != nil {
+		t.Fatalf("parsing flags: %v", err)
+	}
+	if *a != "b" {
+		t.Fatal("bad -a flag: %q", *a)
+	}
+	if !*c {
+		t.Fatal("bad -c flag: %b", *c)
+	}
+	args := flags.Args()
+	if len(args) != 1 || args[0] != "d" {
+		t.Fatalf("unexpected args: %q", args)
+	}
+
+	// bails out on bad flags
+	flags, _ = testFlags("test", rawargs) // TODO test that there is some output ("usage:")
+	err = flags.Parse(nil)
+	if err == flag.ErrHelp {
+		t.Fatal("ErrHelp")
+	}
+	if err == nil {
+		t.Fatal("no error")
+	}
+
+	// returns ErrHelp when -h is given
+	flags, _ = testFlags("test", []string{"-a", "-h"}) // TODO test help output in another test
+	flags.Bool("a", false, "a bool")
+	err = flags.Parse(nil)
+	if err != flag.ErrHelp {
+		t.Fatalf("missing flag.ErrHelp")
+	}
+}