diff --git a/Makefile b/Makefile index ff4fe9e..d0c6314 100644 --- a/Makefile +++ b/Makefile @@ -1,23 +1,10 @@ -# git remote add gitwit git@git.wit.org:wit/arg.git +all: + @echo + @echo "this is from alexflint's github repo" + @echo "the 'github' branch is the upstream branch" + @echo redomod: rm -f go.* GO111MODULE= go mod init GO111MODULE= go mod tidy - -github: - git push origin register - git push origin devel - git push origin jcarr - git push origin --tags - # git push github register - # git push github devel - # git push github --tags - @echo - @echo check https://git.wit.org/wit/arg - @echo - -# init-github: -# git push -u github master -# git push -u github devel -# git push github --tags diff --git a/example_test.go b/example_test.go deleted file mode 100644 index 4bd7632..0000000 --- a/example_test.go +++ /dev/null @@ -1,540 +0,0 @@ -package arg - -import ( - "fmt" - "net" - "net/mail" - "net/url" - "os" - "strings" - "time" -) - -func split(s string) []string { - return strings.Split(s, " ") -} - -// This example demonstrates basic usage -func Example() { - // These are the args you would pass in on the command line - os.Args = split("./example --foo=hello --bar") - - var args struct { - Foo string - Bar bool - } - MustParse(&args) - fmt.Println(args.Foo, args.Bar) - // output: hello true -} - -// This example demonstrates arguments that have default values -func Example_defaultValues() { - // These are the args you would pass in on the command line - os.Args = split("./example") - - var args struct { - Foo string `default:"abc"` - } - MustParse(&args) - fmt.Println(args.Foo) - // output: abc -} - -// This example demonstrates arguments that are required -func Example_requiredArguments() { - // These are the args you would pass in on the command line - os.Args = split("./example --foo=abc --bar") - - var args struct { - Foo string `arg:"required"` - Bar bool - } - MustParse(&args) - fmt.Println(args.Foo, args.Bar) - // output: abc true -} - -// This example demonstrates positional arguments -func Example_positionalArguments() { - // These are the args you would pass in on the command line - os.Args = split("./example in out1 out2 out3") - - var args struct { - Input string `arg:"positional"` - Output []string `arg:"positional"` - } - MustParse(&args) - fmt.Println("In:", args.Input) - fmt.Println("Out:", args.Output) - // output: - // In: in - // Out: [out1 out2 out3] -} - -// This example demonstrates arguments that have multiple values -func Example_multipleValues() { - // The args you would pass in on the command line - os.Args = split("./example --database localhost --ids 1 2 3") - - var args struct { - Database string - IDs []int64 - } - MustParse(&args) - fmt.Printf("Fetching the following IDs from %s: %v", args.Database, args.IDs) - // output: Fetching the following IDs from localhost: [1 2 3] -} - -// This example demonstrates arguments with keys and values -func Example_mappings() { - // The args you would pass in on the command line - os.Args = split("./example --userids john=123 mary=456") - - var args struct { - UserIDs map[string]int - } - MustParse(&args) - fmt.Println(args.UserIDs) - // output: map[john:123 mary:456] -} - -type commaSeparated struct { - M map[string]string -} - -func (c *commaSeparated) UnmarshalText(b []byte) error { - c.M = make(map[string]string) - for _, part := range strings.Split(string(b), ",") { - pos := strings.Index(part, "=") - if pos == -1 { - return fmt.Errorf("error parsing %q, expected format key=value", part) - } - c.M[part[:pos]] = part[pos+1:] - } - return nil -} - -// This example demonstrates arguments with keys and values separated by commas -func Example_mappingWithCommas() { - // The args you would pass in on the command line - os.Args = split("./example --values one=two,three=four") - - var args struct { - Values commaSeparated - } - MustParse(&args) - fmt.Println(args.Values.M) - // output: map[one:two three:four] -} - -// This eample demonstrates multiple value arguments that can be mixed with -// other arguments. -func Example_multipleMixed() { - os.Args = split("./example -c cmd1 db1 -f file1 db2 -c cmd2 -f file2 -f file3 db3 -c cmd3") - var args struct { - Commands []string `arg:"-c,separate"` - Files []string `arg:"-f,separate"` - Databases []string `arg:"positional"` - } - MustParse(&args) - fmt.Println("Commands:", args.Commands) - fmt.Println("Files:", args.Files) - fmt.Println("Databases:", args.Databases) - - // output: - // Commands: [cmd1 cmd2 cmd3] - // Files: [file1 file2 file3] - // Databases: [db1 db2 db3] -} - -// This example shows the usage string generated by go-arg -func Example_helpText() { - // These are the args you would pass in on the command line - os.Args = split("./example --help") - - var args struct { - Input string `arg:"positional,required"` - Output []string `arg:"positional"` - Verbose bool `arg:"-v" help:"verbosity level"` - Dataset string `help:"dataset to use"` - Optimize int `arg:"-O,--optim" help:"optimization level"` - } - - // This is only necessary when running inside golang's runnable example harness - mustParseExit = func(int) {} - - MustParse(&args) - - // output: - // Usage: example [--verbose] [--dataset DATASET] [--optim OPTIM] INPUT [OUTPUT [OUTPUT ...]] - // - // Positional arguments: - // INPUT - // OUTPUT - // - // Options: - // --verbose, -v verbosity level - // --dataset DATASET dataset to use - // --optim OPTIM, -O OPTIM - // optimization level - // --help, -h display this help and exit -} - -// This example shows the usage string generated by go-arg with customized placeholders -func Example_helpPlaceholder() { - // These are the args you would pass in on the command line - os.Args = split("./example --help") - - var args struct { - Input string `arg:"positional,required" placeholder:"SRC"` - Output []string `arg:"positional" placeholder:"DST"` - Optimize int `arg:"-O" help:"optimization level" placeholder:"LEVEL"` - MaxJobs int `arg:"-j" help:"maximum number of simultaneous jobs" placeholder:"N"` - } - - // This is only necessary when running inside golang's runnable example harness - mustParseExit = func(int) {} - - MustParse(&args) - - // output: - - // Usage: example [--optimize LEVEL] [--maxjobs N] SRC [DST [DST ...]] - - // Positional arguments: - // SRC - // DST - - // Options: - // --optimize LEVEL, -O LEVEL - // optimization level - // --maxjobs N, -j N maximum number of simultaneous jobs - // --help, -h display this help and exit -} - -// This example shows the usage string generated by go-arg when using subcommands -func Example_helpTextWithSubcommand() { - // These are the args you would pass in on the command line - os.Args = split("./example --help") - - type getCmd struct { - Item string `arg:"positional" help:"item to fetch"` - } - - type listCmd struct { - Format string `help:"output format"` - Limit int - } - - var args struct { - Verbose bool - Get *getCmd `arg:"subcommand" help:"fetch an item and print it"` - List *listCmd `arg:"subcommand" help:"list available items"` - } - - // This is only necessary when running inside golang's runnable example harness - mustParseExit = func(int) {} - - MustParse(&args) - - // output: - // Usage: example [--verbose] [] - // - // Options: - // --verbose - // --help, -h display this help and exit - // - // Commands: - // get fetch an item and print it - // list list available items -} - -// This example shows the usage string generated by go-arg when using subcommands -func Example_helpTextWhenUsingSubcommand() { - // These are the args you would pass in on the command line - os.Args = split("./example get --help") - - type getCmd struct { - Item string `arg:"positional,required" help:"item to fetch"` - } - - type listCmd struct { - Format string `help:"output format"` - Limit int - } - - var args struct { - Verbose bool - Get *getCmd `arg:"subcommand" help:"fetch an item and print it"` - List *listCmd `arg:"subcommand" help:"list available items"` - } - - // This is only necessary when running inside golang's runnable example harness - mustParseExit = func(int) {} - - MustParse(&args) - - // output: - // Usage: example get ITEM - // - // Positional arguments: - // ITEM item to fetch - // - // Global options: - // --verbose - // --help, -h display this help and exit -} - -// This example shows how to print help for an explicit subcommand -func Example_writeHelpForSubcommand() { - // These are the args you would pass in on the command line - os.Args = split("./example get --help") - - type getCmd struct { - Item string `arg:"positional" help:"item to fetch"` - } - - type listCmd struct { - Format string `help:"output format"` - Limit int - } - - var args struct { - Verbose bool - Get *getCmd `arg:"subcommand" help:"fetch an item and print it"` - List *listCmd `arg:"subcommand" help:"list available items"` - } - - // This is only necessary when running inside golang's runnable example harness - exit := func(int) {} - - p, err := NewParser(Config{Exit: exit}, &args) - if err != nil { - fmt.Println(err) - os.Exit(1) - } - - err = p.WriteHelpForSubcommand(os.Stdout, "list") - if err != nil { - fmt.Println(err) - os.Exit(1) - } - - // output: - // Usage: example list [--format FORMAT] [--limit LIMIT] - // - // Options: - // --format FORMAT output format - // --limit LIMIT - // - // Global options: - // --verbose - // --help, -h display this help and exit -} - -// This example shows how to print help for a subcommand that is nested several levels deep -func Example_writeHelpForSubcommandNested() { - // These are the args you would pass in on the command line - os.Args = split("./example get --help") - - type mostNestedCmd struct { - Item string - } - - type nestedCmd struct { - MostNested *mostNestedCmd `arg:"subcommand"` - } - - type topLevelCmd struct { - Nested *nestedCmd `arg:"subcommand"` - } - - var args struct { - TopLevel *topLevelCmd `arg:"subcommand"` - } - - // This is only necessary when running inside golang's runnable example harness - exit := func(int) {} - - p, err := NewParser(Config{Exit: exit}, &args) - if err != nil { - fmt.Println(err) - os.Exit(1) - } - - err = p.WriteHelpForSubcommand(os.Stdout, "toplevel", "nested", "mostnested") - if err != nil { - fmt.Println(err) - os.Exit(1) - } - - // output: - // Usage: example toplevel nested mostnested [--item ITEM] - // - // Options: - // --item ITEM - // --help, -h display this help and exit -} - -// This example shows the error string generated by go-arg when an invalid option is provided -func Example_errorText() { - // These are the args you would pass in on the command line - os.Args = split("./example --optimize INVALID") - - var args struct { - Input string `arg:"positional,required"` - Output []string `arg:"positional"` - Verbose bool `arg:"-v" help:"verbosity level"` - Dataset string `help:"dataset to use"` - Optimize int `arg:"-O,help:optimization level"` - } - - // This is only necessary when running inside golang's runnable example harness - mustParseExit = func(int) {} - - MustParse(&args) - - // output: - // Usage: example [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] INPUT [OUTPUT [OUTPUT ...]] - // error: error processing --optimize: strconv.ParseInt: parsing "INVALID": invalid syntax -} - -// This example shows the error string generated by go-arg when an invalid option is provided -func Example_errorTextForSubcommand() { - // These are the args you would pass in on the command line - os.Args = split("./example get --count INVALID") - - type getCmd struct { - Count int - } - - var args struct { - Get *getCmd `arg:"subcommand"` - } - - // This is only necessary when running inside golang's runnable example harness - mustParseExit = func(int) {} - - MustParse(&args) - - // output: - // Usage: example get [--count COUNT] - // error: error processing --count: strconv.ParseInt: parsing "INVALID": invalid syntax -} - -// This example demonstrates use of subcommands -func Example_subcommand() { - // These are the args you would pass in on the command line - os.Args = split("./example commit -a -m what-this-commit-is-about") - - type CheckoutCmd struct { - Branch string `arg:"positional"` - Track bool `arg:"-t"` - } - type CommitCmd struct { - All bool `arg:"-a"` - Message string `arg:"-m"` - } - type PushCmd struct { - Remote string `arg:"positional"` - Branch string `arg:"positional"` - SetUpstream bool `arg:"-u"` - } - var args struct { - Checkout *CheckoutCmd `arg:"subcommand:checkout"` - Commit *CommitCmd `arg:"subcommand:commit"` - Push *PushCmd `arg:"subcommand:push"` - Quiet bool `arg:"-q"` // this flag is global to all subcommands - } - - // This is only necessary when running inside golang's runnable example harness - mustParseExit = func(int) {} - - MustParse(&args) - - switch { - case args.Checkout != nil: - fmt.Printf("checkout requested for branch %s\n", args.Checkout.Branch) - case args.Commit != nil: - fmt.Printf("commit requested with message \"%s\"\n", args.Commit.Message) - case args.Push != nil: - fmt.Printf("push requested from %s to %s\n", args.Push.Branch, args.Push.Remote) - } - - // output: - // commit requested with message "what-this-commit-is-about" -} - -func Example_allSupportedTypes() { - // These are the args you would pass in on the command line - os.Args = []string{} - - var args struct { - Bool bool - Byte byte - Rune rune - Int int - Int8 int8 - Int16 int16 - Int32 int32 - Int64 int64 - Float32 float32 - Float64 float64 - String string - Duration time.Duration - URL url.URL - Email mail.Address - MAC net.HardwareAddr - } - - // go-arg supports each of the types above, as well as pointers to any of - // the above and slices of any of the above. It also supports any types that - // implements encoding.TextUnmarshaler. - - MustParse(&args) - - // output: -} - -func Example_envVarOnly() { - os.Args = split("./example") - _ = os.Setenv("AUTH_KEY", "my_key") - - defer os.Unsetenv("AUTH_KEY") - - var args struct { - AuthKey string `arg:"--,env:AUTH_KEY"` - } - - MustParse(&args) - - fmt.Println(args.AuthKey) - // output: my_key -} - -func Example_envVarOnlyShouldIgnoreFlag() { - os.Args = split("./example --=my_key") - - var args struct { - AuthKey string `arg:"--,env:AUTH_KEY"` - } - - err := Parse(&args) - - fmt.Println(err) - // output: unknown argument --=my_key -} - -func Example_envVarOnlyShouldIgnoreShortFlag() { - os.Args = split("./example -=my_key") - - var args struct { - AuthKey string `arg:"--,env:AUTH_KEY"` - } - - err := Parse(&args) - - fmt.Println(err) - // output: unknown argument -=my_key -} diff --git a/go.mod b/go.mod index cf9552c..9a8440b 100644 --- a/go.mod +++ b/go.mod @@ -2,13 +2,4 @@ module go.wit.com/dev/alexflint/go-arg go 1.21.4 -require ( - github.com/alexflint/go-scalar v1.2.0 - github.com/stretchr/testify v1.8.4 -) - -require ( - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect -) +require github.com/alexflint/go-scalar v1.2.0 diff --git a/go.sum b/go.sum index 401488a..50248e2 100644 --- a/go.sum +++ b/go.sum @@ -4,10 +4,5 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/parse_test.go b/parse_test.go deleted file mode 100644 index d53b483..0000000 --- a/parse_test.go +++ /dev/null @@ -1,1739 +0,0 @@ -package arg - -import ( - "bytes" - "encoding/json" - "fmt" - "net" - "net/mail" - "net/url" - "os" - "strings" - "testing" - "time" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func setenv(t *testing.T, name, val string) { - if err := os.Setenv(name, val); err != nil { - t.Error(err) - } -} - -func parse(cmdline string, dest interface{}) error { - _, err := pparse(cmdline, dest) - return err -} - -func pparse(cmdline string, dest interface{}) (*Parser, error) { - return parseWithEnv(cmdline, nil, dest) -} - -func parseWithEnv(cmdline string, env []string, dest interface{}) (*Parser, error) { - p, err := NewParser(Config{}, dest) - if err != nil { - return nil, err - } - - // split the command line - var parts []string - if len(cmdline) > 0 { - parts = strings.Split(cmdline, " ") - } - - // split the environment vars - for _, s := range env { - pos := strings.Index(s, "=") - if pos == -1 { - return nil, fmt.Errorf("missing equals sign in %q", s) - } - err := os.Setenv(s[:pos], s[pos+1:]) - if err != nil { - return nil, err - } - } - - // execute the parser - return p, p.Parse(parts) -} - -func TestString(t *testing.T) { - var args struct { - Foo string - Ptr *string - } - err := parse("--foo bar --ptr baz", &args) - require.NoError(t, err) - assert.Equal(t, "bar", args.Foo) - assert.Equal(t, "baz", *args.Ptr) -} - -func TestBool(t *testing.T) { - var args struct { - A bool - B bool - C *bool - D *bool - } - err := parse("--a --c", &args) - require.NoError(t, err) - assert.True(t, args.A) - assert.False(t, args.B) - assert.True(t, *args.C) - assert.Nil(t, args.D) -} - -func TestInt(t *testing.T) { - var args struct { - Foo int - Ptr *int - } - err := parse("--foo 7 --ptr 8", &args) - require.NoError(t, err) - assert.EqualValues(t, 7, args.Foo) - assert.EqualValues(t, 8, *args.Ptr) -} - -func TestHexOctBin(t *testing.T) { - var args struct { - Hex int - Oct int - Bin int - Underscored int - } - err := parse("--hex 0xA --oct 0o10 --bin 0b101 --underscored 123_456", &args) - require.NoError(t, err) - assert.EqualValues(t, 10, args.Hex) - assert.EqualValues(t, 8, args.Oct) - assert.EqualValues(t, 5, args.Bin) - assert.EqualValues(t, 123456, args.Underscored) -} - -func TestNegativeInt(t *testing.T) { - var args struct { - Foo int - } - err := parse("-foo -100", &args) - require.NoError(t, err) - assert.EqualValues(t, args.Foo, -100) -} - -func TestNegativeIntAndFloatAndTricks(t *testing.T) { - var args struct { - Foo int - Bar float64 - N int `arg:"--100"` - } - err := parse("-foo -100 -bar -60.14 -100 -100", &args) - require.NoError(t, err) - assert.EqualValues(t, args.Foo, -100) - assert.EqualValues(t, args.Bar, -60.14) - assert.EqualValues(t, args.N, -100) -} - -func TestUint(t *testing.T) { - var args struct { - Foo uint - Ptr *uint - } - err := parse("--foo 7 --ptr 8", &args) - require.NoError(t, err) - assert.EqualValues(t, 7, args.Foo) - assert.EqualValues(t, 8, *args.Ptr) -} - -func TestFloat(t *testing.T) { - var args struct { - Foo float32 - Ptr *float32 - } - err := parse("--foo 3.4 --ptr 3.5", &args) - require.NoError(t, err) - assert.EqualValues(t, 3.4, args.Foo) - assert.EqualValues(t, 3.5, *args.Ptr) -} - -func TestDuration(t *testing.T) { - var args struct { - Foo time.Duration - Ptr *time.Duration - } - err := parse("--foo 3ms --ptr 4ms", &args) - require.NoError(t, err) - assert.Equal(t, 3*time.Millisecond, args.Foo) - assert.Equal(t, 4*time.Millisecond, *args.Ptr) -} - -func TestInvalidDuration(t *testing.T) { - var args struct { - Foo time.Duration - } - err := parse("--foo xxx", &args) - require.Error(t, err) -} - -func TestIntPtr(t *testing.T) { - var args struct { - Foo *int - } - err := parse("--foo 123", &args) - require.NoError(t, err) - require.NotNil(t, args.Foo) - assert.Equal(t, 123, *args.Foo) -} - -func TestIntPtrNotPresent(t *testing.T) { - var args struct { - Foo *int - } - err := parse("", &args) - require.NoError(t, err) - assert.Nil(t, args.Foo) -} - -func TestMixed(t *testing.T) { - var args struct { - Foo string `arg:"-f"` - Bar int - Baz uint `arg:"positional"` - Ham bool - Spam float32 - } - args.Bar = 3 - err := parse("123 -spam=1.2 -ham -f xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.Foo) - assert.Equal(t, 3, args.Bar) - assert.Equal(t, uint(123), args.Baz) - assert.Equal(t, true, args.Ham) - assert.EqualValues(t, 1.2, args.Spam) -} - -func TestRequired(t *testing.T) { - var args struct { - Foo string `arg:"required"` - } - err := parse("", &args) - require.Error(t, err, "--foo is required") -} - -func TestRequiredWithEnv(t *testing.T) { - var args struct { - Foo string `arg:"required,env:FOO"` - } - err := parse("", &args) - require.Error(t, err, "--foo is required (or environment variable FOO)") -} - -func TestRequiredWithEnvOnly(t *testing.T) { - var args struct { - Foo string `arg:"required,--,-,env:FOO"` - } - _, err := parseWithEnv("", []string{}, &args) - require.Error(t, err, "environment variable FOO is required") -} - -func TestShortFlag(t *testing.T) { - var args struct { - Foo string `arg:"-f"` - } - - err := parse("-f xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.Foo) - - err = parse("-foo xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.Foo) - - err = parse("--foo xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.Foo) -} - -func TestInvalidShortFlag(t *testing.T) { - var args struct { - Foo string `arg:"-foo"` - } - err := parse("", &args) - assert.Error(t, err) -} - -func TestLongFlag(t *testing.T) { - var args struct { - Foo string `arg:"--abc"` - } - - err := parse("-abc xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.Foo) - - err = parse("--abc xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.Foo) -} - -func TestSlice(t *testing.T) { - var args struct { - Strings []string - } - err := parse("--strings a b c", &args) - require.NoError(t, err) - assert.Equal(t, []string{"a", "b", "c"}, args.Strings) -} -func TestSliceOfBools(t *testing.T) { - var args struct { - B []bool - } - - err := parse("--b true false true", &args) - require.NoError(t, err) - assert.Equal(t, []bool{true, false, true}, args.B) -} - -func TestMap(t *testing.T) { - var args struct { - Values map[string]int - } - err := parse("--values a=1 b=2 c=3", &args) - require.NoError(t, err) - assert.Len(t, args.Values, 3) - assert.Equal(t, 1, args.Values["a"]) - assert.Equal(t, 2, args.Values["b"]) - assert.Equal(t, 3, args.Values["c"]) -} - -func TestMapPositional(t *testing.T) { - var args struct { - Values map[string]int `arg:"positional"` - } - err := parse("a=1 b=2 c=3", &args) - require.NoError(t, err) - assert.Len(t, args.Values, 3) - assert.Equal(t, 1, args.Values["a"]) - assert.Equal(t, 2, args.Values["b"]) - assert.Equal(t, 3, args.Values["c"]) -} - -func TestMapWithSeparate(t *testing.T) { - var args struct { - Values map[string]int `arg:"separate"` - } - err := parse("--values a=1 --values b=2 --values c=3", &args) - require.NoError(t, err) - assert.Len(t, args.Values, 3) - assert.Equal(t, 1, args.Values["a"]) - assert.Equal(t, 2, args.Values["b"]) - assert.Equal(t, 3, args.Values["c"]) -} - -func TestPlaceholder(t *testing.T) { - var args struct { - Input string `arg:"positional" placeholder:"SRC"` - Output []string `arg:"positional" placeholder:"DST"` - Optimize int `arg:"-O" placeholder:"LEVEL"` - MaxJobs int `arg:"-j" placeholder:"N"` - } - err := parse("-O 5 --maxjobs 2 src dest1 dest2", &args) - assert.NoError(t, err) -} - -func TestNoLongName(t *testing.T) { - var args struct { - ShortOnly string `arg:"-s,--"` - EnvOnly string `arg:"--,env"` - } - setenv(t, "ENVONLY", "TestVal") - err := parse("-s TestVal2", &args) - assert.NoError(t, err) - assert.Equal(t, "TestVal", args.EnvOnly) - assert.Equal(t, "TestVal2", args.ShortOnly) -} - -func TestCaseSensitive(t *testing.T) { - var args struct { - Lower bool `arg:"-v"` - Upper bool `arg:"-V"` - } - - err := parse("-v", &args) - require.NoError(t, err) - assert.True(t, args.Lower) - assert.False(t, args.Upper) -} - -func TestCaseSensitive2(t *testing.T) { - var args struct { - Lower bool `arg:"-v"` - Upper bool `arg:"-V"` - } - - err := parse("-V", &args) - require.NoError(t, err) - assert.False(t, args.Lower) - assert.True(t, args.Upper) -} - -func TestPositional(t *testing.T) { - var args struct { - Input string `arg:"positional"` - Output string `arg:"positional"` - } - err := parse("foo", &args) - require.NoError(t, err) - assert.Equal(t, "foo", args.Input) - assert.Equal(t, "", args.Output) -} - -func TestPositionalPointer(t *testing.T) { - var args struct { - Input string `arg:"positional"` - Output []*string `arg:"positional"` - } - err := parse("foo bar baz", &args) - require.NoError(t, err) - assert.Equal(t, "foo", args.Input) - bar := "bar" - baz := "baz" - assert.Equal(t, []*string{&bar, &baz}, args.Output) -} - -func TestRequiredPositional(t *testing.T) { - var args struct { - Input string `arg:"positional"` - Output string `arg:"positional,required"` - } - err := parse("foo", &args) - assert.Error(t, err) -} - -func TestRequiredPositionalMultiple(t *testing.T) { - var args struct { - Input string `arg:"positional"` - Multiple []string `arg:"positional,required"` - } - err := parse("foo", &args) - assert.Error(t, err) -} - -func TestTooManyPositional(t *testing.T) { - var args struct { - Input string `arg:"positional"` - Output string `arg:"positional"` - } - err := parse("foo bar baz", &args) - assert.Error(t, err) -} - -func TestMultiple(t *testing.T) { - var args struct { - Foo []int - Bar []string - } - err := parse("--foo 1 2 3 --bar x y z", &args) - require.NoError(t, err) - assert.Equal(t, []int{1, 2, 3}, args.Foo) - assert.Equal(t, []string{"x", "y", "z"}, args.Bar) -} - -func TestMultiplePositionals(t *testing.T) { - var args struct { - Input string `arg:"positional"` - Multiple []string `arg:"positional,required"` - } - err := parse("foo a b c", &args) - assert.NoError(t, err) - assert.Equal(t, "foo", args.Input) - assert.Equal(t, []string{"a", "b", "c"}, args.Multiple) -} - -func TestMultipleWithEq(t *testing.T) { - var args struct { - Foo []int - Bar []string - } - err := parse("--foo 1 2 3 --bar=x", &args) - require.NoError(t, err) - assert.Equal(t, []int{1, 2, 3}, args.Foo) - assert.Equal(t, []string{"x"}, args.Bar) -} - -func TestMultipleWithDefault(t *testing.T) { - var args struct { - Foo []int - Bar []string - } - args.Foo = []int{42} - args.Bar = []string{"foo"} - err := parse("--foo 1 2 3 --bar x y z", &args) - require.NoError(t, err) - assert.Equal(t, []int{1, 2, 3}, args.Foo) - assert.Equal(t, []string{"x", "y", "z"}, args.Bar) -} - -func TestExemptField(t *testing.T) { - var args struct { - Foo string - Bar interface{} `arg:"-"` - } - err := parse("--foo xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.Foo) -} - -func TestUnknownField(t *testing.T) { - var args struct { - Foo string - } - err := parse("--bar xyz", &args) - assert.Error(t, err) -} - -func TestMissingRequired(t *testing.T) { - var args struct { - Foo string `arg:"required"` - X []string `arg:"positional"` - } - err := parse("x", &args) - assert.Error(t, err) -} - -func TestNonsenseKey(t *testing.T) { - var args struct { - X []string `arg:"positional, nonsense"` - } - err := parse("x", &args) - assert.Error(t, err) -} - -func TestMissingValueAtEnd(t *testing.T) { - var args struct { - Foo string - } - err := parse("--foo", &args) - assert.Error(t, err) -} - -func TestMissingValueInMiddle(t *testing.T) { - var args struct { - Foo string - Bar string - } - err := parse("--foo --bar=abc", &args) - assert.Error(t, err) -} - -func TestNegativeValue(t *testing.T) { - var args struct { - Foo int - } - err := parse("--foo -123", &args) - require.NoError(t, err) - assert.Equal(t, -123, args.Foo) -} - -func TestInvalidInt(t *testing.T) { - var args struct { - Foo int - } - err := parse("--foo=xyz", &args) - assert.Error(t, err) -} - -func TestInvalidUint(t *testing.T) { - var args struct { - Foo uint - } - err := parse("--foo=xyz", &args) - assert.Error(t, err) -} - -func TestInvalidFloat(t *testing.T) { - var args struct { - Foo float64 - } - err := parse("--foo xyz", &args) - require.Error(t, err) -} - -func TestInvalidBool(t *testing.T) { - var args struct { - Foo bool - } - err := parse("--foo=xyz", &args) - require.Error(t, err) -} - -func TestInvalidIntSlice(t *testing.T) { - var args struct { - Foo []int - } - err := parse("--foo 1 2 xyz", &args) - require.Error(t, err) -} - -func TestInvalidPositional(t *testing.T) { - var args struct { - Foo int `arg:"positional"` - } - err := parse("xyz", &args) - require.Error(t, err) -} - -func TestInvalidPositionalSlice(t *testing.T) { - var args struct { - Foo []int `arg:"positional"` - } - err := parse("1 2 xyz", &args) - require.Error(t, err) -} - -func TestNoMoreOptions(t *testing.T) { - var args struct { - Foo string - Bar []string `arg:"positional"` - } - err := parse("abc -- --foo xyz", &args) - require.NoError(t, err) - assert.Equal(t, "", args.Foo) - assert.Equal(t, []string{"abc", "--foo", "xyz"}, args.Bar) -} - -func TestNoMoreOptionsBeforeHelp(t *testing.T) { - var args struct { - Foo int - } - err := parse("not_an_integer -- --help", &args) - assert.NotEqual(t, ErrHelp, err) -} - -func TestHelpFlag(t *testing.T) { - var args struct { - Foo string - Bar interface{} `arg:"-"` - } - err := parse("--help", &args) - assert.Equal(t, ErrHelp, err) -} - -func TestPanicOnNonPointer(t *testing.T) { - var args struct{} - assert.Panics(t, func() { - _ = parse("", args) - }) -} - -func TestErrorOnNonStruct(t *testing.T) { - var args string - err := parse("", &args) - assert.Error(t, err) -} - -func TestUnsupportedType(t *testing.T) { - var args struct { - Foo interface{} - } - err := parse("--foo", &args) - assert.Error(t, err) -} - -func TestUnsupportedSliceElement(t *testing.T) { - var args struct { - Foo []interface{} - } - err := parse("--foo 3", &args) - assert.Error(t, err) -} - -func TestUnsupportedSliceElementMissingValue(t *testing.T) { - var args struct { - Foo []interface{} - } - err := parse("--foo", &args) - assert.Error(t, err) -} - -func TestUnknownTag(t *testing.T) { - var args struct { - Foo string `arg:"this_is_not_valid"` - } - err := parse("--foo xyz", &args) - assert.Error(t, err) -} - -func TestParse(t *testing.T) { - var args struct { - Foo string - } - os.Args = []string{"example", "--foo", "bar"} - err := Parse(&args) - require.NoError(t, err) - assert.Equal(t, "bar", args.Foo) -} - -func TestParseError(t *testing.T) { - var args struct { - Foo string `arg:"this_is_not_valid"` - } - os.Args = []string{"example", "--bar"} - err := Parse(&args) - assert.Error(t, err) -} - -func TestMustParse(t *testing.T) { - var args struct { - Foo string - } - os.Args = []string{"example", "--foo", "bar"} - parser := MustParse(&args) - assert.Equal(t, "bar", args.Foo) - assert.NotNil(t, parser) -} - -func TestEnvironmentVariable(t *testing.T) { - var args struct { - Foo string `arg:"env"` - } - _, err := parseWithEnv("", []string{"FOO=bar"}, &args) - require.NoError(t, err) - assert.Equal(t, "bar", args.Foo) -} - -func TestEnvironmentVariableNotPresent(t *testing.T) { - var args struct { - NotPresent string `arg:"env"` - } - _, err := parseWithEnv("", nil, &args) - require.NoError(t, err) - assert.Equal(t, "", args.NotPresent) -} - -func TestEnvironmentVariableOverrideName(t *testing.T) { - var args struct { - Foo string `arg:"env:BAZ"` - } - _, err := parseWithEnv("", []string{"BAZ=bar"}, &args) - require.NoError(t, err) - assert.Equal(t, "bar", args.Foo) -} - -func TestEnvironmentVariableOverrideArgument(t *testing.T) { - var args struct { - Foo string `arg:"env"` - } - _, err := parseWithEnv("--foo zzz", []string{"FOO=bar"}, &args) - require.NoError(t, err) - assert.Equal(t, "zzz", args.Foo) -} - -func TestEnvironmentVariableError(t *testing.T) { - var args struct { - Foo int `arg:"env"` - } - _, err := parseWithEnv("", []string{"FOO=bar"}, &args) - assert.Error(t, err) -} - -func TestEnvironmentVariableRequired(t *testing.T) { - var args struct { - Foo string `arg:"env,required"` - } - _, err := parseWithEnv("", []string{"FOO=bar"}, &args) - require.NoError(t, err) - assert.Equal(t, "bar", args.Foo) -} - -func TestEnvironmentVariableSliceArgumentString(t *testing.T) { - var args struct { - Foo []string `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=bar,"baz, qux"`}, &args) - require.NoError(t, err) - assert.Equal(t, []string{"bar", "baz, qux"}, args.Foo) -} - -func TestEnvironmentVariableSliceEmpty(t *testing.T) { - var args struct { - Foo []string `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=`}, &args) - require.NoError(t, err) - assert.Len(t, args.Foo, 0) -} - -func TestEnvironmentVariableSliceArgumentInteger(t *testing.T) { - var args struct { - Foo []int `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=1,99`}, &args) - require.NoError(t, err) - assert.Equal(t, []int{1, 99}, args.Foo) -} - -func TestEnvironmentVariableSliceArgumentFloat(t *testing.T) { - var args struct { - Foo []float32 `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=1.1,99.9`}, &args) - require.NoError(t, err) - assert.Equal(t, []float32{1.1, 99.9}, args.Foo) -} - -func TestEnvironmentVariableSliceArgumentBool(t *testing.T) { - var args struct { - Foo []bool `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=true,false,0,1`}, &args) - require.NoError(t, err) - assert.Equal(t, []bool{true, false, false, true}, args.Foo) -} - -func TestEnvironmentVariableSliceArgumentWrongCsv(t *testing.T) { - var args struct { - Foo []int `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=1,99\"`}, &args) - assert.Error(t, err) -} - -func TestEnvironmentVariableSliceArgumentWrongType(t *testing.T) { - var args struct { - Foo []bool `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=one,two`}, &args) - assert.Error(t, err) -} - -func TestEnvironmentVariableMap(t *testing.T) { - var args struct { - Foo map[int]string `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=1=one,99=ninetynine`}, &args) - require.NoError(t, err) - assert.Len(t, args.Foo, 2) - assert.Equal(t, "one", args.Foo[1]) - assert.Equal(t, "ninetynine", args.Foo[99]) -} - -func TestEnvironmentVariableEmptyMap(t *testing.T) { - var args struct { - Foo map[int]string `arg:"env"` - } - _, err := parseWithEnv("", []string{`FOO=`}, &args) - require.NoError(t, err) - assert.Len(t, args.Foo, 0) -} - -func TestEnvironmentVariableIgnored(t *testing.T) { - var args struct { - Foo string `arg:"env"` - } - setenv(t, "FOO", "abc") - - p, err := NewParser(Config{IgnoreEnv: true}, &args) - require.NoError(t, err) - - err = p.Parse(nil) - assert.NoError(t, err) - assert.Equal(t, "", args.Foo) -} - -func TestDefaultValuesIgnored(t *testing.T) { - var args struct { - Foo string `default:"bad"` - } - - p, err := NewParser(Config{IgnoreDefault: true}, &args) - require.NoError(t, err) - - err = p.Parse(nil) - assert.NoError(t, err) - assert.Equal(t, "", args.Foo) -} - -func TestRequiredEnvironmentOnlyVariableIsMissing(t *testing.T) { - var args struct { - Foo string `arg:"required,--,env:FOO"` - } - - _, err := parseWithEnv("", []string{""}, &args) - assert.Error(t, err) -} - -func TestOptionalEnvironmentOnlyVariable(t *testing.T) { - var args struct { - Foo string `arg:"env:FOO"` - } - - _, err := parseWithEnv("", []string{}, &args) - assert.NoError(t, err) -} - -func TestEnvironmentVariableInSubcommandIgnored(t *testing.T) { - var args struct { - Sub *struct { - Foo string `arg:"env"` - } `arg:"subcommand"` - } - setenv(t, "FOO", "abc") - - p, err := NewParser(Config{IgnoreEnv: true}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"sub"}) - require.NoError(t, err) - require.NotNil(t, args.Sub) - assert.Equal(t, "", args.Sub.Foo) -} - -func TestParserMustParseEmptyArgs(t *testing.T) { - // this mirrors TestEmptyArgs - p, err := NewParser(Config{}, &struct{}{}) - require.NoError(t, err) - assert.NotNil(t, p) - p.MustParse(nil) -} - -func TestParserMustParse(t *testing.T) { - tests := []struct { - name string - args versioned - cmdLine []string - code int - output string - }{ - {name: "help", args: struct{}{}, cmdLine: []string{"--help"}, code: 0, output: "display this help and exit"}, - {name: "version", args: versioned{}, cmdLine: []string{"--version"}, code: 0, output: "example 3.2.1"}, - {name: "invalid", args: struct{}{}, cmdLine: []string{"invalid"}, code: -1, output: ""}, - } - - for _, tt := range tests { - tt := tt - t.Run(tt.name, func(t *testing.T) { - var exitCode int - var stdout bytes.Buffer - exit := func(code int) { exitCode = code } - - p, err := NewParser(Config{Exit: exit, Out: &stdout}, &tt.args) - require.NoError(t, err) - assert.NotNil(t, p) - - p.MustParse(tt.cmdLine) - assert.NotNil(t, exitCode) - assert.Equal(t, tt.code, exitCode) - assert.Contains(t, stdout.String(), tt.output) - }) - } -} - -type textUnmarshaler struct { - val int -} - -func (f *textUnmarshaler) UnmarshalText(b []byte) error { - f.val = len(b) - return nil -} - -func TestTextUnmarshaler(t *testing.T) { - // fields that implement TextUnmarshaler should be parsed using that interface - var args struct { - Foo textUnmarshaler - } - err := parse("--foo abc", &args) - require.NoError(t, err) - assert.Equal(t, 3, args.Foo.val) -} - -func TestPtrToTextUnmarshaler(t *testing.T) { - // fields that implement TextUnmarshaler should be parsed using that interface - var args struct { - Foo *textUnmarshaler - } - err := parse("--foo abc", &args) - require.NoError(t, err) - assert.Equal(t, 3, args.Foo.val) -} - -func TestRepeatedTextUnmarshaler(t *testing.T) { - // fields that implement TextUnmarshaler should be parsed using that interface - var args struct { - Foo []textUnmarshaler - } - err := parse("--foo abc d ef", &args) - require.NoError(t, err) - require.Len(t, args.Foo, 3) - assert.Equal(t, 3, args.Foo[0].val) - assert.Equal(t, 1, args.Foo[1].val) - assert.Equal(t, 2, args.Foo[2].val) -} - -func TestRepeatedPtrToTextUnmarshaler(t *testing.T) { - // fields that implement TextUnmarshaler should be parsed using that interface - var args struct { - Foo []*textUnmarshaler - } - err := parse("--foo abc d ef", &args) - require.NoError(t, err) - require.Len(t, args.Foo, 3) - assert.Equal(t, 3, args.Foo[0].val) - assert.Equal(t, 1, args.Foo[1].val) - assert.Equal(t, 2, args.Foo[2].val) -} - -func TestPositionalTextUnmarshaler(t *testing.T) { - // fields that implement TextUnmarshaler should be parsed using that interface - var args struct { - Foo []textUnmarshaler `arg:"positional"` - } - err := parse("abc d ef", &args) - require.NoError(t, err) - require.Len(t, args.Foo, 3) - assert.Equal(t, 3, args.Foo[0].val) - assert.Equal(t, 1, args.Foo[1].val) - assert.Equal(t, 2, args.Foo[2].val) -} - -func TestPositionalPtrToTextUnmarshaler(t *testing.T) { - // fields that implement TextUnmarshaler should be parsed using that interface - var args struct { - Foo []*textUnmarshaler `arg:"positional"` - } - err := parse("abc d ef", &args) - require.NoError(t, err) - require.Len(t, args.Foo, 3) - assert.Equal(t, 3, args.Foo[0].val) - assert.Equal(t, 1, args.Foo[1].val) - assert.Equal(t, 2, args.Foo[2].val) -} - -type boolUnmarshaler bool - -func (p *boolUnmarshaler) UnmarshalText(b []byte) error { - *p = len(b)%2 == 0 - return nil -} - -func TestBoolUnmarhsaler(t *testing.T) { - // test that a bool type that implements TextUnmarshaler is - // handled as a TextUnmarshaler not as a bool - var args struct { - Foo *boolUnmarshaler - } - err := parse("--foo ab", &args) - require.NoError(t, err) - assert.EqualValues(t, true, *args.Foo) -} - -type sliceUnmarshaler []int - -func (p *sliceUnmarshaler) UnmarshalText(b []byte) error { - *p = sliceUnmarshaler{len(b)} - return nil -} - -func TestSliceUnmarhsaler(t *testing.T) { - // test that a slice type that implements TextUnmarshaler is - // handled as a TextUnmarshaler not as a slice - var args struct { - Foo *sliceUnmarshaler - Bar string `arg:"positional"` - } - err := parse("--foo abcde xyz", &args) - require.NoError(t, err) - require.Len(t, *args.Foo, 1) - assert.EqualValues(t, 5, (*args.Foo)[0]) - assert.Equal(t, "xyz", args.Bar) -} - -func TestIP(t *testing.T) { - var args struct { - Host net.IP - } - err := parse("--host 192.168.0.1", &args) - require.NoError(t, err) - assert.Equal(t, "192.168.0.1", args.Host.String()) -} - -func TestPtrToIP(t *testing.T) { - var args struct { - Host *net.IP - } - err := parse("--host 192.168.0.1", &args) - require.NoError(t, err) - assert.Equal(t, "192.168.0.1", args.Host.String()) -} - -func TestURL(t *testing.T) { - var args struct { - URL url.URL - } - err := parse("--url https://example.com/get?item=xyz", &args) - require.NoError(t, err) - assert.Equal(t, "https://example.com/get?item=xyz", args.URL.String()) -} - -func TestPtrToURL(t *testing.T) { - var args struct { - URL *url.URL - } - err := parse("--url http://example.com/#xyz", &args) - require.NoError(t, err) - assert.Equal(t, "http://example.com/#xyz", args.URL.String()) -} - -func TestIPSlice(t *testing.T) { - var args struct { - Host []net.IP - } - err := parse("--host 192.168.0.1 127.0.0.1", &args) - require.NoError(t, err) - require.Len(t, args.Host, 2) - assert.Equal(t, "192.168.0.1", args.Host[0].String()) - assert.Equal(t, "127.0.0.1", args.Host[1].String()) -} - -func TestInvalidIPAddress(t *testing.T) { - var args struct { - Host net.IP - } - err := parse("--host xxx", &args) - assert.Error(t, err) -} - -func TestMAC(t *testing.T) { - var args struct { - Host net.HardwareAddr - } - err := parse("--host 0123.4567.89ab", &args) - require.NoError(t, err) - assert.Equal(t, "01:23:45:67:89:ab", args.Host.String()) -} - -func TestInvalidMac(t *testing.T) { - var args struct { - Host net.HardwareAddr - } - err := parse("--host xxx", &args) - assert.Error(t, err) -} - -func TestMailAddr(t *testing.T) { - var args struct { - Recipient mail.Address - } - err := parse("--recipient foo@example.com", &args) - require.NoError(t, err) - assert.Equal(t, "", args.Recipient.String()) -} - -func TestInvalidMailAddr(t *testing.T) { - var args struct { - Recipient mail.Address - } - err := parse("--recipient xxx", &args) - assert.Error(t, err) -} - -type A struct { - X string -} - -type B struct { - Y int -} - -func TestEmbedded(t *testing.T) { - var args struct { - A - B - Z bool - } - err := parse("--x=hello --y=321 --z", &args) - require.NoError(t, err) - assert.Equal(t, "hello", args.X) - assert.Equal(t, 321, args.Y) - assert.Equal(t, true, args.Z) -} - -func TestEmbeddedPtr(t *testing.T) { - // embedded pointer fields are not supported so this should return an error - var args struct { - *A - } - err := parse("--x=hello", &args) - require.Error(t, err) -} - -func TestEmbeddedPtrIgnored(t *testing.T) { - // embedded pointer fields are not normally supported but here - // we explicitly exclude it so the non-nil embedded structs - // should work as expected - var args struct { - *A `arg:"-"` - B - } - err := parse("--y=321", &args) - require.NoError(t, err) - assert.Equal(t, 321, args.Y) -} - -func TestEmbeddedWithDuplicateField(t *testing.T) { - // see https://github.com/alexflint/go-arg/issues/100 - type T struct { - A string `arg:"--cat"` - } - type U struct { - A string `arg:"--dog"` - } - var args struct { - T - U - } - - err := parse("--cat=cat --dog=dog", &args) - require.NoError(t, err) - assert.Equal(t, "cat", args.T.A) - assert.Equal(t, "dog", args.U.A) -} - -func TestEmbeddedWithDuplicateField2(t *testing.T) { - // see https://github.com/alexflint/go-arg/issues/100 - type T struct { - A string - } - type U struct { - A string - } - var args struct { - T - U - } - - err := parse("--a=xyz", &args) - require.NoError(t, err) - assert.Equal(t, "xyz", args.T.A) - assert.Equal(t, "", args.U.A) -} - -func TestUnexportedEmbedded(t *testing.T) { - type embeddedArgs struct { - Foo string - } - var args struct { - embeddedArgs - } - err := parse("--foo bar", &args) - require.NoError(t, err) - assert.Equal(t, "bar", args.Foo) -} - -func TestIgnoredEmbedded(t *testing.T) { - type embeddedArgs struct { - Foo string - } - var args struct { - embeddedArgs `arg:"-"` - } - err := parse("--foo bar", &args) - require.Error(t, err) -} - -func TestEmptyArgs(t *testing.T) { - origArgs := os.Args - - // test what happens if somehow os.Args is empty - os.Args = nil - var args struct { - Foo string - } - MustParse(&args) - - // put the original arguments back - os.Args = origArgs -} - -func TestTooManyHyphens(t *testing.T) { - var args struct { - TooManyHyphens string `arg:"---x"` - } - err := parse("--foo -", &args) - assert.Error(t, err) -} - -func TestHyphenAsOption(t *testing.T) { - var args struct { - Foo string - } - err := parse("--foo -", &args) - require.NoError(t, err) - assert.Equal(t, "-", args.Foo) -} - -func TestHyphenAsPositional(t *testing.T) { - var args struct { - Foo string `arg:"positional"` - } - err := parse("-", &args) - require.NoError(t, err) - assert.Equal(t, "-", args.Foo) -} - -func TestHyphenInMultiOption(t *testing.T) { - var args struct { - Foo []string - Bar int - } - err := parse("--foo --- x - y --bar 3", &args) - require.NoError(t, err) - assert.Equal(t, []string{"---", "x", "-", "y"}, args.Foo) - assert.Equal(t, 3, args.Bar) -} - -func TestHyphenInMultiPositional(t *testing.T) { - var args struct { - Foo []string `arg:"positional"` - } - err := parse("--- x - y", &args) - require.NoError(t, err) - assert.Equal(t, []string{"---", "x", "-", "y"}, args.Foo) -} - -func TestSeparate(t *testing.T) { - for _, val := range []string{"-f one", "-f=one", "--foo one", "--foo=one"} { - var args struct { - Foo []string `arg:"--foo,-f,separate"` - } - - err := parse(val, &args) - require.NoError(t, err) - assert.Equal(t, []string{"one"}, args.Foo) - } -} - -func TestSeparateWithDefault(t *testing.T) { - args := struct { - Foo []string `arg:"--foo,-f,separate"` - }{ - Foo: []string{"default"}, - } - - err := parse("-f one -f=two", &args) - require.NoError(t, err) - assert.Equal(t, []string{"default", "one", "two"}, args.Foo) -} - -func TestSeparateWithPositional(t *testing.T) { - var args struct { - Foo []string `arg:"--foo,-f,separate"` - Bar string `arg:"positional"` - Moo string `arg:"positional"` - } - - err := parse("zzz --foo one -f=two --foo=three -f four aaa", &args) - require.NoError(t, err) - assert.Equal(t, []string{"one", "two", "three", "four"}, args.Foo) - assert.Equal(t, "zzz", args.Bar) - assert.Equal(t, "aaa", args.Moo) -} - -func TestSeparatePositionalInterweaved(t *testing.T) { - var args struct { - Foo []string `arg:"--foo,-f,separate"` - Bar []string `arg:"--bar,-b,separate"` - Pre string `arg:"positional"` - Post []string `arg:"positional"` - } - - err := parse("zzz -f foo1 -b=bar1 --foo=foo2 -b bar2 post1 -b bar3 post2 post3", &args) - require.NoError(t, err) - assert.Equal(t, []string{"foo1", "foo2"}, args.Foo) - assert.Equal(t, []string{"bar1", "bar2", "bar3"}, args.Bar) - assert.Equal(t, "zzz", args.Pre) - assert.Equal(t, []string{"post1", "post2", "post3"}, args.Post) -} - -func TestSpacesAllowedInTags(t *testing.T) { - var args struct { - Foo []string `arg:"--foo, -f, separate, required, help:quite nice really"` - } - - err := parse("--foo one -f=two --foo=three -f four", &args) - require.NoError(t, err) - assert.Equal(t, []string{"one", "two", "three", "four"}, args.Foo) -} - -func TestReuseParser(t *testing.T) { - var args struct { - Foo string `arg:"required"` - } - - p, err := NewParser(Config{}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"--foo=abc"}) - require.NoError(t, err) - assert.Equal(t, args.Foo, "abc") - - err = p.Parse([]string{}) - assert.Error(t, err) -} - -func TestNoVersion(t *testing.T) { - var args struct{} - - p, err := NewParser(Config{}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"--version"}) - assert.Error(t, err) - assert.NotEqual(t, ErrVersion, err) -} - -func TestBuiltinVersion(t *testing.T) { - var args struct{} - - p, err := NewParser(Config{}, &args) - require.NoError(t, err) - - p.version = "example 3.2.1" - - err = p.Parse([]string{"--version"}) - assert.Equal(t, ErrVersion, err) -} - -func TestArgsVersion(t *testing.T) { - var args struct { - Version bool `arg:"--version"` - } - - p, err := NewParser(Config{}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"--version"}) - require.NoError(t, err) - require.Equal(t, args.Version, true) -} - -func TestArgsAndBuiltinVersion(t *testing.T) { - var args struct { - Version bool `arg:"--version"` - } - - p, err := NewParser(Config{}, &args) - require.NoError(t, err) - - p.version = "example 3.2.1" - - err = p.Parse([]string{"--version"}) - require.NoError(t, err) - require.Equal(t, args.Version, true) -} - -func TestMultipleTerminates(t *testing.T) { - var args struct { - X []string - Y string `arg:"positional"` - } - - err := parse("--x a b -- c", &args) - require.NoError(t, err) - assert.Equal(t, []string{"a", "b"}, args.X) - assert.Equal(t, "c", args.Y) -} - -func TestDefaultOptionValues(t *testing.T) { - var args struct { - A int `default:"123"` - B *int `default:"123"` - C string `default:"abc"` - D *string `default:"abc"` - E float64 `default:"1.23"` - F *float64 `default:"1.23"` - G bool `default:"true"` - H *bool `default:"true"` - } - - err := parse("--c=xyz --e=4.56", &args) - require.NoError(t, err) - - assert.Equal(t, 123, args.A) - if assert.NotNil(t, args.B) { - assert.Equal(t, 123, *args.B) - } - assert.Equal(t, "xyz", args.C) - if assert.NotNil(t, args.D) { - assert.Equal(t, "abc", *args.D) - } - assert.Equal(t, 4.56, args.E) - if assert.NotNil(t, args.F) { - assert.Equal(t, 1.23, *args.F) - } - assert.True(t, args.G) - if assert.NotNil(t, args.H) { - assert.True(t, *args.H) - } -} - -func TestDefaultUnparseable(t *testing.T) { - var args struct { - A int `default:"x"` - } - - err := parse("", &args) - assert.EqualError(t, err, `.A: error processing default value: strconv.ParseInt: parsing "x": invalid syntax`) -} - -func TestDefaultPositionalValues(t *testing.T) { - var args struct { - A int `arg:"positional" default:"123"` - B *int `arg:"positional" default:"123"` - C string `arg:"positional" default:"abc"` - D *string `arg:"positional" default:"abc"` - E float64 `arg:"positional" default:"1.23"` - F *float64 `arg:"positional" default:"1.23"` - G bool `arg:"positional" default:"true"` - H *bool `arg:"positional" default:"true"` - } - - err := parse("456 789", &args) - require.NoError(t, err) - - assert.Equal(t, 456, args.A) - if assert.NotNil(t, args.B) { - assert.Equal(t, 789, *args.B) - } - assert.Equal(t, "abc", args.C) - if assert.NotNil(t, args.D) { - assert.Equal(t, "abc", *args.D) - } - assert.Equal(t, 1.23, args.E) - if assert.NotNil(t, args.F) { - assert.Equal(t, 1.23, *args.F) - } - assert.True(t, args.G) - if assert.NotNil(t, args.H) { - assert.True(t, *args.H) - } -} - -func TestDefaultValuesNotAllowedWithRequired(t *testing.T) { - var args struct { - A int `arg:"required" default:"123"` // required not allowed with default! - } - - err := parse("", &args) - assert.EqualError(t, err, ".A: 'required' cannot be used when a default value is specified") -} - -func TestDefaultValuesNotAllowedWithSlice(t *testing.T) { - var args struct { - A []int `default:"invalid"` // default values not allowed with slices - } - - err := parse("", &args) - assert.EqualError(t, err, ".A: default values are not supported for slice or map fields") -} - -func TestUnexportedFieldsSkipped(t *testing.T) { - var args struct { - unexported struct{} - } - - _, err := NewParser(Config{}, &args) - require.NoError(t, err) -} - -func TestMustParseInvalidParser(t *testing.T) { - var exitCode int - var stdout bytes.Buffer - exit := func(code int) { exitCode = code } - - var args struct { - CannotParse struct{} - } - parser := mustParse(Config{Out: &stdout, Exit: exit}, &args) - assert.Nil(t, parser) - assert.Equal(t, -1, exitCode) -} - -func TestMustParsePrintsHelp(t *testing.T) { - originalArgs := os.Args - defer func() { - os.Args = originalArgs - }() - - os.Args = []string{"someprogram", "--help"} - - var exitCode int - var stdout bytes.Buffer - exit := func(code int) { exitCode = code } - - var args struct{} - parser := mustParse(Config{Out: &stdout, Exit: exit}, &args) - assert.NotNil(t, parser) - assert.Equal(t, 0, exitCode) -} - -func TestMustParsePrintsVersion(t *testing.T) { - originalArgs := os.Args - defer func() { - os.Args = originalArgs - }() - - var exitCode int - var stdout bytes.Buffer - exit := func(code int) { exitCode = code } - - os.Args = []string{"someprogram", "--version"} - - var args versioned - parser := mustParse(Config{Out: &stdout, Exit: exit}, &args) - require.NotNil(t, parser) - assert.Equal(t, 0, exitCode) - assert.Equal(t, "example 3.2.1\n", stdout.String()) -} - -type mapWithUnmarshalText struct { - val map[string]string -} - -func (v *mapWithUnmarshalText) UnmarshalText(data []byte) error { - return json.Unmarshal(data, &v.val) -} - -func TestTextUnmarshalerEmpty(t *testing.T) { - // based on https://github.com/alexflint/go-arg/issues/184 - var args struct { - Config mapWithUnmarshalText `arg:"--config"` - } - - err := parse("", &args) - require.NoError(t, err) - assert.Empty(t, args.Config) -} - -func TestTextUnmarshalerEmptyPointer(t *testing.T) { - // a slight variant on https://github.com/alexflint/go-arg/issues/184 - var args struct { - Config *mapWithUnmarshalText `arg:"--config"` - } - - err := parse("", &args) - require.NoError(t, err) - assert.Nil(t, args.Config) -} - -// similar to the above but also implements MarshalText -type mapWithMarshalText struct { - val map[string]string -} - -func (v *mapWithMarshalText) MarshalText(data []byte) error { - return json.Unmarshal(data, &v.val) -} - -func (v *mapWithMarshalText) UnmarshalText(data []byte) error { - return json.Unmarshal(data, &v.val) -} - -func TestTextMarshalerUnmarshalerEmpty(t *testing.T) { - // based on https://github.com/alexflint/go-arg/issues/184 - var args struct { - Config mapWithMarshalText `arg:"--config"` - } - - err := parse("", &args) - require.NoError(t, err) - assert.Empty(t, args.Config) -} - -func TestTextMarshalerUnmarshalerEmptyPointer(t *testing.T) { - // a slight variant on https://github.com/alexflint/go-arg/issues/184 - var args struct { - Config *mapWithMarshalText `arg:"--config"` - } - - err := parse("", &args) - require.NoError(t, err) - assert.Nil(t, args.Config) -} - -func TestSubcommandGlobalFlag_Before(t *testing.T) { - var args struct { - Global bool `arg:"-g"` - Sub *struct { - } `arg:"subcommand"` - } - - p, err := NewParser(Config{StrictSubcommands: false}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"-g", "sub"}) - assert.NoError(t, err) - assert.True(t, args.Global) -} - -func TestSubcommandGlobalFlag_InCommand(t *testing.T) { - var args struct { - Global bool `arg:"-g"` - Sub *struct { - } `arg:"subcommand"` - } - - p, err := NewParser(Config{StrictSubcommands: false}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"sub", "-g"}) - assert.NoError(t, err) - assert.True(t, args.Global) -} - -func TestSubcommandGlobalFlag_Before_Strict(t *testing.T) { - var args struct { - Global bool `arg:"-g"` - Sub *struct { - } `arg:"subcommand"` - } - - p, err := NewParser(Config{StrictSubcommands: true}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"-g", "sub"}) - assert.NoError(t, err) - assert.True(t, args.Global) -} - -func TestSubcommandGlobalFlag_InCommand_Strict(t *testing.T) { - var args struct { - Global bool `arg:"-g"` - Sub *struct { - } `arg:"subcommand"` - } - - p, err := NewParser(Config{StrictSubcommands: true}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"sub", "-g"}) - assert.Error(t, err) -} - -func TestSubcommandGlobalFlag_InCommand_Strict_Inner(t *testing.T) { - var args struct { - Global bool `arg:"-g"` - Sub *struct { - Guard bool `arg:"-g"` - } `arg:"subcommand"` - } - - p, err := NewParser(Config{StrictSubcommands: true}, &args) - require.NoError(t, err) - - err = p.Parse([]string{"sub", "-g"}) - require.NoError(t, err) - assert.False(t, args.Global) - require.NotNil(t, args.Sub) - assert.True(t, args.Sub.Guard) -} diff --git a/reflect_test.go b/reflect_test.go deleted file mode 100644 index 10909b3..0000000 --- a/reflect_test.go +++ /dev/null @@ -1,112 +0,0 @@ -package arg - -import ( - "reflect" - "testing" - - "github.com/stretchr/testify/assert" -) - -func assertCardinality(t *testing.T, typ reflect.Type, expected cardinality) { - actual, err := cardinalityOf(typ) - assert.Equal(t, expected, actual, "expected %v to have cardinality %v but got %v", typ, expected, actual) - if expected == unsupported { - assert.Error(t, err) - } -} - -func TestCardinalityOf(t *testing.T) { - var b bool - var i int - var s string - var f float64 - var bs []bool - var is []int - var m map[string]int - var unsupported1 struct{} - var unsupported2 []struct{} - var unsupported3 map[string]struct{} - var unsupported4 map[struct{}]string - - assertCardinality(t, reflect.TypeOf(b), zero) - assertCardinality(t, reflect.TypeOf(i), one) - assertCardinality(t, reflect.TypeOf(s), one) - assertCardinality(t, reflect.TypeOf(f), one) - - assertCardinality(t, reflect.TypeOf(&b), zero) - assertCardinality(t, reflect.TypeOf(&s), one) - assertCardinality(t, reflect.TypeOf(&i), one) - assertCardinality(t, reflect.TypeOf(&f), one) - - assertCardinality(t, reflect.TypeOf(bs), multiple) - assertCardinality(t, reflect.TypeOf(is), multiple) - - assertCardinality(t, reflect.TypeOf(&bs), multiple) - assertCardinality(t, reflect.TypeOf(&is), multiple) - - assertCardinality(t, reflect.TypeOf(m), multiple) - assertCardinality(t, reflect.TypeOf(&m), multiple) - - assertCardinality(t, reflect.TypeOf(unsupported1), unsupported) - assertCardinality(t, reflect.TypeOf(&unsupported1), unsupported) - assertCardinality(t, reflect.TypeOf(unsupported2), unsupported) - assertCardinality(t, reflect.TypeOf(&unsupported2), unsupported) - assertCardinality(t, reflect.TypeOf(unsupported3), unsupported) - assertCardinality(t, reflect.TypeOf(&unsupported3), unsupported) - assertCardinality(t, reflect.TypeOf(unsupported4), unsupported) - assertCardinality(t, reflect.TypeOf(&unsupported4), unsupported) -} - -type implementsTextUnmarshaler struct{} - -func (*implementsTextUnmarshaler) UnmarshalText(text []byte) error { - return nil -} - -func TestCardinalityTextUnmarshaler(t *testing.T) { - var x implementsTextUnmarshaler - var s []implementsTextUnmarshaler - var m []implementsTextUnmarshaler - assertCardinality(t, reflect.TypeOf(x), one) - assertCardinality(t, reflect.TypeOf(&x), one) - assertCardinality(t, reflect.TypeOf(s), multiple) - assertCardinality(t, reflect.TypeOf(&s), multiple) - assertCardinality(t, reflect.TypeOf(m), multiple) - assertCardinality(t, reflect.TypeOf(&m), multiple) -} - -func TestIsExported(t *testing.T) { - assert.True(t, isExported("Exported")) - assert.False(t, isExported("notExported")) - assert.False(t, isExported("")) - assert.False(t, isExported(string([]byte{255}))) -} - -func TestCardinalityString(t *testing.T) { - assert.Equal(t, "zero", zero.String()) - assert.Equal(t, "one", one.String()) - assert.Equal(t, "multiple", multiple.String()) - assert.Equal(t, "unsupported", unsupported.String()) - assert.Equal(t, "unknown(42)", cardinality(42).String()) -} - -func TestIsZero(t *testing.T) { - var zero int - var notZero = 3 - var nilSlice []int - var nonNilSlice = []int{1, 2, 3} - var nilMap map[string]string - var nonNilMap = map[string]string{"foo": "bar"} - var uncomparable = func() {} - - assert.True(t, isZero(reflect.ValueOf(zero))) - assert.False(t, isZero(reflect.ValueOf(notZero))) - - assert.True(t, isZero(reflect.ValueOf(nilSlice))) - assert.False(t, isZero(reflect.ValueOf(nonNilSlice))) - - assert.True(t, isZero(reflect.ValueOf(nilMap))) - assert.False(t, isZero(reflect.ValueOf(nonNilMap))) - - assert.False(t, isZero(reflect.ValueOf(uncomparable))) -} diff --git a/sequence_test.go b/sequence_test.go deleted file mode 100644 index fde3e3a..0000000 --- a/sequence_test.go +++ /dev/null @@ -1,152 +0,0 @@ -package arg - -import ( - "reflect" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestSetSliceWithoutClearing(t *testing.T) { - xs := []int{10} - entries := []string{"1", "2", "3"} - err := setSlice(reflect.ValueOf(&xs).Elem(), entries, false) - require.NoError(t, err) - assert.Equal(t, []int{10, 1, 2, 3}, xs) -} - -func TestSetSliceAfterClearing(t *testing.T) { - xs := []int{100} - entries := []string{"1", "2", "3"} - err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true) - require.NoError(t, err) - assert.Equal(t, []int{1, 2, 3}, xs) -} - -func TestSetSliceInvalid(t *testing.T) { - xs := []int{100} - entries := []string{"invalid"} - err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true) - assert.Error(t, err) -} - -func TestSetSlicePtr(t *testing.T) { - var xs []*int - entries := []string{"1", "2", "3"} - err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true) - require.NoError(t, err) - require.Len(t, xs, 3) - assert.Equal(t, 1, *xs[0]) - assert.Equal(t, 2, *xs[1]) - assert.Equal(t, 3, *xs[2]) -} - -func TestSetSliceTextUnmarshaller(t *testing.T) { - // textUnmarshaler is a struct that captures the length of the string passed to it - var xs []*textUnmarshaler - entries := []string{"a", "aa", "aaa"} - err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true) - require.NoError(t, err) - require.Len(t, xs, 3) - assert.Equal(t, 1, xs[0].val) - assert.Equal(t, 2, xs[1].val) - assert.Equal(t, 3, xs[2].val) -} - -func TestSetMapWithoutClearing(t *testing.T) { - m := map[string]int{"foo": 10} - entries := []string{"a=1", "b=2"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, false) - require.NoError(t, err) - require.Len(t, m, 3) - assert.Equal(t, 1, m["a"]) - assert.Equal(t, 2, m["b"]) - assert.Equal(t, 10, m["foo"]) -} - -func TestSetMapAfterClearing(t *testing.T) { - m := map[string]int{"foo": 10} - entries := []string{"a=1", "b=2"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, true) - require.NoError(t, err) - require.Len(t, m, 2) - assert.Equal(t, 1, m["a"]) - assert.Equal(t, 2, m["b"]) -} - -func TestSetMapWithKeyPointer(t *testing.T) { - // textUnmarshaler is a struct that captures the length of the string passed to it - var m map[*string]int - entries := []string{"abc=123"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, true) - require.NoError(t, err) - require.Len(t, m, 1) -} - -func TestSetMapWithValuePointer(t *testing.T) { - // textUnmarshaler is a struct that captures the length of the string passed to it - var m map[string]*int - entries := []string{"abc=123"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, true) - require.NoError(t, err) - require.Len(t, m, 1) - assert.Equal(t, 123, *m["abc"]) -} - -func TestSetMapTextUnmarshaller(t *testing.T) { - // textUnmarshaler is a struct that captures the length of the string passed to it - var m map[textUnmarshaler]*textUnmarshaler - entries := []string{"a=123", "aa=12", "aaa=1"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, true) - require.NoError(t, err) - require.Len(t, m, 3) - assert.Equal(t, &textUnmarshaler{3}, m[textUnmarshaler{1}]) - assert.Equal(t, &textUnmarshaler{2}, m[textUnmarshaler{2}]) - assert.Equal(t, &textUnmarshaler{1}, m[textUnmarshaler{3}]) -} - -func TestSetMapInvalidKey(t *testing.T) { - var m map[int]int - entries := []string{"invalid=123"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, true) - assert.Error(t, err) -} - -func TestSetMapInvalidValue(t *testing.T) { - var m map[int]int - entries := []string{"123=invalid"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, true) - assert.Error(t, err) -} - -func TestSetMapMalformed(t *testing.T) { - // textUnmarshaler is a struct that captures the length of the string passed to it - var m map[string]string - entries := []string{"missing_equals_sign"} - err := setMap(reflect.ValueOf(&m).Elem(), entries, true) - assert.Error(t, err) -} - -func TestSetSliceOrMapErrors(t *testing.T) { - var err error - var dest reflect.Value - - // converting a slice to a reflect.Value in this way will make it read only - var cannotSet []int - dest = reflect.ValueOf(cannotSet) - err = setSliceOrMap(dest, nil, false) - assert.Error(t, err) - - // check what happens when we pass in something that is not a slice or a map - var notSliceOrMap string - dest = reflect.ValueOf(¬SliceOrMap).Elem() - err = setSliceOrMap(dest, nil, false) - assert.Error(t, err) - - // check what happens when we pass in a pointer to something that is not a slice or a map - var stringPtr *string - dest = reflect.ValueOf(&stringPtr).Elem() - err = setSliceOrMap(dest, nil, false) - assert.Error(t, err) -} diff --git a/subcommand_test.go b/subcommand_test.go deleted file mode 100644 index 00efae0..0000000 --- a/subcommand_test.go +++ /dev/null @@ -1,508 +0,0 @@ -package arg - -import ( - "reflect" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -// This file contains tests for parse.go but I decided to put them here -// since that file is getting large - -func TestSubcommandNotAPointer(t *testing.T) { - var args struct { - A string `arg:"subcommand"` - } - _, err := NewParser(Config{}, &args) - assert.Error(t, err) -} - -func TestSubcommandNotAPointerToStruct(t *testing.T) { - var args struct { - A struct{} `arg:"subcommand"` - } - _, err := NewParser(Config{}, &args) - assert.Error(t, err) -} - -func TestPositionalAndSubcommandNotAllowed(t *testing.T) { - var args struct { - A string `arg:"positional"` - B *struct{} `arg:"subcommand"` - } - _, err := NewParser(Config{}, &args) - assert.Error(t, err) -} - -func TestMinimalSubcommand(t *testing.T) { - type listCmd struct { - } - var args struct { - List *listCmd `arg:"subcommand"` - } - p, err := pparse("list", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, args.List, p.Subcommand()) - assert.Equal(t, []string{"list"}, p.SubcommandNames()) -} - -func TestSubcommandNamesBeforeParsing(t *testing.T) { - type listCmd struct{} - var args struct { - List *listCmd `arg:"subcommand"` - } - p, err := NewParser(Config{}, &args) - require.NoError(t, err) - assert.Nil(t, p.Subcommand()) - assert.Nil(t, p.SubcommandNames()) -} - -func TestNoSuchSubcommand(t *testing.T) { - type listCmd struct { - } - var args struct { - List *listCmd `arg:"subcommand"` - } - _, err := pparse("invalid", &args) - assert.Error(t, err) -} - -func TestNamedSubcommand(t *testing.T) { - type listCmd struct { - } - var args struct { - List *listCmd `arg:"subcommand:ls"` - } - p, err := pparse("ls", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, args.List, p.Subcommand()) - assert.Equal(t, []string{"ls"}, p.SubcommandNames()) -} - -func TestSubcommandAliases(t *testing.T) { - type listCmd struct { - } - var args struct { - List *listCmd `arg:"subcommand:list|ls"` - } - p, err := pparse("ls", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, args.List, p.Subcommand()) - assert.Equal(t, []string{"ls"}, p.SubcommandNames()) -} - -func TestEmptySubcommand(t *testing.T) { - type listCmd struct { - } - var args struct { - List *listCmd `arg:"subcommand"` - } - p, err := pparse("", &args) - require.NoError(t, err) - assert.Nil(t, args.List) - assert.Nil(t, p.Subcommand()) - assert.Empty(t, p.SubcommandNames()) -} - -func TestTwoSubcommands(t *testing.T) { - type getCmd struct { - } - type listCmd struct { - } - var args struct { - Get *getCmd `arg:"subcommand"` - List *listCmd `arg:"subcommand"` - } - p, err := pparse("list", &args) - require.NoError(t, err) - assert.Nil(t, args.Get) - assert.NotNil(t, args.List) - assert.Equal(t, args.List, p.Subcommand()) - assert.Equal(t, []string{"list"}, p.SubcommandNames()) -} - -func TestTwoSubcommandsWithAliases(t *testing.T) { - type getCmd struct { - } - type listCmd struct { - } - var args struct { - Get *getCmd `arg:"subcommand:get|g"` - List *listCmd `arg:"subcommand:list|ls"` - } - p, err := pparse("ls", &args) - require.NoError(t, err) - assert.Nil(t, args.Get) - assert.NotNil(t, args.List) - assert.Equal(t, args.List, p.Subcommand()) - assert.Equal(t, []string{"ls"}, p.SubcommandNames()) -} - -func TestSubcommandsWithOptions(t *testing.T) { - type getCmd struct { - Name string - } - type listCmd struct { - Limit int - } - type cmd struct { - Verbose bool - Get *getCmd `arg:"subcommand"` - List *listCmd `arg:"subcommand"` - } - - { - var args cmd - err := parse("list", &args) - require.NoError(t, err) - assert.Nil(t, args.Get) - assert.NotNil(t, args.List) - } - - { - var args cmd - err := parse("list --limit 3", &args) - require.NoError(t, err) - assert.Nil(t, args.Get) - assert.NotNil(t, args.List) - assert.Equal(t, args.List.Limit, 3) - } - - { - var args cmd - err := parse("list --limit 3 --verbose", &args) - require.NoError(t, err) - assert.Nil(t, args.Get) - assert.NotNil(t, args.List) - assert.Equal(t, args.List.Limit, 3) - assert.True(t, args.Verbose) - } - - { - var args cmd - err := parse("list --verbose --limit 3", &args) - require.NoError(t, err) - assert.Nil(t, args.Get) - assert.NotNil(t, args.List) - assert.Equal(t, args.List.Limit, 3) - assert.True(t, args.Verbose) - } - - { - var args cmd - err := parse("--verbose list --limit 3", &args) - require.NoError(t, err) - assert.Nil(t, args.Get) - assert.NotNil(t, args.List) - assert.Equal(t, args.List.Limit, 3) - assert.True(t, args.Verbose) - } - - { - var args cmd - err := parse("get", &args) - require.NoError(t, err) - assert.NotNil(t, args.Get) - assert.Nil(t, args.List) - } - - { - var args cmd - err := parse("get --name test", &args) - require.NoError(t, err) - assert.NotNil(t, args.Get) - assert.Nil(t, args.List) - assert.Equal(t, args.Get.Name, "test") - } -} - -func TestSubcommandsWithEnvVars(t *testing.T) { - type getCmd struct { - Name string `arg:"env"` - } - type listCmd struct { - Limit int `arg:"env"` - } - type cmd struct { - Verbose bool - Get *getCmd `arg:"subcommand"` - List *listCmd `arg:"subcommand"` - } - - { - var args cmd - setenv(t, "LIMIT", "123") - err := parse("list", &args) - require.NoError(t, err) - require.NotNil(t, args.List) - assert.Equal(t, 123, args.List.Limit) - } - - { - var args cmd - setenv(t, "LIMIT", "not_an_integer") - err := parse("list", &args) - assert.Error(t, err) - } -} - -func TestNestedSubcommands(t *testing.T) { - type child struct{} - type parent struct { - Child *child `arg:"subcommand"` - } - type grandparent struct { - Parent *parent `arg:"subcommand"` - } - type root struct { - Grandparent *grandparent `arg:"subcommand"` - } - - { - var args root - p, err := pparse("grandparent parent child", &args) - require.NoError(t, err) - require.NotNil(t, args.Grandparent) - require.NotNil(t, args.Grandparent.Parent) - require.NotNil(t, args.Grandparent.Parent.Child) - assert.Equal(t, args.Grandparent.Parent.Child, p.Subcommand()) - assert.Equal(t, []string{"grandparent", "parent", "child"}, p.SubcommandNames()) - } - - { - var args root - p, err := pparse("grandparent parent", &args) - require.NoError(t, err) - require.NotNil(t, args.Grandparent) - require.NotNil(t, args.Grandparent.Parent) - require.Nil(t, args.Grandparent.Parent.Child) - assert.Equal(t, args.Grandparent.Parent, p.Subcommand()) - assert.Equal(t, []string{"grandparent", "parent"}, p.SubcommandNames()) - } - - { - var args root - p, err := pparse("grandparent", &args) - require.NoError(t, err) - require.NotNil(t, args.Grandparent) - require.Nil(t, args.Grandparent.Parent) - assert.Equal(t, args.Grandparent, p.Subcommand()) - assert.Equal(t, []string{"grandparent"}, p.SubcommandNames()) - } - - { - var args root - p, err := pparse("", &args) - require.NoError(t, err) - require.Nil(t, args.Grandparent) - assert.Nil(t, p.Subcommand()) - assert.Empty(t, p.SubcommandNames()) - } -} - -func TestNestedSubcommandsWithAliases(t *testing.T) { - type child struct{} - type parent struct { - Child *child `arg:"subcommand:child|ch"` - } - type grandparent struct { - Parent *parent `arg:"subcommand:parent|pa"` - } - type root struct { - Grandparent *grandparent `arg:"subcommand:grandparent|gp"` - } - - { - var args root - p, err := pparse("gp parent child", &args) - require.NoError(t, err) - require.NotNil(t, args.Grandparent) - require.NotNil(t, args.Grandparent.Parent) - require.NotNil(t, args.Grandparent.Parent.Child) - assert.Equal(t, args.Grandparent.Parent.Child, p.Subcommand()) - assert.Equal(t, []string{"gp", "parent", "child"}, p.SubcommandNames()) - } - - { - var args root - p, err := pparse("grandparent pa", &args) - require.NoError(t, err) - require.NotNil(t, args.Grandparent) - require.NotNil(t, args.Grandparent.Parent) - require.Nil(t, args.Grandparent.Parent.Child) - assert.Equal(t, args.Grandparent.Parent, p.Subcommand()) - assert.Equal(t, []string{"grandparent", "pa"}, p.SubcommandNames()) - } - - { - var args root - p, err := pparse("grandparent", &args) - require.NoError(t, err) - require.NotNil(t, args.Grandparent) - require.Nil(t, args.Grandparent.Parent) - assert.Equal(t, args.Grandparent, p.Subcommand()) - assert.Equal(t, []string{"grandparent"}, p.SubcommandNames()) - } - - { - var args root - p, err := pparse("", &args) - require.NoError(t, err) - require.Nil(t, args.Grandparent) - assert.Nil(t, p.Subcommand()) - assert.Empty(t, p.SubcommandNames()) - } -} - -func TestSubcommandsWithPositionals(t *testing.T) { - type listCmd struct { - Pattern string `arg:"positional"` - } - type cmd struct { - Format string - List *listCmd `arg:"subcommand"` - } - - { - var args cmd - err := parse("list", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, "", args.List.Pattern) - } - - { - var args cmd - err := parse("list --format json", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, "", args.List.Pattern) - assert.Equal(t, "json", args.Format) - } - - { - var args cmd - err := parse("list somepattern", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, "somepattern", args.List.Pattern) - } - - { - var args cmd - err := parse("list somepattern --format json", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, "somepattern", args.List.Pattern) - assert.Equal(t, "json", args.Format) - } - - { - var args cmd - err := parse("list --format json somepattern", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, "somepattern", args.List.Pattern) - assert.Equal(t, "json", args.Format) - } - - { - var args cmd - err := parse("--format json list somepattern", &args) - require.NoError(t, err) - assert.NotNil(t, args.List) - assert.Equal(t, "somepattern", args.List.Pattern) - assert.Equal(t, "json", args.Format) - } - - { - var args cmd - err := parse("--format json", &args) - require.NoError(t, err) - assert.Nil(t, args.List) - assert.Equal(t, "json", args.Format) - } -} -func TestSubcommandsWithMultiplePositionals(t *testing.T) { - type getCmd struct { - Items []string `arg:"positional"` - } - type cmd struct { - Limit int - Get *getCmd `arg:"subcommand"` - } - - { - var args cmd - err := parse("get", &args) - require.NoError(t, err) - assert.NotNil(t, args.Get) - assert.Empty(t, args.Get.Items) - } - - { - var args cmd - err := parse("get --limit 5", &args) - require.NoError(t, err) - assert.NotNil(t, args.Get) - assert.Empty(t, args.Get.Items) - assert.Equal(t, 5, args.Limit) - } - - { - var args cmd - err := parse("get item1", &args) - require.NoError(t, err) - assert.NotNil(t, args.Get) - assert.Equal(t, []string{"item1"}, args.Get.Items) - } - - { - var args cmd - err := parse("get item1 item2 item3", &args) - require.NoError(t, err) - assert.NotNil(t, args.Get) - assert.Equal(t, []string{"item1", "item2", "item3"}, args.Get.Items) - } - - { - var args cmd - err := parse("get item1 --limit 5 item2", &args) - require.NoError(t, err) - assert.NotNil(t, args.Get) - assert.Equal(t, []string{"item1", "item2"}, args.Get.Items) - assert.Equal(t, 5, args.Limit) - } -} - -func TestValForNilStruct(t *testing.T) { - type subcmd struct{} - var cmd struct { - Sub *subcmd `arg:"subcommand"` - } - - p, err := NewParser(Config{}, &cmd) - require.NoError(t, err) - - typ := reflect.TypeOf(cmd) - subField, _ := typ.FieldByName("Sub") - - v := p.val(path{fields: []reflect.StructField{subField, subField}}) - assert.False(t, v.IsValid()) -} - -func TestSubcommandInvalidInternal(t *testing.T) { - // this situation should never arise in practice but still good to test for it - var cmd struct{} - p, err := NewParser(Config{}, &cmd) - require.NoError(t, err) - - p.subcommand = []string{"should", "never", "happen"} - sub := p.Subcommand() - assert.Nil(t, sub) -} diff --git a/usage_test.go b/usage_test.go deleted file mode 100644 index b1693a9..0000000 --- a/usage_test.go +++ /dev/null @@ -1,717 +0,0 @@ -package arg - -import ( - "bytes" - "errors" - "fmt" - "os" - "strings" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -type NameDotName struct { - Head, Tail string -} - -func (n *NameDotName) UnmarshalText(b []byte) error { - s := string(b) - pos := strings.Index(s, ".") - if pos == -1 { - return fmt.Errorf("missing period in %s", s) - } - n.Head = s[:pos] - n.Tail = s[pos+1:] - return nil -} - -func (n *NameDotName) MarshalText() (text []byte, err error) { - text = []byte(fmt.Sprintf("%s.%s", n.Head, n.Tail)) - return -} - -func TestWriteUsage(t *testing.T) { - expectedUsage := "Usage: example [--name NAME] [--value VALUE] [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] [--ids IDS] [--values VALUES] [--workers WORKERS] [--testenv TESTENV] [--file FILE] INPUT [OUTPUT [OUTPUT ...]]" - - expectedHelp := ` -Usage: example [--name NAME] [--value VALUE] [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] [--ids IDS] [--values VALUES] [--workers WORKERS] [--testenv TESTENV] [--file FILE] INPUT [OUTPUT [OUTPUT ...]] - -Positional arguments: - INPUT - OUTPUT list of outputs - -Options: - --name NAME name to use [default: Foo Bar] - --value VALUE secret value [default: 42] - --verbose, -v verbosity level - --dataset DATASET dataset to use - --optimize OPTIMIZE, -O OPTIMIZE - optimization level - --ids IDS Ids - --values VALUES Values - --workers WORKERS, -w WORKERS - number of workers to start [default: 10, env: WORKERS] - --testenv TESTENV, -a TESTENV [env: TEST_ENV] - --file FILE, -f FILE File with mandatory extension [default: scratch.txt] - --help, -h display this help and exit - -Environment variables: - API_KEY Required. Only via env-var for security reasons - TRACE Optional. Record low-level trace -` - - var args struct { - Input string `arg:"positional,required"` - Output []string `arg:"positional" help:"list of outputs"` - Name string `help:"name to use"` - Value int `help:"secret value"` - Verbose bool `arg:"-v" help:"verbosity level"` - Dataset string `help:"dataset to use"` - Optimize int `arg:"-O" help:"optimization level"` - Ids []int64 `help:"Ids"` - Values []float64 `help:"Values"` - Workers int `arg:"-w,env:WORKERS" help:"number of workers to start" default:"10"` - TestEnv string `arg:"-a,env:TEST_ENV"` - ApiKey string `arg:"required,-,--,env:API_KEY" help:"Only via env-var for security reasons"` - Trace bool `arg:"-,--,env" help:"Record low-level trace"` - File *NameDotName `arg:"-f" help:"File with mandatory extension"` - } - args.Name = "Foo Bar" - args.Value = 42 - args.File = &NameDotName{"scratch", "txt"} - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - os.Args[0] = "example" - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -type MyEnum int - -func (n *MyEnum) UnmarshalText(b []byte) error { - return nil -} - -func (n *MyEnum) MarshalText() ([]byte, error) { - return nil, errors.New("There was a problem") -} - -func TestUsageWithDefaults(t *testing.T) { - expectedUsage := "Usage: example [--label LABEL] [--content CONTENT]" - - expectedHelp := ` -Usage: example [--label LABEL] [--content CONTENT] - -Options: - --label LABEL [default: cat] - --content CONTENT [default: dog] - --help, -h display this help and exit -` - var args struct { - Label string - Content string `default:"dog"` - } - args.Label = "cat" - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - args.Label = "should_ignore_this" - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestUsageCannotMarshalToString(t *testing.T) { - var args struct { - Name *MyEnum - } - v := MyEnum(42) - args.Name = &v - _, err := NewParser(Config{Program: "example"}, &args) - assert.EqualError(t, err, `args.Name: error marshaling default value to string: There was a problem`) -} - -func TestUsageLongPositionalWithHelp_legacyForm(t *testing.T) { - expectedUsage := "Usage: example [VERYLONGPOSITIONALWITHHELP]" - - expectedHelp := ` -Usage: example [VERYLONGPOSITIONALWITHHELP] - -Positional arguments: - VERYLONGPOSITIONALWITHHELP - this positional argument is very long but cannot include commas - -Options: - --help, -h display this help and exit -` - var args struct { - VeryLongPositionalWithHelp string `arg:"positional,help:this positional argument is very long but cannot include commas"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestUsageLongPositionalWithHelp_newForm(t *testing.T) { - expectedUsage := "Usage: example [VERYLONGPOSITIONALWITHHELP]" - - expectedHelp := ` -Usage: example [VERYLONGPOSITIONALWITHHELP] - -Positional arguments: - VERYLONGPOSITIONALWITHHELP - this positional argument is very long, and includes: commas, colons etc - -Options: - --help, -h display this help and exit -` - var args struct { - VeryLongPositionalWithHelp string `arg:"positional" help:"this positional argument is very long, and includes: commas, colons etc"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestUsageWithProgramName(t *testing.T) { - expectedUsage := "Usage: myprogram" - - expectedHelp := ` -Usage: myprogram - -Options: - --help, -h display this help and exit -` - config := Config{ - Program: "myprogram", - } - p, err := NewParser(config, &struct{}{}) - require.NoError(t, err) - - os.Args[0] = "example" - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -type versioned struct{} - -// Version returns the version for this program -func (versioned) Version() string { - return "example 3.2.1" -} - -func TestUsageWithVersion(t *testing.T) { - expectedUsage := "example 3.2.1\nUsage: example" - - expectedHelp := ` -example 3.2.1 -Usage: example - -Options: - --help, -h display this help and exit - --version display version and exit -` - os.Args[0] = "example" - p, err := NewParser(Config{}, &versioned{}) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -type described struct{} - -// Described returns the description for this program -func (described) Description() string { - return "this program does this and that" -} - -func TestUsageWithDescription(t *testing.T) { - expectedUsage := "Usage: example" - - expectedHelp := ` -this program does this and that -Usage: example - -Options: - --help, -h display this help and exit -` - os.Args[0] = "example" - p, err := NewParser(Config{}, &described{}) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -type epilogued struct{} - -// Epilogued returns the epilogue for this program -func (epilogued) Epilogue() string { - return "For more information visit github.com/alexflint/go-arg" -} - -func TestUsageWithEpilogue(t *testing.T) { - expectedUsage := "Usage: example" - - expectedHelp := ` -Usage: example - -Options: - --help, -h display this help and exit - -For more information visit github.com/alexflint/go-arg -` - os.Args[0] = "example" - p, err := NewParser(Config{}, &epilogued{}) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestUsageForRequiredPositionals(t *testing.T) { - expectedUsage := "Usage: example REQUIRED1 REQUIRED2\n" - var args struct { - Required1 string `arg:"positional,required"` - Required2 string `arg:"positional,required"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, usage.String()) -} - -func TestUsageForMixedPositionals(t *testing.T) { - expectedUsage := "Usage: example REQUIRED1 REQUIRED2 [OPTIONAL1 [OPTIONAL2]]\n" - var args struct { - Required1 string `arg:"positional,required"` - Required2 string `arg:"positional,required"` - Optional1 string `arg:"positional"` - Optional2 string `arg:"positional"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, usage.String()) -} - -func TestUsageForRepeatedPositionals(t *testing.T) { - expectedUsage := "Usage: example REQUIRED1 REQUIRED2 REPEATED [REPEATED ...]\n" - var args struct { - Required1 string `arg:"positional,required"` - Required2 string `arg:"positional,required"` - Repeated []string `arg:"positional,required"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, usage.String()) -} - -func TestUsageForMixedAndRepeatedPositionals(t *testing.T) { - expectedUsage := "Usage: example REQUIRED1 REQUIRED2 [OPTIONAL1 [OPTIONAL2 [REPEATED [REPEATED ...]]]]\n" - var args struct { - Required1 string `arg:"positional,required"` - Required2 string `arg:"positional,required"` - Optional1 string `arg:"positional"` - Optional2 string `arg:"positional"` - Repeated []string `arg:"positional"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, usage.String()) -} - -func TestRequiredMultiplePositionals(t *testing.T) { - expectedUsage := "Usage: example REQUIREDMULTIPLE [REQUIREDMULTIPLE ...]\n" - - expectedHelp := ` -Usage: example REQUIREDMULTIPLE [REQUIREDMULTIPLE ...] - -Positional arguments: - REQUIREDMULTIPLE required multiple positional - -Options: - --help, -h display this help and exit -` - var args struct { - RequiredMultiple []string `arg:"positional,required" help:"required multiple positional"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, usage.String()) -} - -func TestUsageWithNestedSubcommands(t *testing.T) { - expectedUsage := "Usage: example child nested [--enable] OUTPUT" - - expectedHelp := ` -Usage: example child nested [--enable] OUTPUT - -Positional arguments: - OUTPUT - -Options: - --enable - -Global options: - --values VALUES Values - --verbose, -v verbosity level - --help, -h display this help and exit -` - - var args struct { - Verbose bool `arg:"-v" help:"verbosity level"` - Child *struct { - Values []float64 `help:"Values"` - Nested *struct { - Enable bool - Output string `arg:"positional,required"` - } `arg:"subcommand:nested"` - } `arg:"subcommand:child"` - } - - os.Args[0] = "example" - p, err := NewParser(Config{}, &args) - require.NoError(t, err) - - _ = p.Parse([]string{"child", "nested", "value"}) - - assert.Equal(t, []string{"child", "nested"}, p.SubcommandNames()) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var help2 bytes.Buffer - p.WriteHelpForSubcommand(&help2, "child", "nested") - assert.Equal(t, expectedHelp[1:], help2.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) - - var usage2 bytes.Buffer - p.WriteUsageForSubcommand(&usage2, "child", "nested") - assert.Equal(t, expectedUsage, strings.TrimSpace(usage2.String())) -} - -func TestNonexistentSubcommand(t *testing.T) { - var args struct { - sub *struct{} `arg:"subcommand"` - } - p, err := NewParser(Config{Exit: func(int) {}}, &args) - require.NoError(t, err) - - var b bytes.Buffer - - err = p.WriteUsageForSubcommand(&b, "does_not_exist") - assert.Error(t, err) - - err = p.WriteHelpForSubcommand(&b, "does_not_exist") - assert.Error(t, err) - - err = p.FailSubcommand("something went wrong", "does_not_exist") - assert.Error(t, err) - - err = p.WriteUsageForSubcommand(&b, "sub", "does_not_exist") - assert.Error(t, err) - - err = p.WriteHelpForSubcommand(&b, "sub", "does_not_exist") - assert.Error(t, err) - - err = p.FailSubcommand("something went wrong", "sub", "does_not_exist") - assert.Error(t, err) -} - -func TestUsageWithoutLongNames(t *testing.T) { - expectedUsage := "Usage: example [-a PLACEHOLDER] -b SHORTONLY2" - - expectedHelp := ` -Usage: example [-a PLACEHOLDER] -b SHORTONLY2 - -Options: - -a PLACEHOLDER some help [default: some val] - -b SHORTONLY2 some help2 - --help, -h display this help and exit -` - var args struct { - ShortOnly string `arg:"-a,--" help:"some help" default:"some val" placeholder:"PLACEHOLDER"` - ShortOnly2 string `arg:"-b,--,required" help:"some help2"` - } - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestUsageWithShortFirst(t *testing.T) { - expectedUsage := "Usage: example [-c CAT] [--dog DOG]" - - expectedHelp := ` -Usage: example [-c CAT] [--dog DOG] - -Options: - -c CAT - --dog DOG - --help, -h display this help and exit -` - var args struct { - Dog string - Cat string `arg:"-c,--"` - } - p, err := NewParser(Config{Program: "example"}, &args) - assert.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestUsageWithEnvOptions(t *testing.T) { - expectedUsage := "Usage: example [-s SHORT]" - - expectedHelp := ` -Usage: example [-s SHORT] - -Options: - -s SHORT [env: SHORT] - --help, -h display this help and exit - -Environment variables: - ENVONLY Optional. - ENVONLY2 Optional. - CUSTOM Optional. -` - var args struct { - Short string `arg:"--,-s,env"` - EnvOnly string `arg:"--,env"` - EnvOnly2 string `arg:"--,-,env"` - EnvOnlyOverriden string `arg:"--,env:CUSTOM"` - } - - p, err := NewParser(Config{Program: "example"}, &args) - assert.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestEnvOnlyArgs(t *testing.T) { - expectedUsage := "Usage: example [--arg ARG]" - - expectedHelp := ` -Usage: example [--arg ARG] - -Options: - --arg ARG, -a ARG [env: MY_ARG] - --help, -h display this help and exit - -Environment variables: - AUTH_KEY Required. -` - var args struct { - ArgParam string `arg:"-a,--arg,env:MY_ARG"` - AuthKey string `arg:"required,--,env:AUTH_KEY"` - } - p, err := NewParser(Config{Program: "example"}, &args) - assert.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) - - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) -} - -func TestFail(t *testing.T) { - var stdout bytes.Buffer - var exitCode int - exit := func(code int) { exitCode = code } - - expectedStdout := ` -Usage: example [--foo FOO] -error: something went wrong -` - - var args struct { - Foo int - } - p, err := NewParser(Config{Program: "example", Exit: exit, Out: &stdout}, &args) - require.NoError(t, err) - p.Fail("something went wrong") - - assert.Equal(t, expectedStdout[1:], stdout.String()) - assert.Equal(t, -1, exitCode) -} - -func TestFailSubcommand(t *testing.T) { - var stdout bytes.Buffer - var exitCode int - exit := func(code int) { exitCode = code } - - expectedStdout := ` -Usage: example sub -error: something went wrong -` - - var args struct { - Sub *struct{} `arg:"subcommand"` - } - p, err := NewParser(Config{Program: "example", Exit: exit, Out: &stdout}, &args) - require.NoError(t, err) - - err = p.FailSubcommand("something went wrong", "sub") - require.NoError(t, err) - - assert.Equal(t, expectedStdout[1:], stdout.String()) - assert.Equal(t, -1, exitCode) -} - -type lengthOf struct { - Length int -} - -func (p *lengthOf) UnmarshalText(b []byte) error { - p.Length = len(b) - return nil -} - -func TestHelpShowsDefaultValueFromOriginalTag(t *testing.T) { - // check that the usage text prints the original string from the default tag, not - // the serialization of the parsed value - - expectedHelp := ` -Usage: example [--test TEST] - -Options: - --test TEST [default: some_default_value] - --help, -h display this help and exit -` - - var args struct { - Test *lengthOf `default:"some_default_value"` - } - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) -} - -func TestHelpShowsSubcommandAliases(t *testing.T) { - expectedHelp := ` -Usage: example [] - -Options: - --help, -h display this help and exit - -Commands: - remove, rm, r remove something from somewhere - simple do something simple - halt, stop stop now -` - - var args struct { - Remove *struct{} `arg:"subcommand:remove|rm|r" help:"remove something from somewhere"` - Simple *struct{} `arg:"subcommand" help:"do something simple"` - Stop *struct{} `arg:"subcommand:halt|stop" help:"stop now"` - } - p, err := NewParser(Config{Program: "example"}, &args) - require.NoError(t, err) - - var help bytes.Buffer - p.WriteHelp(&help) - assert.Equal(t, expectedHelp[1:], help.String()) -}