2015-07-20 19:18:25 +00:00
|
|
|
package cli
|
2014-04-14 21:44:32 +00:00
|
|
|
|
|
|
|
import (
|
2015-10-27 20:33:55 +00:00
|
|
|
"errors"
|
2014-06-18 05:33:30 +00:00
|
|
|
"flag"
|
2015-12-25 20:45:58 +00:00
|
|
|
"fmt"
|
2016-02-04 07:25:41 +00:00
|
|
|
"io/ioutil"
|
2015-12-25 20:45:58 +00:00
|
|
|
"strings"
|
2016-02-04 07:25:41 +00:00
|
|
|
"testing"
|
2014-04-14 21:44:32 +00:00
|
|
|
)
|
|
|
|
|
2015-10-27 20:33:55 +00:00
|
|
|
func TestCommandFlagParsing(t *testing.T) {
|
|
|
|
cases := []struct {
|
2017-11-13 21:28:23 +00:00
|
|
|
testArgs []string
|
|
|
|
skipFlagParsing bool
|
|
|
|
skipArgReorder bool
|
|
|
|
expectedErr error
|
|
|
|
UseShortOptionHandling bool
|
2015-10-27 20:33:55 +00:00
|
|
|
}{
|
2016-09-11 19:04:35 +00:00
|
|
|
// Test normal "not ignoring flags" flow
|
2019-09-12 04:08:52 +00:00
|
|
|
{[]string{"test-cmd", "blah", "blah", "-break"}, false, false, nil, false},
|
2016-09-11 19:04:35 +00:00
|
|
|
|
|
|
|
// Test no arg reorder
|
2017-11-13 21:28:23 +00:00
|
|
|
{[]string{"test-cmd", "blah", "blah", "-break"}, false, true, nil, false},
|
2017-11-20 15:32:03 +00:00
|
|
|
{[]string{"test-cmd", "blah", "blah", "-break", "ls", "-l"}, false, true, nil, true},
|
2017-11-13 21:28:23 +00:00
|
|
|
|
|
|
|
{[]string{"test-cmd", "blah", "blah"}, true, false, nil, false}, // Test SkipFlagParsing without any args that look like flags
|
|
|
|
{[]string{"test-cmd", "blah", "-break"}, true, false, nil, false}, // Test SkipFlagParsing with random flag arg
|
|
|
|
{[]string{"test-cmd", "blah", "-help"}, true, false, nil, false}, // Test SkipFlagParsing with "special" help flag arg
|
|
|
|
{[]string{"test-cmd", "blah"}, false, false, nil, true}, // Test UseShortOptionHandling
|
2016-09-11 19:04:35 +00:00
|
|
|
|
2014-04-14 21:44:32 +00:00
|
|
|
}
|
|
|
|
|
2015-10-27 20:33:55 +00:00
|
|
|
for _, c := range cases {
|
|
|
|
app := NewApp()
|
2015-11-28 17:26:10 +00:00
|
|
|
app.Writer = ioutil.Discard
|
2015-10-27 20:33:55 +00:00
|
|
|
set := flag.NewFlagSet("test", 0)
|
2019-08-07 14:44:50 +00:00
|
|
|
_ = set.Parse(c.testArgs)
|
2014-04-14 21:44:32 +00:00
|
|
|
|
2015-10-27 20:33:55 +00:00
|
|
|
context := NewContext(app, set, nil)
|
2014-04-14 21:44:32 +00:00
|
|
|
|
2015-10-27 20:33:55 +00:00
|
|
|
command := Command{
|
2017-11-13 21:28:23 +00:00
|
|
|
Name: "test-cmd",
|
|
|
|
Aliases: []string{"tc"},
|
|
|
|
Usage: "this is for testing",
|
|
|
|
Description: "testing",
|
|
|
|
Action: func(_ *Context) error { return nil },
|
|
|
|
SkipFlagParsing: c.skipFlagParsing,
|
|
|
|
SkipArgReorder: c.skipArgReorder,
|
|
|
|
UseShortOptionHandling: c.UseShortOptionHandling,
|
2015-10-27 20:33:55 +00:00
|
|
|
}
|
2015-09-25 21:13:36 +00:00
|
|
|
|
2016-04-27 13:12:34 +00:00
|
|
|
err := command.Run(context)
|
2015-09-25 21:13:36 +00:00
|
|
|
|
2015-10-27 20:33:55 +00:00
|
|
|
expect(t, err, c.expectedErr)
|
|
|
|
expect(t, []string(context.Args()), c.testArgs)
|
2015-09-25 21:13:36 +00:00
|
|
|
}
|
|
|
|
}
|
2015-12-25 20:45:58 +00:00
|
|
|
|
2018-06-28 14:41:02 +00:00
|
|
|
func TestParseAndRunShortOpts(t *testing.T) {
|
|
|
|
cases := []struct {
|
2019-08-07 14:44:50 +00:00
|
|
|
testArgs []string
|
|
|
|
expectedErr error
|
|
|
|
expectedArgs []string
|
2018-06-28 14:41:02 +00:00
|
|
|
}{
|
|
|
|
{[]string{"foo", "test", "-a"}, nil, []string{}},
|
|
|
|
{[]string{"foo", "test", "-c", "arg1", "arg2"}, nil, []string{"arg1", "arg2"}},
|
|
|
|
{[]string{"foo", "test", "-f"}, nil, []string{}},
|
|
|
|
{[]string{"foo", "test", "-ac", "--fgh"}, nil, []string{}},
|
|
|
|
{[]string{"foo", "test", "-af"}, nil, []string{}},
|
|
|
|
{[]string{"foo", "test", "-cf"}, nil, []string{}},
|
|
|
|
{[]string{"foo", "test", "-acf"}, nil, []string{}},
|
|
|
|
{[]string{"foo", "test", "-invalid"}, errors.New("flag provided but not defined: -invalid"), []string{}},
|
2019-08-07 14:44:50 +00:00
|
|
|
{[]string{"foo", "test", "-acf", "arg1", "-invalid"}, nil, []string{"arg1", "-invalid"}},
|
2018-06-28 14:41:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
var args []string
|
|
|
|
cmd := Command{
|
2019-08-07 14:44:50 +00:00
|
|
|
Name: "test",
|
|
|
|
Usage: "this is for testing",
|
|
|
|
Description: "testing",
|
|
|
|
Action: func(c *Context) error {
|
|
|
|
args = c.Args()
|
|
|
|
return nil
|
|
|
|
},
|
2018-06-28 14:41:02 +00:00
|
|
|
SkipArgReorder: true,
|
|
|
|
UseShortOptionHandling: true,
|
|
|
|
Flags: []Flag{
|
|
|
|
BoolFlag{Name: "abc, a"},
|
|
|
|
BoolFlag{Name: "cde, c"},
|
|
|
|
BoolFlag{Name: "fgh, f"},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, c := range cases {
|
|
|
|
app := NewApp()
|
|
|
|
app.Commands = []Command{cmd}
|
|
|
|
|
|
|
|
err := app.Run(c.testArgs)
|
|
|
|
|
|
|
|
expect(t, err, c.expectedErr)
|
|
|
|
expect(t, args, c.expectedArgs)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-25 20:45:58 +00:00
|
|
|
func TestCommand_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
|
|
|
|
app := NewApp()
|
|
|
|
app.Commands = []Command{
|
2016-05-09 13:40:09 +00:00
|
|
|
{
|
2016-04-25 22:10:10 +00:00
|
|
|
Name: "bar",
|
2016-04-27 13:12:34 +00:00
|
|
|
Before: func(c *Context) error {
|
|
|
|
return fmt.Errorf("before error")
|
2016-04-25 22:10:10 +00:00
|
|
|
},
|
2016-04-27 13:12:34 +00:00
|
|
|
After: func(c *Context) error {
|
|
|
|
return fmt.Errorf("after error")
|
2016-04-25 22:10:10 +00:00
|
|
|
},
|
2015-12-25 20:45:58 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2016-04-27 13:12:34 +00:00
|
|
|
err := app.Run([]string{"foo", "bar"})
|
2015-12-25 20:45:58 +00:00
|
|
|
if err == nil {
|
2016-01-20 09:56:46 +00:00
|
|
|
t.Fatalf("expected to receive error from Run, got none")
|
2015-12-25 20:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
2016-01-23 11:47:24 +00:00
|
|
|
|
2016-07-11 06:39:58 +00:00
|
|
|
func TestCommand_Run_BeforeSavesMetadata(t *testing.T) {
|
|
|
|
var receivedMsgFromAction string
|
|
|
|
var receivedMsgFromAfter string
|
|
|
|
|
|
|
|
app := NewApp()
|
|
|
|
app.Commands = []Command{
|
|
|
|
{
|
|
|
|
Name: "bar",
|
|
|
|
Before: func(c *Context) error {
|
|
|
|
c.App.Metadata["msg"] = "hello world"
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
Action: func(c *Context) error {
|
|
|
|
msg, ok := c.App.Metadata["msg"]
|
|
|
|
if !ok {
|
|
|
|
return errors.New("msg not found")
|
|
|
|
}
|
|
|
|
receivedMsgFromAction = msg.(string)
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
After: func(c *Context) error {
|
|
|
|
msg, ok := c.App.Metadata["msg"]
|
|
|
|
if !ok {
|
|
|
|
return errors.New("msg not found")
|
|
|
|
}
|
|
|
|
receivedMsgFromAfter = msg.(string)
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run([]string{"foo", "bar"})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("expected no error from Run, got %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
expectedMsg := "hello world"
|
|
|
|
|
|
|
|
if receivedMsgFromAction != expectedMsg {
|
|
|
|
t.Fatalf("expected msg from Action to match. Given: %q\nExpected: %q",
|
|
|
|
receivedMsgFromAction, expectedMsg)
|
|
|
|
}
|
|
|
|
if receivedMsgFromAfter != expectedMsg {
|
|
|
|
t.Fatalf("expected msg from After to match. Given: %q\nExpected: %q",
|
|
|
|
receivedMsgFromAction, expectedMsg)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-24 22:19:34 +00:00
|
|
|
func TestCommand_OnUsageError_hasCommandContext(t *testing.T) {
|
|
|
|
app := NewApp()
|
|
|
|
app.Commands = []Command{
|
|
|
|
{
|
|
|
|
Name: "bar",
|
|
|
|
Flags: []Flag{
|
|
|
|
IntFlag{Name: "flag"},
|
|
|
|
},
|
|
|
|
OnUsageError: func(c *Context, err error, _ bool) error {
|
|
|
|
return fmt.Errorf("intercepted in %s: %s", c.Command.Name, err.Error())
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run([]string{"foo", "bar", "--flag=wrong"})
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected to receive error from Run, got none")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !strings.HasPrefix(err.Error(), "intercepted in bar") {
|
|
|
|
t.Errorf("Expect an intercepted error, but got \"%v\"", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-23 11:47:24 +00:00
|
|
|
func TestCommand_OnUsageError_WithWrongFlagValue(t *testing.T) {
|
|
|
|
app := NewApp()
|
|
|
|
app.Commands = []Command{
|
2016-05-09 13:40:09 +00:00
|
|
|
{
|
2016-04-25 22:10:10 +00:00
|
|
|
Name: "bar",
|
2016-01-23 11:47:24 +00:00
|
|
|
Flags: []Flag{
|
|
|
|
IntFlag{Name: "flag"},
|
|
|
|
},
|
2016-04-25 22:29:05 +00:00
|
|
|
OnUsageError: func(c *Context, err error, _ bool) error {
|
2016-01-23 11:47:24 +00:00
|
|
|
if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
|
2017-05-05 22:01:44 +00:00
|
|
|
t.Errorf("Expect an invalid value error, but got \"%v\"", err)
|
|
|
|
}
|
|
|
|
return errors.New("intercepted: " + err.Error())
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run([]string{"foo", "bar", "--flag=wrong"})
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected to receive error from Run, got none")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
|
|
|
|
t.Errorf("Expect an intercepted error, but got \"%v\"", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestCommand_OnUsageError_WithSubcommand(t *testing.T) {
|
|
|
|
app := NewApp()
|
|
|
|
app.Commands = []Command{
|
|
|
|
{
|
|
|
|
Name: "bar",
|
|
|
|
Subcommands: []Command{
|
|
|
|
{
|
|
|
|
Name: "baz",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Flags: []Flag{
|
|
|
|
IntFlag{Name: "flag"},
|
|
|
|
},
|
|
|
|
OnUsageError: func(c *Context, err error, _ bool) error {
|
|
|
|
if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
|
2016-01-23 11:47:24 +00:00
|
|
|
t.Errorf("Expect an invalid value error, but got \"%v\"", err)
|
|
|
|
}
|
|
|
|
return errors.New("intercepted: " + err.Error())
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2016-04-27 13:12:34 +00:00
|
|
|
err := app.Run([]string{"foo", "bar", "--flag=wrong"})
|
2016-01-23 11:47:24 +00:00
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected to receive error from Run, got none")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
|
|
|
|
t.Errorf("Expect an intercepted error, but got \"%v\"", err)
|
|
|
|
}
|
|
|
|
}
|
2017-01-19 04:29:26 +00:00
|
|
|
|
|
|
|
func TestCommand_Run_SubcommandsCanUseErrWriter(t *testing.T) {
|
|
|
|
app := NewApp()
|
|
|
|
app.ErrWriter = ioutil.Discard
|
|
|
|
app.Commands = []Command{
|
|
|
|
{
|
|
|
|
Name: "bar",
|
|
|
|
Usage: "this is for testing",
|
|
|
|
Subcommands: []Command{
|
|
|
|
{
|
|
|
|
Name: "baz",
|
|
|
|
Usage: "this is for testing",
|
|
|
|
Action: func(c *Context) error {
|
|
|
|
if c.App.ErrWriter != ioutil.Discard {
|
|
|
|
return fmt.Errorf("ErrWriter not passed")
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run([]string{"foo", "bar", "baz"})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2017-12-04 17:23:40 +00:00
|
|
|
|
|
|
|
func TestCommandFlagReordering(t *testing.T) {
|
|
|
|
cases := []struct {
|
|
|
|
testArgs []string
|
|
|
|
expectedValue string
|
|
|
|
expectedArgs []string
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{[]string{"some-exec", "some-command", "some-arg", "--flag", "foo"}, "foo", []string{"some-arg"}, nil},
|
|
|
|
{[]string{"some-exec", "some-command", "some-arg", "--flag=foo"}, "foo", []string{"some-arg"}, nil},
|
|
|
|
{[]string{"some-exec", "some-command", "--flag=foo", "some-arg"}, "foo", []string{"some-arg"}, nil},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, c := range cases {
|
|
|
|
value := ""
|
2019-08-07 14:44:50 +00:00
|
|
|
var args []string
|
2017-12-04 17:23:40 +00:00
|
|
|
app := &App{
|
|
|
|
Commands: []Command{
|
|
|
|
{
|
|
|
|
Name: "some-command",
|
|
|
|
Flags: []Flag{
|
|
|
|
StringFlag{Name: "flag"},
|
|
|
|
},
|
|
|
|
Action: func(c *Context) {
|
|
|
|
fmt.Printf("%+v\n", c.String("flag"))
|
|
|
|
value = c.String("flag")
|
|
|
|
args = c.Args()
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run(c.testArgs)
|
|
|
|
expect(t, err, c.expectedErr)
|
|
|
|
expect(t, value, c.expectedValue)
|
|
|
|
expect(t, args, c.expectedArgs)
|
|
|
|
}
|
|
|
|
}
|
2017-12-29 18:38:18 +00:00
|
|
|
|
|
|
|
func TestCommandSkipFlagParsing(t *testing.T) {
|
|
|
|
cases := []struct {
|
|
|
|
testArgs []string
|
|
|
|
expectedArgs []string
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{[]string{"some-exec", "some-command", "some-arg", "--flag", "foo"}, []string{"some-arg", "--flag", "foo"}, nil},
|
|
|
|
{[]string{"some-exec", "some-command", "some-arg", "--flag=foo"}, []string{"some-arg", "--flag=foo"}, nil},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, c := range cases {
|
2019-08-07 14:44:50 +00:00
|
|
|
var args []string
|
2017-12-29 18:38:18 +00:00
|
|
|
app := &App{
|
|
|
|
Commands: []Command{
|
|
|
|
{
|
|
|
|
SkipFlagParsing: true,
|
|
|
|
Name: "some-command",
|
|
|
|
Flags: []Flag{
|
|
|
|
StringFlag{Name: "flag"},
|
|
|
|
},
|
|
|
|
Action: func(c *Context) {
|
|
|
|
fmt.Printf("%+v\n", c.String("flag"))
|
|
|
|
args = c.Args()
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err := app.Run(c.testArgs)
|
|
|
|
expect(t, err, c.expectedErr)
|
|
|
|
expect(t, args, c.expectedArgs)
|
|
|
|
}
|
|
|
|
}
|