func TestSanitizePath(t *testing.T) { assert.Equal(t, "", sanitizePath("////")) assert.Equal(t, "", sanitizePath("/../..")) assert.Equal(t, "a", sanitizePath("/a//b/..")) assert.Equal(t, "a", sanitizePath("../a")) assert.Equal(t, "a", sanitizePath("./a")) }
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 TestInterspersedFalse(t *testing.T) { app := New("test", "help").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 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"}) 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 TestDefaultSubcommandWithFlags(t *testing.T) { app := New("app", "").Terminate(nil) 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 TestDefaultSubcommandWithArg(t *testing.T) { app := New("app", "").Terminate(nil) 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 TestParseBase2Bytes(t *testing.T) { n, err := ParseBase2Bytes("0B") assert.NoError(t, err) assert.Equal(t, 0, n) n, err = ParseBase2Bytes("1KB") assert.NoError(t, err) assert.Equal(t, 1024, n) n, err = ParseBase2Bytes("1MB1KB25B") assert.NoError(t, err) assert.Equal(t, 1049625, n) n, err = ParseBase2Bytes("1.5MB") assert.NoError(t, err) assert.Equal(t, 1572864, n) }
func TestParseMetricBytes(t *testing.T) { n, err := ParseMetricBytes("0B") assert.NoError(t, err) assert.Equal(t, 0, n) n, err = ParseMetricBytes("1KB1B") assert.NoError(t, err) assert.Equal(t, 1001, n) n, err = ParseMetricBytes("1MB1KB25B") assert.NoError(t, err) assert.Equal(t, 1001025, n) n, err = ParseMetricBytes("1.5MB") assert.NoError(t, err) assert.Equal(t, 1500000, n) }
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", " ")) 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 TestParseContextPush(t *testing.T) { app := New("test", "") app.Command("foo", "").Command("bar", "") c := tokenize([]string{"foo", "bar"}) 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 TestCommander(t *testing.T) { c := New("test", "test") 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 TestParserExpandFromFile(t *testing.T) { f, err := ioutil.TempFile("", "") assert.NoError(t, err) defer os.Remove(f.Name()) f.WriteString("hello\nworld\n") f.Close() app := New("test", "") arg0 := app.Arg("arg0", "").String() arg1 := app.Arg("arg1", "").String() _, err = app.Parse([]string{"@" + f.Name()}) assert.NoError(t, err) assert.Equal(t, "hello", *arg0) assert.Equal(t, "world", *arg1) }
func TestTopLevelArgWorks(t *testing.T) { c := New("test", "test") s := c.Arg("arg", "help").String() _, err := c.Parse([]string{"foo"}) assert.NoError(t, err) assert.Equal(t, "foo", *s) }
func TestCombinedShortFlagArg(t *testing.T) { a := New("test", "") n := a.Flag("short", "").Short('s').Int() _, err := a.Parse([]string{"-s10"}) assert.NoError(t, err) assert.Equal(t, 10, *n) }
func TestParseIP(t *testing.T) { p := parserMixin{} v := p.IP() p.value.Set("10.1.1.2") ip := net.ParseIP("10.1.1.2") assert.Equal(t, ip, *v) }
func TestParseStringMap(t *testing.T) { p := parserMixin{} v := p.StringMap() p.value.Set("a:b") p.value.Set("b:c") assert.Equal(t, map[string]string{"a": "b", "b": "c"}, *v) }
func TestStringsStringer(t *testing.T) { target := []string{} v := newAccumulator(&target, func(v interface{}) Value { return newStringValue(v.(*string)) }) v.Set("hello") v.Set("world") assert.Equal(t, "hello,world", v.String()) }
func TestParseStrings(t *testing.T) { p := parserMixin{} v := p.Strings() p.value.Set("a") p.value.Set("b") assert.Equal(t, []string{"a", "b"}, *v) }
func TestArgRemainder(t *testing.T) { app := New("test", "") v := app.Arg("test", "").Strings() args := []string{"hello", "world"} _, err := app.Parse(args) assert.NoError(t, err) assert.Equal(t, args, *v) }
func TestSelectedCommand(t *testing.T) { app := New("test", "help") c0 := app.Command("c0", "") c0.Command("c1", "") s, err := app.Parse([]string{"c0", "c1"}) assert.NoError(t, err) assert.Equal(t, "c0 c1", s) }
func TestStrings(t *testing.T) { app := New("", "") app.Arg("a", "").Required().String() app.Arg("b", "").Required().String() c := app.Arg("c", "").Required().Strings() app.Parse([]string{"a", "b", "a", "b"}) assert.Equal(t, []string{"a", "b"}, *c) }
func TestParseURL(t *testing.T) { p := parserMixin{} v := p.URL() p.value.Set("http://w3.org") u, err := url.Parse("http://w3.org") assert.NoError(t, err) assert.Equal(t, *u, **v) }
func TestRequiredWithEnvar(t *testing.T) { os.Setenv("TEST_ENVAR", "123") app := New("test", "") flag := app.Flag("t", "").OverrideDefaultFromEnvar("TEST_ENVAR").Required().Int() _, err := app.Parse([]string{}) assert.NoError(t, err) assert.Equal(t, 123, *flag) }
func TestCommandParseDoesNotFailRequired(t *testing.T) { app := New("test", "") flag := app.Flag("flag", "").Required().String() app.Command("cmd", "") _, err := app.Parse([]string{"cmd", "--flag=123"}) assert.NoError(t, err) assert.Equal(t, "123", *flag) }
func TestEnum(t *testing.T) { app := New("", "") a := app.Arg("a", "").Enum("one", "two", "three") _, err := app.Parse([]string{"moo"}) assert.Error(t, err) _, err = app.Parse([]string{"one"}) assert.NoError(t, err) assert.Equal(t, "one", *a) }
func TestParseTCPAddrList(t *testing.T) { p := parserMixin{} _ = p.TCPList() err := p.value.Set("127.0.0.1:1234") assert.NoError(t, err) err = p.value.Set("127.0.0.1:1235") assert.NoError(t, err) assert.Equal(t, "127.0.0.1:1234,127.0.0.1:1235", p.value.String()) }
func TestParseTCPAddr(t *testing.T) { p := parserMixin{} v := p.TCP() err := p.value.Set("127.0.0.1:1234") assert.NoError(t, err) expected, err := net.ResolveTCPAddr("tcp", "127.0.0.1:1234") assert.NoError(t, err) assert.Equal(t, *expected, **v) }
func TestCommandParseDoesNotResetFlagsToDefault(t *testing.T) { app := New("test", "") flag := app.Flag("flag", "").Default("default").String() app.Command("cmd", "") _, err := app.Parse([]string{"--flag=123", "cmd"}) assert.NoError(t, err) assert.Equal(t, "123", *flag) }
func TestDefaultSubcommandEOL(t *testing.T) { app := New("app", "").Terminate(nil) c0 := app.Command("c0", "").Default() c0.Command("c01", "").Default() c0.Command("c02", "") cmd, err := app.Parse([]string{"c0"}) assert.NoError(t, err) assert.Equal(t, "c0 c01", cmd) }
func TestNestedCommandWithArgAndMergedFlags(t *testing.T) { app := New("app", "") cmd0 := app.Command("a", "") cmd0f0 := cmd0.Flag("aflag", "").Bool() // cmd1 := app.Command("b", "") // cmd1f0 := cmd0.Flag("bflag", "").Bool() cmd00 := cmd0.Command("aa", "") cmd00a0 := cmd00.Arg("arg", "").String() cmd00f0 := cmd00.Flag("aaflag", "").Bool() err := app.init() assert.NoError(t, err) context := tokenize(strings.Split("a aa hello --aflag --aaflag", " ")) selected, err := parseAndExecute(app, context) assert.NoError(t, err) assert.True(t, *cmd0f0) assert.True(t, *cmd00f0) assert.Equal(t, "a aa", selected) assert.Equal(t, "hello", *cmd00a0) }