| package cli |
| |
| import ( |
| "flag" |
| "os" |
| "testing" |
| "time" |
| ) |
| |
| func TestNewContext(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Int("myflag", 12, "doc") |
| set.Int64("myflagInt64", int64(12), "doc") |
| set.Uint("myflagUint", uint(93), "doc") |
| set.Uint64("myflagUint64", uint64(93), "doc") |
| set.Float64("myflag64", float64(17), "doc") |
| globalSet := flag.NewFlagSet("test", 0) |
| globalSet.Int("myflag", 42, "doc") |
| globalSet.Int64("myflagInt64", int64(42), "doc") |
| globalSet.Uint("myflagUint", uint(33), "doc") |
| globalSet.Uint64("myflagUint64", uint64(33), "doc") |
| globalSet.Float64("myflag64", float64(47), "doc") |
| globalCtx := NewContext(nil, globalSet, nil) |
| command := Command{Name: "mycommand"} |
| c := NewContext(nil, set, globalCtx) |
| c.Command = command |
| expect(t, c.Int("myflag"), 12) |
| expect(t, c.Int64("myflagInt64"), int64(12)) |
| expect(t, c.Uint("myflagUint"), uint(93)) |
| expect(t, c.Uint64("myflagUint64"), uint64(93)) |
| expect(t, c.Float64("myflag64"), float64(17)) |
| expect(t, c.GlobalInt("myflag"), 42) |
| expect(t, c.GlobalInt64("myflagInt64"), int64(42)) |
| expect(t, c.GlobalUint("myflagUint"), uint(33)) |
| expect(t, c.GlobalUint64("myflagUint64"), uint64(33)) |
| expect(t, c.GlobalFloat64("myflag64"), float64(47)) |
| expect(t, c.Command.Name, "mycommand") |
| } |
| |
| func TestContext_Int(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Int("myflag", 12, "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.Int("myflag"), 12) |
| } |
| |
| func TestContext_Int64(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Int64("myflagInt64", 12, "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.Int64("myflagInt64"), int64(12)) |
| } |
| |
| func TestContext_Uint(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Uint("myflagUint", uint(13), "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.Uint("myflagUint"), uint(13)) |
| } |
| |
| func TestContext_Uint64(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Uint64("myflagUint64", uint64(9), "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.Uint64("myflagUint64"), uint64(9)) |
| } |
| |
| func TestContext_GlobalInt(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Int("myflag", 12, "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.GlobalInt("myflag"), 12) |
| expect(t, c.GlobalInt("nope"), 0) |
| } |
| |
| func TestContext_GlobalInt64(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Int64("myflagInt64", 12, "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.GlobalInt64("myflagInt64"), int64(12)) |
| expect(t, c.GlobalInt64("nope"), int64(0)) |
| } |
| |
| func TestContext_Float64(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Float64("myflag", float64(17), "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.Float64("myflag"), float64(17)) |
| } |
| |
| func TestContext_GlobalFloat64(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Float64("myflag", float64(17), "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.GlobalFloat64("myflag"), float64(17)) |
| expect(t, c.GlobalFloat64("nope"), float64(0)) |
| } |
| |
| func TestContext_Duration(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Duration("myflag", time.Duration(12*time.Second), "doc") |
| c := NewContext(nil, set, nil) |
| 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 := NewContext(nil, set, nil) |
| expect(t, c.String("myflag"), "hello world") |
| } |
| |
| func TestContext_Bool(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Bool("myflag", false, "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.Bool("myflag"), false) |
| } |
| |
| func TestContext_BoolT(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Bool("myflag", true, "doc") |
| c := NewContext(nil, set, nil) |
| expect(t, c.BoolT("myflag"), true) |
| } |
| |
| func TestContext_GlobalBool(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| |
| globalSet := flag.NewFlagSet("test-global", 0) |
| globalSet.Bool("myflag", false, "doc") |
| globalCtx := NewContext(nil, globalSet, nil) |
| |
| c := NewContext(nil, set, globalCtx) |
| expect(t, c.GlobalBool("myflag"), false) |
| expect(t, c.GlobalBool("nope"), false) |
| } |
| |
| func TestContext_GlobalBoolT(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| |
| globalSet := flag.NewFlagSet("test-global", 0) |
| globalSet.Bool("myflag", true, "doc") |
| globalCtx := NewContext(nil, globalSet, nil) |
| |
| c := NewContext(nil, set, globalCtx) |
| expect(t, c.GlobalBoolT("myflag"), true) |
| expect(t, c.GlobalBoolT("nope"), false) |
| } |
| |
| func TestContext_Args(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Bool("myflag", false, "doc") |
| c := NewContext(nil, set, nil) |
| set.Parse([]string{"--myflag", "bat", "baz"}) |
| expect(t, len(c.Args()), 2) |
| expect(t, c.Bool("myflag"), true) |
| } |
| |
| func TestContext_NArg(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Bool("myflag", false, "doc") |
| c := NewContext(nil, set, nil) |
| set.Parse([]string{"--myflag", "bat", "baz"}) |
| expect(t, c.NArg(), 2) |
| } |
| |
| 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") |
| globalCtx := NewContext(nil, globalSet, nil) |
| c := NewContext(nil, set, globalCtx) |
| 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) |
| } |
| |
| // XXX Corresponds to hack in context.IsSet for flags with EnvVar field |
| // Should be moved to `flag_test` in v2 |
| func TestContext_IsSet_fromEnv(t *testing.T) { |
| var ( |
| timeoutIsSet, tIsSet bool |
| noEnvVarIsSet, nIsSet bool |
| passwordIsSet, pIsSet bool |
| unparsableIsSet, uIsSet bool |
| ) |
| |
| clearenv() |
| os.Setenv("APP_TIMEOUT_SECONDS", "15.5") |
| os.Setenv("APP_PASSWORD", "") |
| a := App{ |
| Flags: []Flag{ |
| Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"}, |
| StringFlag{Name: "password, p", EnvVar: "APP_PASSWORD"}, |
| Float64Flag{Name: "unparsable, u", EnvVar: "APP_UNPARSABLE"}, |
| Float64Flag{Name: "no-env-var, n"}, |
| }, |
| Action: func(ctx *Context) error { |
| timeoutIsSet = ctx.IsSet("timeout") |
| tIsSet = ctx.IsSet("t") |
| passwordIsSet = ctx.IsSet("password") |
| pIsSet = ctx.IsSet("p") |
| unparsableIsSet = ctx.IsSet("unparsable") |
| uIsSet = ctx.IsSet("u") |
| noEnvVarIsSet = ctx.IsSet("no-env-var") |
| nIsSet = ctx.IsSet("n") |
| return nil |
| }, |
| } |
| a.Run([]string{"run"}) |
| expect(t, timeoutIsSet, true) |
| expect(t, tIsSet, true) |
| expect(t, passwordIsSet, true) |
| expect(t, pIsSet, true) |
| expect(t, noEnvVarIsSet, false) |
| expect(t, nIsSet, false) |
| |
| os.Setenv("APP_UNPARSABLE", "foobar") |
| a.Run([]string{"run"}) |
| expect(t, unparsableIsSet, false) |
| expect(t, uIsSet, 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") |
| globalCtx := NewContext(nil, globalSet, nil) |
| c := NewContext(nil, set, globalCtx) |
| 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) |
| } |
| |
| // XXX Corresponds to hack in context.IsSet for flags with EnvVar field |
| // Should be moved to `flag_test` in v2 |
| func TestContext_GlobalIsSet_fromEnv(t *testing.T) { |
| var ( |
| timeoutIsSet, tIsSet bool |
| noEnvVarIsSet, nIsSet bool |
| passwordIsSet, pIsSet bool |
| unparsableIsSet, uIsSet bool |
| ) |
| |
| clearenv() |
| os.Setenv("APP_TIMEOUT_SECONDS", "15.5") |
| os.Setenv("APP_PASSWORD", "") |
| a := App{ |
| Flags: []Flag{ |
| Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"}, |
| StringFlag{Name: "password, p", EnvVar: "APP_PASSWORD"}, |
| Float64Flag{Name: "no-env-var, n"}, |
| Float64Flag{Name: "unparsable, u", EnvVar: "APP_UNPARSABLE"}, |
| }, |
| Commands: []Command{ |
| { |
| Name: "hello", |
| Action: func(ctx *Context) error { |
| timeoutIsSet = ctx.GlobalIsSet("timeout") |
| tIsSet = ctx.GlobalIsSet("t") |
| passwordIsSet = ctx.GlobalIsSet("password") |
| pIsSet = ctx.GlobalIsSet("p") |
| unparsableIsSet = ctx.GlobalIsSet("unparsable") |
| uIsSet = ctx.GlobalIsSet("u") |
| noEnvVarIsSet = ctx.GlobalIsSet("no-env-var") |
| nIsSet = ctx.GlobalIsSet("n") |
| return nil |
| }, |
| }, |
| }, |
| } |
| if err := a.Run([]string{"run", "hello"}); err != nil { |
| t.Logf("error running Run(): %+v", err) |
| } |
| expect(t, timeoutIsSet, true) |
| expect(t, tIsSet, true) |
| expect(t, passwordIsSet, true) |
| expect(t, pIsSet, true) |
| expect(t, noEnvVarIsSet, false) |
| expect(t, nIsSet, false) |
| |
| os.Setenv("APP_UNPARSABLE", "foobar") |
| if err := a.Run([]string{"run"}); err != nil { |
| t.Logf("error running Run(): %+v", err) |
| } |
| expect(t, unparsableIsSet, false) |
| expect(t, uIsSet, 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") |
| globalCtx := NewContext(nil, globalSet, nil) |
| c := NewContext(nil, set, globalCtx) |
| set.Parse([]string{"--myflag", "--otherflag=foo"}) |
| globalSet.Parse([]string{"--myflagGlobal"}) |
| expect(t, c.NumFlags(), 2) |
| } |
| |
| func TestContext_GlobalFlag(t *testing.T) { |
| var globalFlag string |
| var globalFlagSet bool |
| app := NewApp() |
| app.Flags = []Flag{ |
| StringFlag{Name: "global, g", Usage: "global"}, |
| } |
| app.Action = func(c *Context) error { |
| globalFlag = c.GlobalString("global") |
| globalFlagSet = c.GlobalIsSet("global") |
| return nil |
| } |
| app.Run([]string{"command", "-g", "foo"}) |
| expect(t, globalFlag, "foo") |
| expect(t, globalFlagSet, true) |
| |
| } |
| |
| func TestContext_GlobalFlagsInSubcommands(t *testing.T) { |
| subcommandRun := false |
| parentFlag := false |
| app := NewApp() |
| |
| app.Flags = []Flag{ |
| BoolFlag{Name: "debug, d", Usage: "Enable debugging"}, |
| } |
| |
| app.Commands = []Command{ |
| { |
| Name: "foo", |
| Flags: []Flag{ |
| BoolFlag{Name: "parent, p", Usage: "Parent flag"}, |
| }, |
| Subcommands: []Command{ |
| { |
| Name: "bar", |
| Action: func(c *Context) error { |
| if c.GlobalBool("debug") { |
| subcommandRun = true |
| } |
| if c.GlobalBool("parent") { |
| parentFlag = true |
| } |
| return nil |
| }, |
| }, |
| }, |
| }, |
| } |
| |
| app.Run([]string{"command", "-d", "foo", "-p", "bar"}) |
| |
| expect(t, subcommandRun, true) |
| expect(t, parentFlag, true) |
| } |
| |
| func TestContext_Set(t *testing.T) { |
| set := flag.NewFlagSet("test", 0) |
| set.Int("int", 5, "an int") |
| c := NewContext(nil, set, nil) |
| |
| c.Set("int", "1") |
| expect(t, c.Int("int"), 1) |
| } |
| |
| func TestContext_GlobalSet(t *testing.T) { |
| gSet := flag.NewFlagSet("test", 0) |
| gSet.Int("int", 5, "an int") |
| |
| set := flag.NewFlagSet("sub", 0) |
| set.Int("int", 3, "an int") |
| |
| pc := NewContext(nil, gSet, nil) |
| c := NewContext(nil, set, pc) |
| |
| c.Set("int", "1") |
| expect(t, c.Int("int"), 1) |
| expect(t, c.GlobalInt("int"), 5) |
| |
| c.GlobalSet("int", "1") |
| expect(t, c.Int("int"), 1) |
| expect(t, c.GlobalInt("int"), 1) |
| } |
