func TestTake(t *testing.T) { s := FromInts(1, 2, 3, 4, 5) a := s.Take(2).ToArray() b := s.Take(3).ToArray() assert.Equal(t, []int{1, 2}, a) assert.Equal(t, []int{1, 2, 3}, b) }
func TestRepeat(t *testing.T) { s := RepeatInt(5, 3) a := s.ToArray() b := s.ToArray() assert.Equal(t, []int{5, 5, 5}, a) assert.Equal(t, []int{5, 5, 5}, b) }
func TestHiddenCmdCompletion(t *testing.T) { app := newTestApp() // top level visible & hidden cmds, with no sub-cmds app.Command("visible1", "") app.Command("hidden1", "").Hidden() // visible cmd with visible & hidden sub-cmds visible2 := app.Command("visible2", "") visible2.Command("visible2-visible", "") visible2.Command("visible2-hidden", "").Hidden() // hidden cmd with visible & hidden sub-cmds hidden2 := app.Command("hidden2", "").Hidden() hidden2.Command("hidden2-visible", "") hidden2.Command("hidden2-hidden", "").Hidden() // Only top level visible cmds should show assert.Equal(t, []string{"help", "visible1", "visible2"}, complete(t, app)) // Only visible sub-cmds should show assert.Equal(t, []string{"visible2-visible"}, complete(t, app, "visible2")) // Hidden commands should still complete visible sub-cmds assert.Equal(t, []string{"hidden2-visible"}, complete(t, app, "hidden2")) }
func TestTakeLast(t *testing.T) { s := FromInts(1, 2, 3, 4, 5) a := s.TakeLast(2).ToArray() b := s.TakeLast(3).ToArray() assert.Equal(t, []int{4, 5}, a) assert.Equal(t, []int{3, 4, 5}, b) }
func TestRange(t *testing.T) { s := Range(1, 5) a := s.ToArray() b := s.ToArray() assert.Equal(t, []int{1, 2, 3, 4, 5}, a) assert.Equal(t, []int{1, 2, 3, 4, 5}, b) }
func TestStart(t *testing.T) { s := StartInt(func() (int, error) { return 42, nil }) a := s.ToArray() b := s.ToArray() assert.Equal(t, []int{42}, a) assert.Equal(t, []int{42}, b) }
func TestAccumulatorStrings(t *testing.T) { target := []string{} acc := newAccumulator(&target, func(v interface{}) Value { return newStringValue(v.(*string)) }) acc.Set("a") assert.Equal(t, []string{"a"}, target) acc.Set("b") assert.Equal(t, []string{"a", "b"}, target) }
func TestConcat(t *testing.T) { a := []int{1, 2, 3} b := []int{4, 5} c := []int{6, 7} s := FromIntArray(a).Concat(FromIntArray(b)).Concat(FromIntArray(c)).ToArray() assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7}, s) s = FromIntArray(a).Concat(FromIntArray(b), FromIntArray(c)).ToArray() assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7}, s) }
func TestDefaultCmdCompletion(t *testing.T) { app := newTestApp() cmd1 := app.Command("cmd1", "") cmd1Sub1 := cmd1.Command("cmd1-sub1", "") cmd1Sub1.Arg("cmd1-sub1-arg1", "").HintOptions("cmd1-arg1").String() cmd2 := app.Command("cmd2", "").Default() cmd2.Command("cmd2-sub1", "") cmd2Sub2 := cmd2.Command("cmd2-sub2", "").Default() cmd2Sub2Sub1 := cmd2Sub2.Command("cmd2-sub2-sub1", "").Default() cmd2Sub2Sub1.Arg("cmd2-sub2-sub1-arg1", "").HintOptions("cmd2-sub2-sub1-arg1").String() cmd2Sub2Sub1.Arg("cmd2-sub2-sub1-arg2", "").HintOptions("cmd2-sub2-sub1-arg2").String() // Without args, should get: // - root cmds (incuding implicit "help") // - thread of default cmds // - first arg hints for the final default cmd assert.Equal(t, []string{"cmd1", "cmd2", "cmd2-sub1", "cmd2-sub2", "cmd2-sub2-sub1", "cmd2-sub2-sub1-arg1", "help"}, complete(t, app)) // With a non-default cmd already listed, should get: // - sub cmds of that arg assert.Equal(t, []string{"cmd1-sub1"}, complete(t, app, "cmd1")) // With an explicit default cmd listed, should get: // - default child-cmds // - first arg hints for the final default cmd assert.Equal(t, []string{"cmd2-sub1", "cmd2-sub2", "cmd2-sub2-sub1", "cmd2-sub2-sub1-arg1"}, complete(t, app, "cmd2")) // Args should be completed when all preceding cmds are explicit, and when // any of them are implicit (not listed). Check this by trying all possible // combinations of choosing/excluding the three levels of cmds. This tests // root-level default, middle default, and end default. for i := 0; i < 8; i++ { var cmdline []string if i&1 != 0 { cmdline = append(cmdline, "cmd2") } if i&2 != 0 { cmdline = append(cmdline, "cmd2-sub2") } if i&4 != 0 { cmdline = append(cmdline, "cmd2-sub2-sub1") } assert.Contains(t, complete(t, app, cmdline...), "cmd2-sub2-sub1-arg1", "with cmdline: %v", cmdline) } // With both args of a default sub cmd, should get no completions assert.Empty(t, complete(t, app, "arg1", "arg2")) }
func TestCmdCompletion(t *testing.T) { app := newTestApp() app.Command("one", "") two := app.Command("two", "") two.Command("sub1", "") two.Command("sub2", "") assert.Equal(t, []string{"help", "one", "two"}, complete(t, app)) assert.Equal(t, []string{"sub1", "sub2"}, complete(t, app, "two")) }
func TestAliasedCommand(t *testing.T) { app := newTestApp() app.Command("one", "").Alias("two") selected, _ := app.Parse([]string{"one"}) assert.Equal(t, "one", selected) selected, _ = app.Parse([]string{"two"}) assert.Equal(t, "one", selected) // 2 due to "help" and "one" assert.Equal(t, 2, len(app.Model().FlattenedCommands())) }
func Test_Writer(t *testing.T) { dropSize := 16 numShort := 0 shortSize := 0 validate := func(buf []byte) error { switch { case len(buf) == dropSize: if numShort > 0 { return fmt.Errorf("got full after short") } return nil case len(buf) < dropSize: if numShort > 0 { return fmt.Errorf("got second short (%d)", len(buf)) } numShort++ shortSize = len(buf) default: return fmt.Errorf("drop too large (%d > %d)", len(buf), dropSize) } return nil } buf := make([]byte, dropSize) countingWriter := counter.NewWriter(nil) dw := &Writer{ Buffer: buf, Validate: validate, Writer: countingWriter, } rbuf := make([]byte, 128) write := func(l int) { written, wErr := dw.Write(rbuf[0:l]) assert.Equal(t, l, written) assert.NoError(t, wErr) } write(12) write(4) write(10) write(6) write(16) write(64) write(5) assert.NoError(t, dw.Close()) assert.Equal(t, 5, shortSize) assert.Equal(t, int64(12+4+10+6+16+64+5), countingWriter.Count()) }
func TestDefaultEnvars(t *testing.T) { a := New("some-app", "").Terminate(nil).DefaultEnvars() f0 := a.Flag("some-flag", "") f0.Bool() f1 := a.Flag("some-other-flag", "").NoEnvar() f1.Bool() _, err := a.Parse([]string{}) assert.NoError(t, err) assert.Equal(t, "SOME_APP_SOME_FLAG", f0.envar) assert.Equal(t, "", f1.envar) }
func TestGetFlagAndOverrideDefault(t *testing.T) { app := newTestApp() a := app.Flag("a", "").Default("default").String() _, err := app.Parse([]string{}) assert.NoError(t, err) assert.Equal(t, "default", *a) app.GetFlag("a").Default("new") _, err = app.Parse([]string{}) assert.NoError(t, err) assert.Equal(t, "new", *a) }
func TestInterspersedFalse(t *testing.T) { app := newTestApp().Interspersed(false) a1 := app.Arg("a1", "").String() a2 := app.Arg("a2", "").String() f1 := app.Flag("flag", "").String() _, err := app.Parse([]string{"a1", "--flag=flag"}) assert.NoError(t, err) assert.Equal(t, "a1", *a1) assert.Equal(t, "--flag=flag", *a2) assert.Equal(t, "", *f1) }
func TestCreate(t *testing.T) { s := CreateInt(func(observer IntObserver, subscription Subscription) { observer.Next(0) observer.Next(1) observer.Next(2) observer.Complete() }) a := s.ToArray() b := s.ToArray() assert.Equal(t, []int{0, 1, 2}, a) assert.Equal(t, []int{0, 1, 2}, b) }
func TestDefaultSubcommandWithFlags(t *testing.T) { app := newTestApp() c0 := app.Command("c0", "").Default() _ = c0.Flag("f0", "").Int() c0c1 := c0.Command("c1", "").Default() c0c1f1 := c0c1.Flag("f1", "").Int() selected, err := app.Parse([]string{"--f1=2"}) assert.NoError(t, err) assert.Equal(t, "c0 c1", selected) assert.Equal(t, 2, *c0c1f1) _, err = app.Parse([]string{"--f2"}) assert.Error(t, err) }
func TestNestedCommandsWithArgs(t *testing.T) { app := New("app", "") cmd := app.Command("a", "").Command("b", "") a := cmd.Arg("a", "").String() b := cmd.Arg("b", "").String() context := tokenize([]string{"a", "b", "c", "d"}, false) selected, err := parseAndExecute(app, context) assert.NoError(t, err) assert.True(t, context.EOL()) assert.Equal(t, "a b", selected) assert.Equal(t, "c", *a) assert.Equal(t, "d", *b) }
func TestReplay(t *testing.T) { ch := make(chan int, 5) for i := 0; i < 5; i++ { ch <- i } close(ch) s := FromIntChannel(ch).Replay(0, 0) a := s.ToArray() b := s.ToArray() expected := []int{0, 1, 2, 3, 4} assert.Equal(t, expected, a) assert.Equal(t, expected, b) }
func TestDefaultSubcommandWithArg(t *testing.T) { app := newTestApp() c0 := app.Command("c0", "").Default() c01 := c0.Command("c01", "").Default() c012 := c01.Command("c012", "").Default() a0 := c012.Arg("a0", "").String() c0.Command("c02", "") cmd, err := app.Parse([]string{"c0", "hello"}) assert.NoError(t, err) assert.Equal(t, "c0 c01 c012", cmd) assert.Equal(t, "hello", *a0) }
func TestReplayWithSize(t *testing.T) { ch := make(chan int, 5) for i := 0; i < 5; i++ { ch <- i } close(ch) s := FromIntChannel(ch).Replay(2, 0) a := s.ToArray() b := s.ToArray() assert.Equal(t, []int{0, 1, 2, 3, 4}, a) assert.Equal(t, []int{3, 4}, b) assert.Equal(t, []int{3, 4}, s.ToArray()) }
func TestReplayWithExpiry(t *testing.T) { ch := make(chan int) go func() { for i := 0; i < 5; i++ { ch <- i time.Sleep(time.Millisecond * 100) } close(ch) }() s := FromIntChannel(ch).Replay(0, time.Millisecond*600) time.Sleep(time.Millisecond * 500) assert.Equal(t, []int{0, 1, 2, 3, 4}, s.ToArray()) time.Sleep(time.Millisecond * 100) assert.Equal(t, []int{1, 2, 3, 4}, s.ToArray()) }
func TestParseContextPush(t *testing.T) { app := New("test", "") app.Command("foo", "").Command("bar", "") c := tokenize([]string{"foo", "bar"}, false) a := c.Next() assert.Equal(t, TokenArg, a.Type) b := c.Next() assert.Equal(t, TokenArg, b.Type) c.Push(b) c.Push(a) a = c.Next() assert.Equal(t, "foo", a.Value) b = c.Next() assert.Equal(t, "bar", b.Value) }
func TestNestedCommandsWithFlags(t *testing.T) { app := New("app", "") cmd := app.Command("a", "").Command("b", "") a := cmd.Flag("aaa", "").Short('a').String() b := cmd.Flag("bbb", "").Short('b').String() err := app.init() assert.NoError(t, err) context := tokenize(strings.Split("a b --aaa x -b x", " "), false) selected, err := parseAndExecute(app, context) assert.NoError(t, err) assert.True(t, context.EOL()) assert.Equal(t, "a b", selected) assert.Equal(t, "x", *a) assert.Equal(t, "x", *b) }
func TestCommander(t *testing.T) { c := newTestApp() ping := c.Command("ping", "Ping an IP address.") pingTTL := ping.Flag("ttl", "TTL for ICMP packets").Short('t').Default("5s").Duration() selected, err := c.Parse([]string{"ping"}) assert.NoError(t, err) assert.Equal(t, "ping", selected) assert.Equal(t, 5*time.Second, *pingTTL) selected, err = c.Parse([]string{"ping", "--ttl=10s"}) assert.NoError(t, err) assert.Equal(t, "ping", selected) assert.Equal(t, 10*time.Second, *pingTTL) }
func TestFlagEnumVar(t *testing.T) { c := newTestApp() var bar string a := c.Flag("foo", "foo") a.Enum("opt1", "opt2") b := c.Flag("bar", "bar") b.EnumVar(&bar, "opt3", "opt4") args := a.resolveCompletions() assert.Equal(t, []string{"opt1", "opt2"}, args) args = b.resolveCompletions() assert.Equal(t, []string{"opt3", "opt4"}, args) }
func TestCombinedShortFlagArg(t *testing.T) { a := newTestApp() n := a.Flag("short", "").Short('s').Int() _, err := a.Parse([]string{"-s10"}) assert.NoError(t, err) assert.Equal(t, 10, *n) }
func TestMultiHintOptions(t *testing.T) { c := newTestApp() a := c.Flag("foo", "foo").HintOptions("opt1").HintOptions("opt2") args := a.resolveCompletions() assert.Equal(t, []string{"opt1", "opt2"}, args) }
func TestFlagMultipleValuesDefault(t *testing.T) { app := newTestApp() a := app.Flag("a", "").Default("default1", "default2").Strings() _, err := app.Parse([]string{}) assert.NoError(t, err) assert.Equal(t, []string{"default1", "default2"}, *a) }
func TestTopLevelArgWorks(t *testing.T) { c := newTestApp() s := c.Arg("arg", "help").String() _, err := c.Parse([]string{"foo"}) assert.NoError(t, err) assert.Equal(t, "foo", *s) }