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", ShortName: "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 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", ShortName: "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 Example() { app := cli.NewApp() app.Name = "todo" app.Usage = "task list on the command line" app.Commands = []cli.Command{ { Name: "add", ShortName: "a", Usage: "add a task to the list", Action: func(c *cli.Context) { println("added task: ", c.Args().First()) }, }, { Name: "complete", ShortName: "c", Usage: "complete a task on the list", Action: func(c *cli.Context) { println("completed task: ", c.Args().First()) }, }, } app.Run(os.Args) }
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", ShortName: "hi", Usage: "use it to see a description", Description: "This is how we describe hello the function", Subcommands: []cli.Command{ { Name: "english", ShortName: "en", Usage: "sends a greeting in english", Description: "greets someone in english", Flags: []cli.Flag{ cli.StringFlag{"name", "Bob", "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 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) }
func main() { app := cli.NewApp() app.Name = "etcdctl" app.Version = version.Version app.Usage = "A simple command line client for etcd." app.Flags = []cli.Flag{ cli.BoolFlag{Name: "debug", Usage: "output cURL commands which can be used to reproduce the request"}, cli.BoolFlag{Name: "no-sync", Usage: "don't synchronize cluster information before sending request"}, cli.StringFlag{Name: "output, o", Value: "simple", Usage: "output response in the given format (`simple` or `json`)"}, cli.StringFlag{Name: "peers, C", Value: "", Usage: "a comma-delimited list of machine addresses in the cluster (default: \"127.0.0.1:4001\")"}, cli.StringFlag{Name: "cert-file", Value: "", Usage: "identify HTTPS client using this SSL certificate file"}, cli.StringFlag{Name: "key-file", Value: "", Usage: "identify HTTPS client using this SSL key file"}, cli.StringFlag{Name: "ca-file", Value: "", Usage: "verify certificates of HTTPS-enabled servers using this CA bundle"}, } app.Commands = []cli.Command{ command.NewBackupCommand(), command.NewMakeCommand(), command.NewMakeDirCommand(), command.NewRemoveCommand(), command.NewRemoveDirCommand(), command.NewGetCommand(), command.NewLsCommand(), command.NewSetCommand(), command.NewSetDirCommand(), command.NewUpdateCommand(), command.NewUpdateDirCommand(), command.NewWatchCommand(), command.NewExecWatchCommand(), command.NewMemberCommand(), } app.Run(os.Args) }
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 ExampleSubcommand() { app := cli.NewApp() app.Name = "say" app.Commands = []cli.Command{ { Name: "hello", ShortName: "hi", Usage: "use it to see a description", Description: "This is how we describe hello the function", Subcommands: []cli.Command{ { Name: "english", ShortName: "en", Usage: "sends a greeting in english", Description: "greets someone in english", Flags: []cli.Flag{ cli.StringFlag{"name", "Bob", "Name of the person to greet"}, }, Action: func(c *cli.Context) { println("Hello, ", c.String("name")) }, }, { Name: "spanish", ShortName: "sp", Usage: "sends a greeting in spanish", Flags: []cli.Flag{ cli.StringFlag{"surname", "Jones", "Surname of the person to greet"}, }, Action: func(c *cli.Context) { println("Hola, ", c.String("surname")) }, }, { Name: "french", ShortName: "fr", Usage: "sends a greeting in french", Flags: []cli.Flag{ cli.StringFlag{"nickname", "Stevie", "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) }
func TestApp_Command(t *testing.T) { app := cli.NewApp() fooCommand := cli.Command{Name: "foobar", ShortName: "f"} batCommand := cli.Command{Name: "batbaz", ShortName: "b"} app.Commands = []cli.Command{ fooCommand, batCommand, } for _, test := range commandAppTests { expect(t, app.Command(test.name) != nil, test.expected) } }
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_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") }
func main() { app := cli.NewApp() app.Name = "etcdctlv3" app.Version = version.Version app.Usage = "A simple command line client for etcd3." app.Commands = []cli.Command{ command.NewRangeCommand(), command.NewPutCommand(), command.NewDeleteRangeCommand(), command.NewTxnCommand(), } app.Run(os.Args) }
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.Run(os.Args) // Output: // Hello Jeremy }
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 main() { app := cli.NewApp() app.Name = "etcdctlv3" app.Version = version.Version app.Usage = "A simple command line client for etcd3." app.Flags = []cli.Flag{ cli.StringFlag{Name: "endpoint", Value: "127.0.0.1:2378", Usage: "gRPC endpoint"}, } app.Commands = []cli.Command{ command.NewRangeCommand(), command.NewPutCommand(), command.NewDeleteRangeCommand(), command.NewTxnCommand(), command.NewCompactionCommand(), } app.Run(os.Args) }
func main() { app := cli.NewApp() app.Name = "etcdctl" app.Version = version.Version app.Usage = "A simple command line client for etcd." app.Flags = []cli.Flag{ cli.BoolFlag{Name: "debug", Usage: "output cURL commands which can be used to reproduce the request"}, cli.BoolFlag{Name: "no-sync", Usage: "don't synchronize cluster information before sending request"}, cli.StringFlag{Name: "output, o", Value: "simple", Usage: "output response in the given format (`simple`, `extended` or `json`)"}, cli.StringFlag{Name: "discovery-srv, D", Usage: "domain name to query for SRV records describing cluster endpoints"}, cli.StringFlag{Name: "peers, C", Value: "", Usage: "DEPRECATED - \"--endpoints\" should be used instead"}, cli.StringFlag{Name: "endpoint", Value: "", Usage: "DEPRECATED - \"--endpoints\" should be used instead"}, cli.StringFlag{Name: "endpoints", Value: "", Usage: "a comma-delimited list of machine addresses in the cluster (default: \"http://127.0.0.1:2379,http://127.0.0.1:4001\")"}, cli.StringFlag{Name: "cert-file", Value: "", Usage: "identify HTTPS client using this SSL certificate file"}, cli.StringFlag{Name: "key-file", Value: "", Usage: "identify HTTPS client using this SSL key file"}, cli.StringFlag{Name: "ca-file", Value: "", Usage: "verify certificates of HTTPS-enabled servers using this CA bundle"}, cli.StringFlag{Name: "username, u", Value: "", Usage: "provide username[:password] and prompt if password is not supplied."}, cli.DurationFlag{Name: "timeout", Value: time.Second, Usage: "connection timeout per request"}, cli.DurationFlag{Name: "total-timeout", Value: 5 * time.Second, Usage: "timeout for the command execution (except watch)"}, } app.Commands = []cli.Command{ command.NewBackupCommand(), command.NewClusterHealthCommand(), command.NewMakeCommand(), command.NewMakeDirCommand(), command.NewRemoveCommand(), command.NewRemoveDirCommand(), command.NewGetCommand(), command.NewLsCommand(), command.NewSetCommand(), command.NewSetDirCommand(), command.NewUpdateCommand(), command.NewUpdateDirCommand(), command.NewWatchCommand(), command.NewExecWatchCommand(), command.NewMemberCommand(), command.NewImportSnapCommand(), command.NewUserCommands(), command.NewRoleCommands(), command.NewAuthCommands(), } app.Run(os.Args) }
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 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", ShortName: "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", ShortName: "tc", Usage: "this is for testing", Description: "testing", Action: func(_ *cli.Context) {}, SkipFlagParsing: true, } err := command.Run(c) expect(t, err, nil) }
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 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 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") } }