2013-07-20 22:50:13 +00:00
|
|
|
package cli_test
|
|
|
|
|
|
|
|
import (
|
2015-05-04 01:37:51 +00:00
|
|
|
"bytes"
|
2014-12-02 04:20:21 +00:00
|
|
|
"flag"
|
2013-07-20 22:50:13 +00:00
|
|
|
"fmt"
|
2015-05-04 00:43:52 +00:00
|
|
|
"io"
|
2013-07-20 22:50:13 +00:00
|
|
|
"os"
|
2015-05-04 01:37:51 +00:00
|
|
|
"strings"
|
2013-09-14 22:29:57 +00:00
|
|
|
"testing"
|
2014-07-06 09:04:48 +00:00
|
|
|
|
2015-01-30 23:05:45 +00:00
|
|
|
"github.com/codegangsta/cli"
|
2013-07-20 22:50:13 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
func ExampleApp() {
|
|
|
|
// set args for examples sake
|
|
|
|
os.Args = []string{"greet", "--name", "Jeremy"}
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Name = "greet"
|
|
|
|
app.Flags = []cli.Flag{
|
2013-11-15 10:35:24 +00:00
|
|
|
cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
|
2013-07-20 22:50:13 +00:00
|
|
|
}
|
|
|
|
app.Action = func(c *cli.Context) {
|
|
|
|
fmt.Printf("Hello %v\n", c.String("name"))
|
|
|
|
}
|
2015-02-20 23:44:00 +00:00
|
|
|
app.Author = "Harrison"
|
|
|
|
app.Email = "harrison@lolwut.com"
|
2015-03-17 01:04:57 +00:00
|
|
|
app.Authors = []cli.Author{cli.Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
|
2013-07-20 22:50:13 +00:00
|
|
|
app.Run(os.Args)
|
|
|
|
// Output:
|
|
|
|
// Hello Jeremy
|
|
|
|
}
|
2013-09-14 22:29:57 +00:00
|
|
|
|
2015-03-17 01:04:57 +00:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2014-02-19 21:32:01 +00:00
|
|
|
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{
|
2014-02-19 21:37:20 +00:00
|
|
|
{
|
2014-04-12 22:13:47 +00:00
|
|
|
Name: "describeit",
|
2015-03-10 04:24:57 +00:00
|
|
|
Aliases: []string{"d"},
|
2014-04-12 22:13:47 +00:00
|
|
|
Usage: "use it to see a description",
|
2014-02-19 21:32:01 +00:00
|
|
|
Description: "This is how we describe describeit the function",
|
|
|
|
Action: func(c *cli.Context) {
|
2014-02-19 21:37:20 +00:00
|
|
|
fmt.Printf("i like to describe things")
|
|
|
|
},
|
2014-02-19 21:32:01 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
app.Run(os.Args)
|
|
|
|
// Output:
|
2014-02-19 21:37:20 +00:00
|
|
|
// NAME:
|
|
|
|
// describeit - use it to see a description
|
2014-02-19 21:32:01 +00:00
|
|
|
//
|
2014-02-19 21:37:20 +00:00
|
|
|
// USAGE:
|
2014-07-13 17:52:30 +00:00
|
|
|
// command describeit [arguments...]
|
2014-02-19 21:32:01 +00:00
|
|
|
//
|
2014-02-19 21:37:20 +00:00
|
|
|
// DESCRIPTION:
|
|
|
|
// This is how we describe describeit the function
|
2014-02-19 21:32:01 +00:00
|
|
|
}
|
|
|
|
|
2014-04-12 22:13:47 +00:00
|
|
|
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",
|
2015-03-10 04:24:57 +00:00
|
|
|
Aliases: []string{"d"},
|
2014-04-12 22:13:47 +00:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2013-09-14 22:29:57 +00:00
|
|
|
func TestApp_Run(t *testing.T) {
|
|
|
|
s := ""
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Action = func(c *cli.Context) {
|
2013-11-24 13:40:21 +00:00
|
|
|
s = s + c.Args().First()
|
2013-09-14 22:29:57 +00:00
|
|
|
}
|
|
|
|
|
2013-11-01 13:23:19 +00:00
|
|
|
err := app.Run([]string{"command", "foo"})
|
|
|
|
expect(t, err, nil)
|
|
|
|
err = app.Run([]string{"command", "bar"})
|
|
|
|
expect(t, err, nil)
|
2013-09-14 22:29:57 +00:00
|
|
|
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()
|
2015-03-10 04:24:57 +00:00
|
|
|
fooCommand := cli.Command{Name: "foobar", Aliases: []string{"f"}}
|
|
|
|
batCommand := cli.Command{Name: "batbaz", Aliases: []string{"b"}}
|
2013-09-14 22:29:57 +00:00
|
|
|
app.Commands = []cli.Command{
|
|
|
|
fooCommand,
|
|
|
|
batCommand,
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, test := range commandAppTests {
|
|
|
|
expect(t, app.Command(test.name) != nil, test.expected)
|
|
|
|
}
|
|
|
|
}
|
2013-09-18 16:24:20 +00:00
|
|
|
|
|
|
|
func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
|
|
|
|
var parsedOption, firstArg string
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
command := cli.Command{
|
|
|
|
Name: "cmd",
|
|
|
|
Flags: []cli.Flag{
|
2013-11-15 10:35:24 +00:00
|
|
|
cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
|
2013-09-18 16:24:20 +00:00
|
|
|
},
|
|
|
|
Action: func(c *cli.Context) {
|
|
|
|
parsedOption = c.String("option")
|
2013-11-24 13:40:21 +00:00
|
|
|
firstArg = c.Args().First()
|
2013-09-18 16:24:20 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
app.Commands = []cli.Command{command}
|
|
|
|
|
|
|
|
app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
|
|
|
|
|
|
|
|
expect(t, parsedOption, "my-option")
|
|
|
|
expect(t, firstArg, "my-arg")
|
|
|
|
}
|
2013-09-24 19:36:01 +00:00
|
|
|
|
2015-01-09 19:46:29 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2014-12-08 17:42:04 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2013-12-03 13:42:09 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2013-09-24 19:36:01 +00:00
|
|
|
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{
|
2013-11-15 10:35:24 +00:00
|
|
|
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"},
|
2013-09-24 19:36:01 +00:00
|
|
|
},
|
|
|
|
Action: func(c *cli.Context) {
|
|
|
|
parsedIntSlice = c.IntSlice("p")
|
|
|
|
parsedStringSlice = c.StringSlice("ip")
|
|
|
|
parsedOption = c.String("option")
|
2013-11-24 13:40:21 +00:00
|
|
|
firstArg = c.Args().First()
|
2013-09-24 19:36:01 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
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) {
|
2014-07-11 22:16:19 +00:00
|
|
|
t.Errorf("%v does not match %v", parsedIntSlice, expectedIntSlice)
|
2013-09-24 19:36:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if !StrsEquals(parsedStringSlice, expectedStringSlice) {
|
2014-07-11 22:16:19 +00:00
|
|
|
t.Errorf("%v does not match %v", parsedStringSlice, expectedStringSlice)
|
2013-09-24 19:36:01 +00:00
|
|
|
}
|
|
|
|
}
|
2014-01-04 16:14:33 +00:00
|
|
|
|
2015-05-31 20:50:23 +00:00
|
|
|
func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
|
|
|
|
var parsedIntSlice []int
|
|
|
|
var parsedStringSlice []string
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
command := cli.Command{
|
|
|
|
Name: "cmd",
|
|
|
|
Flags: []cli.Flag{
|
|
|
|
cli.IntSliceFlag{Name: "a", Usage: "set numbers"},
|
|
|
|
cli.StringSliceFlag{Name: "str", Usage: "set strings"},
|
|
|
|
},
|
|
|
|
Action: func(c *cli.Context) {
|
|
|
|
parsedIntSlice = c.IntSlice("a")
|
|
|
|
parsedStringSlice = c.StringSlice("str")
|
|
|
|
},
|
|
|
|
}
|
|
|
|
app.Commands = []cli.Command{command}
|
|
|
|
|
|
|
|
app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"})
|
|
|
|
|
|
|
|
var expectedIntSlice = []int{2}
|
|
|
|
var expectedStringSlice = []string{"A"}
|
|
|
|
|
|
|
|
if parsedIntSlice[0] != expectedIntSlice[0] {
|
|
|
|
t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
|
|
|
|
}
|
|
|
|
|
|
|
|
if parsedStringSlice[0] != expectedStringSlice[0] {
|
|
|
|
t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-12 07:39:13 +00:00
|
|
|
func TestApp_DefaultStdout(t *testing.T) {
|
|
|
|
app := cli.NewApp()
|
|
|
|
|
2014-12-02 04:50:04 +00:00
|
|
|
if app.Writer != os.Stdout {
|
2014-06-12 07:39:13 +00:00
|
|
|
t.Error("Default output writer not set.")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-10 15:31:53 +00:00
|
|
|
type mockWriter struct {
|
2014-06-12 07:39:13 +00:00
|
|
|
written []byte
|
|
|
|
}
|
|
|
|
|
2014-12-10 15:31:53 +00:00
|
|
|
func (fw *mockWriter) Write(p []byte) (n int, err error) {
|
2014-06-12 07:39:13 +00:00
|
|
|
if fw.written == nil {
|
|
|
|
fw.written = p
|
|
|
|
} else {
|
|
|
|
fw.written = append(fw.written, p...)
|
|
|
|
}
|
|
|
|
|
|
|
|
return len(p), nil
|
|
|
|
}
|
|
|
|
|
2014-12-10 15:31:53 +00:00
|
|
|
func (fw *mockWriter) GetWritten() (b []byte) {
|
2014-06-12 07:39:13 +00:00
|
|
|
return fw.written
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestApp_SetStdout(t *testing.T) {
|
2014-12-10 15:31:53 +00:00
|
|
|
w := &mockWriter{}
|
2014-06-12 07:39:13 +00:00
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Name = "test"
|
2014-12-10 15:31:53 +00:00
|
|
|
app.Writer = w
|
2014-06-12 07:39:13 +00:00
|
|
|
|
|
|
|
err := app.Run([]string{"help"})
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Run error: %s", err)
|
|
|
|
}
|
|
|
|
|
2014-12-10 15:31:53 +00:00
|
|
|
if len(w.written) == 0 {
|
2014-06-12 07:39:13 +00:00
|
|
|
t.Error("App did not write output to desired writer.")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-04 16:14:33 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2014-02-04 16:40:06 +00:00
|
|
|
|
2014-11-18 22:44:21 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
}
|
2014-02-04 16:40:06 +00:00
|
|
|
|
2014-12-02 04:20:21 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-04 16:40:06 +00:00
|
|
|
func TestAppHelpPrinter(t *testing.T) {
|
|
|
|
oldPrinter := cli.HelpPrinter
|
|
|
|
defer func() {
|
|
|
|
cli.HelpPrinter = oldPrinter
|
|
|
|
}()
|
|
|
|
|
|
|
|
var wasCalled = false
|
2015-05-04 00:43:52 +00:00
|
|
|
cli.HelpPrinter = func(w io.Writer, template string, data interface{}) {
|
2014-02-04 16:40:06 +00:00
|
|
|
wasCalled = true
|
|
|
|
}
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Run([]string{"-h"})
|
|
|
|
|
|
|
|
if wasCalled == false {
|
|
|
|
t.Errorf("Help printer expected to be called, but was not")
|
|
|
|
}
|
|
|
|
}
|
2014-03-31 03:40:46 +00:00
|
|
|
|
2014-06-18 04:37:55 +00:00
|
|
|
func TestAppVersionPrinter(t *testing.T) {
|
2014-06-18 05:33:30 +00:00
|
|
|
oldPrinter := cli.VersionPrinter
|
2014-06-18 04:37:55 +00:00
|
|
|
defer func() {
|
|
|
|
cli.VersionPrinter = oldPrinter
|
|
|
|
}()
|
|
|
|
|
|
|
|
var wasCalled = false
|
|
|
|
cli.VersionPrinter = func(c *cli.Context) {
|
|
|
|
wasCalled = true
|
|
|
|
}
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
2014-06-18 05:33:30 +00:00
|
|
|
ctx := cli.NewContext(app, nil, nil)
|
|
|
|
cli.ShowVersion(ctx)
|
2014-06-18 04:37:55 +00:00
|
|
|
|
|
|
|
if wasCalled == false {
|
|
|
|
t.Errorf("Version printer expected to be called, but was not")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-31 03:40:46 +00:00
|
|
|
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)
|
|
|
|
}
|
2014-07-06 09:04:48 +00:00
|
|
|
|
2015-06-29 21:20:27 +00:00
|
|
|
func TestGlobalFlag(t *testing.T) {
|
|
|
|
var globalFlag string
|
|
|
|
var globalFlagSet bool
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Flags = []cli.Flag{
|
|
|
|
cli.StringFlag{Name: "global, g", Usage: "global"},
|
|
|
|
}
|
|
|
|
app.Action = func(c *cli.Context) {
|
|
|
|
globalFlag = c.GlobalString("global")
|
|
|
|
globalFlagSet = c.GlobalIsSet("global")
|
|
|
|
}
|
|
|
|
app.Run([]string{"command", "-g", "foo"})
|
|
|
|
expect(t, globalFlag, "foo")
|
|
|
|
expect(t, globalFlagSet, true)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2014-07-06 09:04:48 +00:00
|
|
|
func TestGlobalFlagsInSubcommands(t *testing.T) {
|
|
|
|
subcommandRun := false
|
2015-05-18 15:39:48 +00:00
|
|
|
parentFlag := false
|
2014-07-06 09:04:48 +00:00
|
|
|
app := cli.NewApp()
|
|
|
|
|
|
|
|
app.Flags = []cli.Flag{
|
|
|
|
cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
|
|
|
|
}
|
|
|
|
|
|
|
|
app.Commands = []cli.Command{
|
|
|
|
cli.Command{
|
|
|
|
Name: "foo",
|
2015-05-18 15:39:48 +00:00
|
|
|
Flags: []cli.Flag{
|
|
|
|
cli.BoolFlag{Name: "parent, p", Usage: "Parent flag"},
|
|
|
|
},
|
2014-07-06 09:04:48 +00:00
|
|
|
Subcommands: []cli.Command{
|
|
|
|
{
|
|
|
|
Name: "bar",
|
|
|
|
Action: func(c *cli.Context) {
|
|
|
|
if c.GlobalBool("debug") {
|
|
|
|
subcommandRun = true
|
|
|
|
}
|
2015-05-18 15:39:48 +00:00
|
|
|
if c.GlobalBool("parent") {
|
|
|
|
parentFlag = true
|
|
|
|
}
|
2014-07-06 09:04:48 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2015-05-18 15:39:48 +00:00
|
|
|
app.Run([]string{"command", "-d", "foo", "-p", "bar"})
|
2014-07-06 09:04:48 +00:00
|
|
|
|
|
|
|
expect(t, subcommandRun, true)
|
2015-05-18 15:39:48 +00:00
|
|
|
expect(t, parentFlag, true)
|
2014-07-06 09:04:48 +00:00
|
|
|
}
|
2015-05-04 01:37:51 +00:00
|
|
|
|
|
|
|
func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
|
|
|
|
var subcommandHelpTopics = [][]string{
|
|
|
|
{"command", "foo", "--help"},
|
|
|
|
{"command", "foo", "-h"},
|
|
|
|
{"command", "foo", "help"},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, flagSet := range subcommandHelpTopics {
|
|
|
|
t.Logf("==> checking with flags %v", flagSet)
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
app.Writer = buf
|
|
|
|
|
|
|
|
subCmdBar := cli.Command{
|
|
|
|
Name: "bar",
|
|
|
|
Usage: "does bar things",
|
|
|
|
}
|
|
|
|
subCmdBaz := cli.Command{
|
|
|
|
Name: "baz",
|
|
|
|
Usage: "does baz things",
|
|
|
|
}
|
|
|
|
cmd := cli.Command{
|
|
|
|
Name: "foo",
|
|
|
|
Description: "descriptive wall of text about how it does foo things",
|
|
|
|
Subcommands: []cli.Command{subCmdBar, subCmdBaz},
|
|
|
|
}
|
|
|
|
|
|
|
|
app.Commands = []cli.Command{cmd}
|
|
|
|
err := app.Run(flagSet)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
output := buf.String()
|
|
|
|
t.Logf("output: %q\n", buf.Bytes())
|
|
|
|
|
|
|
|
if strings.Contains(output, "No help topic for") {
|
|
|
|
t.Errorf("expect a help topic, got none: \n%q", output)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, shouldContain := range []string{
|
|
|
|
cmd.Name, cmd.Description,
|
|
|
|
subCmdBar.Name, subCmdBar.Usage,
|
|
|
|
subCmdBaz.Name, subCmdBaz.Usage,
|
|
|
|
} {
|
|
|
|
if !strings.Contains(output, shouldContain) {
|
|
|
|
t.Errorf("want help to contain %q, did not: \n%q", shouldContain, output)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-06-03 03:16:44 +00:00
|
|
|
|
2015-06-20 23:59:54 +00:00
|
|
|
func TestApp_Run_SubcommandFullPath(t *testing.T) {
|
|
|
|
app := cli.NewApp()
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
app.Writer = buf
|
|
|
|
|
|
|
|
subCmd := cli.Command{
|
|
|
|
Name: "bar",
|
|
|
|
Usage: "does bar things",
|
|
|
|
}
|
|
|
|
cmd := cli.Command{
|
|
|
|
Name: "foo",
|
|
|
|
Description: "foo commands",
|
|
|
|
Subcommands: []cli.Command{subCmd},
|
|
|
|
}
|
|
|
|
app.Commands = []cli.Command{cmd}
|
|
|
|
|
|
|
|
err := app.Run([]string{"command", "foo", "bar", "--help"})
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
output := buf.String()
|
|
|
|
if !strings.Contains(output, "foo bar - does bar things") {
|
|
|
|
t.Errorf("expected full path to subcommand: %s", output)
|
|
|
|
}
|
|
|
|
if !strings.Contains(output, "command foo bar [arguments...]") {
|
|
|
|
t.Errorf("expected full path to subcommand: %s", output)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-03 03:16:44 +00:00
|
|
|
func TestApp_Run_Help(t *testing.T) {
|
|
|
|
var helpArguments = [][]string{{"boom", "--help"}, {"boom", "-h"}, {"boom", "help"}}
|
|
|
|
|
|
|
|
for _, args := range helpArguments {
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
|
|
|
|
t.Logf("==> checking with arguments %v", args)
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Name = "boom"
|
|
|
|
app.Usage = "make an explosive entrance"
|
|
|
|
app.Writer = buf
|
|
|
|
app.Action = func(c *cli.Context) {
|
|
|
|
buf.WriteString("boom I say!")
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run(args)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
output := buf.String()
|
|
|
|
t.Logf("output: %q\n", buf.Bytes())
|
|
|
|
|
|
|
|
if !strings.Contains(output, "boom - make an explosive entrance") {
|
|
|
|
t.Errorf("want help to contain %q, did not: \n%q", "boom - make an explosive entrance", output)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestApp_Run_Version(t *testing.T) {
|
|
|
|
var versionArguments = [][]string{{"boom", "--version"}, {"boom", "-v"}}
|
|
|
|
|
|
|
|
for _, args := range versionArguments {
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
|
|
|
|
t.Logf("==> checking with arguments %v", args)
|
|
|
|
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Name = "boom"
|
|
|
|
app.Usage = "make an explosive entrance"
|
|
|
|
app.Version = "0.1.0"
|
|
|
|
app.Writer = buf
|
|
|
|
app.Action = func(c *cli.Context) {
|
|
|
|
buf.WriteString("boom I say!")
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run(args)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
output := buf.String()
|
|
|
|
t.Logf("output: %q\n", buf.Bytes())
|
|
|
|
|
|
|
|
if !strings.Contains(output, "0.1.0") {
|
|
|
|
t.Errorf("want version to contain %q, did not: \n%q", "0.1.0", output)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-06-11 05:23:20 +00:00
|
|
|
|
2015-06-02 04:11:20 +00:00
|
|
|
func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Action = func(c *cli.Context) {}
|
|
|
|
app.Before = func(c *cli.Context) error { return fmt.Errorf("before error") }
|
|
|
|
app.After = func(c *cli.Context) error { return fmt.Errorf("after error") }
|
|
|
|
|
|
|
|
err := app.Run([]string{"foo"})
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected to recieve error from Run, got none")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !strings.Contains(err.Error(), "before error") {
|
|
|
|
t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
|
|
|
|
}
|
|
|
|
if !strings.Contains(err.Error(), "after error") {
|
|
|
|
t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestApp_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) {
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Commands = []cli.Command{
|
|
|
|
cli.Command{
|
|
|
|
Name: "bar",
|
|
|
|
Before: func(c *cli.Context) error { return fmt.Errorf("before error") },
|
|
|
|
After: func(c *cli.Context) error { return fmt.Errorf("after error") },
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run([]string{"foo", "bar"})
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected to recieve error from Run, got none")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !strings.Contains(err.Error(), "before error") {
|
|
|
|
t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
|
|
|
|
}
|
|
|
|
if !strings.Contains(err.Error(), "after error") {
|
|
|
|
t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
|
|
|
|
}
|
|
|
|
}
|