Merge pull request #150 from alexflint/push-coverage-up-more

Push test coverage up to 100%

1 files changed, 122 insertions, 33 deletions

diff --git a/parse_test.go b/parse_test.go
index d03cbfd..09fb508 100644
--- a/parse_test.go
+++ b/parse_test.go
@@ -1,6 +1,8 @@
 package arg
 
 import (
+	"bytes"
+	"fmt"
 	"net"
 	"net/mail"
 	"os"
@@ -24,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)
 }
 
@@ -461,7 +483,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 +568,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
@@ -633,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)
 }
 
@@ -643,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)
 }
 
@@ -652,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)
 }
 
@@ -662,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)
 }
 
@@ -682,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)
 }
 
@@ -692,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)
 }
 
@@ -701,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)
 }
 
@@ -710,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)
 }
 
@@ -719,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)
 }
 
@@ -728,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)
 }
 
@@ -737,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)
 }
 
@@ -746,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])
@@ -1299,3 +1321,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())
+}