forked from mirror/go-ethereum
Péter Szilágyi
9 years ago
parent
fd27f074fe
commit
3c6e285d3b
@ -1,622 +0,0 @@ |
||||
package cli_test |
||||
|
||||
import ( |
||||
"flag" |
||||
"fmt" |
||||
"os" |
||||
"testing" |
||||
|
||||
"github.com/codegangsta/cli" |
||||
) |
||||
|
||||
func ExampleApp() { |
||||
// set args for examples sake
|
||||
os.Args = []string{"greet", "--name", "Jeremy"} |
||||
|
||||
app := cli.NewApp() |
||||
app.Name = "greet" |
||||
app.Flags = []cli.Flag{ |
||||
cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"}, |
||||
} |
||||
app.Action = func(c *cli.Context) { |
||||
fmt.Printf("Hello %v\n", c.String("name")) |
||||
} |
||||
app.Author = "Harrison" |
||||
app.Email = "harrison@lolwut.com" |
||||
app.Authors = []cli.Author{cli.Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}} |
||||
app.Run(os.Args) |
||||
// Output:
|
||||
// Hello Jeremy
|
||||
} |
||||
|
||||
func ExampleAppSubcommand() { |
||||
// set args for examples sake
|
||||
os.Args = []string{"say", "hi", "english", "--name", "Jeremy"} |
||||
app := cli.NewApp() |
||||
app.Name = "say" |
||||
app.Commands = []cli.Command{ |
||||
{ |
||||
Name: "hello", |
||||
Aliases: []string{"hi"}, |
||||
Usage: "use it to see a description", |
||||
Description: "This is how we describe hello the function", |
||||
Subcommands: []cli.Command{ |
||||
{ |
||||
Name: "english", |
||||
Aliases: []string{"en"}, |
||||
Usage: "sends a greeting in english", |
||||
Description: "greets someone in english", |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{ |
||||
Name: "name", |
||||
Value: "Bob", |
||||
Usage: "Name of the person to greet", |
||||
}, |
||||
}, |
||||
Action: func(c *cli.Context) { |
||||
fmt.Println("Hello,", c.String("name")) |
||||
}, |
||||
}, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Run(os.Args) |
||||
// Output:
|
||||
// Hello, Jeremy
|
||||
} |
||||
|
||||
func ExampleAppHelp() { |
||||
// set args for examples sake
|
||||
os.Args = []string{"greet", "h", "describeit"} |
||||
|
||||
app := cli.NewApp() |
||||
app.Name = "greet" |
||||
app.Flags = []cli.Flag{ |
||||
cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"}, |
||||
} |
||||
app.Commands = []cli.Command{ |
||||
{ |
||||
Name: "describeit", |
||||
Aliases: []string{"d"}, |
||||
Usage: "use it to see a description", |
||||
Description: "This is how we describe describeit the function", |
||||
Action: func(c *cli.Context) { |
||||
fmt.Printf("i like to describe things") |
||||
}, |
||||
}, |
||||
} |
||||
app.Run(os.Args) |
||||
// Output:
|
||||
// NAME:
|
||||
// describeit - use it to see a description
|
||||
//
|
||||
// USAGE:
|
||||
// command describeit [arguments...]
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// This is how we describe describeit the function
|
||||
} |
||||
|
||||
func ExampleAppBashComplete() { |
||||
// set args for examples sake
|
||||
os.Args = []string{"greet", "--generate-bash-completion"} |
||||
|
||||
app := cli.NewApp() |
||||
app.Name = "greet" |
||||
app.EnableBashCompletion = true |
||||
app.Commands = []cli.Command{ |
||||
{ |
||||
Name: "describeit", |
||||
Aliases: []string{"d"}, |
||||
Usage: "use it to see a description", |
||||
Description: "This is how we describe describeit the function", |
||||
Action: func(c *cli.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) { |
||||
fmt.Printf("the next example") |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Run(os.Args) |
||||
// Output:
|
||||
// describeit
|
||||
// d
|
||||
// next
|
||||
// help
|
||||
// h
|
||||
} |
||||
|
||||
func TestApp_Run(t *testing.T) { |
||||
s := "" |
||||
|
||||
app := cli.NewApp() |
||||
app.Action = func(c *cli.Context) { |
||||
s = s + c.Args().First() |
||||
} |
||||
|
||||
err := app.Run([]string{"command", "foo"}) |
||||
expect(t, err, nil) |
||||
err = app.Run([]string{"command", "bar"}) |
||||
expect(t, err, nil) |
||||
expect(t, s, "foobar") |
||||
} |
||||
|
||||
var commandAppTests = []struct { |
||||
name string |
||||
expected bool |
||||
}{ |
||||
{"foobar", true}, |
||||
{"batbaz", true}, |
||||
{"b", true}, |
||||
{"f", true}, |
||||
{"bat", false}, |
||||
{"nothing", false}, |
||||
} |
||||
|
||||
func TestApp_Command(t *testing.T) { |
||||
app := cli.NewApp() |
||||
fooCommand := cli.Command{Name: "foobar", Aliases: []string{"f"}} |
||||
batCommand := cli.Command{Name: "batbaz", Aliases: []string{"b"}} |
||||
app.Commands = []cli.Command{ |
||||
fooCommand, |
||||
batCommand, |
||||
} |
||||
|
||||
for _, test := range commandAppTests { |
||||
expect(t, app.Command(test.name) != nil, test.expected) |
||||
} |
||||
} |
||||
|
||||
func TestApp_CommandWithArgBeforeFlags(t *testing.T) { |
||||
var parsedOption, firstArg string |
||||
|
||||
app := cli.NewApp() |
||||
command := cli.Command{ |
||||
Name: "cmd", |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{Name: "option", Value: "", Usage: "some option"}, |
||||
}, |
||||
Action: func(c *cli.Context) { |
||||
parsedOption = c.String("option") |
||||
firstArg = c.Args().First() |
||||
}, |
||||
} |
||||
app.Commands = []cli.Command{command} |
||||
|
||||
app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"}) |
||||
|
||||
expect(t, parsedOption, "my-option") |
||||
expect(t, firstArg, "my-arg") |
||||
} |
||||
|
||||
func TestApp_RunAsSubcommandParseFlags(t *testing.T) { |
||||
var context *cli.Context |
||||
|
||||
a := cli.NewApp() |
||||
a.Commands = []cli.Command{ |
||||
{ |
||||
Name: "foo", |
||||
Action: func(c *cli.Context) { |
||||
context = c |
||||
}, |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{ |
||||
Name: "lang", |
||||
Value: "english", |
||||
Usage: "language for the greeting", |
||||
}, |
||||
}, |
||||
Before: func(_ *cli.Context) error { return nil }, |
||||
}, |
||||
} |
||||
a.Run([]string{"", "foo", "--lang", "spanish", "abcd"}) |
||||
|
||||
expect(t, context.Args().Get(0), "abcd") |
||||
expect(t, context.String("lang"), "spanish") |
||||
} |
||||
|
||||
func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) { |
||||
var parsedOption string |
||||
var args []string |
||||
|
||||
app := cli.NewApp() |
||||
command := cli.Command{ |
||||
Name: "cmd", |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{Name: "option", Value: "", Usage: "some option"}, |
||||
}, |
||||
Action: func(c *cli.Context) { |
||||
parsedOption = c.String("option") |
||||
args = c.Args() |
||||
}, |
||||
} |
||||
app.Commands = []cli.Command{command} |
||||
|
||||
app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"}) |
||||
|
||||
expect(t, parsedOption, "my-option") |
||||
expect(t, args[0], "my-arg") |
||||
expect(t, args[1], "--") |
||||
expect(t, args[2], "--notARealFlag") |
||||
} |
||||
|
||||
func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) { |
||||
var args []string |
||||
|
||||
app := cli.NewApp() |
||||
command := cli.Command{ |
||||
Name: "cmd", |
||||
Action: func(c *cli.Context) { |
||||
args = c.Args() |
||||
}, |
||||
} |
||||
app.Commands = []cli.Command{command} |
||||
|
||||
app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"}) |
||||
|
||||
expect(t, args[0], "my-arg") |
||||
expect(t, args[1], "--") |
||||
expect(t, args[2], "notAFlagAtAll") |
||||
} |
||||
|
||||
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.Action = func(c *cli.Context) { |
||||
meters = c.Float64("height") |
||||
} |
||||
|
||||
app.Run([]string{"", "--height", "1.93"}) |
||||
expect(t, meters, 1.93) |
||||
} |
||||
|
||||
func TestApp_ParseSliceFlags(t *testing.T) { |
||||
var parsedOption, firstArg string |
||||
var parsedIntSlice []int |
||||
var parsedStringSlice []string |
||||
|
||||
app := cli.NewApp() |
||||
command := cli.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"}, |
||||
}, |
||||
Action: func(c *cli.Context) { |
||||
parsedIntSlice = c.IntSlice("p") |
||||
parsedStringSlice = c.StringSlice("ip") |
||||
parsedOption = c.String("option") |
||||
firstArg = c.Args().First() |
||||
}, |
||||
} |
||||
app.Commands = []cli.Command{command} |
||||
|
||||
app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"}) |
||||
|
||||
IntsEquals := func(a, b []int) bool { |
||||
if len(a) != len(b) { |
||||
return false |
||||
} |
||||
for i, v := range a { |
||||
if v != b[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
StrsEquals := func(a, b []string) bool { |
||||
if len(a) != len(b) { |
||||
return false |
||||
} |
||||
for i, v := range a { |
||||
if v != b[i] { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
var expectedIntSlice = []int{22, 80} |
||||
var expectedStringSlice = []string{"8.8.8.8", "8.8.4.4"} |
||||
|
||||
if !IntsEquals(parsedIntSlice, expectedIntSlice) { |
||||
t.Errorf("%v does not match %v", parsedIntSlice, expectedIntSlice) |
||||
} |
||||
|
||||
if !StrsEquals(parsedStringSlice, expectedStringSlice) { |
||||
t.Errorf("%v does not match %v", parsedStringSlice, expectedStringSlice) |
||||
} |
||||
} |
||||
|
||||
func TestApp_DefaultStdout(t *testing.T) { |
||||
app := cli.NewApp() |
||||
|
||||
if app.Writer != os.Stdout { |
||||
t.Error("Default output writer not set.") |
||||
} |
||||
} |
||||
|
||||
type mockWriter struct { |
||||
written []byte |
||||
} |
||||
|
||||
func (fw *mockWriter) Write(p []byte) (n int, err error) { |
||||
if fw.written == nil { |
||||
fw.written = p |
||||
} else { |
||||
fw.written = append(fw.written, p...) |
||||
} |
||||
|
||||
return len(p), nil |
||||
} |
||||
|
||||
func (fw *mockWriter) GetWritten() (b []byte) { |
||||
return fw.written |
||||
} |
||||
|
||||
func TestApp_SetStdout(t *testing.T) { |
||||
w := &mockWriter{} |
||||
|
||||
app := cli.NewApp() |
||||
app.Name = "test" |
||||
app.Writer = w |
||||
|
||||
err := app.Run([]string{"help"}) |
||||
|
||||
if err != nil { |
||||
t.Fatalf("Run error: %s", err) |
||||
} |
||||
|
||||
if len(w.written) == 0 { |
||||
t.Error("App did not write output to desired writer.") |
||||
} |
||||
} |
||||
|
||||
func TestApp_BeforeFunc(t *testing.T) { |
||||
beforeRun, subcommandRun := false, false |
||||
beforeError := fmt.Errorf("fail") |
||||
var err error |
||||
|
||||
app := cli.NewApp() |
||||
|
||||
app.Before = func(c *cli.Context) error { |
||||
beforeRun = true |
||||
s := c.String("opt") |
||||
if s == "fail" { |
||||
return beforeError |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
app.Commands = []cli.Command{ |
||||
cli.Command{ |
||||
Name: "sub", |
||||
Action: func(c *cli.Context) { |
||||
subcommandRun = true |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Flags = []cli.Flag{ |
||||
cli.StringFlag{Name: "opt"}, |
||||
} |
||||
|
||||
// run with the Before() func succeeding
|
||||
err = app.Run([]string{"command", "--opt", "succeed", "sub"}) |
||||
|
||||
if err != nil { |
||||
t.Fatalf("Run error: %s", err) |
||||
} |
||||
|
||||
if beforeRun == false { |
||||
t.Errorf("Before() not executed when expected") |
||||
} |
||||
|
||||
if subcommandRun == false { |
||||
t.Errorf("Subcommand not executed when expected") |
||||
} |
||||
|
||||
// reset
|
||||
beforeRun, subcommandRun = false, false |
||||
|
||||
// run with the Before() func failing
|
||||
err = app.Run([]string{"command", "--opt", "fail", "sub"}) |
||||
|
||||
// should be the same error produced by the Before func
|
||||
if err != beforeError { |
||||
t.Errorf("Run error expected, but not received") |
||||
} |
||||
|
||||
if beforeRun == false { |
||||
t.Errorf("Before() not executed when expected") |
||||
} |
||||
|
||||
if subcommandRun == true { |
||||
t.Errorf("Subcommand executed when NOT expected") |
||||
} |
||||
|
||||
} |
||||
|
||||
func TestApp_AfterFunc(t *testing.T) { |
||||
afterRun, subcommandRun := false, false |
||||
afterError := fmt.Errorf("fail") |
||||
var err error |
||||
|
||||
app := cli.NewApp() |
||||
|
||||
app.After = func(c *cli.Context) error { |
||||
afterRun = true |
||||
s := c.String("opt") |
||||
if s == "fail" { |
||||
return afterError |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
app.Commands = []cli.Command{ |
||||
cli.Command{ |
||||
Name: "sub", |
||||
Action: func(c *cli.Context) { |
||||
subcommandRun = true |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Flags = []cli.Flag{ |
||||
cli.StringFlag{Name: "opt"}, |
||||
} |
||||
|
||||
// run with the After() func succeeding
|
||||
err = app.Run([]string{"command", "--opt", "succeed", "sub"}) |
||||
|
||||
if err != nil { |
||||
t.Fatalf("Run error: %s", err) |
||||
} |
||||
|
||||
if afterRun == false { |
||||
t.Errorf("After() not executed when expected") |
||||
} |
||||
|
||||
if subcommandRun == false { |
||||
t.Errorf("Subcommand not executed when expected") |
||||
} |
||||
|
||||
// reset
|
||||
afterRun, subcommandRun = false, false |
||||
|
||||
// run with the Before() func failing
|
||||
err = app.Run([]string{"command", "--opt", "fail", "sub"}) |
||||
|
||||
// should be the same error produced by the Before func
|
||||
if err != afterError { |
||||
t.Errorf("Run error expected, but not received") |
||||
} |
||||
|
||||
if afterRun == false { |
||||
t.Errorf("After() not executed when expected") |
||||
} |
||||
|
||||
if subcommandRun == false { |
||||
t.Errorf("Subcommand not executed when expected") |
||||
} |
||||
} |
||||
|
||||
func TestAppNoHelpFlag(t *testing.T) { |
||||
oldFlag := cli.HelpFlag |
||||
defer func() { |
||||
cli.HelpFlag = oldFlag |
||||
}() |
||||
|
||||
cli.HelpFlag = cli.BoolFlag{} |
||||
|
||||
app := cli.NewApp() |
||||
err := app.Run([]string{"test", "-h"}) |
||||
|
||||
if err != flag.ErrHelp { |
||||
t.Errorf("expected error about missing help flag, but got: %s (%T)", err, err) |
||||
} |
||||
} |
||||
|
||||
func TestAppHelpPrinter(t *testing.T) { |
||||
oldPrinter := cli.HelpPrinter |
||||
defer func() { |
||||
cli.HelpPrinter = oldPrinter |
||||
}() |
||||
|
||||
var wasCalled = false |
||||
cli.HelpPrinter = func(template string, data interface{}) { |
||||
wasCalled = true |
||||
} |
||||
|
||||
app := cli.NewApp() |
||||
app.Run([]string{"-h"}) |
||||
|
||||
if wasCalled == false { |
||||
t.Errorf("Help printer expected to be called, but was not") |
||||
} |
||||
} |
||||
|
||||
func TestAppVersionPrinter(t *testing.T) { |
||||
oldPrinter := cli.VersionPrinter |
||||
defer func() { |
||||
cli.VersionPrinter = oldPrinter |
||||
}() |
||||
|
||||
var wasCalled = false |
||||
cli.VersionPrinter = func(c *cli.Context) { |
||||
wasCalled = true |
||||
} |
||||
|
||||
app := cli.NewApp() |
||||
ctx := cli.NewContext(app, nil, nil) |
||||
cli.ShowVersion(ctx) |
||||
|
||||
if wasCalled == false { |
||||
t.Errorf("Version printer expected to be called, but was not") |
||||
} |
||||
} |
||||
|
||||
func TestAppCommandNotFound(t *testing.T) { |
||||
beforeRun, subcommandRun := false, false |
||||
app := cli.NewApp() |
||||
|
||||
app.CommandNotFound = func(c *cli.Context, command string) { |
||||
beforeRun = true |
||||
} |
||||
|
||||
app.Commands = []cli.Command{ |
||||
cli.Command{ |
||||
Name: "bar", |
||||
Action: func(c *cli.Context) { |
||||
subcommandRun = true |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Run([]string{"command", "foo"}) |
||||
|
||||
expect(t, beforeRun, true) |
||||
expect(t, subcommandRun, false) |
||||
} |
||||
|
||||
func TestGlobalFlagsInSubcommands(t *testing.T) { |
||||
subcommandRun := false |
||||
app := cli.NewApp() |
||||
|
||||
app.Flags = []cli.Flag{ |
||||
cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"}, |
||||
} |
||||
|
||||
app.Commands = []cli.Command{ |
||||
cli.Command{ |
||||
Name: "foo", |
||||
Subcommands: []cli.Command{ |
||||
{ |
||||
Name: "bar", |
||||
Action: func(c *cli.Context) { |
||||
if c.GlobalBool("debug") { |
||||
subcommandRun = true |
||||
} |
||||
}, |
||||
}, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Run([]string{"command", "-d", "foo", "bar"}) |
||||
|
||||
expect(t, subcommandRun, true) |
||||
} |
||||
2
Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete
generated
vendored
2
Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete
generated
vendored
@ -1,100 +0,0 @@ |
||||
package cli_test |
||||
|
||||
import ( |
||||
"os" |
||||
|
||||
"github.com/codegangsta/cli" |
||||
) |
||||
|
||||
func Example() { |
||||
app := cli.NewApp() |
||||
app.Name = "todo" |
||||
app.Usage = "task list on the command line" |
||||
app.Commands = []cli.Command{ |
||||
{ |
||||
Name: "add", |
||||
Aliases: []string{"a"}, |
||||
Usage: "add a task to the list", |
||||
Action: func(c *cli.Context) { |
||||
println("added task: ", c.Args().First()) |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "complete", |
||||
Aliases: []string{"c"}, |
||||
Usage: "complete a task on the list", |
||||
Action: func(c *cli.Context) { |
||||
println("completed task: ", c.Args().First()) |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Run(os.Args) |
||||
} |
||||
|
||||
func ExampleSubcommand() { |
||||
app := cli.NewApp() |
||||
app.Name = "say" |
||||
app.Commands = []cli.Command{ |
||||
{ |
||||
Name: "hello", |
||||
Aliases: []string{"hi"}, |
||||
Usage: "use it to see a description", |
||||
Description: "This is how we describe hello the function", |
||||
Subcommands: []cli.Command{ |
||||
{ |
||||
Name: "english", |
||||
Aliases: []string{"en"}, |
||||
Usage: "sends a greeting in english", |
||||
Description: "greets someone in english", |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{ |
||||
Name: "name", |
||||
Value: "Bob", |
||||
Usage: "Name of the person to greet", |
||||
}, |
||||
}, |
||||
Action: func(c *cli.Context) { |
||||
println("Hello, ", c.String("name")) |
||||
}, |
||||
}, { |
||||
Name: "spanish", |
||||
Aliases: []string{"sp"}, |
||||
Usage: "sends a greeting in spanish", |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{ |
||||
Name: "surname", |
||||
Value: "Jones", |
||||
Usage: "Surname of the person to greet", |
||||
}, |
||||
}, |
||||
Action: func(c *cli.Context) { |
||||
println("Hola, ", c.String("surname")) |
||||
}, |
||||
}, { |
||||
Name: "french", |
||||
Aliases: []string{"fr"}, |
||||
Usage: "sends a greeting in french", |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{ |
||||
Name: "nickname", |
||||
Value: "Stevie", |
||||
Usage: "Nickname of the person to greet", |
||||
}, |
||||
}, |
||||
Action: func(c *cli.Context) { |
||||
println("Bonjour, ", c.String("nickname")) |
||||
}, |
||||
}, |
||||
}, |
||||
}, { |
||||
Name: "bye", |
||||
Usage: "says goodbye", |
||||
Action: func(c *cli.Context) { |
||||
println("bye") |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
app.Run(os.Args) |
||||
} |
||||
@ -1,49 +0,0 @@ |
||||
package cli_test |
||||
|
||||
import ( |
||||
"flag" |
||||
"testing" |
||||
|
||||
"github.com/codegangsta/cli" |
||||
) |
||||
|
||||
func TestCommandDoNotIgnoreFlags(t *testing.T) { |
||||
app := cli.NewApp() |
||||
set := flag.NewFlagSet("test", 0) |
||||
test := []string{"blah", "blah", "-break"} |
||||
set.Parse(test) |
||||
|
||||
c := cli.NewContext(app, set, set) |
||||
|
||||
command := cli.Command{ |
||||
Name: "test-cmd", |
||||
Aliases: []string{"tc"}, |
||||
Usage: "this is for testing", |
||||
Description: "testing", |
||||
Action: func(_ *cli.Context) {}, |
||||
} |
||||
err := command.Run(c) |
||||
|
||||
expect(t, err.Error(), "flag provided but not defined: -break") |
||||
} |
||||
|
||||
func TestCommandIgnoreFlags(t *testing.T) { |
||||
app := cli.NewApp() |
||||
set := flag.NewFlagSet("test", 0) |
||||
test := []string{"blah", "blah"} |
||||
set.Parse(test) |
||||
|
||||
c := cli.NewContext(app, set, set) |
||||
|
||||
command := cli.Command{ |
||||
Name: "test-cmd", |
||||
Aliases: []string{"tc"}, |
||||
Usage: "this is for testing", |
||||
Description: "testing", |
||||
Action: func(_ *cli.Context) {}, |
||||
SkipFlagParsing: true, |
||||
} |
||||
err := command.Run(c) |
||||
|
||||
expect(t, err, nil) |
||||
} |
||||
@ -1,111 +0,0 @@ |
||||
package cli_test |
||||
|
||||
import ( |
||||
"flag" |
||||
"testing" |
||||
"time" |
||||
|
||||
"github.com/codegangsta/cli" |
||||
) |
||||
|
||||
func TestNewContext(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Int("myflag", 12, "doc") |
||||
globalSet := flag.NewFlagSet("test", 0) |
||||
globalSet.Int("myflag", 42, "doc") |
||||
command := cli.Command{Name: "mycommand"} |
||||
c := cli.NewContext(nil, set, globalSet) |
||||
c.Command = command |
||||
expect(t, c.Int("myflag"), 12) |
||||
expect(t, c.GlobalInt("myflag"), 42) |
||||
expect(t, c.Command.Name, "mycommand") |
||||
} |
||||
|
||||
func TestContext_Int(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Int("myflag", 12, "doc") |
||||
c := cli.NewContext(nil, set, set) |
||||
expect(t, c.Int("myflag"), 12) |
||||
} |
||||
|
||||
func TestContext_Duration(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Duration("myflag", time.Duration(12*time.Second), "doc") |
||||
c := cli.NewContext(nil, set, set) |
||||
expect(t, c.Duration("myflag"), time.Duration(12*time.Second)) |
||||
} |
||||
|
||||
func TestContext_String(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.String("myflag", "hello world", "doc") |
||||
c := cli.NewContext(nil, set, set) |
||||
expect(t, c.String("myflag"), "hello world") |
||||
} |
||||
|
||||
func TestContext_Bool(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Bool("myflag", false, "doc") |
||||
c := cli.NewContext(nil, set, set) |
||||
expect(t, c.Bool("myflag"), false) |
||||
} |
||||
|
||||
func TestContext_BoolT(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Bool("myflag", true, "doc") |
||||
c := cli.NewContext(nil, set, set) |
||||
expect(t, c.BoolT("myflag"), true) |
||||
} |
||||
|
||||
func TestContext_Args(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Bool("myflag", false, "doc") |
||||
c := cli.NewContext(nil, set, set) |
||||
set.Parse([]string{"--myflag", "bat", "baz"}) |
||||
expect(t, len(c.Args()), 2) |
||||
expect(t, c.Bool("myflag"), true) |
||||
} |
||||
|
||||
func TestContext_IsSet(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Bool("myflag", false, "doc") |
||||
set.String("otherflag", "hello world", "doc") |
||||
globalSet := flag.NewFlagSet("test", 0) |
||||
globalSet.Bool("myflagGlobal", true, "doc") |
||||
c := cli.NewContext(nil, set, globalSet) |
||||
set.Parse([]string{"--myflag", "bat", "baz"}) |
||||
globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"}) |
||||
expect(t, c.IsSet("myflag"), true) |
||||
expect(t, c.IsSet("otherflag"), false) |
||||
expect(t, c.IsSet("bogusflag"), false) |
||||
expect(t, c.IsSet("myflagGlobal"), false) |
||||
} |
||||
|
||||
func TestContext_GlobalIsSet(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Bool("myflag", false, "doc") |
||||
set.String("otherflag", "hello world", "doc") |
||||
globalSet := flag.NewFlagSet("test", 0) |
||||
globalSet.Bool("myflagGlobal", true, "doc") |
||||
globalSet.Bool("myflagGlobalUnset", true, "doc") |
||||
c := cli.NewContext(nil, set, globalSet) |
||||
set.Parse([]string{"--myflag", "bat", "baz"}) |
||||
globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"}) |
||||
expect(t, c.GlobalIsSet("myflag"), false) |
||||
expect(t, c.GlobalIsSet("otherflag"), false) |
||||
expect(t, c.GlobalIsSet("bogusflag"), false) |
||||
expect(t, c.GlobalIsSet("myflagGlobal"), true) |
||||
expect(t, c.GlobalIsSet("myflagGlobalUnset"), false) |
||||
expect(t, c.GlobalIsSet("bogusGlobal"), false) |
||||
} |
||||
|
||||
func TestContext_NumFlags(t *testing.T) { |
||||
set := flag.NewFlagSet("test", 0) |
||||
set.Bool("myflag", false, "doc") |
||||
set.String("otherflag", "hello world", "doc") |
||||
globalSet := flag.NewFlagSet("test", 0) |
||||
globalSet.Bool("myflagGlobal", true, "doc") |
||||
c := cli.NewContext(nil, set, globalSet) |
||||
set.Parse([]string{"--myflag", "--otherflag=foo"}) |
||||
globalSet.Parse([]string{"--myflagGlobal"}) |
||||
expect(t, c.NumFlags(), 2) |
||||
} |
||||
@ -1,742 +0,0 @@ |
||||
package cli_test |
||||
|
||||
import ( |
||||
"fmt" |
||||
"os" |
||||
"reflect" |
||||
"strings" |
||||
"testing" |
||||
|
||||
"github.com/codegangsta/cli" |
||||
) |
||||
|
||||
var boolFlagTests = []struct { |
||||
name string |
||||
expected string |
||||
}{ |
||||
{"help", "--help\t"}, |
||||
{"h", "-h\t"}, |
||||
} |
||||
|
||||
func TestBoolFlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range boolFlagTests { |
||||
flag := cli.BoolFlag{Name: test.name} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%s does not match %s", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var stringFlagTests = []struct { |
||||
name string |
||||
value string |
||||
expected string |
||||
}{ |
||||
{"help", "", "--help \t"}, |
||||
{"h", "", "-h \t"}, |
||||
{"h", "", "-h \t"}, |
||||
{"test", "Something", "--test \"Something\"\t"}, |
||||
} |
||||
|
||||
func TestStringFlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range stringFlagTests { |
||||
flag := cli.StringFlag{Name: test.name, Value: test.value} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%s does not match %s", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestStringFlagWithEnvVarHelpOutput(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_FOO", "derp") |
||||
for _, test := range stringFlagTests { |
||||
flag := cli.StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"} |
||||
output := flag.String() |
||||
|
||||
if !strings.HasSuffix(output, " [$APP_FOO]") { |
||||
t.Errorf("%s does not end with [$APP_FOO]", output) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var stringSliceFlagTests = []struct { |
||||
name string |
||||
value *cli.StringSlice |
||||
expected string |
||||
}{ |
||||
{"help", func() *cli.StringSlice { |
||||
s := &cli.StringSlice{} |
||||
s.Set("") |
||||
return s |
||||
}(), "--help [--help option --help option]\t"}, |
||||
{"h", func() *cli.StringSlice { |
||||
s := &cli.StringSlice{} |
||||
s.Set("") |
||||
return s |
||||
}(), "-h [-h option -h option]\t"}, |
||||
{"h", func() *cli.StringSlice { |
||||
s := &cli.StringSlice{} |
||||
s.Set("") |
||||
return s |
||||
}(), "-h [-h option -h option]\t"}, |
||||
{"test", func() *cli.StringSlice { |
||||
s := &cli.StringSlice{} |
||||
s.Set("Something") |
||||
return s |
||||
}(), "--test [--test option --test option]\t"}, |
||||
} |
||||
|
||||
func TestStringSliceFlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range stringSliceFlagTests { |
||||
flag := cli.StringSliceFlag{Name: test.name, Value: test.value} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%q does not match %q", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_QWWX", "11,4") |
||||
for _, test := range stringSliceFlagTests { |
||||
flag := cli.StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"} |
||||
output := flag.String() |
||||
|
||||
if !strings.HasSuffix(output, " [$APP_QWWX]") { |
||||
t.Errorf("%q does not end with [$APP_QWWX]", output) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var intFlagTests = []struct { |
||||
name string |
||||
expected string |
||||
}{ |
||||
{"help", "--help \"0\"\t"}, |
||||
{"h", "-h \"0\"\t"}, |
||||
} |
||||
|
||||
func TestIntFlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range intFlagTests { |
||||
flag := cli.IntFlag{Name: test.name} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%s does not match %s", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestIntFlagWithEnvVarHelpOutput(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_BAR", "2") |
||||
for _, test := range intFlagTests { |
||||
flag := cli.IntFlag{Name: test.name, EnvVar: "APP_BAR"} |
||||
output := flag.String() |
||||
|
||||
if !strings.HasSuffix(output, " [$APP_BAR]") { |
||||
t.Errorf("%s does not end with [$APP_BAR]", output) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var durationFlagTests = []struct { |
||||
name string |
||||
expected string |
||||
}{ |
||||
{"help", "--help \"0\"\t"}, |
||||
{"h", "-h \"0\"\t"}, |
||||
} |
||||
|
||||
func TestDurationFlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range durationFlagTests { |
||||
flag := cli.DurationFlag{Name: test.name} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%s does not match %s", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_BAR", "2h3m6s") |
||||
for _, test := range durationFlagTests { |
||||
flag := cli.DurationFlag{Name: test.name, EnvVar: "APP_BAR"} |
||||
output := flag.String() |
||||
|
||||
if !strings.HasSuffix(output, " [$APP_BAR]") { |
||||
t.Errorf("%s does not end with [$APP_BAR]", output) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var intSliceFlagTests = []struct { |
||||
name string |
||||
value *cli.IntSlice |
||||
expected string |
||||
}{ |
||||
{"help", &cli.IntSlice{}, "--help [--help option --help option]\t"}, |
||||
{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"}, |
||||
{"h", &cli.IntSlice{}, "-h [-h option -h option]\t"}, |
||||
{"test", func() *cli.IntSlice { |
||||
i := &cli.IntSlice{} |
||||
i.Set("9") |
||||
return i |
||||
}(), "--test [--test option --test option]\t"}, |
||||
} |
||||
|
||||
func TestIntSliceFlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range intSliceFlagTests { |
||||
flag := cli.IntSliceFlag{Name: test.name, Value: test.value} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%q does not match %q", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_SMURF", "42,3") |
||||
for _, test := range intSliceFlagTests { |
||||
flag := cli.IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"} |
||||
output := flag.String() |
||||
|
||||
if !strings.HasSuffix(output, " [$APP_SMURF]") { |
||||
t.Errorf("%q does not end with [$APP_SMURF]", output) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var float64FlagTests = []struct { |
||||
name string |
||||
expected string |
||||
}{ |
||||
{"help", "--help \"0\"\t"}, |
||||
{"h", "-h \"0\"\t"}, |
||||
} |
||||
|
||||
func TestFloat64FlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range float64FlagTests { |
||||
flag := cli.Float64Flag{Name: test.name} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%s does not match %s", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_BAZ", "99.4") |
||||
for _, test := range float64FlagTests { |
||||
flag := cli.Float64Flag{Name: test.name, EnvVar: "APP_BAZ"} |
||||
output := flag.String() |
||||
|
||||
if !strings.HasSuffix(output, " [$APP_BAZ]") { |
||||
t.Errorf("%s does not end with [$APP_BAZ]", output) |
||||
} |
||||
} |
||||
} |
||||
|
||||
var genericFlagTests = []struct { |
||||
name string |
||||
value cli.Generic |
||||
expected string |
||||
}{ |
||||
{"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"}, |
||||
{"t", &Parser{"abc", "def"}, "-t \"abc,def\"\ttest flag"}, |
||||
} |
||||
|
||||
func TestGenericFlagHelpOutput(t *testing.T) { |
||||
|
||||
for _, test := range genericFlagTests { |
||||
flag := cli.GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"} |
||||
output := flag.String() |
||||
|
||||
if output != test.expected { |
||||
t.Errorf("%q does not match %q", output, test.expected) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_ZAP", "3") |
||||
for _, test := range genericFlagTests { |
||||
flag := cli.GenericFlag{Name: test.name, EnvVar: "APP_ZAP"} |
||||
output := flag.String() |
||||
|
||||
if !strings.HasSuffix(output, " [$APP_ZAP]") { |
||||
t.Errorf("%s does not end with [$APP_ZAP]", output) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestParseMultiString(t *testing.T) { |
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{Name: "serve, s"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.String("serve") != "10" { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.String("s") != "10" { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
}).Run([]string{"run", "-s", "10"}) |
||||
} |
||||
|
||||
func TestParseMultiStringFromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_COUNT", "20") |
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{Name: "count, c", EnvVar: "APP_COUNT"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.String("count") != "20" { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.String("c") != "20" { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
}).Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiStringFromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_COUNT", "20") |
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.String("count") != "20" { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.String("c") != "20" { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
}).Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiStringSlice(t *testing.T) { |
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.StringSliceFlag{Name: "serve, s", Value: &cli.StringSlice{}}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if !reflect.DeepEqual(ctx.StringSlice("s"), []string{"10", "20"}) { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
}).Run([]string{"run", "-s", "10", "-s", "20"}) |
||||
} |
||||
|
||||
func TestParseMultiStringSliceFromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_INTERVALS", "20,30,40") |
||||
|
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "APP_INTERVALS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
}).Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiStringSliceFromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_INTERVALS", "20,30,40") |
||||
|
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
}).Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiInt(t *testing.T) { |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.IntFlag{Name: "serve, s"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Int("serve") != 10 { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.Int("s") != 10 { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run", "-s", "10"}) |
||||
} |
||||
|
||||
func TestParseMultiIntFromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_TIMEOUT_SECONDS", "10") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Int("timeout") != 10 { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.Int("t") != 10 { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiIntFromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_TIMEOUT_SECONDS", "10") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Int("timeout") != 10 { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.Int("t") != 10 { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiIntSlice(t *testing.T) { |
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.IntSliceFlag{Name: "serve, s", Value: &cli.IntSlice{}}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if !reflect.DeepEqual(ctx.IntSlice("s"), []int{10, 20}) { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
}).Run([]string{"run", "-s", "10", "-s", "20"}) |
||||
} |
||||
|
||||
func TestParseMultiIntSliceFromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_INTERVALS", "20,30,40") |
||||
|
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "APP_INTERVALS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
}).Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiIntSliceFromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_INTERVALS", "20,30,40") |
||||
|
||||
(&cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
}).Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiFloat64(t *testing.T) { |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.Float64Flag{Name: "serve, s"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Float64("serve") != 10.2 { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.Float64("s") != 10.2 { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run", "-s", "10.2"}) |
||||
} |
||||
|
||||
func TestParseMultiFloat64FromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_TIMEOUT_SECONDS", "15.5") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Float64("timeout") != 15.5 { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.Float64("t") != 15.5 { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiFloat64FromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_TIMEOUT_SECONDS", "15.5") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Float64("timeout") != 15.5 { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.Float64("t") != 15.5 { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiBool(t *testing.T) { |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.BoolFlag{Name: "serve, s"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Bool("serve") != true { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.Bool("s") != true { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run", "--serve"}) |
||||
} |
||||
|
||||
func TestParseMultiBoolFromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_DEBUG", "1") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Bool("debug") != true { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if ctx.Bool("d") != true { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiBoolFromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_DEBUG", "1") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.Bool("debug") != true { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if ctx.Bool("d") != true { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiBoolT(t *testing.T) { |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.BoolTFlag{Name: "serve, s"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.BoolT("serve") != true { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if ctx.BoolT("s") != true { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run", "--serve"}) |
||||
} |
||||
|
||||
func TestParseMultiBoolTFromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_DEBUG", "0") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.BoolT("debug") != false { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if ctx.BoolT("d") != false { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseMultiBoolTFromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_DEBUG", "0") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if ctx.BoolT("debug") != false { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if ctx.BoolT("d") != false { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
type Parser [2]string |
||||
|
||||
func (p *Parser) Set(value string) error { |
||||
parts := strings.Split(value, ",") |
||||
if len(parts) != 2 { |
||||
return fmt.Errorf("invalid format") |
||||
} |
||||
|
||||
(*p)[0] = parts[0] |
||||
(*p)[1] = parts[1] |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (p *Parser) String() string { |
||||
return fmt.Sprintf("%s,%s", p[0], p[1]) |
||||
} |
||||
|
||||
func TestParseGeneric(t *testing.T) { |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.GenericFlag{Name: "serve, s", Value: &Parser{}}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) { |
||||
t.Errorf("main name not set") |
||||
} |
||||
if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"10", "20"}) { |
||||
t.Errorf("short name not set") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run", "-s", "10,20"}) |
||||
} |
||||
|
||||
func TestParseGenericFromEnv(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_SERVE", "20,30") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) { |
||||
t.Errorf("main name not set from env") |
||||
} |
||||
if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"20", "30"}) { |
||||
t.Errorf("short name not set from env") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
|
||||
func TestParseGenericFromEnvCascade(t *testing.T) { |
||||
os.Clearenv() |
||||
os.Setenv("APP_FOO", "99,2000") |
||||
a := cli.App{ |
||||
Flags: []cli.Flag{ |
||||
cli.GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"}, |
||||
}, |
||||
Action: func(ctx *cli.Context) { |
||||
if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) { |
||||
t.Errorf("value not set from env") |
||||
} |
||||
}, |
||||
} |
||||
a.Run([]string{"run"}) |
||||
} |
||||
@ -1,19 +0,0 @@ |
||||
package cli_test |
||||
|
||||
import ( |
||||
"reflect" |
||||
"testing" |
||||
) |
||||
|
||||
/* Test Helpers */ |
||||
func expect(t *testing.T, a interface{}, b interface{}) { |
||||
if a != b { |
||||
t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a)) |
||||
} |
||||
} |
||||
|
||||
func refute(t *testing.T, a interface{}, b interface{}) { |
||||
if a == b { |
||||
t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a)) |
||||
} |
||||
} |
||||
@ -0,0 +1,212 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of go-ethereum.
|
||||
//
|
||||
// go-ethereum is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// go-ethereum is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// Contains the geth command usage template and generator.
|
||||
|
||||
package main |
||||
|
||||
import ( |
||||
"io" |
||||
|
||||
"github.com/codegangsta/cli" |
||||
"github.com/ethereum/go-ethereum/cmd/utils" |
||||
) |
||||
|
||||
// AppHelpTemplate is the test template for the default, global app help topic.
|
||||
var AppHelpTemplate = `NAME: |
||||
{{.App.Name}} - {{.App.Usage}} |
||||
|
||||
USAGE: |
||||
{{.App.HelpName}} [options]{{if .App.Commands}} command [command options]{{end}} {{if .App.ArgsUsage}}{{.App.ArgsUsage}}{{else}}[arguments...]{{end}} |
||||
{{if .App.Version}} |
||||
VERSION: |
||||
{{.App.Version}} |
||||
{{end}}{{if len .App.Authors}} |
||||
AUTHOR(S): |
||||
{{range .App.Authors}}{{ . }}{{end}} |
||||
{{end}}{{if .App.Commands}} |
||||
COMMANDS: |
||||
{{range .App.Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}} |
||||
{{end}}{{end}}{{if .FlagGroups}} |
||||
{{range .FlagGroups}}{{.Name}} OPTIONS: |
||||
{{range .Flags}}{{.}} |
||||
{{end}} |
||||
{{end}}{{end}}{{if .App.Copyright }} |
||||
COPYRIGHT: |
||||
{{.App.Copyright}} |
||||
{{end}} |
||||
` |
||||
|
||||
// flagGroup is a collection of flags belonging to a single topic.
|
||||
type flagGroup struct { |
||||
Name string |
||||
Flags []cli.Flag |
||||
} |
||||
|
||||
// AppHelpFlagGroups is the application flags, grouped by functionality.
|
||||
var AppHelpFlagGroups = []flagGroup{ |
||||
{ |
||||
Name: "ETHEREUM", |
||||
Flags: []cli.Flag{ |
||||
utils.DataDirFlag, |
||||
utils.NetworkIdFlag, |
||||
utils.OlympicFlag, |
||||
utils.TestNetFlag, |
||||
utils.DevModeFlag, |
||||
utils.GenesisFileFlag, |
||||
utils.IdentityFlag, |
||||
utils.FastSyncFlag, |
||||
utils.CacheFlag, |
||||
utils.BlockchainVersionFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "ACCOUNT", |
||||
Flags: []cli.Flag{ |
||||
utils.UnlockedAccountFlag, |
||||
utils.PasswordFileFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "API AND CONSOLE", |
||||
Flags: []cli.Flag{ |
||||
utils.RPCEnabledFlag, |
||||
utils.RPCListenAddrFlag, |
||||
utils.RPCPortFlag, |
||||
utils.RpcApiFlag, |
||||
utils.IPCDisabledFlag, |
||||
utils.IPCApiFlag, |
||||
utils.IPCPathFlag, |
||||
utils.RPCCORSDomainFlag, |
||||
utils.JSpathFlag, |
||||
utils.ExecFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "NETWORKING", |
||||
Flags: []cli.Flag{ |
||||
utils.BootnodesFlag, |
||||
utils.ListenPortFlag, |
||||
utils.MaxPeersFlag, |
||||
utils.MaxPendingPeersFlag, |
||||
utils.NATFlag, |
||||
utils.NoDiscoverFlag, |
||||
utils.NodeKeyFileFlag, |
||||
utils.NodeKeyHexFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "MINER", |
||||
Flags: []cli.Flag{ |
||||
utils.MiningEnabledFlag, |
||||
utils.MinerThreadsFlag, |
||||
utils.MiningGPUFlag, |
||||
utils.AutoDAGFlag, |
||||
utils.EtherbaseFlag, |
||||
utils.GasPriceFlag, |
||||
utils.ExtraDataFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "GAS PRICE ORACLE", |
||||
Flags: []cli.Flag{ |
||||
utils.GpoMinGasPriceFlag, |
||||
utils.GpoMaxGasPriceFlag, |
||||
utils.GpoFullBlockRatioFlag, |
||||
utils.GpobaseStepDownFlag, |
||||
utils.GpobaseStepUpFlag, |
||||
utils.GpobaseCorrectionFactorFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "VIRTUAL MACHINE", |
||||
Flags: []cli.Flag{ |
||||
utils.VMDebugFlag, |
||||
utils.VMEnableJitFlag, |
||||
utils.VMForceJitFlag, |
||||
utils.VMJitCacheFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "LOGGING AND DEBUGGING", |
||||
Flags: []cli.Flag{ |
||||
utils.VerbosityFlag, |
||||
utils.LogVModuleFlag, |
||||
utils.BacktraceAtFlag, |
||||
utils.LogFileFlag, |
||||
utils.PProfEanbledFlag, |
||||
utils.PProfPortFlag, |
||||
utils.MetricsEnabledFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "EXPERIMENTAL", |
||||
Flags: []cli.Flag{ |
||||
utils.WhisperEnabledFlag, |
||||
utils.NatspecEnabledFlag, |
||||
}, |
||||
}, |
||||
{ |
||||
Name: "MISCELLANEOUS", |
||||
Flags: []cli.Flag{ |
||||
utils.SolcPathFlag, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
func init() { |
||||
// Override the default app help template
|
||||
cli.AppHelpTemplate = AppHelpTemplate |
||||
|
||||
// Define a one shot struct to pass to the usage template
|
||||
type helpData struct { |
||||
App interface{} |
||||
FlagGroups []flagGroup |
||||
} |
||||
// Override the default app help printer, but only for the global app help
|
||||
originalHelpPrinter := cli.HelpPrinter |
||||
cli.HelpPrinter = func(w io.Writer, tmpl string, data interface{}) { |
||||
if tmpl == AppHelpTemplate { |
||||
// Iterate over all the flags and add any uncategorized ones
|
||||
categorized := make(map[string]struct{}) |
||||
for _, group := range AppHelpFlagGroups { |
||||
for _, flag := range group.Flags { |
||||
categorized[flag.String()] = struct{}{} |
||||
} |
||||
} |
||||
uncategorized := []cli.Flag{} |
||||
for _, flag := range data.(*cli.App).Flags { |
||||
if _, ok := categorized[flag.String()]; !ok { |
||||
uncategorized = append(uncategorized, flag) |
||||
} |
||||
} |
||||
if len(uncategorized) > 0 { |
||||
// Append all ungategorized options to the misc group
|
||||
miscs := len(AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags) |
||||
AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags = append(AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags, uncategorized...) |
||||
|
||||
// Make sure they are removed afterwards
|
||||
defer func() { |
||||
AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags = AppHelpFlagGroups[len(AppHelpFlagGroups)-1].Flags[:miscs] |
||||
}() |
||||
} |
||||
// Render out custom usage screen
|
||||
originalHelpPrinter(w, tmpl, helpData{data, AppHelpFlagGroups}) |
||||
} else { |
||||
originalHelpPrinter(w, tmpl, data) |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue