From fe4a138ac8c39cb00bbee7279a0957897ab88fae Mon Sep 17 00:00:00 2001 From: Alex Flint Date: Mon, 19 Apr 2021 21:03:43 -0700 Subject: [PATCH 1/2] test coverage 100% !! --- example_test.go | 17 +++++ parse.go | 31 +------- parse_test.go | 78 ++++++++++++++++++- reflect.go | 12 +++ reflect_test.go | 21 +++++ subcommand_test.go | 58 ++++++++++++++ usage.go | 6 +- usage_test.go | 187 ++++++++++++++++++++++++++++++++++----------- 8 files changed, 338 insertions(+), 72 deletions(-) diff --git a/example_test.go b/example_test.go index 5645156..26f24e7 100644 --- a/example_test.go +++ b/example_test.go @@ -95,6 +95,19 @@ func Example_mappings() { // output: map[john:123 mary:456] } +// This example demonstrates arguments with keys and values separated by commas +func Example_mappingsWithCommas() { + // 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] +} + // This eample demonstrates multiple value arguments that can be mixed with // other arguments. func Example_multipleMixed() { @@ -130,6 +143,7 @@ func Example_helpText() { // This is only necessary when running inside golang's runnable example harness osExit = func(int) {} + stdout = os.Stdout MustParse(&args) @@ -162,6 +176,7 @@ func Example_helpPlaceholder() { // This is only necessary when running inside golang's runnable example harness osExit = func(int) {} + stdout = os.Stdout MustParse(&args) @@ -202,6 +217,7 @@ func Example_helpTextWithSubcommand() { // This is only necessary when running inside golang's runnable example harness osExit = func(int) {} + stdout = os.Stdout MustParse(&args) @@ -239,6 +255,7 @@ func Example_helpTextForSubcommand() { // This is only necessary when running inside golang's runnable example harness osExit = func(int) {} + stdout = os.Stdout MustParse(&args) diff --git a/parse.go b/parse.go index d357d5c..94c0a89 100644 --- a/parse.go +++ b/parse.go @@ -13,9 +13,6 @@ import ( scalar "github.com/alexflint/go-scalar" ) -// to enable monkey-patching during tests -var osExit = os.Exit - // path represents a sequence of steps to find the output location for an // argument or subcommand in the final destination struct type path struct { @@ -80,7 +77,7 @@ var ErrVersion = errors.New("version requested by user") func MustParse(dest ...interface{}) *Parser { p, err := NewParser(Config{}, dest...) if err != nil { - fmt.Println(err) + fmt.Fprintln(stdout, err) osExit(-1) return nil // just in case osExit was monkey-patched } @@ -88,10 +85,10 @@ func MustParse(dest ...interface{}) *Parser { err = p.Parse(flags()) switch { case err == ErrHelp: - p.writeHelpForCommand(os.Stdout, p.lastCmd) + p.writeHelpForCommand(stdout, p.lastCmd) osExit(0) case err == ErrVersion: - fmt.Println(p.version) + fmt.Fprintln(stdout, p.version) osExit(0) case err != nil: p.failWithCommand(err.Error(), p.lastCmd) @@ -688,15 +685,7 @@ func (p *Parser) val(dest path) reflect.Value { v = v.Elem() } - next := v.FieldByIndex(field.Index) - if !next.IsValid() { - // it is appropriate to panic here because this can only happen due to - // an internal bug in this library (since we construct the path ourselves - // by reflecting on the same struct) - panic(fmt.Errorf("error resolving path %v: %v has no field named %v", - dest.fields, v.Type(), field)) - } - v = next + v = v.FieldByIndex(field.Index) } return v } @@ -723,15 +712,3 @@ func findSubcommand(cmds []*command, name string) *command { } return nil } - -// isZero returns true if v contains the zero value for its type -func isZero(v reflect.Value) bool { - t := v.Type() - if t.Kind() == reflect.Slice || t.Kind() == reflect.Map { - return v.IsNil() - } - if !t.Comparable() { - return false - } - return v.Interface() == reflect.Zero(t).Interface() -} diff --git a/parse_test.go b/parse_test.go index d03cbfd..b190e83 100644 --- a/parse_test.go +++ b/parse_test.go @@ -1,6 +1,7 @@ package arg import ( + "bytes" "net" "net/mail" "os" @@ -461,7 +462,7 @@ func TestMissingValueAtEnd(t *testing.T) { assert.Error(t, err) } -func TestMissingValueInMIddle(t *testing.T) { +func TestMissingValueInMiddle(t *testing.T) { var args struct { Foo string Bar string @@ -546,6 +547,14 @@ func TestNoMoreOptions(t *testing.T) { 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 @@ -1299,3 +1308,70 @@ func TestUnexportedFieldsSkipped(t *testing.T) { _, err := NewParser(Config{}, &args) require.NoError(t, err) } + +func TestMustParseInvalidParser(t *testing.T) { + originalExit := osExit + originalStdout := stdout + defer func() { + osExit = originalExit + stdout = originalStdout + }() + + var exitCode int + osExit = func(code int) { exitCode = code } + stdout = &bytes.Buffer{} + + var args struct { + CannotParse struct{} + } + parser := MustParse(&args) + assert.Nil(t, parser) + assert.Equal(t, -1, exitCode) +} + +func TestMustParsePrintsHelp(t *testing.T) { + originalExit := osExit + originalStdout := stdout + originalArgs := os.Args + defer func() { + osExit = originalExit + stdout = originalStdout + os.Args = originalArgs + }() + + var exitCode *int + osExit = func(code int) { exitCode = &code } + os.Args = []string{"someprogram", "--help"} + stdout = &bytes.Buffer{} + + var args struct{} + parser := MustParse(&args) + assert.NotNil(t, parser) + require.NotNil(t, exitCode) + assert.Equal(t, 0, *exitCode) +} + +func TestMustParsePrintsVersion(t *testing.T) { + originalExit := osExit + originalStdout := stdout + originalArgs := os.Args + defer func() { + osExit = originalExit + stdout = originalStdout + os.Args = originalArgs + }() + + var exitCode *int + osExit = func(code int) { exitCode = &code } + os.Args = []string{"someprogram", "--version"} + + var b bytes.Buffer + stdout = &b + + var args versioned + parser := MustParse(&args) + require.NotNil(t, parser) + require.NotNil(t, exitCode) + assert.Equal(t, 0, *exitCode) + assert.Equal(t, "example 3.2.1\n", b.String()) +} diff --git a/reflect.go b/reflect.go index 1806973..c719b52 100644 --- a/reflect.go +++ b/reflect.go @@ -94,3 +94,15 @@ func isExported(field string) bool { r, _ := utf8.DecodeRuneInString(field) // returns RuneError for empty string or invalid UTF8 return unicode.IsLetter(r) && unicode.IsUpper(r) } + +// isZero returns true if v contains the zero value for its type +func isZero(v reflect.Value) bool { + t := v.Type() + if t.Kind() == reflect.Slice || t.Kind() == reflect.Map { + return v.IsNil() + } + if !t.Comparable() { + return false + } + return v.Interface() == reflect.Zero(t).Interface() +} diff --git a/reflect_test.go b/reflect_test.go index 8d65fd9..10909b3 100644 --- a/reflect_test.go +++ b/reflect_test.go @@ -89,3 +89,24 @@ func TestCardinalityString(t *testing.T) { 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/subcommand_test.go b/subcommand_test.go index c34ab01..2c61dd3 100644 --- a/subcommand_test.go +++ b/subcommand_test.go @@ -1,6 +1,7 @@ package arg import ( + "reflect" "testing" "github.com/stretchr/testify/assert" @@ -48,6 +49,17 @@ func TestMinimalSubcommand(t *testing.T) { 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 { } @@ -179,6 +191,36 @@ func TestSubcommandsWithOptions(t *testing.T) { } } +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 { @@ -353,3 +395,19 @@ func TestSubcommandsWithMultiplePositionals(t *testing.T) { 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()) +} diff --git a/usage.go b/usage.go index 231476b..c121c45 100644 --- a/usage.go +++ b/usage.go @@ -11,7 +11,11 @@ import ( const colWidth = 25 // to allow monkey patching in tests -var stderr = os.Stderr +var ( + stdout io.Writer = os.Stdout + stderr io.Writer = os.Stderr + osExit = os.Exit +) // Fail prints usage information to stderr and exits with non-zero status func (p *Parser) Fail(msg string) { diff --git a/usage_test.go b/usage_test.go index 6dee402..1b6c475 100644 --- a/usage_test.go +++ b/usage_test.go @@ -33,9 +33,10 @@ func (n *NameDotName) MarshalText() (text []byte, err error) { } 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 ...]]\n" + 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 ...]] + 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 @@ -56,6 +57,7 @@ Options: --file FILE, -f FILE File with mandatory extension [default: scratch.txt] --help, -h display this help and exit ` + var args struct { Input string `arg:"positional"` Output []string `arg:"positional" help:"list of outputs"` @@ -79,13 +81,13 @@ Options: os.Args[0] = "example" - var usage bytes.Buffer - p.WriteUsage(&usage) - assert.Equal(t, expectedUsage, usage.String()) - var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + 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 @@ -99,7 +101,10 @@ func (n *MyEnum) MarshalText() ([]byte, error) { } func TestUsageWithDefaults(t *testing.T) { - expectedHelp := `Usage: example [--label LABEL] [--content CONTENT] + expectedUsage := "Usage: example [--label LABEL] [--content CONTENT]" + + expectedHelp := ` +Usage: example [--label LABEL] [--content CONTENT] Options: --label LABEL [default: cat] @@ -118,7 +123,11 @@ Options: var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + 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) { @@ -132,7 +141,10 @@ func TestUsageCannotMarshalToString(t *testing.T) { } func TestUsageLongPositionalWithHelp_legacyForm(t *testing.T) { - expectedHelp := `Usage: example VERYLONGPOSITIONALWITHHELP + expectedUsage := "Usage: example VERYLONGPOSITIONALWITHHELP" + + expectedHelp := ` +Usage: example VERYLONGPOSITIONALWITHHELP Positional arguments: VERYLONGPOSITIONALWITHHELP @@ -145,17 +157,23 @@ Options: VeryLongPositionalWithHelp string `arg:"positional,help:this positional argument is very long but cannot include commas"` } - p, err := NewParser(Config{}, &args) + 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, help.String()) + 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) { - expectedHelp := `Usage: example VERYLONGPOSITIONALWITHHELP + expectedUsage := "Usage: example VERYLONGPOSITIONALWITHHELP" + + expectedHelp := ` +Usage: example VERYLONGPOSITIONALWITHHELP Positional arguments: VERYLONGPOSITIONALWITHHELP @@ -168,17 +186,23 @@ Options: VeryLongPositionalWithHelp string `arg:"positional" help:"this positional argument is very long, and includes: commas, colons etc"` } - p, err := NewParser(Config{}, &args) + 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, help.String()) + 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) { - expectedHelp := `Usage: myprogram + expectedUsage := "Usage: myprogram" + + expectedHelp := ` +Usage: myprogram Options: --help, -h display this help and exit @@ -190,9 +214,14 @@ Options: require.NoError(t, err) os.Args[0] = "example" + var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + 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{} @@ -203,7 +232,10 @@ func (versioned) Version() string { } func TestUsageWithVersion(t *testing.T) { - expectedHelp := `example 3.2.1 + expectedUsage := "example 3.2.1\nUsage: example" + + expectedHelp := ` +example 3.2.1 Usage: example Options: @@ -216,12 +248,11 @@ Options: var help bytes.Buffer p.WriteHelp(&help) - actual := help.String() - if expectedHelp != actual { - t.Logf("Expected:\n%s", expectedHelp) - t.Logf("Actual:\n%s", actual) - t.Fail() - } + 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{} @@ -232,7 +263,10 @@ func (described) Description() string { } func TestUsageWithDescription(t *testing.T) { - expectedHelp := `this program does this and that + expectedUsage := "Usage: example" + + expectedHelp := ` +this program does this and that Usage: example Options: @@ -244,16 +278,18 @@ Options: var help bytes.Buffer p.WriteHelp(&help) - actual := help.String() - if expectedHelp != actual { - t.Logf("Expected:\n%s", expectedHelp) - t.Logf("Actual:\n%s", actual) - t.Fail() - } + assert.Equal(t, expectedHelp[1:], help.String()) + + var usage bytes.Buffer + p.WriteUsage(&usage) + assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) } func TestRequiredMultiplePositionals(t *testing.T) { - expectedHelp := `Usage: example REQUIREDMULTIPLE [REQUIREDMULTIPLE ...] + expectedUsage := "Usage: example REQUIREDMULTIPLE [REQUIREDMULTIPLE ...]" + + expectedHelp := ` +Usage: example REQUIREDMULTIPLE [REQUIREDMULTIPLE ...] Positional arguments: REQUIREDMULTIPLE required multiple positional @@ -270,11 +306,18 @@ Options: var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + assert.Equal(t, expectedHelp[1:], help.String()) + + var usage bytes.Buffer + p.WriteUsage(&usage) + assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) } func TestUsageWithNestedSubcommands(t *testing.T) { - expectedHelp := `Usage: example child nested [--enable] OUTPUT + expectedUsage := "Usage: example child nested [--enable] OUTPUT" + + expectedHelp := ` +Usage: example child nested [--enable] OUTPUT Positional arguments: OUTPUT @@ -307,11 +350,18 @@ Global options: var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + assert.Equal(t, expectedHelp[1:], help.String()) + + var usage bytes.Buffer + p.WriteUsage(&usage) + assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String())) } func TestUsageWithoutLongNames(t *testing.T) { - expectedHelp := `Usage: example [-a PLACEHOLDER] -b SHORTONLY2 + expectedUsage := "Usage: example [-a PLACEHOLDER] -b SHORTONLY2" + + expectedHelp := ` +Usage: example [-a PLACEHOLDER] -b SHORTONLY2 Options: -a PLACEHOLDER some help [default: some val] @@ -324,13 +374,21 @@ Options: } p, err := NewParser(Config{Program: "example"}, &args) assert.NoError(t, err) + var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + 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) { - expectedHelp := `Usage: example [-c CAT] [--dog DOG] + expectedUsage := "Usage: example [-c CAT] [--dog DOG]" + + expectedHelp := ` +Usage: example [-c CAT] [--dog DOG] Options: -c CAT @@ -343,13 +401,21 @@ Options: } p, err := NewParser(Config{Program: "example"}, &args) assert.NoError(t, err) + var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + 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) { - expectedHelp := `Usage: example [-s SHORT] + expectedUsage := "Usage: example [-s SHORT]" + + expectedHelp := ` +Usage: example [-s SHORT] Options: -s SHORT [env: SHORT] @@ -363,7 +429,42 @@ Options: p, err := NewParser(Config{Program: "example"}, &args) assert.NoError(t, err) + var help bytes.Buffer p.WriteHelp(&help) - assert.Equal(t, expectedHelp, help.String()) + 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) { + originalStderr := stderr + originalExit := osExit + defer func() { + stderr = originalStderr + osExit = originalExit + }() + + var b bytes.Buffer + stderr = &b + + var exitCode int + osExit = 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"}, &args) + require.NoError(t, err) + p.Fail("something went wrong") + + assert.Equal(t, expectedStdout[1:], b.String()) + assert.Equal(t, -1, exitCode) } From 01a9fab8d768fbcb11e51d4df3c8fda6230462da Mon Sep 17 00:00:00 2001 From: Alex Flint Date: Mon, 19 Apr 2021 21:22:12 -0700 Subject: [PATCH 2/2] clean up environment variable tests --- parse_test.go | 77 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 45 insertions(+), 32 deletions(-) diff --git a/parse_test.go b/parse_test.go index b190e83..09fb508 100644 --- a/parse_test.go +++ b/parse_test.go @@ -2,6 +2,7 @@ package arg import ( "bytes" + "fmt" "net" "net/mail" "os" @@ -25,14 +26,34 @@ func parse(cmdline string, dest interface{}) error { } 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) } @@ -642,9 +663,8 @@ func TestEnvironmentVariable(t *testing.T) { var args struct { Foo string `arg:"env"` } - setenv(t, "FOO", "bar") - os.Args = []string{"example"} - MustParse(&args) + _, err := parseWithEnv("", []string{"FOO=bar"}, &args) + require.NoError(t, err) assert.Equal(t, "bar", args.Foo) } @@ -652,8 +672,8 @@ func TestEnvironmentVariableNotPresent(t *testing.T) { var args struct { NotPresent string `arg:"env"` } - os.Args = []string{"example"} - MustParse(&args) + _, err := parseWithEnv("", nil, &args) + require.NoError(t, err) assert.Equal(t, "", args.NotPresent) } @@ -661,9 +681,8 @@ func TestEnvironmentVariableOverrideName(t *testing.T) { var args struct { Foo string `arg:"env:BAZ"` } - setenv(t, "BAZ", "bar") - os.Args = []string{"example"} - MustParse(&args) + _, err := parseWithEnv("", []string{"BAZ=bar"}, &args) + require.NoError(t, err) assert.Equal(t, "bar", args.Foo) } @@ -671,19 +690,16 @@ func TestEnvironmentVariableOverrideArgument(t *testing.T) { var args struct { Foo string `arg:"env"` } - setenv(t, "FOO", "bar") - os.Args = []string{"example", "--foo", "baz"} - MustParse(&args) - assert.Equal(t, "baz", args.Foo) + _, 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"` } - setenv(t, "FOO", "bar") - os.Args = []string{"example"} - err := Parse(&args) + _, err := parseWithEnv("", []string{"FOO=bar"}, &args) assert.Error(t, err) } @@ -691,9 +707,8 @@ func TestEnvironmentVariableRequired(t *testing.T) { var args struct { Foo string `arg:"env,required"` } - setenv(t, "FOO", "bar") - os.Args = []string{"example"} - MustParse(&args) + _, err := parseWithEnv("", []string{"FOO=bar"}, &args) + require.NoError(t, err) assert.Equal(t, "bar", args.Foo) } @@ -701,8 +716,8 @@ func TestEnvironmentVariableSliceArgumentString(t *testing.T) { var args struct { Foo []string `arg:"env"` } - setenv(t, "FOO", `bar,"baz, qux"`) - MustParse(&args) + _, err := parseWithEnv("", []string{`FOO=bar,"baz, qux"`}, &args) + require.NoError(t, err) assert.Equal(t, []string{"bar", "baz, qux"}, args.Foo) } @@ -710,8 +725,8 @@ func TestEnvironmentVariableSliceArgumentInteger(t *testing.T) { var args struct { Foo []int `arg:"env"` } - setenv(t, "FOO", "1,99") - MustParse(&args) + _, err := parseWithEnv("", []string{`FOO=1,99`}, &args) + require.NoError(t, err) assert.Equal(t, []int{1, 99}, args.Foo) } @@ -719,8 +734,8 @@ func TestEnvironmentVariableSliceArgumentFloat(t *testing.T) { var args struct { Foo []float32 `arg:"env"` } - setenv(t, "FOO", "1.1,99.9") - MustParse(&args) + _, err := parseWithEnv("", []string{`FOO=1.1,99.9`}, &args) + require.NoError(t, err) assert.Equal(t, []float32{1.1, 99.9}, args.Foo) } @@ -728,8 +743,8 @@ func TestEnvironmentVariableSliceArgumentBool(t *testing.T) { var args struct { Foo []bool `arg:"env"` } - setenv(t, "FOO", "true,false,0,1") - MustParse(&args) + _, err := parseWithEnv("", []string{`FOO=true,false,0,1`}, &args) + require.NoError(t, err) assert.Equal(t, []bool{true, false, false, true}, args.Foo) } @@ -737,8 +752,7 @@ func TestEnvironmentVariableSliceArgumentWrongCsv(t *testing.T) { var args struct { Foo []int `arg:"env"` } - setenv(t, "FOO", "1,99\"") - err := Parse(&args) + _, err := parseWithEnv("", []string{`FOO=1,99\"`}, &args) assert.Error(t, err) } @@ -746,8 +760,7 @@ func TestEnvironmentVariableSliceArgumentWrongType(t *testing.T) { var args struct { Foo []bool `arg:"env"` } - setenv(t, "FOO", "one,two") - err := Parse(&args) + _, err := parseWithEnv("", []string{`FOO=one,two`}, &args) assert.Error(t, err) } @@ -755,8 +768,8 @@ func TestEnvironmentVariableMap(t *testing.T) { var args struct { Foo map[int]string `arg:"env"` } - setenv(t, "FOO", "1=one,99=ninetynine") - MustParse(&args) + _, 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])