migrate to upstream libcompose in one and a half go

vendor/github.com/codegangsta/cli/app_test.go

@@ -1,59 +1,60 @@
-package cli_test
+package cli
 
 import (
+	"bytes"
 	"flag"
 	"fmt"
+	"io"
 	"os"
+	"strings"
 	"testing"
-
-	"github.com/codegangsta/cli"
 )
 
-func ExampleApp() {
+func ExampleApp_Run() {
 	// set args for examples sake
 	os.Args = []string{"greet", "--name", "Jeremy"}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "greet"
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+	app.Flags = []Flag{
+		StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
 	}
-	app.Action = func(c *cli.Context) {
+	app.Action = func(c *Context) {
 		fmt.Printf("Hello %v\n", c.String("name"))
 	}
 	app.Author = "Harrison"
 	app.Email = "harrison@lolwut.com"
-	app.Authors = []cli.Author{{"Oliver Allen", "oliver@toyshop.com"}}
+	app.Authors = []Author{Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
 	app.Run(os.Args)
 	// Output:
 	// Hello Jeremy
 }
 
-func ExampleAppSubcommand() {
+func ExampleApp_Run_subcommand() {
 	// set args for examples sake
 	os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "say"
-	app.Commands = []cli.Command{
+	app.Commands = []Command{
 		{
 			Name:        "hello",
-			ShortName:   "hi",
+			Aliases:     []string{"hi"},
 			Usage:       "use it to see a description",
 			Description: "This is how we describe hello the function",
-			Subcommands: []cli.Command{
+			Subcommands: []Command{
 				{
 					Name:        "english",
-					ShortName:   "en",
+					Aliases:     []string{"en"},
 					Usage:       "sends a greeting in english",
 					Description: "greets someone in english",
-					Flags: []cli.Flag{
-						cli.StringFlag{
+					Flags: []Flag{
+						StringFlag{
 							Name:  "name",
 							Value: "Bob",
 							Usage: "Name of the person to greet",
 						},
 					},
-					Action: func(c *cli.Context) {
+					Action: func(c *Context) {
 						fmt.Println("Hello,", c.String("name"))
 					},
 				},
@@ -66,22 +67,22 @@ func ExampleAppSubcommand() {
 	// Hello, Jeremy
 }
 
-func ExampleAppHelp() {
+func ExampleApp_Run_help() {
 	// set args for examples sake
 	os.Args = []string{"greet", "h", "describeit"}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "greet"
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+	app.Flags = []Flag{
+		StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
 	}
-	app.Commands = []cli.Command{
+	app.Commands = []Command{
 		{
 			Name:        "describeit",
-			ShortName:   "d",
+			Aliases:     []string{"d"},
 			Usage:       "use it to see a description",
 			Description: "This is how we describe describeit the function",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				fmt.Printf("i like to describe things")
 			},
 		},
@@ -89,36 +90,36 @@ func ExampleAppHelp() {
 	app.Run(os.Args)
 	// Output:
 	// NAME:
-	//    describeit - use it to see a description
+	//    greet describeit - use it to see a description
 	//
 	// USAGE:
-	//    command describeit [arguments...]
+	//    greet describeit [arguments...]
 	//
 	// DESCRIPTION:
 	//    This is how we describe describeit the function
 }
 
-func ExampleAppBashComplete() {
+func ExampleApp_Run_bashComplete() {
 	// set args for examples sake
 	os.Args = []string{"greet", "--generate-bash-completion"}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "greet"
 	app.EnableBashCompletion = true
-	app.Commands = []cli.Command{
+	app.Commands = []Command{
 		{
 			Name:        "describeit",
-			ShortName:   "d",
+			Aliases:     []string{"d"},
 			Usage:       "use it to see a description",
 			Description: "This is how we describe describeit the function",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				fmt.Printf("i like to describe things")
 			},
 		}, {
 			Name:        "next",
 			Usage:       "next example",
 			Description: "more stuff to see when generating bash completion",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				fmt.Printf("the next example")
 			},
 		},
@@ -136,8 +137,8 @@ func ExampleAppBashComplete() {
 func TestApp_Run(t *testing.T) {
 	s := ""
 
-	app := cli.NewApp()
-	app.Action = func(c *cli.Context) {
+	app := NewApp()
+	app.Action = func(c *Context) {
 		s = s + c.Args().First()
 	}
 
@@ -161,10 +162,10 @@ var commandAppTests = []struct {
 }
 
 func TestApp_Command(t *testing.T) {
-	app := cli.NewApp()
-	fooCommand := cli.Command{Name: "foobar", ShortName: "f"}
-	batCommand := cli.Command{Name: "batbaz", ShortName: "b"}
-	app.Commands = []cli.Command{
+	app := NewApp()
+	fooCommand := Command{Name: "foobar", Aliases: []string{"f"}}
+	batCommand := Command{Name: "batbaz", Aliases: []string{"b"}}
+	app.Commands = []Command{
 		fooCommand,
 		batCommand,
 	}
@@ -177,18 +178,18 @@ func TestApp_Command(t *testing.T) {
 func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
 	var parsedOption, firstArg string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
+		Flags: []Flag{
+			StringFlag{Name: "option", Value: "", Usage: "some option"},
 		},
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			parsedOption = c.String("option")
 			firstArg = c.Args().First()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
 
@@ -197,23 +198,23 @@ func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
 }
 
 func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
-	var context *cli.Context
+	var context *Context
 
-	a := cli.NewApp()
-	a.Commands = []cli.Command{
+	a := NewApp()
+	a.Commands = []Command{
 		{
 			Name: "foo",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				context = c
 			},
-			Flags: []cli.Flag{
-				cli.StringFlag{
+			Flags: []Flag{
+				StringFlag{
 					Name:  "lang",
 					Value: "english",
 					Usage: "language for the greeting",
 				},
 			},
-			Before: func(_ *cli.Context) error { return nil },
+			Before: func(_ *Context) error { return nil },
 		},
 	}
 	a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
@@ -226,18 +227,18 @@ func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
 	var parsedOption string
 	var args []string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
+		Flags: []Flag{
+			StringFlag{Name: "option", Value: "", Usage: "some option"},
 		},
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			parsedOption = c.String("option")
 			args = c.Args()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"})
 
@@ -250,14 +251,14 @@ func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
 func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
 	var args []string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			args = c.Args()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"})
 
@@ -269,11 +270,11 @@ func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
 func TestApp_Float64Flag(t *testing.T) {
 	var meters float64
 
-	app := cli.NewApp()
-	app.Flags = []cli.Flag{
-		cli.Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
+	app := NewApp()
+	app.Flags = []Flag{
+		Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
 	}
-	app.Action = func(c *cli.Context) {
+	app.Action = func(c *Context) {
 		meters = c.Float64("height")
 	}
 
@@ -286,21 +287,21 @@ func TestApp_ParseSliceFlags(t *testing.T) {
 	var parsedIntSlice []int
 	var parsedStringSlice []string
 
-	app := cli.NewApp()
-	command := cli.Command{
+	app := NewApp()
+	command := Command{
 		Name: "cmd",
-		Flags: []cli.Flag{
-			cli.IntSliceFlag{Name: "p", Value: &cli.IntSlice{}, Usage: "set one or more ip addr"},
-			cli.StringSliceFlag{Name: "ip", Value: &cli.StringSlice{}, Usage: "set one or more ports to open"},
+		Flags: []Flag{
+			IntSliceFlag{Name: "p", Value: &IntSlice{}, Usage: "set one or more ip addr"},
+			StringSliceFlag{Name: "ip", Value: &StringSlice{}, Usage: "set one or more ports to open"},
 		},
-		Action: func(c *cli.Context) {
+		Action: func(c *Context) {
 			parsedIntSlice = c.IntSlice("p")
 			parsedStringSlice = c.StringSlice("ip")
 			parsedOption = c.String("option")
 			firstArg = c.Args().First()
 		},
 	}
-	app.Commands = []cli.Command{command}
+	app.Commands = []Command{command}
 
 	app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
 
@@ -339,8 +340,40 @@ func TestApp_ParseSliceFlags(t *testing.T) {
 	}
 }
 
+func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
+	var parsedIntSlice []int
+	var parsedStringSlice []string
+
+	app := NewApp()
+	command := Command{
+		Name: "cmd",
+		Flags: []Flag{
+			IntSliceFlag{Name: "a", Usage: "set numbers"},
+			StringSliceFlag{Name: "str", Usage: "set strings"},
+		},
+		Action: func(c *Context) {
+			parsedIntSlice = c.IntSlice("a")
+			parsedStringSlice = c.StringSlice("str")
+		},
+	}
+	app.Commands = []Command{command}
+
+	app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"})
+
+	var expectedIntSlice = []int{2}
+	var expectedStringSlice = []string{"A"}
+
+	if parsedIntSlice[0] != expectedIntSlice[0] {
+		t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
+	}
+
+	if parsedStringSlice[0] != expectedStringSlice[0] {
+		t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
+	}
+}
+
 func TestApp_DefaultStdout(t *testing.T) {
-	app := cli.NewApp()
+	app := NewApp()
 
 	if app.Writer != os.Stdout {
 		t.Error("Default output writer not set.")
@@ -368,7 +401,7 @@ func (fw *mockWriter) GetWritten() (b []byte) {
 func TestApp_SetStdout(t *testing.T) {
 	w := &mockWriter{}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Name = "test"
 	app.Writer = w
 
@@ -388,9 +421,9 @@ func TestApp_BeforeFunc(t *testing.T) {
 	beforeError := fmt.Errorf("fail")
 	var err error
 
-	app := cli.NewApp()
+	app := NewApp()
 
-	app.Before = func(c *cli.Context) error {
+	app.Before = func(c *Context) error {
 		beforeRun = true
 		s := c.String("opt")
 		if s == "fail" {
@@ -400,17 +433,17 @@ func TestApp_BeforeFunc(t *testing.T) {
 		return nil
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "sub",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				subcommandRun = true
 			},
 		},
 	}
 
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "opt"},
+	app.Flags = []Flag{
+		StringFlag{Name: "opt"},
 	}
 
 	// run with the Before() func succeeding
@@ -454,9 +487,9 @@ func TestApp_AfterFunc(t *testing.T) {
 	afterError := fmt.Errorf("fail")
 	var err error
 
-	app := cli.NewApp()
+	app := NewApp()
 
-	app.After = func(c *cli.Context) error {
+	app.After = func(c *Context) error {
 		afterRun = true
 		s := c.String("opt")
 		if s == "fail" {
@@ -466,17 +499,17 @@ func TestApp_AfterFunc(t *testing.T) {
 		return nil
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "sub",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				subcommandRun = true
 			},
 		},
 	}
 
-	app.Flags = []cli.Flag{
-		cli.StringFlag{Name: "opt"},
+	app.Flags = []Flag{
+		StringFlag{Name: "opt"},
 	}
 
 	// run with the After() func succeeding
@@ -515,14 +548,14 @@ func TestApp_AfterFunc(t *testing.T) {
 }
 
 func TestAppNoHelpFlag(t *testing.T) {
-	oldFlag := cli.HelpFlag
+	oldFlag := HelpFlag
 	defer func() {
-		cli.HelpFlag = oldFlag
+		HelpFlag = oldFlag
 	}()
 
-	cli.HelpFlag = cli.BoolFlag{}
+	HelpFlag = BoolFlag{}
 
-	app := cli.NewApp()
+	app := NewApp()
 	err := app.Run([]string{"test", "-h"})
 
 	if err != flag.ErrHelp {
@@ -531,17 +564,17 @@ func TestAppNoHelpFlag(t *testing.T) {
 }
 
 func TestAppHelpPrinter(t *testing.T) {
-	oldPrinter := cli.HelpPrinter
+	oldPrinter := HelpPrinter
 	defer func() {
-		cli.HelpPrinter = oldPrinter
+		HelpPrinter = oldPrinter
 	}()
 
 	var wasCalled = false
-	cli.HelpPrinter = func(template string, data interface{}) {
+	HelpPrinter = func(w io.Writer, template string, data interface{}) {
 		wasCalled = true
 	}
 
-	app := cli.NewApp()
+	app := NewApp()
 	app.Run([]string{"-h"})
 
 	if wasCalled == false {
@@ -550,19 +583,19 @@ func TestAppHelpPrinter(t *testing.T) {
 }
 
 func TestAppVersionPrinter(t *testing.T) {
-	oldPrinter := cli.VersionPrinter
+	oldPrinter := VersionPrinter
 	defer func() {
-		cli.VersionPrinter = oldPrinter
+		VersionPrinter = oldPrinter
 	}()
 
 	var wasCalled = false
-	cli.VersionPrinter = func(c *cli.Context) {
+	VersionPrinter = func(c *Context) {
 		wasCalled = true
 	}
 
-	app := cli.NewApp()
-	ctx := cli.NewContext(app, nil, nil)
-	cli.ShowVersion(ctx)
+	app := NewApp()
+	ctx := NewContext(app, nil, nil)
+	ShowVersion(ctx)
 
 	if wasCalled == false {
 		t.Errorf("Version printer expected to be called, but was not")
@@ -571,16 +604,16 @@ func TestAppVersionPrinter(t *testing.T) {
 
 func TestAppCommandNotFound(t *testing.T) {
 	beforeRun, subcommandRun := false, false
-	app := cli.NewApp()
+	app := NewApp()
 
-	app.CommandNotFound = func(c *cli.Context, command string) {
+	app.CommandNotFound = func(c *Context, command string) {
 		beforeRun = true
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "bar",
-			Action: func(c *cli.Context) {
+			Action: func(c *Context) {
 				subcommandRun = true
 			},
 		},
@@ -592,31 +625,336 @@ func TestAppCommandNotFound(t *testing.T) {
 	expect(t, subcommandRun, false)
 }
 
+func TestGlobalFlag(t *testing.T) {
+	var globalFlag string
+	var globalFlagSet bool
+	app := NewApp()
+	app.Flags = []Flag{
+		StringFlag{Name: "global, g", Usage: "global"},
+	}
+	app.Action = func(c *Context) {
+		globalFlag = c.GlobalString("global")
+		globalFlagSet = c.GlobalIsSet("global")
+	}
+	app.Run([]string{"command", "-g", "foo"})
+	expect(t, globalFlag, "foo")
+	expect(t, globalFlagSet, true)
+
+}
+
 func TestGlobalFlagsInSubcommands(t *testing.T) {
 	subcommandRun := false
-	app := cli.NewApp()
+	parentFlag := false
+	app := NewApp()
 
-	app.Flags = []cli.Flag{
-		cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
+	app.Flags = []Flag{
+		BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
 	}
 
-	app.Commands = []cli.Command{
-		cli.Command{
+	app.Commands = []Command{
+		Command{
 			Name: "foo",
-			Subcommands: []cli.Command{
+			Flags: []Flag{
+				BoolFlag{Name: "parent, p", Usage: "Parent flag"},
+			},
+			Subcommands: []Command{
 				{
 					Name: "bar",
-					Action: func(c *cli.Context) {
+					Action: func(c *Context) {
 						if c.GlobalBool("debug") {
 							subcommandRun = true
 						}
+						if c.GlobalBool("parent") {
+							parentFlag = true
+						}
 					},
 				},
 			},
 		},
 	}
 
-	app.Run([]string{"command", "-d", "foo", "bar"})
+	app.Run([]string{"command", "-d", "foo", "-p", "bar"})
 
 	expect(t, subcommandRun, true)
+	expect(t, parentFlag, true)
+}
+
+func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
+	var subcommandHelpTopics = [][]string{
+		{"command", "foo", "--help"},
+		{"command", "foo", "-h"},
+		{"command", "foo", "help"},
+	}
+
+	for _, flagSet := range subcommandHelpTopics {
+		t.Logf("==> checking with flags %v", flagSet)
+
+		app := NewApp()
+		buf := new(bytes.Buffer)
+		app.Writer = buf
+
+		subCmdBar := Command{
+			Name:  "bar",
+			Usage: "does bar things",
+		}
+		subCmdBaz := Command{
+			Name:  "baz",
+			Usage: "does baz things",
+		}
+		cmd := Command{
+			Name:        "foo",
+			Description: "descriptive wall of text about how it does foo things",
+			Subcommands: []Command{subCmdBar, subCmdBaz},
+		}
+
+		app.Commands = []Command{cmd}
+		err := app.Run(flagSet)
+
+		if err != nil {
+			t.Error(err)
+		}
+
+		output := buf.String()
+		t.Logf("output: %q\n", buf.Bytes())
+
+		if strings.Contains(output, "No help topic for") {
+			t.Errorf("expect a help topic, got none: \n%q", output)
+		}
+
+		for _, shouldContain := range []string{
+			cmd.Name, cmd.Description,
+			subCmdBar.Name, subCmdBar.Usage,
+			subCmdBaz.Name, subCmdBaz.Usage,
+		} {
+			if !strings.Contains(output, shouldContain) {
+				t.Errorf("want help to contain %q, did not: \n%q", shouldContain, output)
+			}
+		}
+	}
+}
+
+func TestApp_Run_SubcommandFullPath(t *testing.T) {
+	app := NewApp()
+	buf := new(bytes.Buffer)
+	app.Writer = buf
+	app.Name = "command"
+	subCmd := Command{
+		Name:  "bar",
+		Usage: "does bar things",
+	}
+	cmd := Command{
+		Name:        "foo",
+		Description: "foo commands",
+		Subcommands: []Command{subCmd},
+	}
+	app.Commands = []Command{cmd}
+
+	err := app.Run([]string{"command", "foo", "bar", "--help"})
+	if err != nil {
+		t.Error(err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "command foo bar - does bar things") {
+		t.Errorf("expected full path to subcommand: %s", output)
+	}
+	if !strings.Contains(output, "command foo bar [arguments...]") {
+		t.Errorf("expected full path to subcommand: %s", output)
+	}
+}
+
+func TestApp_Run_SubcommandHelpName(t *testing.T) {
+	app := NewApp()
+	buf := new(bytes.Buffer)
+	app.Writer = buf
+	app.Name = "command"
+	subCmd := Command{
+		Name:     "bar",
+		HelpName: "custom",
+		Usage:    "does bar things",
+	}
+	cmd := Command{
+		Name:        "foo",
+		Description: "foo commands",
+		Subcommands: []Command{subCmd},
+	}
+	app.Commands = []Command{cmd}
+
+	err := app.Run([]string{"command", "foo", "bar", "--help"})
+	if err != nil {
+		t.Error(err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "custom - does bar things") {
+		t.Errorf("expected HelpName for subcommand: %s", output)
+	}
+	if !strings.Contains(output, "custom [arguments...]") {
+		t.Errorf("expected HelpName to subcommand: %s", output)
+	}
+}
+
+func TestApp_Run_CommandHelpName(t *testing.T) {
+	app := NewApp()
+	buf := new(bytes.Buffer)
+	app.Writer = buf
+	app.Name = "command"
+	subCmd := Command{
+		Name:  "bar",
+		Usage: "does bar things",
+	}
+	cmd := Command{
+		Name:        "foo",
+		HelpName:    "custom",
+		Description: "foo commands",
+		Subcommands: []Command{subCmd},
+	}
+	app.Commands = []Command{cmd}
+
+	err := app.Run([]string{"command", "foo", "bar", "--help"})
+	if err != nil {
+		t.Error(err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "command foo bar - does bar things") {
+		t.Errorf("expected full path to subcommand: %s", output)
+	}
+	if !strings.Contains(output, "command foo bar [arguments...]") {
+		t.Errorf("expected full path to subcommand: %s", output)
+	}
+}
+
+func TestApp_Run_CommandSubcommandHelpName(t *testing.T) {
+	app := NewApp()
+	buf := new(bytes.Buffer)
+	app.Writer = buf
+	app.Name = "base"
+	subCmd := Command{
+		Name:     "bar",
+		HelpName: "custom",
+		Usage:    "does bar things",
+	}
+	cmd := Command{
+		Name:        "foo",
+		Description: "foo commands",
+		Subcommands: []Command{subCmd},
+	}
+	app.Commands = []Command{cmd}
+
+	err := app.Run([]string{"command", "foo", "--help"})
+	if err != nil {
+		t.Error(err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, "base foo - foo commands") {
+		t.Errorf("expected full path to subcommand: %s", output)
+	}
+	if !strings.Contains(output, "base foo command [command options] [arguments...]") {
+		t.Errorf("expected full path to subcommand: %s", output)
+	}
+}
+
+func TestApp_Run_Help(t *testing.T) {
+	var helpArguments = [][]string{{"boom", "--help"}, {"boom", "-h"}, {"boom", "help"}}
+
+	for _, args := range helpArguments {
+		buf := new(bytes.Buffer)
+
+		t.Logf("==> checking with arguments %v", args)
+
+		app := NewApp()
+		app.Name = "boom"
+		app.Usage = "make an explosive entrance"
+		app.Writer = buf
+		app.Action = func(c *Context) {
+			buf.WriteString("boom I say!")
+		}
+
+		err := app.Run(args)
+		if err != nil {
+			t.Error(err)
+		}
+
+		output := buf.String()
+		t.Logf("output: %q\n", buf.Bytes())
+
+		if !strings.Contains(output, "boom - make an explosive entrance") {
+			t.Errorf("want help to contain %q, did not: \n%q", "boom - make an explosive entrance", output)
+		}
+	}
+}
+
+func TestApp_Run_Version(t *testing.T) {
+	var versionArguments = [][]string{{"boom", "--version"}, {"boom", "-v"}}
+
+	for _, args := range versionArguments {
+		buf := new(bytes.Buffer)
+
+		t.Logf("==> checking with arguments %v", args)
+
+		app := NewApp()
+		app.Name = "boom"
+		app.Usage = "make an explosive entrance"
+		app.Version = "0.1.0"
+		app.Writer = buf
+		app.Action = func(c *Context) {
+			buf.WriteString("boom I say!")
+		}
+
+		err := app.Run(args)
+		if err != nil {
+			t.Error(err)
+		}
+
+		output := buf.String()
+		t.Logf("output: %q\n", buf.Bytes())
+
+		if !strings.Contains(output, "0.1.0") {
+			t.Errorf("want version to contain %q, did not: \n%q", "0.1.0", output)
+		}
+	}
+}
+
+func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
+	app := NewApp()
+	app.Action = func(c *Context) {}
+	app.Before = func(c *Context) error { return fmt.Errorf("before error") }
+	app.After = func(c *Context) error { return fmt.Errorf("after error") }
+
+	err := app.Run([]string{"foo"})
+	if err == nil {
+		t.Fatalf("expected to recieve error from Run, got none")
+	}
+
+	if !strings.Contains(err.Error(), "before error") {
+		t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
+	}
+	if !strings.Contains(err.Error(), "after error") {
+		t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
+	}
+}
+
+func TestApp_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) {
+	app := NewApp()
+	app.Commands = []Command{
+		Command{
+			Name:   "bar",
+			Before: func(c *Context) error { return fmt.Errorf("before error") },
+			After:  func(c *Context) error { return fmt.Errorf("after error") },
+		},
+	}
+
+	err := app.Run([]string{"foo", "bar"})
+	if err == nil {
+		t.Fatalf("expected to recieve error from Run, got none")
+	}
+
+	if !strings.Contains(err.Error(), "before error") {
+		t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
+	}
+	if !strings.Contains(err.Error(), "after error") {
+		t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
+	}
 }