x/urfave-cli
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Improve vendoring options by removing self-referential imports in tests.

Browse Source
This commit is contained in:
Edward Sheffler III 2015-07-20 12:18:25 -07:00 committed by Edward Sheffler III
parent bca61c476e
commit 8ea1232ede
7 changed files with 319 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

282
app_test.go
View File

@ -1,4 +1,4 @@
package cli_test package cli
import ( import (
"bytes" "bytes"
@ -8,25 +8,23 @@ import (
"os" "os"
"strings" "strings"
"testing" "testing"
"github.com/codegangsta/cli"
) )
func ExampleApp() { func ExampleApp() {
// set args for examples sake // set args for examples sake
os.Args = []string{"greet", "--name", "Jeremy"} os.Args = []string{"greet", "--name", "Jeremy"}
app := cli.NewApp() app := NewApp()
app.Name = "greet" app.Name = "greet"
app.Flags = []cli.Flag{ app.Flags = []Flag{
cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"}, 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")) fmt.Printf("Hello %v\n", c.String("name"))
} }
app.Author = "Harrison" app.Author = "Harrison"
app.Email = "harrison@lolwut.com" app.Email = "harrison@lolwut.com"
app.Authors = []cli.Author{cli.Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}} app.Authors = []Author{Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
app.Run(os.Args) app.Run(os.Args)
// Output: // Output:
// Hello Jeremy // Hello Jeremy
@ -35,28 +33,28 @@ func ExampleApp() {
func ExampleAppSubcommand() { func ExampleAppSubcommand() {
// set args for examples sake // set args for examples sake
os.Args = []string{"say", "hi", "english", "--name", "Jeremy"} os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
app := cli.NewApp() app := NewApp()
app.Name = "say" app.Name = "say"
app.Commands = []cli.Command{ app.Commands = []Command{
{ {
Name: "hello", Name: "hello",
Aliases: []string{"hi"}, Aliases: []string{"hi"},
Usage: "use it to see a description", Usage: "use it to see a description",
Description: "This is how we describe hello the function", Description: "This is how we describe hello the function",
Subcommands: []cli.Command{ Subcommands: []Command{
{ {
Name: "english", Name: "english",
Aliases: []string{"en"}, Aliases: []string{"en"},
Usage: "sends a greeting in english", Usage: "sends a greeting in english",
Description: "greets someone in english", Description: "greets someone in english",
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{ StringFlag{
Name: "name", Name: "name",
Value: "Bob", Value: "Bob",
Usage: "Name of the person to greet", Usage: "Name of the person to greet",
}, },
}, },
Action: func(c *cli.Context) { Action: func(c *Context) {
fmt.Println("Hello,", c.String("name")) fmt.Println("Hello,", c.String("name"))
}, },
}, },
@ -73,18 +71,18 @@ func ExampleAppHelp() {
// set args for examples sake // set args for examples sake
os.Args = []string{"greet", "h", "describeit"} os.Args = []string{"greet", "h", "describeit"}
app := cli.NewApp() app := NewApp()
app.Name = "greet" app.Name = "greet"
app.Flags = []cli.Flag{ app.Flags = []Flag{
cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"}, StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
} }
app.Commands = []cli.Command{ app.Commands = []Command{
{ {
Name: "describeit", Name: "describeit",
Aliases: []string{"d"}, Aliases: []string{"d"},
Usage: "use it to see a description", Usage: "use it to see a description",
Description: "This is how we describe describeit the function", 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") fmt.Printf("i like to describe things")
}, },
}, },
@ -105,23 +103,23 @@ func ExampleAppBashComplete() {
// set args for examples sake // set args for examples sake
os.Args = []string{"greet", "--generate-bash-completion"} os.Args = []string{"greet", "--generate-bash-completion"}
app := cli.NewApp() app := NewApp()
app.Name = "greet" app.Name = "greet"
app.EnableBashCompletion = true app.EnableBashCompletion = true
app.Commands = []cli.Command{ app.Commands = []Command{
{ {
Name: "describeit", Name: "describeit",
Aliases: []string{"d"}, Aliases: []string{"d"},
Usage: "use it to see a description", Usage: "use it to see a description",
Description: "This is how we describe describeit the function", 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") fmt.Printf("i like to describe things")
}, },
}, { }, {
Name: "next", Name: "next",
Usage: "next example", Usage: "next example",
Description: "more stuff to see when generating bash completion", Description: "more stuff to see when generating bash completion",
Action: func(c *cli.Context) { Action: func(c *Context) {
fmt.Printf("the next example") fmt.Printf("the next example")
}, },
}, },
@ -139,8 +137,8 @@ func ExampleAppBashComplete() {
func TestApp_Run(t *testing.T) { func TestApp_Run(t *testing.T) {
s := "" s := ""
app := cli.NewApp() app := NewApp()
app.Action = func(c *cli.Context) { app.Action = func(c *Context) {
s = s + c.Args().First() s = s + c.Args().First()
} }
@ -164,10 +162,10 @@ var commandAppTests = []struct {
} }
func TestApp_Command(t *testing.T) { func TestApp_Command(t *testing.T) {
app := cli.NewApp() app := NewApp()
fooCommand := cli.Command{Name: "foobar", Aliases: []string{"f"}} fooCommand := Command{Name: "foobar", Aliases: []string{"f"}}
batCommand := cli.Command{Name: "batbaz", Aliases: []string{"b"}} batCommand := Command{Name: "batbaz", Aliases: []string{"b"}}
app.Commands = []cli.Command{ app.Commands = []Command{
fooCommand, fooCommand,
batCommand, batCommand,
} }
@ -180,18 +178,18 @@ func TestApp_Command(t *testing.T) {
func TestApp_CommandWithArgBeforeFlags(t *testing.T) { func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
var parsedOption, firstArg string var parsedOption, firstArg string
app := cli.NewApp() app := NewApp()
command := cli.Command{ command := Command{
Name: "cmd", Name: "cmd",
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{Name: "option", Value: "", Usage: "some option"}, StringFlag{Name: "option", Value: "", Usage: "some option"},
}, },
Action: func(c *cli.Context) { Action: func(c *Context) {
parsedOption = c.String("option") parsedOption = c.String("option")
firstArg = c.Args().First() firstArg = c.Args().First()
}, },
} }
app.Commands = []cli.Command{command} app.Commands = []Command{command}
app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"}) app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
@ -200,23 +198,23 @@ func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
} }
func TestApp_RunAsSubcommandParseFlags(t *testing.T) { func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
var context *cli.Context var context *Context
a := cli.NewApp() a := NewApp()
a.Commands = []cli.Command{ a.Commands = []Command{
{ {
Name: "foo", Name: "foo",
Action: func(c *cli.Context) { Action: func(c *Context) {
context = c context = c
}, },
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{ StringFlag{
Name: "lang", Name: "lang",
Value: "english", Value: "english",
Usage: "language for the greeting", 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"}) a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
@ -229,18 +227,18 @@ func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
var parsedOption string var parsedOption string
var args []string var args []string
app := cli.NewApp() app := NewApp()
command := cli.Command{ command := Command{
Name: "cmd", Name: "cmd",
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{Name: "option", Value: "", Usage: "some option"}, StringFlag{Name: "option", Value: "", Usage: "some option"},
}, },
Action: func(c *cli.Context) { Action: func(c *Context) {
parsedOption = c.String("option") parsedOption = c.String("option")
args = c.Args() args = c.Args()
}, },
} }
app.Commands = []cli.Command{command} app.Commands = []Command{command}
app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"}) app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"})
@ -253,14 +251,14 @@ func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) { func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
var args []string var args []string
app := cli.NewApp() app := NewApp()
command := cli.Command{ command := Command{
Name: "cmd", Name: "cmd",
Action: func(c *cli.Context) { Action: func(c *Context) {
args = c.Args() args = c.Args()
}, },
} }
app.Commands = []cli.Command{command} app.Commands = []Command{command}
app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"}) app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"})
@ -272,11 +270,11 @@ func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
func TestApp_Float64Flag(t *testing.T) { func TestApp_Float64Flag(t *testing.T) {
var meters float64 var meters float64
app := cli.NewApp() app := NewApp()
app.Flags = []cli.Flag{ app.Flags = []Flag{
cli.Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"}, 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") meters = c.Float64("height")
} }
@ -289,21 +287,21 @@ func TestApp_ParseSliceFlags(t *testing.T) {
var parsedIntSlice []int var parsedIntSlice []int
var parsedStringSlice []string var parsedStringSlice []string
app := cli.NewApp() app := NewApp()
command := cli.Command{ command := Command{
Name: "cmd", Name: "cmd",
Flags: []cli.Flag{ Flags: []Flag{
cli.IntSliceFlag{Name: "p", Value: &cli.IntSlice{}, Usage: "set one or more ip addr"}, IntSliceFlag{Name: "p", Value: &IntSlice{}, Usage: "set one or more ip addr"},
cli.StringSliceFlag{Name: "ip", Value: &cli.StringSlice{}, Usage: "set one or more ports to open"}, 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") parsedIntSlice = c.IntSlice("p")
parsedStringSlice = c.StringSlice("ip") parsedStringSlice = c.StringSlice("ip")
parsedOption = c.String("option") parsedOption = c.String("option")
firstArg = c.Args().First() 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"}) app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
@ -346,19 +344,19 @@ func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
var parsedIntSlice []int var parsedIntSlice []int
var parsedStringSlice []string var parsedStringSlice []string
app := cli.NewApp() app := NewApp()
command := cli.Command{ command := Command{
Name: "cmd", Name: "cmd",
Flags: []cli.Flag{ Flags: []Flag{
cli.IntSliceFlag{Name: "a", Usage: "set numbers"}, IntSliceFlag{Name: "a", Usage: "set numbers"},
cli.StringSliceFlag{Name: "str", Usage: "set strings"}, StringSliceFlag{Name: "str", Usage: "set strings"},
}, },
Action: func(c *cli.Context) { Action: func(c *Context) {
parsedIntSlice = c.IntSlice("a") parsedIntSlice = c.IntSlice("a")
parsedStringSlice = c.StringSlice("str") parsedStringSlice = c.StringSlice("str")
}, },
} }
app.Commands = []cli.Command{command} app.Commands = []Command{command}
app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"}) app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"})
@ -375,7 +373,7 @@ func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
} }
func TestApp_DefaultStdout(t *testing.T) { func TestApp_DefaultStdout(t *testing.T) {
app := cli.NewApp() app := NewApp()
if app.Writer != os.Stdout { if app.Writer != os.Stdout {
t.Error("Default output writer not set.") t.Error("Default output writer not set.")
@ -403,7 +401,7 @@ func (fw *mockWriter) GetWritten() (b []byte) {
func TestApp_SetStdout(t *testing.T) { func TestApp_SetStdout(t *testing.T) {
w := &mockWriter{} w := &mockWriter{}
app := cli.NewApp() app := NewApp()
app.Name = "test" app.Name = "test"
app.Writer = w app.Writer = w
@ -423,9 +421,9 @@ func TestApp_BeforeFunc(t *testing.T) {
beforeError := fmt.Errorf("fail") beforeError := fmt.Errorf("fail")
var err error var err error
app := cli.NewApp() app := NewApp()
app.Before = func(c *cli.Context) error { app.Before = func(c *Context) error {
beforeRun = true beforeRun = true
s := c.String("opt") s := c.String("opt")
if s == "fail" { if s == "fail" {
@ -435,17 +433,17 @@ func TestApp_BeforeFunc(t *testing.T) {
return nil return nil
} }
app.Commands = []cli.Command{ app.Commands = []Command{
cli.Command{ Command{
Name: "sub", Name: "sub",
Action: func(c *cli.Context) { Action: func(c *Context) {
subcommandRun = true subcommandRun = true
}, },
}, },
} }
app.Flags = []cli.Flag{ app.Flags = []Flag{
cli.StringFlag{Name: "opt"}, StringFlag{Name: "opt"},
} }
// run with the Before() func succeeding // run with the Before() func succeeding
@ -489,9 +487,9 @@ func TestApp_AfterFunc(t *testing.T) {
afterError := fmt.Errorf("fail") afterError := fmt.Errorf("fail")
var err error var err error
app := cli.NewApp() app := NewApp()
app.After = func(c *cli.Context) error { app.After = func(c *Context) error {
afterRun = true afterRun = true
s := c.String("opt") s := c.String("opt")
if s == "fail" { if s == "fail" {
@ -501,17 +499,17 @@ func TestApp_AfterFunc(t *testing.T) {
return nil return nil
} }
app.Commands = []cli.Command{ app.Commands = []Command{
cli.Command{ Command{
Name: "sub", Name: "sub",
Action: func(c *cli.Context) { Action: func(c *Context) {
subcommandRun = true subcommandRun = true
}, },
}, },
} }
app.Flags = []cli.Flag{ app.Flags = []Flag{
cli.StringFlag{Name: "opt"}, StringFlag{Name: "opt"},
} }
// run with the After() func succeeding // run with the After() func succeeding
@ -550,14 +548,14 @@ func TestApp_AfterFunc(t *testing.T) {
} }
func TestAppNoHelpFlag(t *testing.T) { func TestAppNoHelpFlag(t *testing.T) {
oldFlag := cli.HelpFlag oldFlag := HelpFlag
defer func() { defer func() {
cli.HelpFlag = oldFlag HelpFlag = oldFlag
}() }()
cli.HelpFlag = cli.BoolFlag{} HelpFlag = BoolFlag{}
app := cli.NewApp() app := NewApp()
err := app.Run([]string{"test", "-h"}) err := app.Run([]string{"test", "-h"})
if err != flag.ErrHelp { if err != flag.ErrHelp {
@ -566,17 +564,17 @@ func TestAppNoHelpFlag(t *testing.T) {
} }
func TestAppHelpPrinter(t *testing.T) { func TestAppHelpPrinter(t *testing.T) {
oldPrinter := cli.HelpPrinter oldPrinter := HelpPrinter
defer func() { defer func() {
cli.HelpPrinter = oldPrinter HelpPrinter = oldPrinter
}() }()
var wasCalled = false var wasCalled = false
cli.HelpPrinter = func(w io.Writer, template string, data interface{}) { HelpPrinter = func(w io.Writer, template string, data interface{}) {
wasCalled = true wasCalled = true
} }
app := cli.NewApp() app := NewApp()
app.Run([]string{"-h"}) app.Run([]string{"-h"})
if wasCalled == false { if wasCalled == false {
@ -585,19 +583,19 @@ func TestAppHelpPrinter(t *testing.T) {
} }
func TestAppVersionPrinter(t *testing.T) { func TestAppVersionPrinter(t *testing.T) {
oldPrinter := cli.VersionPrinter oldPrinter := VersionPrinter
defer func() { defer func() {
cli.VersionPrinter = oldPrinter VersionPrinter = oldPrinter
}() }()
var wasCalled = false var wasCalled = false
cli.VersionPrinter = func(c *cli.Context) { VersionPrinter = func(c *Context) {
wasCalled = true wasCalled = true
} }
app := cli.NewApp() app := NewApp()
ctx := cli.NewContext(app, nil, nil) ctx := NewContext(app, nil, nil)
cli.ShowVersion(ctx) ShowVersion(ctx)
if wasCalled == false { if wasCalled == false {
t.Errorf("Version printer expected to be called, but was not") t.Errorf("Version printer expected to be called, but was not")
@ -606,16 +604,16 @@ func TestAppVersionPrinter(t *testing.T) {
func TestAppCommandNotFound(t *testing.T) { func TestAppCommandNotFound(t *testing.T) {
beforeRun, subcommandRun := false, false 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 beforeRun = true
} }
app.Commands = []cli.Command{ app.Commands = []Command{
cli.Command{ Command{
Name: "bar", Name: "bar",
Action: func(c *cli.Context) { Action: func(c *Context) {
subcommandRun = true subcommandRun = true
}, },
}, },
@ -630,11 +628,11 @@ func TestAppCommandNotFound(t *testing.T) {
func TestGlobalFlag(t *testing.T) { func TestGlobalFlag(t *testing.T) {
var globalFlag string var globalFlag string
var globalFlagSet bool var globalFlagSet bool
app := cli.NewApp() app := NewApp()
app.Flags = []cli.Flag{ app.Flags = []Flag{
cli.StringFlag{Name: "global, g", Usage: "global"}, StringFlag{Name: "global, g", Usage: "global"},
} }
app.Action = func(c *cli.Context) { app.Action = func(c *Context) {
globalFlag = c.GlobalString("global") globalFlag = c.GlobalString("global")
globalFlagSet = c.GlobalIsSet("global") globalFlagSet = c.GlobalIsSet("global")
} }
@ -647,22 +645,22 @@ func TestGlobalFlag(t *testing.T) {
func TestGlobalFlagsInSubcommands(t *testing.T) { func TestGlobalFlagsInSubcommands(t *testing.T) {
subcommandRun := false subcommandRun := false
parentFlag := false parentFlag := false
app := cli.NewApp() app := NewApp()
app.Flags = []cli.Flag{ app.Flags = []Flag{
cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"}, BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
} }
app.Commands = []cli.Command{ app.Commands = []Command{
cli.Command{ Command{
Name: "foo", Name: "foo",
Flags: []cli.Flag{ Flags: []Flag{
cli.BoolFlag{Name: "parent, p", Usage: "Parent flag"}, BoolFlag{Name: "parent, p", Usage: "Parent flag"},
}, },
Subcommands: []cli.Command{ Subcommands: []Command{
{ {
Name: "bar", Name: "bar",
Action: func(c *cli.Context) { Action: func(c *Context) {
if c.GlobalBool("debug") { if c.GlobalBool("debug") {
subcommandRun = true subcommandRun = true
} }
@ -691,25 +689,25 @@ func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
for _, flagSet := range subcommandHelpTopics { for _, flagSet := range subcommandHelpTopics {
t.Logf("==> checking with flags %v", flagSet) t.Logf("==> checking with flags %v", flagSet)
app := cli.NewApp() app := NewApp()
buf := new(bytes.Buffer) buf := new(bytes.Buffer)
app.Writer = buf app.Writer = buf
subCmdBar := cli.Command{ subCmdBar := Command{
Name: "bar", Name: "bar",
Usage: "does bar things", Usage: "does bar things",
} }
subCmdBaz := cli.Command{ subCmdBaz := Command{
Name: "baz", Name: "baz",
Usage: "does baz things", Usage: "does baz things",
} }
cmd := cli.Command{ cmd := Command{
Name: "foo", Name: "foo",
Description: "descriptive wall of text about how it does foo things", Description: "descriptive wall of text about how it does foo things",
Subcommands: []cli.Command{subCmdBar, subCmdBaz}, Subcommands: []Command{subCmdBar, subCmdBaz},
} }
app.Commands = []cli.Command{cmd} app.Commands = []Command{cmd}
err := app.Run(flagSet) err := app.Run(flagSet)
if err != nil { if err != nil {
@ -736,20 +734,20 @@ func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
} }
func TestApp_Run_SubcommandFullPath(t *testing.T) { func TestApp_Run_SubcommandFullPath(t *testing.T) {
app := cli.NewApp() app := NewApp()
buf := new(bytes.Buffer) buf := new(bytes.Buffer)
app.Writer = buf app.Writer = buf
subCmd := cli.Command{ subCmd := Command{
Name: "bar", Name: "bar",
Usage: "does bar things", Usage: "does bar things",
} }
cmd := cli.Command{ cmd := Command{
Name: "foo", Name: "foo",
Description: "foo commands", Description: "foo commands",
Subcommands: []cli.Command{subCmd}, Subcommands: []Command{subCmd},
} }
app.Commands = []cli.Command{cmd} app.Commands = []Command{cmd}
err := app.Run([]string{"command", "foo", "bar", "--help"}) err := app.Run([]string{"command", "foo", "bar", "--help"})
if err != nil { if err != nil {
@ -773,11 +771,11 @@ func TestApp_Run_Help(t *testing.T) {
t.Logf("==> checking with arguments %v", args) t.Logf("==> checking with arguments %v", args)
app := cli.NewApp() app := NewApp()
app.Name = "boom" app.Name = "boom"
app.Usage = "make an explosive entrance" app.Usage = "make an explosive entrance"
app.Writer = buf app.Writer = buf
app.Action = func(c *cli.Context) { app.Action = func(c *Context) {
buf.WriteString("boom I say!") buf.WriteString("boom I say!")
} }
@ -803,12 +801,12 @@ func TestApp_Run_Version(t *testing.T) {
t.Logf("==> checking with arguments %v", args) t.Logf("==> checking with arguments %v", args)
app := cli.NewApp() app := NewApp()
app.Name = "boom" app.Name = "boom"
app.Usage = "make an explosive entrance" app.Usage = "make an explosive entrance"
app.Version = "0.1.0" app.Version = "0.1.0"
app.Writer = buf app.Writer = buf
app.Action = func(c *cli.Context) { app.Action = func(c *Context) {
buf.WriteString("boom I say!") buf.WriteString("boom I say!")
} }
@ -827,10 +825,10 @@ func TestApp_Run_Version(t *testing.T) {
} }
func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) { func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
app := cli.NewApp() app := NewApp()
app.Action = func(c *cli.Context) {} app.Action = func(c *Context) {}
app.Before = func(c *cli.Context) error { return fmt.Errorf("before error") } app.Before = func(c *Context) error { return fmt.Errorf("before error") }
app.After = func(c *cli.Context) error { return fmt.Errorf("after error") } app.After = func(c *Context) error { return fmt.Errorf("after error") }
err := app.Run([]string{"foo"}) err := app.Run([]string{"foo"})
if err == nil { if err == nil {
@ -846,12 +844,12 @@ func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
} }
func TestApp_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) { func TestApp_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) {
app := cli.NewApp() app := NewApp()
app.Commands = []cli.Command{ app.Commands = []Command{
cli.Command{ Command{
Name: "bar", Name: "bar",
Before: func(c *cli.Context) error { return fmt.Errorf("before error") }, Before: func(c *Context) error { return fmt.Errorf("before error") },
After: func(c *cli.Context) error { return fmt.Errorf("after error") }, After: func(c *Context) error { return fmt.Errorf("after error") },
}, },
} }

38
cli_test.go
View File

@ -1,21 +1,19 @@
package cli_test package cli
import ( import (
"os" "os"
"github.com/codegangsta/cli"
) )
func Example() { func Example() {
app := cli.NewApp() app := NewApp()
app.Name = "todo" app.Name = "todo"
app.Usage = "task list on the command line" app.Usage = "task list on the command line"
app.Commands = []cli.Command{ app.Commands = []Command{
{ {
Name: "add", Name: "add",
Aliases: []string{"a"}, Aliases: []string{"a"},
Usage: "add a task to the list", Usage: "add a task to the list",
Action: func(c *cli.Context) { Action: func(c *Context) {
println("added task: ", c.Args().First()) println("added task: ", c.Args().First())
}, },
}, },
@ -23,7 +21,7 @@ func Example() {
Name: "complete", Name: "complete",
Aliases: []string{"c"}, Aliases: []string{"c"},
Usage: "complete a task on the list", Usage: "complete a task on the list",
Action: func(c *cli.Context) { Action: func(c *Context) {
println("completed task: ", c.Args().First()) println("completed task: ", c.Args().First())
}, },
}, },
@ -33,56 +31,56 @@ func Example() {
} }
func ExampleSubcommand() { func ExampleSubcommand() {
app := cli.NewApp() app := NewApp()
app.Name = "say" app.Name = "say"
app.Commands = []cli.Command{ app.Commands = []Command{
{ {
Name: "hello", Name: "hello",
Aliases: []string{"hi"}, Aliases: []string{"hi"},
Usage: "use it to see a description", Usage: "use it to see a description",
Description: "This is how we describe hello the function", Description: "This is how we describe hello the function",
Subcommands: []cli.Command{ Subcommands: []Command{
{ {
Name: "english", Name: "english",
Aliases: []string{"en"}, Aliases: []string{"en"},
Usage: "sends a greeting in english", Usage: "sends a greeting in english",
Description: "greets someone in english", Description: "greets someone in english",
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{ StringFlag{
Name: "name", Name: "name",
Value: "Bob", Value: "Bob",
Usage: "Name of the person to greet", Usage: "Name of the person to greet",
}, },
}, },
Action: func(c *cli.Context) { Action: func(c *Context) {
println("Hello, ", c.String("name")) println("Hello, ", c.String("name"))
}, },
}, { }, {
Name: "spanish", Name: "spanish",
Aliases: []string{"sp"}, Aliases: []string{"sp"},
Usage: "sends a greeting in spanish", Usage: "sends a greeting in spanish",
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{ StringFlag{
Name: "surname", Name: "surname",
Value: "Jones", Value: "Jones",
Usage: "Surname of the person to greet", Usage: "Surname of the person to greet",
}, },
}, },
Action: func(c *cli.Context) { Action: func(c *Context) {
println("Hola, ", c.String("surname")) println("Hola, ", c.String("surname"))
}, },
}, { }, {
Name: "french", Name: "french",
Aliases: []string{"fr"}, Aliases: []string{"fr"},
Usage: "sends a greeting in french", Usage: "sends a greeting in french",
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{ StringFlag{
Name: "nickname", Name: "nickname",
Value: "Stevie", Value: "Stevie",
Usage: "Nickname of the person to greet", Usage: "Nickname of the person to greet",
}, },
}, },
Action: func(c *cli.Context) { Action: func(c *Context) {
println("Bonjour, ", c.String("nickname")) println("Bonjour, ", c.String("nickname"))
}, },
}, },
@ -90,7 +88,7 @@ func ExampleSubcommand() {
}, { }, {
Name: "bye", Name: "bye",
Usage: "says goodbye", Usage: "says goodbye",
Action: func(c *cli.Context) { Action: func(c *Context) {
println("bye") println("bye")
}, },
}, },

20
command_test.go
View File

@ -1,26 +1,24 @@
package cli_test package cli
import ( import (
"flag" "flag"
"testing" "testing"
"github.com/codegangsta/cli"
) )
func TestCommandDoNotIgnoreFlags(t *testing.T) { func TestCommandDoNotIgnoreFlags(t *testing.T) {
app := cli.NewApp() app := NewApp()
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
test := []string{"blah", "blah", "-break"} test := []string{"blah", "blah", "-break"}
set.Parse(test) set.Parse(test)
c := cli.NewContext(app, set, nil) c := NewContext(app, set, nil)
command := cli.Command{ command := Command{
Name: "test-cmd", Name: "test-cmd",
Aliases: []string{"tc"}, Aliases: []string{"tc"},
Usage: "this is for testing", Usage: "this is for testing",
Description: "testing", Description: "testing",
Action: func(_ *cli.Context) {}, Action: func(_ *Context) {},
} }
err := command.Run(c) err := command.Run(c)
@ -28,19 +26,19 @@ func TestCommandDoNotIgnoreFlags(t *testing.T) {
} }
func TestCommandIgnoreFlags(t *testing.T) { func TestCommandIgnoreFlags(t *testing.T) {
app := cli.NewApp() app := NewApp()
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
test := []string{"blah", "blah"} test := []string{"blah", "blah"}
set.Parse(test) set.Parse(test)
c := cli.NewContext(app, set, nil) c := NewContext(app, set, nil)
command := cli.Command{ command := Command{
Name: "test-cmd", Name: "test-cmd",
Aliases: []string{"tc"}, Aliases: []string{"tc"},
Usage: "this is for testing", Usage: "this is for testing",
Description: "testing", Description: "testing",
Action: func(_ *cli.Context) {}, Action: func(_ *Context) {},
SkipFlagParsing: true, SkipFlagParsing: true,
} }
err := command.Run(c) err := command.Run(c)

34
context_test.go
View File

@ -1,11 +1,9 @@
package cli_test package cli
import ( import (
"flag" "flag"
"testing" "testing"
"time" "time"
"github.com/codegangsta/cli"
) )
func TestNewContext(t *testing.T) { func TestNewContext(t *testing.T) {
@ -13,9 +11,9 @@ func TestNewContext(t *testing.T) {
set.Int("myflag", 12, "doc") set.Int("myflag", 12, "doc")
globalSet := flag.NewFlagSet("test", 0) globalSet := flag.NewFlagSet("test", 0)
globalSet.Int("myflag", 42, "doc") globalSet.Int("myflag", 42, "doc")
globalCtx := cli.NewContext(nil, globalSet, nil) globalCtx := NewContext(nil, globalSet, nil)
command := cli.Command{Name: "mycommand"} command := Command{Name: "mycommand"}
c := cli.NewContext(nil, set, globalCtx) c := NewContext(nil, set, globalCtx)
c.Command = command c.Command = command
expect(t, c.Int("myflag"), 12) expect(t, c.Int("myflag"), 12)
expect(t, c.GlobalInt("myflag"), 42) expect(t, c.GlobalInt("myflag"), 42)
@ -25,42 +23,42 @@ func TestNewContext(t *testing.T) {
func TestContext_Int(t *testing.T) { func TestContext_Int(t *testing.T) {
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
set.Int("myflag", 12, "doc") set.Int("myflag", 12, "doc")
c := cli.NewContext(nil, set, nil) c := NewContext(nil, set, nil)
expect(t, c.Int("myflag"), 12) expect(t, c.Int("myflag"), 12)
} }
func TestContext_Duration(t *testing.T) { func TestContext_Duration(t *testing.T) {
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
set.Duration("myflag", time.Duration(12*time.Second), "doc") set.Duration("myflag", time.Duration(12*time.Second), "doc")
c := cli.NewContext(nil, set, nil) c := NewContext(nil, set, nil)
expect(t, c.Duration("myflag"), time.Duration(12*time.Second)) expect(t, c.Duration("myflag"), time.Duration(12*time.Second))
} }
func TestContext_String(t *testing.T) { func TestContext_String(t *testing.T) {
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
set.String("myflag", "hello world", "doc") set.String("myflag", "hello world", "doc")
c := cli.NewContext(nil, set, nil) c := NewContext(nil, set, nil)
expect(t, c.String("myflag"), "hello world") expect(t, c.String("myflag"), "hello world")
} }
func TestContext_Bool(t *testing.T) { func TestContext_Bool(t *testing.T) {
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
set.Bool("myflag", false, "doc") set.Bool("myflag", false, "doc")
c := cli.NewContext(nil, set, nil) c := NewContext(nil, set, nil)
expect(t, c.Bool("myflag"), false) expect(t, c.Bool("myflag"), false)
} }
func TestContext_BoolT(t *testing.T) { func TestContext_BoolT(t *testing.T) {
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
set.Bool("myflag", true, "doc") set.Bool("myflag", true, "doc")
c := cli.NewContext(nil, set, nil) c := NewContext(nil, set, nil)
expect(t, c.BoolT("myflag"), true) expect(t, c.BoolT("myflag"), true)
} }
func TestContext_Args(t *testing.T) { func TestContext_Args(t *testing.T) {
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
set.Bool("myflag", false, "doc") set.Bool("myflag", false, "doc")
c := cli.NewContext(nil, set, nil) c := NewContext(nil, set, nil)
set.Parse([]string{"--myflag", "bat", "baz"}) set.Parse([]string{"--myflag", "bat", "baz"})
expect(t, len(c.Args()), 2) expect(t, len(c.Args()), 2)
expect(t, c.Bool("myflag"), true) expect(t, c.Bool("myflag"), true)
@ -72,8 +70,8 @@ func TestContext_IsSet(t *testing.T) {
set.String("otherflag", "hello world", "doc") set.String("otherflag", "hello world", "doc")
globalSet := flag.NewFlagSet("test", 0) globalSet := flag.NewFlagSet("test", 0)
globalSet.Bool("myflagGlobal", true, "doc") globalSet.Bool("myflagGlobal", true, "doc")
globalCtx := cli.NewContext(nil, globalSet, nil) globalCtx := NewContext(nil, globalSet, nil)
c := cli.NewContext(nil, set, globalCtx) c := NewContext(nil, set, globalCtx)
set.Parse([]string{"--myflag", "bat", "baz"}) set.Parse([]string{"--myflag", "bat", "baz"})
globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"}) globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
expect(t, c.IsSet("myflag"), true) expect(t, c.IsSet("myflag"), true)
@ -89,8 +87,8 @@ func TestContext_GlobalIsSet(t *testing.T) {
globalSet := flag.NewFlagSet("test", 0) globalSet := flag.NewFlagSet("test", 0)
globalSet.Bool("myflagGlobal", true, "doc") globalSet.Bool("myflagGlobal", true, "doc")
globalSet.Bool("myflagGlobalUnset", true, "doc") globalSet.Bool("myflagGlobalUnset", true, "doc")
globalCtx := cli.NewContext(nil, globalSet, nil) globalCtx := NewContext(nil, globalSet, nil)
c := cli.NewContext(nil, set, globalCtx) c := NewContext(nil, set, globalCtx)
set.Parse([]string{"--myflag", "bat", "baz"}) set.Parse([]string{"--myflag", "bat", "baz"})
globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"}) globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
expect(t, c.GlobalIsSet("myflag"), false) expect(t, c.GlobalIsSet("myflag"), false)
@ -107,8 +105,8 @@ func TestContext_NumFlags(t *testing.T) {
set.String("otherflag", "hello world", "doc") set.String("otherflag", "hello world", "doc")
globalSet := flag.NewFlagSet("test", 0) globalSet := flag.NewFlagSet("test", 0)
globalSet.Bool("myflagGlobal", true, "doc") globalSet.Bool("myflagGlobal", true, "doc")
globalCtx := cli.NewContext(nil, globalSet, nil) globalCtx := NewContext(nil, globalSet, nil)
c := cli.NewContext(nil, set, globalCtx) c := NewContext(nil, set, globalCtx)
set.Parse([]string{"--myflag", "--otherflag=foo"}) set.Parse([]string{"--myflag", "--otherflag=foo"})
globalSet.Parse([]string{"--myflagGlobal"}) globalSet.Parse([]string{"--myflagGlobal"})
expect(t, c.NumFlags(), 2) expect(t, c.NumFlags(), 2)

258
flag_test.go
View File

@ -1,4 +1,4 @@
package cli_test package cli
import ( import (
"fmt" "fmt"
@ -6,8 +6,6 @@ import (
"reflect" "reflect"
"strings" "strings"
"testing" "testing"
"github.com/codegangsta/cli"
) )
var boolFlagTests = []struct { var boolFlagTests = []struct {
@ -21,7 +19,7 @@ var boolFlagTests = []struct {
func TestBoolFlagHelpOutput(t *testing.T) { func TestBoolFlagHelpOutput(t *testing.T) {
for _, test := range boolFlagTests { for _, test := range boolFlagTests {
flag := cli.BoolFlag{Name: test.name} flag := BoolFlag{Name: test.name}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -44,7 +42,7 @@ var stringFlagTests = []struct {
func TestStringFlagHelpOutput(t *testing.T) { func TestStringFlagHelpOutput(t *testing.T) {
for _, test := range stringFlagTests { for _, test := range stringFlagTests {
flag := cli.StringFlag{Name: test.name, Value: test.value} flag := StringFlag{Name: test.name, Value: test.value}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -57,7 +55,7 @@ func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_FOO", "derp") os.Setenv("APP_FOO", "derp")
for _, test := range stringFlagTests { for _, test := range stringFlagTests {
flag := cli.StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"} flag := StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
output := flag.String() output := flag.String()
if !strings.HasSuffix(output, " [$APP_FOO]") { if !strings.HasSuffix(output, " [$APP_FOO]") {
@ -68,26 +66,26 @@ func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
var stringSliceFlagTests = []struct { var stringSliceFlagTests = []struct {
name string name string
value *cli.StringSlice value *StringSlice
expected string expected string
}{ }{
{"help", func() *cli.StringSlice { {"help", func() *StringSlice {
s := &cli.StringSlice{} s := &StringSlice{}
s.Set("") s.Set("")
return s return s
}(), "--help [--help option --help option]\t"}, }(), "--help [--help option --help option]\t"},
{"h", func() *cli.StringSlice { {"h", func() *StringSlice {
s := &cli.StringSlice{} s := &StringSlice{}
s.Set("") s.Set("")
return s return s
}(), "-h [-h option -h option]\t"}, }(), "-h [-h option -h option]\t"},
{"h", func() *cli.StringSlice { {"h", func() *StringSlice {
s := &cli.StringSlice{} s := &StringSlice{}
s.Set("") s.Set("")
return s return s
}(), "-h [-h option -h option]\t"}, }(), "-h [-h option -h option]\t"},
{"test", func() *cli.StringSlice { {"test", func() *StringSlice {
s := &cli.StringSlice{} s := &StringSlice{}
s.Set("Something") s.Set("Something")
return s return s
}(), "--test [--test option --test option]\t"}, }(), "--test [--test option --test option]\t"},
@ -96,7 +94,7 @@ var stringSliceFlagTests = []struct {
func TestStringSliceFlagHelpOutput(t *testing.T) { func TestStringSliceFlagHelpOutput(t *testing.T) {
for _, test := range stringSliceFlagTests { for _, test := range stringSliceFlagTests {
flag := cli.StringSliceFlag{Name: test.name, Value: test.value} flag := StringSliceFlag{Name: test.name, Value: test.value}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -109,7 +107,7 @@ func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_QWWX", "11,4") os.Setenv("APP_QWWX", "11,4")
for _, test := range stringSliceFlagTests { for _, test := range stringSliceFlagTests {
flag := cli.StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"} flag := StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
output := flag.String() output := flag.String()
if !strings.HasSuffix(output, " [$APP_QWWX]") { if !strings.HasSuffix(output, " [$APP_QWWX]") {
@ -129,7 +127,7 @@ var intFlagTests = []struct {
func TestIntFlagHelpOutput(t *testing.T) { func TestIntFlagHelpOutput(t *testing.T) {
for _, test := range intFlagTests { for _, test := range intFlagTests {
flag := cli.IntFlag{Name: test.name} flag := IntFlag{Name: test.name}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -142,7 +140,7 @@ func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_BAR", "2") os.Setenv("APP_BAR", "2")
for _, test := range intFlagTests { for _, test := range intFlagTests {
flag := cli.IntFlag{Name: test.name, EnvVar: "APP_BAR"} flag := IntFlag{Name: test.name, EnvVar: "APP_BAR"}
output := flag.String() output := flag.String()
if !strings.HasSuffix(output, " [$APP_BAR]") { if !strings.HasSuffix(output, " [$APP_BAR]") {
@ -162,7 +160,7 @@ var durationFlagTests = []struct {
func TestDurationFlagHelpOutput(t *testing.T) { func TestDurationFlagHelpOutput(t *testing.T) {
for _, test := range durationFlagTests { for _, test := range durationFlagTests {
flag := cli.DurationFlag{Name: test.name} flag := DurationFlag{Name: test.name}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -175,7 +173,7 @@ func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_BAR", "2h3m6s") os.Setenv("APP_BAR", "2h3m6s")
for _, test := range durationFlagTests { for _, test := range durationFlagTests {
flag := cli.DurationFlag{Name: test.name, EnvVar: "APP_BAR"} flag := DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
output := flag.String() output := flag.String()
if !strings.HasSuffix(output, " [$APP_BAR]") { if !strings.HasSuffix(output, " [$APP_BAR]") {
@ -186,14 +184,14 @@ func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
var intSliceFlagTests = []struct { var intSliceFlagTests = []struct {
name string name string
value *cli.IntSlice value *IntSlice
expected string expected string
}{ }{
{"help", &cli.IntSlice{}, "--help [--help option --help option]\t"}, {"help", &IntSlice{}, "--help [--help option --help option]\t"},
{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"}, {"h", &IntSlice{}, "-h [-h option -h option]\t"},
{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"}, {"h", &IntSlice{}, "-h [-h option -h option]\t"},
{"test", func() *cli.IntSlice { {"test", func() *IntSlice {
i := &cli.IntSlice{} i := &IntSlice{}
i.Set("9") i.Set("9")
return i return i
}(), "--test [--test option --test option]\t"}, }(), "--test [--test option --test option]\t"},
@ -202,7 +200,7 @@ var intSliceFlagTests = []struct {
func TestIntSliceFlagHelpOutput(t *testing.T) { func TestIntSliceFlagHelpOutput(t *testing.T) {
for _, test := range intSliceFlagTests { for _, test := range intSliceFlagTests {
flag := cli.IntSliceFlag{Name: test.name, Value: test.value} flag := IntSliceFlag{Name: test.name, Value: test.value}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -215,7 +213,7 @@ func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_SMURF", "42,3") os.Setenv("APP_SMURF", "42,3")
for _, test := range intSliceFlagTests { for _, test := range intSliceFlagTests {
flag := cli.IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"} flag := IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
output := flag.String() output := flag.String()
if !strings.HasSuffix(output, " [$APP_SMURF]") { if !strings.HasSuffix(output, " [$APP_SMURF]") {
@ -235,7 +233,7 @@ var float64FlagTests = []struct {
func TestFloat64FlagHelpOutput(t *testing.T) { func TestFloat64FlagHelpOutput(t *testing.T) {
for _, test := range float64FlagTests { for _, test := range float64FlagTests {
flag := cli.Float64Flag{Name: test.name} flag := Float64Flag{Name: test.name}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -248,7 +246,7 @@ func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_BAZ", "99.4") os.Setenv("APP_BAZ", "99.4")
for _, test := range float64FlagTests { for _, test := range float64FlagTests {
flag := cli.Float64Flag{Name: test.name, EnvVar: "APP_BAZ"} flag := Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
output := flag.String() output := flag.String()
if !strings.HasSuffix(output, " [$APP_BAZ]") { if !strings.HasSuffix(output, " [$APP_BAZ]") {
@ -259,7 +257,7 @@ func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
var genericFlagTests = []struct { var genericFlagTests = []struct {
name string name string
value cli.Generic value Generic
expected string expected string
}{ }{
{"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"}, {"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"},
@ -269,7 +267,7 @@ var genericFlagTests = []struct {
func TestGenericFlagHelpOutput(t *testing.T) { func TestGenericFlagHelpOutput(t *testing.T) {
for _, test := range genericFlagTests { for _, test := range genericFlagTests {
flag := cli.GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"} flag := GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
output := flag.String() output := flag.String()
if output != test.expected { if output != test.expected {
@ -282,7 +280,7 @@ func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_ZAP", "3") os.Setenv("APP_ZAP", "3")
for _, test := range genericFlagTests { for _, test := range genericFlagTests {
flag := cli.GenericFlag{Name: test.name, EnvVar: "APP_ZAP"} flag := GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
output := flag.String() output := flag.String()
if !strings.HasSuffix(output, " [$APP_ZAP]") { if !strings.HasSuffix(output, " [$APP_ZAP]") {
@ -292,11 +290,11 @@ func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
} }
func TestParseMultiString(t *testing.T) { func TestParseMultiString(t *testing.T) {
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{Name: "serve, s"}, StringFlag{Name: "serve, s"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.String("serve") != "10" { if ctx.String("serve") != "10" {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -310,11 +308,11 @@ func TestParseMultiString(t *testing.T) {
func TestParseMultiStringFromEnv(t *testing.T) { func TestParseMultiStringFromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_COUNT", "20") os.Setenv("APP_COUNT", "20")
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{Name: "count, c", EnvVar: "APP_COUNT"}, StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.String("count") != "20" { if ctx.String("count") != "20" {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -328,11 +326,11 @@ func TestParseMultiStringFromEnv(t *testing.T) {
func TestParseMultiStringFromEnvCascade(t *testing.T) { func TestParseMultiStringFromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_COUNT", "20") os.Setenv("APP_COUNT", "20")
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"}, StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.String("count") != "20" { if ctx.String("count") != "20" {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -344,11 +342,11 @@ func TestParseMultiStringFromEnvCascade(t *testing.T) {
} }
func TestParseMultiStringSlice(t *testing.T) { func TestParseMultiStringSlice(t *testing.T) {
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.StringSliceFlag{Name: "serve, s", Value: &cli.StringSlice{}}, StringSliceFlag{Name: "serve, s", Value: &StringSlice{}},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) { if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -363,11 +361,11 @@ func TestParseMultiStringSliceFromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_INTERVALS", "20,30,40") os.Setenv("APP_INTERVALS", "20,30,40")
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "APP_INTERVALS"}, StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "APP_INTERVALS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) { if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -382,11 +380,11 @@ func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_INTERVALS", "20,30,40") os.Setenv("APP_INTERVALS", "20,30,40")
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"}, StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) { if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -398,11 +396,11 @@ func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
} }
func TestParseMultiInt(t *testing.T) { func TestParseMultiInt(t *testing.T) {
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.IntFlag{Name: "serve, s"}, IntFlag{Name: "serve, s"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Int("serve") != 10 { if ctx.Int("serve") != 10 {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -417,11 +415,11 @@ func TestParseMultiInt(t *testing.T) {
func TestParseMultiIntFromEnv(t *testing.T) { func TestParseMultiIntFromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_TIMEOUT_SECONDS", "10") os.Setenv("APP_TIMEOUT_SECONDS", "10")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"}, IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Int("timeout") != 10 { if ctx.Int("timeout") != 10 {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -436,11 +434,11 @@ func TestParseMultiIntFromEnv(t *testing.T) {
func TestParseMultiIntFromEnvCascade(t *testing.T) { func TestParseMultiIntFromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_TIMEOUT_SECONDS", "10") os.Setenv("APP_TIMEOUT_SECONDS", "10")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"}, IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Int("timeout") != 10 { if ctx.Int("timeout") != 10 {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -453,11 +451,11 @@ func TestParseMultiIntFromEnvCascade(t *testing.T) {
} }
func TestParseMultiIntSlice(t *testing.T) { func TestParseMultiIntSlice(t *testing.T) {
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.IntSliceFlag{Name: "serve, s", Value: &cli.IntSlice{}}, IntSliceFlag{Name: "serve, s", Value: &IntSlice{}},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) { if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -472,11 +470,11 @@ func TestParseMultiIntSliceFromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_INTERVALS", "20,30,40") os.Setenv("APP_INTERVALS", "20,30,40")
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "APP_INTERVALS"}, IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "APP_INTERVALS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) { if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -491,11 +489,11 @@ func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_INTERVALS", "20,30,40") os.Setenv("APP_INTERVALS", "20,30,40")
(&cli.App{ (&App{
Flags: []cli.Flag{ Flags: []Flag{
cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"}, IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) { if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -507,11 +505,11 @@ func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
} }
func TestParseMultiFloat64(t *testing.T) { func TestParseMultiFloat64(t *testing.T) {
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.Float64Flag{Name: "serve, s"}, Float64Flag{Name: "serve, s"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Float64("serve") != 10.2 { if ctx.Float64("serve") != 10.2 {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -526,11 +524,11 @@ func TestParseMultiFloat64(t *testing.T) {
func TestParseMultiFloat64FromEnv(t *testing.T) { func TestParseMultiFloat64FromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_TIMEOUT_SECONDS", "15.5") os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"}, Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Float64("timeout") != 15.5 { if ctx.Float64("timeout") != 15.5 {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -545,11 +543,11 @@ func TestParseMultiFloat64FromEnv(t *testing.T) {
func TestParseMultiFloat64FromEnvCascade(t *testing.T) { func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_TIMEOUT_SECONDS", "15.5") os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"}, Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Float64("timeout") != 15.5 { if ctx.Float64("timeout") != 15.5 {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -562,11 +560,11 @@ func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
} }
func TestParseMultiBool(t *testing.T) { func TestParseMultiBool(t *testing.T) {
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.BoolFlag{Name: "serve, s"}, BoolFlag{Name: "serve, s"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Bool("serve") != true { if ctx.Bool("serve") != true {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -581,11 +579,11 @@ func TestParseMultiBool(t *testing.T) {
func TestParseMultiBoolFromEnv(t *testing.T) { func TestParseMultiBoolFromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_DEBUG", "1") os.Setenv("APP_DEBUG", "1")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"}, BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Bool("debug") != true { if ctx.Bool("debug") != true {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -600,11 +598,11 @@ func TestParseMultiBoolFromEnv(t *testing.T) {
func TestParseMultiBoolFromEnvCascade(t *testing.T) { func TestParseMultiBoolFromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_DEBUG", "1") os.Setenv("APP_DEBUG", "1")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"}, BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.Bool("debug") != true { if ctx.Bool("debug") != true {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -617,11 +615,11 @@ func TestParseMultiBoolFromEnvCascade(t *testing.T) {
} }
func TestParseMultiBoolT(t *testing.T) { func TestParseMultiBoolT(t *testing.T) {
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.BoolTFlag{Name: "serve, s"}, BoolTFlag{Name: "serve, s"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.BoolT("serve") != true { if ctx.BoolT("serve") != true {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -636,11 +634,11 @@ func TestParseMultiBoolT(t *testing.T) {
func TestParseMultiBoolTFromEnv(t *testing.T) { func TestParseMultiBoolTFromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_DEBUG", "0") os.Setenv("APP_DEBUG", "0")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"}, BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.BoolT("debug") != false { if ctx.BoolT("debug") != false {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -655,11 +653,11 @@ func TestParseMultiBoolTFromEnv(t *testing.T) {
func TestParseMultiBoolTFromEnvCascade(t *testing.T) { func TestParseMultiBoolTFromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_DEBUG", "0") os.Setenv("APP_DEBUG", "0")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"}, BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if ctx.BoolT("debug") != false { if ctx.BoolT("debug") != false {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -690,11 +688,11 @@ func (p *Parser) String() string {
} }
func TestParseGeneric(t *testing.T) { func TestParseGeneric(t *testing.T) {
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.GenericFlag{Name: "serve, s", Value: &Parser{}}, GenericFlag{Name: "serve, s", Value: &Parser{}},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) { if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
t.Errorf("main name not set") t.Errorf("main name not set")
} }
@ -709,11 +707,11 @@ func TestParseGeneric(t *testing.T) {
func TestParseGenericFromEnv(t *testing.T) { func TestParseGenericFromEnv(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_SERVE", "20,30") os.Setenv("APP_SERVE", "20,30")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"}, GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) { if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
t.Errorf("main name not set from env") t.Errorf("main name not set from env")
} }
@ -728,11 +726,11 @@ func TestParseGenericFromEnv(t *testing.T) {
func TestParseGenericFromEnvCascade(t *testing.T) { func TestParseGenericFromEnvCascade(t *testing.T) {
os.Clearenv() os.Clearenv()
os.Setenv("APP_FOO", "99,2000") os.Setenv("APP_FOO", "99,2000")
a := cli.App{ a := App{
Flags: []cli.Flag{ Flags: []Flag{
cli.GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"}, GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
}, },
Action: func(ctx *cli.Context) { Action: func(ctx *Context) {
if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) { if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) {
t.Errorf("value not set from env") t.Errorf("value not set from env")
} }

16
help_test.go
View File

@ -1,20 +1,18 @@
package cli_test package cli
import ( import (
"bytes" "bytes"
"testing" "testing"
"github.com/codegangsta/cli"
) )
func Test_ShowAppHelp_NoAuthor(t *testing.T) { func Test_ShowAppHelp_NoAuthor(t *testing.T) {
output := new(bytes.Buffer) output := new(bytes.Buffer)
app := cli.NewApp() app := NewApp()
app.Writer = output app.Writer = output
c := cli.NewContext(app, nil, nil) c := NewContext(app, nil, nil)
cli.ShowAppHelp(c) ShowAppHelp(c)
if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 { if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 {
t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):") t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):")
@ -23,14 +21,14 @@ func Test_ShowAppHelp_NoAuthor(t *testing.T) {
func Test_ShowAppHelp_NoVersion(t *testing.T) { func Test_ShowAppHelp_NoVersion(t *testing.T) {
output := new(bytes.Buffer) output := new(bytes.Buffer)
app := cli.NewApp() app := NewApp()
app.Writer = output app.Writer = output
app.Version = "" app.Version = ""
c := cli.NewContext(app, nil, nil) c := NewContext(app, nil, nil)
cli.ShowAppHelp(c) ShowAppHelp(c)
if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 { if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:") t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")

2
helpers_test.go
View File

@ -1,4 +1,4 @@
package cli_test package cli
import ( import (
"reflect" "reflect"