diff --git a/.golangci.yml b/.golangci.yml index f7be904..e90edb8 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -36,6 +36,11 @@ linters: - thelper - godox - goconst + - varnamelen + - ireturn + - exhaustruct + - nonamedreturns + - nilnil linters-settings: govet: diff --git a/benchmark_test.go b/benchmark_test.go index 0fd2469..4ec3143 100644 --- a/benchmark_test.go +++ b/benchmark_test.go @@ -5,7 +5,7 @@ import ( "strconv" "testing" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func BenchmarkKong_interpolate(b *testing.B) { @@ -23,7 +23,7 @@ func BenchmarkKong_interpolate(b *testing.B) { Param0 string `help:"${help_param0}"` }{} model, err := build(k, grammar) - require.NoError(t, err) + assert.NoError(t, err) for i := 0; i < count; i++ { model.Node.Flags = append(model.Node.Flags, &Flag{ Value: &Value{ @@ -44,7 +44,7 @@ func BenchmarkKong_interpolate(b *testing.B) { for i := 0; i < b.N; i++ { err = k.interpolate(k.Model.Node) } - require.NoError(b, err) + assert.NoError(b, err) b.ReportAllocs() }) } diff --git a/bin/.go-1.17.8.pkg b/bin/.go-1.18.3.pkg similarity index 100% rename from bin/.go-1.17.8.pkg rename to bin/.go-1.18.3.pkg diff --git a/bin/.golangci-lint-1.42.0.pkg b/bin/.golangci-lint-1.46.2.pkg similarity index 100% rename from bin/.golangci-lint-1.42.0.pkg rename to bin/.golangci-lint-1.46.2.pkg diff --git a/bin/go b/bin/go index 2a04058..697e82b 120000 --- a/bin/go +++ b/bin/go @@ -1 +1 @@ -.go-1.17.8.pkg \ No newline at end of file +.go-1.18.3.pkg \ No newline at end of file diff --git a/bin/gofmt b/bin/gofmt index 2a04058..697e82b 120000 --- a/bin/gofmt +++ b/bin/gofmt @@ -1 +1 @@ -.go-1.17.8.pkg \ No newline at end of file +.go-1.18.3.pkg \ No newline at end of file diff --git a/bin/golangci-lint b/bin/golangci-lint index 4a00c9d..de42e34 120000 --- a/bin/golangci-lint +++ b/bin/golangci-lint @@ -1 +1 @@ -.golangci-lint-1.42.0.pkg \ No newline at end of file +.golangci-lint-1.46.2.pkg \ No newline at end of file diff --git a/callbacks.go b/callbacks.go index 1cfaccf..4e38e17 100644 --- a/callbacks.go +++ b/callbacks.go @@ -96,5 +96,5 @@ func callMethod(name string, v, f reflect.Value, bindings bindings) error { if out[0].IsNil() { return nil } - return out[0].Interface().(error) + return out[0].Interface().(error) // nolint } diff --git a/config_test.go b/config_test.go index a63205b..0d7f2cc 100644 --- a/config_test.go +++ b/config_test.go @@ -6,8 +6,7 @@ import ( "os" "testing" - "github.com/stretchr/testify/require" - + "github.com/alecthomas/assert/v2" "github.com/alecthomas/kong" ) @@ -26,8 +25,8 @@ func TestMultipleConfigLoading(t *testing.T) { p := mustNew(t, &cli, kong.Configuration(kong.JSON, first, second)) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, "first", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "first", cli.Flag) } func TestConfigValidation(t *testing.T) { @@ -41,15 +40,15 @@ func TestConfigValidation(t *testing.T) { p := mustNew(t, &cli, kong.Configuration(kong.JSON, conf)) _, err := p.Parse(nil) - require.Error(t, err) + assert.Error(t, err) } func makeConfig(t *testing.T, config interface{}) (path string, cleanup func()) { t.Helper() w, err := ioutil.TempFile("", "") - require.NoError(t, err) + assert.NoError(t, err) defer w.Close() // nolint: gosec err = json.NewEncoder(w).Encode(config) - require.NoError(t, err) + assert.NoError(t, err) return w.Name(), func() { os.Remove(w.Name()) } } diff --git a/defaults_test.go b/defaults_test.go index b67640d..c78d334 100644 --- a/defaults_test.go +++ b/defaults_test.go @@ -4,7 +4,7 @@ import ( "testing" "time" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func TestApplyDefaults(t *testing.T) { @@ -26,8 +26,8 @@ func TestApplyDefaults(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { err := ApplyDefaults(&tt.target) - require.NoError(t, err) - require.Equal(t, tt.expected, tt.target) + assert.NoError(t, err) + assert.Equal(t, tt.expected, tt.target) }) } } diff --git a/global_test.go b/global_test.go index 6f97302..86c46de 100644 --- a/global_test.go +++ b/global_test.go @@ -4,7 +4,7 @@ import ( "os" "testing" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func TestParseHandlingBadBuild(t *testing.T) { @@ -21,11 +21,11 @@ func TestParseHandlingBadBuild(t *testing.T) { defer func() { if r := recover(); r != nil { - require.Equal(t, "fail=' is not quoted properly", r.(error).Error()) + assert.Equal(t, "fail=' is not quoted properly", r.(error).Error()) // nolint } }() Parse(&cli, Exit(func(_ int) { panic("exiting") })) - require.Fail(t, "we were expecting a panic") + t.Fatal("we were expecting a panic") } diff --git a/go.mod b/go.mod index 7c8aa54..159f5f7 100644 --- a/go.mod +++ b/go.mod @@ -1,9 +1,10 @@ module github.com/alecthomas/kong require ( - github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142 - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/stretchr/testify v1.7.2 + github.com/alecthomas/assert/v2 v2.1.0 + github.com/alecthomas/repr v0.1.0 ) -go 1.13 +require github.com/hexops/gotextdiff v1.0.3 // indirect + +go 1.18 diff --git a/go.sum b/go.sum index 32d72f0..f5d4fd4 100644 --- a/go.sum +++ b/go.sum @@ -1,14 +1,6 @@ -github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142 h1:8Uy0oSf5co/NZXje7U1z8Mpep++QJOldL2hs/sBQf48= -github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -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/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8s= -github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= -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= +github.com/alecthomas/assert/v2 v2.1.0 h1:tbredtNcQnoSd3QBhQWI7QZ3XHOVkw1Moklp2ojoH/0= +github.com/alecthomas/assert/v2 v2.1.0/go.mod h1:b/+1DI2Q6NckYi+3mXyH3wFb8qG37K/DuK80n7WefXA= +github.com/alecthomas/repr v0.1.0 h1:ENn2e1+J3k09gyj2shc0dHr/yjaWSHRlrJ4DPMevDqE= +github.com/alecthomas/repr v0.1.0/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8= +github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= +github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= diff --git a/help_test.go b/help_test.go index 2018b0f..77ac8cb 100644 --- a/help_test.go +++ b/help_test.go @@ -6,11 +6,22 @@ import ( "strings" "testing" - "github.com/stretchr/testify/require" - + "github.com/alecthomas/assert/v2" "github.com/alecthomas/kong" ) +func panicsTrue(t *testing.T, f func()) { + defer func() { + if value := recover(); value != nil { + if boolval, ok := value.(bool); !ok || !boolval { + t.Fatalf("expected panic with true but got %v", value) + } + } + }() + f() + t.Fatal("expected panic did not occur") +} + type threeArg struct { RequiredThree bool `required` Three string `arg` @@ -35,11 +46,11 @@ func TestHelpOptionalArgs(t *testing.T) { panic(true) // Panic to fake "exit". }), ) - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app [ []] Arguments: @@ -49,7 +60,7 @@ Arguments: Flags: -h, --help Show context-sensitive help. ` - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) } func TestHelp(t *testing.T) { @@ -89,11 +100,11 @@ func TestHelp(t *testing.T) { ) t.Run("Full", func(t *testing.T) { - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app --required A test app. @@ -122,17 +133,17 @@ Run "test-app --help" for more information on a command. ` t.Log(w.String()) t.Log(expected) - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) t.Run("Selected", func(t *testing.T) { exited = false w.Truncate(0) - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"two", "hello", "--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app two --required --required-two --required-three Sub-sub-arg. @@ -156,7 +167,7 @@ Flags: ` t.Log(expected) t.Log(w.String()) - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) } @@ -199,11 +210,11 @@ func TestFlagsLast(t *testing.T) { ) t.Run("Full", func(t *testing.T) { - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app --required A test app. @@ -231,17 +242,17 @@ Run "test-app --help" for more information on a command. ` t.Log(w.String()) t.Log(expected) - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) t.Run("Selected", func(t *testing.T) { exited = false w.Truncate(0) - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"two", "hello", "--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app two --required --required-two --required-three Sub-sub-arg. @@ -264,7 +275,7 @@ Flags: ` t.Log(expected) t.Log(w.String()) - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) } @@ -304,11 +315,11 @@ func TestHelpTree(t *testing.T) { ) t.Run("Full", func(t *testing.T) { - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app A test app. @@ -331,17 +342,17 @@ Run "test-app --help" for more information on a command. if expected != w.String() { t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected) } - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) t.Run("Selected", func(t *testing.T) { exited = false w.Truncate(0) - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"one", "--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app one (un,uno) subcommand one @@ -358,7 +369,7 @@ Commands: if expected != w.String() { t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected) } - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) } @@ -398,11 +409,11 @@ func TestHelpCompactNoExpand(t *testing.T) { ) t.Run("Full", func(t *testing.T) { - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app A test app. @@ -421,17 +432,17 @@ Run "test-app --help" for more information on a command. if expected != w.String() { t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected) } - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) t.Run("Selected", func(t *testing.T) { exited = false w.Truncate(0) - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"one", "--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.True(t, exited) + assert.True(t, exited) expected := `Usage: test-app one (un,uno) subcommand one @@ -446,7 +457,7 @@ Group A if expected != w.String() { t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected) } - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) } @@ -457,8 +468,8 @@ func TestEnvarAutoHelp(t *testing.T) { w := &strings.Builder{} p := mustNew(t, &cli, kong.Writers(w, w), kong.Exit(func(int) {})) _, err := p.Parse([]string{"--help"}) - require.NoError(t, err) - require.Contains(t, w.String(), "A flag ($FLAG).") + assert.NoError(t, err) + assert.Contains(t, w.String(), "A flag ($FLAG).") } func TestEnvarAutoHelpWithEnvPrefix(t *testing.T) { @@ -472,9 +483,9 @@ func TestEnvarAutoHelpWithEnvPrefix(t *testing.T) { w := &strings.Builder{} p := mustNew(t, &cli, kong.Writers(w, w), kong.Exit(func(int) {})) _, err := p.Parse([]string{"--help"}) - require.NoError(t, err) - require.Contains(t, w.String(), "A flag ($ANON_FLAG).") - require.Contains(t, w.String(), "A different flag.") + assert.NoError(t, err) + assert.Contains(t, w.String(), "A flag ($ANON_FLAG).") + assert.Contains(t, w.String(), "A different flag.") } func TestCustomValueFormatter(t *testing.T) { @@ -490,8 +501,8 @@ func TestCustomValueFormatter(t *testing.T) { }), ) _, err := p.Parse([]string{"--help"}) - require.NoError(t, err) - require.Contains(t, w.String(), "A flag.") + assert.NoError(t, err) + assert.Contains(t, w.String(), "A flag.") } func TestAutoGroup(t *testing.T) { @@ -541,14 +552,14 @@ func TestAutoGroup(t *testing.T) { if node, ok := parent.(*kong.Node); ok { return &kong.Group{ Key: node.Name, - Title: strings.Title(node.Name) + " flags:", + Title: strings.Title(node.Name) + " flags:", // nolint } } return nil }), ) _, _ = app.Parse([]string{"--help", "two"}) - require.Equal(t, `Usage: test two + assert.Equal(t, `Usage: test two A non grouped subcommand. @@ -627,10 +638,10 @@ func TestHelpGrouping(t *testing.T) { ) t.Run("Full", func(t *testing.T) { - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"--help"}) - require.True(t, exited) - require.NoError(t, err) + assert.True(t, exited) + assert.NoError(t, err) }) expected := `Usage: test-app @@ -677,16 +688,16 @@ Run "test-app --help" for more information on a command. ` t.Log(w.String()) t.Log(expected) - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) t.Run("Selected", func(t *testing.T) { exited = false w.Truncate(0) - require.PanicsWithValue(t, true, func() { + panicsTrue(t, func() { _, err := app.Parse([]string{"two", "--help"}) - require.NoError(t, err) - require.True(t, exited) + assert.NoError(t, err) + assert.True(t, exited) }) expected := `Usage: test-app two @@ -719,7 +730,7 @@ Group 2 ` t.Log(expected) t.Log(w.String()) - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) }) } @@ -747,7 +758,7 @@ Flags: test: error: missing flags: --flag=STRING ` - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) } func TestShortUsageOnError(t *testing.T) { @@ -762,7 +773,7 @@ func TestShortUsageOnError(t *testing.T) { kong.ShortUsageOnError(), ) _, err := p.Parse([]string{}) - require.Error(t, err) + assert.Error(t, err) p.FatalIfErrorf(err) expected := `Usage: test --flag=STRING @@ -770,7 +781,7 @@ Run "test --help" for more information. test: error: missing flags: --flag=STRING ` - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) } func TestCustomShortUsageOnError(t *testing.T) { @@ -790,14 +801,14 @@ func TestCustomShortUsageOnError(t *testing.T) { kong.ShortUsageOnError(), ) _, err := p.Parse([]string{}) - require.Error(t, err) + assert.Error(t, err) p.FatalIfErrorf(err) expected := `🤷 wish I could help test: error: missing flags: --flag=STRING ` - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) } func TestCustomWrap(t *testing.T) { @@ -817,7 +828,7 @@ func TestCustomWrap(t *testing.T) { ) _, err := app.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) expected := `Usage: test-app A test app. @@ -832,5 +843,5 @@ Flags: ` t.Log(w.String()) t.Log(expected) - require.Equal(t, expected, w.String()) + assert.Equal(t, expected, w.String()) } diff --git a/interpolate_test.go b/interpolate_test.go index 927be41..51fad1b 100644 --- a/interpolate_test.go +++ b/interpolate_test.go @@ -3,7 +3,7 @@ package kong import ( "testing" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func TestInterpolate(t *testing.T) { @@ -15,16 +15,16 @@ func TestInterpolate(t *testing.T) { "height": "180", } actual, err := interpolate("${name=Bobby Brown} is ${age} years old, ${height} cm tall, lives in ${city=}, and likes $${AUD}", vars, updatedVars) - require.NoError(t, err) - require.Equal(t, `Bobby Brown is 35 years old, 180 cm tall, lives in Melbourne, and likes ${AUD}`, actual) + assert.NoError(t, err) + assert.Equal(t, `Bobby Brown is 35 years old, 180 cm tall, lives in Melbourne, and likes ${AUD}`, actual) } func TestHasInterpolatedVar(t *testing.T) { for _, tag := range []string{"name", "age", "height", "city"} { - require.True(t, HasInterpolatedVar("${name=Bobby Brown} is ${age} years old, ${height} cm tall, lives in ${city=}, and likes $${AUD}", tag), tag) + assert.True(t, HasInterpolatedVar("${name=Bobby Brown} is ${age} years old, ${height} cm tall, lives in ${city=}, and likes $${AUD}", tag), tag) } for _, tag := range []string{"name", "age", "height", "AUD"} { - require.False(t, HasInterpolatedVar("$name $$age {height} $${AUD}", tag), tag) + assert.False(t, HasInterpolatedVar("$name $$age {height} $${AUD}", tag), tag) } } diff --git a/kong.go b/kong.go index 6f2af97..19e2b85 100644 --- a/kong.go +++ b/kong.go @@ -379,7 +379,7 @@ func (k *Kong) FatalIfErrorf(err error, args ...interface{}) { } msg := err.Error() if len(args) > 0 { - msg = fmt.Sprintf(args[0].(string), args[1:]...) + ": " + err.Error() + msg = fmt.Sprintf(args[0].(string), args[1:]...) + ": " + err.Error() // nolint } // Maybe display usage information. var parseErr *ParseError diff --git a/kong_test.go b/kong_test.go index 0e57f25..8dff864 100644 --- a/kong_test.go +++ b/kong_test.go @@ -7,8 +7,7 @@ import ( "strings" "testing" - "github.com/stretchr/testify/require" - + "github.com/alecthomas/assert/v2" "github.com/alecthomas/kong" "github.com/alecthomas/repr" ) @@ -23,7 +22,7 @@ func mustNew(t *testing.T, cli interface{}, options ...kong.Option) *kong.Kong { }), }, options...) parser, err := kong.New(cli, options...) - require.NoError(t, err) + assert.NoError(t, err) return parser } @@ -39,11 +38,11 @@ func TestPositionalArguments(t *testing.T) { } p := mustNew(t, &cli) ctx, err := p.Parse([]string{"user", "create", "10", "Alec", "Thomas"}) - require.NoError(t, err) - require.Equal(t, "user create ", ctx.Command()) + assert.NoError(t, err) + assert.Equal(t, "user create ", ctx.Command()) t.Run("Missing", func(t *testing.T) { _, err := p.Parse([]string{"user", "create", "10"}) - require.Error(t, err) + assert.Error(t, err) }) } @@ -75,12 +74,12 @@ func TestBranchingArgument(t *testing.T) { } p := mustNew(t, &cli) ctx, err := p.Parse([]string{"user", "10", "delete"}) - require.NoError(t, err) - require.Equal(t, 10, cli.User.ID.ID) - require.Equal(t, "user delete", ctx.Command()) + assert.NoError(t, err) + assert.Equal(t, 10, cli.User.ID.ID) + assert.Equal(t, "user delete", ctx.Command()) t.Run("Missing", func(t *testing.T) { _, err = p.Parse([]string{"user"}) - require.Error(t, err) + assert.Error(t, err) }) } @@ -93,9 +92,9 @@ func TestResetWithDefaults(t *testing.T) { cli.FlagWithDefault = "BLAH" parser := mustNew(t, &cli) _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "", cli.Flag) - require.Equal(t, "default", cli.FlagWithDefault) + assert.NoError(t, err) + assert.Equal(t, "", cli.Flag) + assert.Equal(t, "default", cli.FlagWithDefault) } func TestFlagSlice(t *testing.T) { @@ -104,8 +103,8 @@ func TestFlagSlice(t *testing.T) { } parser := mustNew(t, &cli) _, err := parser.Parse([]string{"--slice=1,2,3"}) - require.NoError(t, err) - require.Equal(t, []int{1, 2, 3}, cli.Slice) + assert.NoError(t, err) + assert.Equal(t, []int{1, 2, 3}, cli.Slice) } func TestFlagSliceWithSeparator(t *testing.T) { @@ -114,8 +113,8 @@ func TestFlagSliceWithSeparator(t *testing.T) { } parser := mustNew(t, &cli) _, err := parser.Parse([]string{`--slice=a\,b,c`}) - require.NoError(t, err) - require.Equal(t, []string{"a,b", "c"}, cli.Slice) + assert.NoError(t, err) + assert.Equal(t, []string{"a,b", "c"}, cli.Slice) } func TestArgSlice(t *testing.T) { @@ -125,9 +124,9 @@ func TestArgSlice(t *testing.T) { } parser := mustNew(t, &cli) _, err := parser.Parse([]string{"1", "2", "3", "--flag"}) - require.NoError(t, err) - require.Equal(t, []int{1, 2, 3}, cli.Slice) - require.Equal(t, true, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, []int{1, 2, 3}, cli.Slice) + assert.Equal(t, true, cli.Flag) } func TestArgSliceWithSeparator(t *testing.T) { @@ -137,9 +136,9 @@ func TestArgSliceWithSeparator(t *testing.T) { } parser := mustNew(t, &cli) _, err := parser.Parse([]string{"a,b", "c", "--flag"}) - require.NoError(t, err) - require.Equal(t, []string{"a,b", "c"}, cli.Slice) - require.Equal(t, true, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, []string{"a,b", "c"}, cli.Slice) + assert.Equal(t, true, cli.Flag) } func TestUnsupportedFieldErrors(t *testing.T) { @@ -147,7 +146,7 @@ func TestUnsupportedFieldErrors(t *testing.T) { Keys struct{} } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestMatchingArgField(t *testing.T) { @@ -158,7 +157,7 @@ func TestMatchingArgField(t *testing.T) { } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestCantMixPositionalAndBranches(t *testing.T) { @@ -168,7 +167,7 @@ func TestCantMixPositionalAndBranches(t *testing.T) { } `kong:"cmd"` } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestPropagatedFlags(t *testing.T) { @@ -182,9 +181,9 @@ func TestPropagatedFlags(t *testing.T) { parser := mustNew(t, &cli) _, err := parser.Parse([]string{"command-1", "command-2", "--flag-2", "--flag-1=moo"}) - require.NoError(t, err) - require.Equal(t, "moo", cli.Flag1) - require.Equal(t, true, cli.Command1.Flag2) + assert.NoError(t, err) + assert.Equal(t, "moo", cli.Flag1) + assert.Equal(t, true, cli.Command1.Flag2) } func TestRequiredFlag(t *testing.T) { @@ -194,7 +193,7 @@ func TestRequiredFlag(t *testing.T) { parser := mustNew(t, &cli) _, err := parser.Parse([]string{}) - require.Error(t, err) + assert.Error(t, err) } func TestOptionalArg(t *testing.T) { @@ -204,7 +203,7 @@ func TestOptionalArg(t *testing.T) { parser := mustNew(t, &cli) _, err := parser.Parse([]string{}) - require.NoError(t, err) + assert.NoError(t, err) } func TestOptionalArgWithDefault(t *testing.T) { @@ -214,8 +213,8 @@ func TestOptionalArgWithDefault(t *testing.T) { parser := mustNew(t, &cli) _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "moo", cli.Arg) + assert.NoError(t, err) + assert.Equal(t, "moo", cli.Arg) } func TestArgWithDefaultIsOptional(t *testing.T) { @@ -225,8 +224,8 @@ func TestArgWithDefaultIsOptional(t *testing.T) { parser := mustNew(t, &cli) _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "moo", cli.Arg) + assert.NoError(t, err) + assert.Equal(t, "moo", cli.Arg) } func TestRequiredArg(t *testing.T) { @@ -236,7 +235,7 @@ func TestRequiredArg(t *testing.T) { parser := mustNew(t, &cli) _, err := parser.Parse([]string{}) - require.Error(t, err) + assert.Error(t, err) } func TestInvalidRequiredAfterOptional(t *testing.T) { @@ -246,7 +245,7 @@ func TestInvalidRequiredAfterOptional(t *testing.T) { } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestOptionalStructArg(t *testing.T) { @@ -261,20 +260,20 @@ func TestOptionalStructArg(t *testing.T) { t.Run("WithFlag", func(t *testing.T) { _, err := parser.Parse([]string{"gak", "--enabled"}) - require.NoError(t, err) - require.Equal(t, "gak", cli.Name.Name) - require.Equal(t, true, cli.Name.Enabled) + assert.NoError(t, err) + assert.Equal(t, "gak", cli.Name.Name) + assert.Equal(t, true, cli.Name.Enabled) }) t.Run("WithoutFlag", func(t *testing.T) { _, err := parser.Parse([]string{"gak"}) - require.NoError(t, err) - require.Equal(t, "gak", cli.Name.Name) + assert.NoError(t, err) + assert.Equal(t, "gak", cli.Name.Name) }) t.Run("WithNothing", func(t *testing.T) { _, err := parser.Parse([]string{}) - require.NoError(t, err) + assert.NoError(t, err) }) } @@ -288,15 +287,15 @@ func TestMixedRequiredArgs(t *testing.T) { t.Run("SingleRequired", func(t *testing.T) { _, err := parser.Parse([]string{"gak", "5"}) - require.NoError(t, err) - require.Equal(t, "gak", cli.Name) - require.Equal(t, 5, cli.ID) + assert.NoError(t, err) + assert.Equal(t, "gak", cli.Name) + assert.Equal(t, 5, cli.ID) }) t.Run("ExtraOptional", func(t *testing.T) { _, err := parser.Parse([]string{"gak"}) - require.NoError(t, err) - require.Equal(t, "gak", cli.Name) + assert.NoError(t, err) + assert.Equal(t, "gak", cli.Name) }) } @@ -306,7 +305,7 @@ func TestInvalidDefaultErrors(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.Error(t, err) + assert.Error(t, err) } func TestCommandMissingTagIsInvalid(t *testing.T) { @@ -314,7 +313,7 @@ func TestCommandMissingTagIsInvalid(t *testing.T) { One struct{} } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestDuplicateFlag(t *testing.T) { @@ -325,7 +324,7 @@ func TestDuplicateFlag(t *testing.T) { } `kong:"cmd"` } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestDuplicateFlagOnPeerCommandIsOkay(t *testing.T) { @@ -338,7 +337,7 @@ func TestDuplicateFlagOnPeerCommandIsOkay(t *testing.T) { } `kong:"cmd"` } _, err := kong.New(&cli) - require.NoError(t, err) + assert.NoError(t, err) } func TestTraceErrorPartiallySucceeds(t *testing.T) { @@ -350,9 +349,9 @@ func TestTraceErrorPartiallySucceeds(t *testing.T) { } p := mustNew(t, &cli) ctx, err := kong.Trace(p, []string{"one", "bad"}) - require.NoError(t, err) - require.Error(t, ctx.Error) - require.Equal(t, "one", ctx.Command()) + assert.NoError(t, err) + assert.Error(t, ctx.Error) + assert.Equal(t, "one", ctx.Command()) } type commandWithNegatableFlag struct { @@ -406,13 +405,13 @@ func TestNegatableFlag(t *testing.T) { p := mustNew(t, &cli) kctx, err := p.Parse(tt.args) - require.NoError(t, err) - require.Equal(t, tt.expected, cli.Cmd.Flag) + assert.NoError(t, err) + assert.Equal(t, tt.expected, cli.Cmd.Flag) err = kctx.Run() - require.NoError(t, err) - require.Equal(t, tt.expected, cli.Cmd.Flag) - require.True(t, cli.Cmd.ran) + assert.NoError(t, err) + assert.Equal(t, tt.expected, cli.Cmd.Flag) + assert.True(t, cli.Cmd.ran) }) } } @@ -427,9 +426,9 @@ func TestExistingNoFlag(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"cmd", "--no-flag=none"}) - require.NoError(t, err) - require.Equal(t, true, cli.Cmd.Flag) - require.Equal(t, "none", cli.Cmd.NoFlag) + assert.NoError(t, err) + assert.Equal(t, true, cli.Cmd.Flag) + assert.Equal(t, "none", cli.Cmd.NoFlag) } func TestInvalidNegatedNonBool(t *testing.T) { @@ -440,7 +439,7 @@ func TestInvalidNegatedNonBool(t *testing.T) { } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } type hookContext struct { @@ -499,8 +498,8 @@ func TestHooks(t *testing.T) { cli.One = hookCmd{} t.Run(test.name, func(t *testing.T) { _, err := p.Parse(strings.Split(test.input, " ")) - require.NoError(t, err) - require.Equal(t, &test.values, ctx) + assert.NoError(t, err) + assert.Equal(t, &test.values, ctx) }) } } @@ -512,9 +511,9 @@ func TestShort(t *testing.T) { } app := mustNew(t, &cli) _, err := app.Parse([]string{"-b", "-shello"}) - require.NoError(t, err) - require.True(t, cli.Bool) - require.Equal(t, "hello", cli.String) + assert.NoError(t, err) + assert.True(t, cli.Bool) + assert.Equal(t, "hello", cli.String) } func TestDuplicateFlagChoosesLast(t *testing.T) { @@ -523,8 +522,8 @@ func TestDuplicateFlagChoosesLast(t *testing.T) { } _, err := mustNew(t, &cli).Parse([]string{"--flag=1", "--flag=2"}) - require.NoError(t, err) - require.Equal(t, 2, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, 2, cli.Flag) } func TestDuplicateSliceAccumulates(t *testing.T) { @@ -534,8 +533,8 @@ func TestDuplicateSliceAccumulates(t *testing.T) { args := []string{"--flag=1,2", "--flag=3,4"} _, err := mustNew(t, &cli).Parse(args) - require.NoError(t, err) - require.Equal(t, []int{1, 2, 3, 4}, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, []int{1, 2, 3, 4}, cli.Flag) } func TestMapFlag(t *testing.T) { @@ -543,8 +542,8 @@ func TestMapFlag(t *testing.T) { Set map[string]int } _, err := mustNew(t, &cli).Parse([]string{"--set", "a=10", "--set", "b=20"}) - require.NoError(t, err) - require.Equal(t, map[string]int{"a": 10, "b": 20}, cli.Set) + assert.NoError(t, err) + assert.Equal(t, map[string]int{"a": 10, "b": 20}, cli.Set) } func TestMapFlagWithSliceValue(t *testing.T) { @@ -552,8 +551,8 @@ func TestMapFlagWithSliceValue(t *testing.T) { Set map[string][]int } _, err := mustNew(t, &cli).Parse([]string{"--set", "a=1,2", "--set", "b=3"}) - require.NoError(t, err) - require.Equal(t, map[string][]int{"a": {1, 2}, "b": {3}}, cli.Set) + assert.NoError(t, err) + assert.Equal(t, map[string][]int{"a": {1, 2}, "b": {3}}, cli.Set) } type embeddedFlags struct { @@ -567,9 +566,9 @@ func TestEmbeddedStruct(t *testing.T) { } _, err := mustNew(t, &cli).Parse([]string{"--embedded=moo", "--not-embedded=foo"}) - require.NoError(t, err) - require.Equal(t, "moo", cli.Embedded) - require.Equal(t, "foo", cli.NotEmbedded) + assert.NoError(t, err) + assert.Equal(t, "moo", cli.Embedded) + assert.Equal(t, "foo", cli.NotEmbedded) } func TestSliceWithDisabledSeparator(t *testing.T) { @@ -577,8 +576,8 @@ func TestSliceWithDisabledSeparator(t *testing.T) { Flag []string `sep:"none"` } _, err := mustNew(t, &cli).Parse([]string{"--flag=a,b", "--flag=b,c"}) - require.NoError(t, err) - require.Equal(t, []string{"a,b", "b,c"}, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, []string{"a,b", "b,c"}, cli.Flag) } func TestMultilineMessage(t *testing.T) { @@ -586,7 +585,7 @@ func TestMultilineMessage(t *testing.T) { var cli struct{} p := mustNew(t, &cli, kong.Writers(w, w)) p.Printf("hello\nworld") - require.Equal(t, "test: hello\n world\n", w.String()) + assert.Equal(t, "test: hello\n world\n", w.String()) } type cmdWithRun struct { @@ -624,21 +623,21 @@ func TestRun(t *testing.T) { p := mustNew(t, cli) ctx, err := p.Parse([]string{"one", "two"}) - require.NoError(t, err) + assert.NoError(t, err) err = ctx.Run("hello") - require.NoError(t, err) - require.Equal(t, "twohello", cli.One.Arg) + assert.NoError(t, err) + assert.Equal(t, "twohello", cli.One.Arg) ctx, err = p.Parse([]string{"two", "three"}) - require.NoError(t, err) + assert.NoError(t, err) err = ctx.Run("ERROR") - require.Error(t, err) + assert.Error(t, err) ctx, err = p.Parse([]string{"three", "sub-command", "arg"}) - require.NoError(t, err) + assert.NoError(t, err) err = ctx.Run("ping") - require.NoError(t, err) - require.Equal(t, "argping", cli.Three.SubCommand.Arg) + assert.NoError(t, err) + assert.Equal(t, "argping", cli.Three.SubCommand.Arg) } func TestInterpolationIntoModel(t *testing.T) { @@ -648,25 +647,25 @@ func TestInterpolationIntoModel(t *testing.T) { EnvRef string `env:"${env}" help:"God ${env}"` } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) p, err := kong.New(&cli, kong.Vars{ "default": "Some default value.", "somebody": "chickens!", "enum": "a,b,c,d", "env": "SAVE_THE_QUEEN", }) - require.NoError(t, err) - require.Len(t, p.Model.Flags, 4) + assert.NoError(t, err) + assert.Equal(t, 4, len(p.Model.Flags)) flag := p.Model.Flags[1] flag2 := p.Model.Flags[2] flag3 := p.Model.Flags[3] - require.Equal(t, "Some default value.", flag.Default) - require.Equal(t, "Help, I need chickens!", flag.Help) - require.Equal(t, map[string]bool{"a": true, "b": true, "c": true, "d": true}, flag.EnumMap()) - require.Equal(t, []string{"a", "b", "c", "d"}, flag.EnumSlice()) - require.Equal(t, "One of a,b", flag2.Help) - require.Equal(t, "SAVE_THE_QUEEN", flag3.Env) - require.Equal(t, "God SAVE_THE_QUEEN", flag3.Help) + assert.Equal(t, "Some default value.", flag.Default) + assert.Equal(t, "Help, I need chickens!", flag.Help) + assert.Equal(t, map[string]bool{"a": true, "b": true, "c": true, "d": true}, flag.EnumMap()) + assert.Equal(t, []string{"a", "b", "c", "d"}, flag.EnumSlice()) + assert.Equal(t, "One of a,b", flag2.Help) + assert.Equal(t, "SAVE_THE_QUEEN", flag3.Env) + assert.Equal(t, "God SAVE_THE_QUEEN", flag3.Help) } func TestIssue244(t *testing.T) { @@ -676,8 +675,8 @@ func TestIssue244(t *testing.T) { w := &strings.Builder{} k := mustNew(t, &Config{}, kong.Exit(func(int) {}), kong.Writers(w, w)) _, err := k.Parse([]string{"--help"}) - require.NoError(t, err) - require.Contains(t, w.String(), `Environment variable: CI_PROJECT_ID`) + assert.NoError(t, err) + assert.Contains(t, w.String(), `Environment variable: CI_PROJECT_ID`) } func TestErrorMissingArgs(t *testing.T) { @@ -688,8 +687,8 @@ func TestErrorMissingArgs(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse(nil) - require.Error(t, err) - require.Equal(t, "expected \" \"", err.Error()) + assert.Error(t, err) + assert.Equal(t, "expected \" \"", err.Error()) } func TestBoolOverride(t *testing.T) { @@ -698,9 +697,9 @@ func TestBoolOverride(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--flag=false"}) - require.NoError(t, err) + assert.NoError(t, err) _, err = p.Parse([]string{"--flag", "false"}) - require.Error(t, err) + assert.Error(t, err) } func TestAnonymousPrefix(t *testing.T) { @@ -712,8 +711,8 @@ func TestAnonymousPrefix(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--anon-flag=moo"}) - require.NoError(t, err) - require.Equal(t, "moo", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "moo", cli.Flag) } type TestInterface interface { @@ -734,9 +733,9 @@ func TestEmbedInterface(t *testing.T) { cli := &CLI{TestInterface: &TestImpl{}} p := mustNew(t, cli) _, err := p.Parse([]string{"--some-flag=foo", "--flag=yes"}) - require.NoError(t, err) - require.Equal(t, "foo", cli.SomeFlag) - require.Equal(t, "yes", cli.TestInterface.(*TestImpl).Flag) + assert.NoError(t, err) + assert.Equal(t, "foo", cli.SomeFlag) + assert.Equal(t, "yes", cli.TestInterface.(*TestImpl).Flag) // nolint } func TestExcludedField(t *testing.T) { @@ -747,9 +746,9 @@ func TestExcludedField(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"--flag=foo"}) - require.NoError(t, err) + assert.NoError(t, err) _, err = p.Parse([]string{"--excluded=foo"}) - require.Error(t, err) + assert.Error(t, err) } func TestUnnamedFieldEmbeds(t *testing.T) { @@ -763,9 +762,9 @@ func TestUnnamedFieldEmbeds(t *testing.T) { buf := &strings.Builder{} p := mustNew(t, &cli, kong.Writers(buf, buf), kong.Exit(func(int) {})) _, err := p.Parse([]string{"--help"}) - require.NoError(t, err) - require.Contains(t, buf.String(), `--one-flag=STRING`) - require.Contains(t, buf.String(), `--two-flag=STRING`) + assert.NoError(t, err) + assert.Contains(t, buf.String(), `--one-flag=STRING`) + assert.Contains(t, buf.String(), `--two-flag=STRING`) } func TestHooksCalledForDefault(t *testing.T) { @@ -775,9 +774,9 @@ func TestHooksCalledForDefault(t *testing.T) { ctx := &hookContext{} _, err := mustNew(t, &cli, kong.Bind(ctx)).Parse(nil) - require.NoError(t, err) - require.Equal(t, "default", string(cli.Flag)) - require.Equal(t, []string{"before:default", "after:default"}, ctx.values) + assert.NoError(t, err) + assert.Equal(t, "default", string(cli.Flag)) + assert.Equal(t, []string{"before:default", "after:default"}, ctx.values) } func TestEnum(t *testing.T) { @@ -785,7 +784,7 @@ func TestEnum(t *testing.T) { Flag string `enum:"a,b,c" required:""` } _, err := mustNew(t, &cli).Parse([]string{"--flag", "d"}) - require.EqualError(t, err, "--flag must be one of \"a\",\"b\",\"c\" but got \"d\"") + assert.EqualError(t, err, "--flag must be one of \"a\",\"b\",\"c\" but got \"d\"") } func TestEnumMeaningfulOrder(t *testing.T) { @@ -793,7 +792,7 @@ func TestEnumMeaningfulOrder(t *testing.T) { Flag string `enum:"first,second,third,fourth,fifth" required:""` } _, err := mustNew(t, &cli).Parse([]string{"--flag", "sixth"}) - require.EqualError(t, err, "--flag must be one of \"first\",\"second\",\"third\",\"fourth\",\"fifth\" but got \"sixth\"") + assert.EqualError(t, err, "--flag must be one of \"first\",\"second\",\"third\",\"fourth\",\"fifth\" but got \"sixth\"") } type commandWithHook struct { @@ -818,8 +817,8 @@ func (c *cliWithHook) AfterApply(ctx *kong.Context) error { func TestParentBindings(t *testing.T) { cli := &cliWithHook{} _, err := mustNew(t, cli).Parse([]string{"command", "--flag=foo"}) - require.NoError(t, err) - require.Equal(t, "foo", cli.Command.value) + assert.NoError(t, err) + assert.Equal(t, "foo", cli.Command.value) } func TestNumericParamErrors(t *testing.T) { @@ -828,7 +827,7 @@ func TestNumericParamErrors(t *testing.T) { } parser := mustNew(t, &cli) _, err := parser.Parse([]string{"--name", "-10"}) - require.EqualError(t, err, `--name: expected string value but got "-10" (short flag); perhaps try --name="-10"?`) + assert.EqualError(t, err, `--name: expected string value but got "-10" (short flag); perhaps try --name="-10"?`) } func TestDefaultValueIsHyphen(t *testing.T) { @@ -837,8 +836,8 @@ func TestDefaultValueIsHyphen(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, "-", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "-", cli.Flag) } func TestDefaultEnumValidated(t *testing.T) { @@ -847,7 +846,7 @@ func TestDefaultEnumValidated(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.EqualError(t, err, "--flag must be one of \"valid\" but got \"invalid\"") + assert.EqualError(t, err, "--flag must be one of \"valid\" but got \"invalid\"") } func TestEnvarEnumValidated(t *testing.T) { @@ -860,7 +859,7 @@ func TestEnvarEnumValidated(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.EqualError(t, err, "--flag must be one of \"valid\" but got \"invalid\"") + assert.EqualError(t, err, "--flag must be one of \"valid\" but got \"invalid\"") } func TestXor(t *testing.T) { @@ -871,11 +870,11 @@ func TestXor(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--hello", "--one", "--two=hi"}) - require.EqualError(t, err, "--one and --two can't be used together") + assert.EqualError(t, err, "--one and --two can't be used together") p = mustNew(t, &cli) _, err = p.Parse([]string{"--one", "--hello"}) - require.NoError(t, err) + assert.NoError(t, err) } func TestXorChild(t *testing.T) { @@ -888,11 +887,11 @@ func TestXorChild(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--one", "cmd", "--two=hi"}) - require.NoError(t, err) + assert.NoError(t, err) p = mustNew(t, &cli) _, err = p.Parse([]string{"--two=hi", "cmd", "--three"}) - require.Error(t, err, "--two and --three can't be used together") + assert.Error(t, err, "--two and --three can't be used together") } func TestMultiXor(t *testing.T) { @@ -904,11 +903,11 @@ func TestMultiXor(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"--hello", "--one"}) - require.EqualError(t, err, "--hello and --one can't be used together") + assert.EqualError(t, err, "--hello and --one can't be used together") p = mustNew(t, &cli) _, err = p.Parse([]string{"--hello", "--two=foo"}) - require.EqualError(t, err, "--hello and --two can't be used together") + assert.EqualError(t, err, "--hello and --two can't be used together") } func TestXorRequired(t *testing.T) { @@ -920,15 +919,15 @@ func TestXorRequired(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--one"}) - require.EqualError(t, err, "missing flags: --four") + assert.EqualError(t, err, "missing flags: --four") p = mustNew(t, &cli) _, err = p.Parse([]string{"--two"}) - require.EqualError(t, err, "missing flags: --four, --one or --three") + assert.EqualError(t, err, "missing flags: --four, --one or --three") p = mustNew(t, &cli) _, err = p.Parse([]string{}) - require.EqualError(t, err, "missing flags: --four, --one or --three, --one or --two") + assert.EqualError(t, err, "missing flags: --four, --one or --three, --one or --two") } func TestXorRequiredMany(t *testing.T) { @@ -939,15 +938,15 @@ func TestXorRequiredMany(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--one"}) - require.NoError(t, err) + assert.NoError(t, err) p = mustNew(t, &cli) _, err = p.Parse([]string{"--three"}) - require.NoError(t, err) + assert.NoError(t, err) p = mustNew(t, &cli) _, err = p.Parse([]string{}) - require.EqualError(t, err, "missing flags: --one or --two or --three") + assert.EqualError(t, err, "missing flags: --one or --two or --three") } func TestEnumSequence(t *testing.T) { @@ -956,8 +955,8 @@ func TestEnumSequence(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, []string{"a"}, cli.State) + assert.NoError(t, err) + assert.Equal(t, []string{"a"}, cli.State) } func TestIssue40EnumAcrossCommands(t *testing.T) { @@ -975,13 +974,13 @@ func TestIssue40EnumAcrossCommands(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"one", "two"}) - require.NoError(t, err) + assert.NoError(t, err) _, err = p.Parse([]string{"two", "d"}) - require.Error(t, err) + assert.Error(t, err) _, err = p.Parse([]string{"three", "d"}) - require.Error(t, err) + assert.Error(t, err) _, err = p.Parse([]string{"three", "c"}) - require.NoError(t, err) + assert.NoError(t, err) } func TestIssue179(t *testing.T) { @@ -998,7 +997,7 @@ func TestIssue179(t *testing.T) { p := mustNew(t, &root) _, err := p.Parse([]string{"b"}) - require.NoError(t, err) + assert.NoError(t, err) } func TestIssue153(t *testing.T) { @@ -1017,8 +1016,8 @@ func TestIssue153(t *testing.T) { }) defer revert() _, err := p.Parse([]string{"ls"}) - require.NoError(t, err) - require.Equal(t, []string{"hello"}, cli.Ls.Paths) + assert.NoError(t, err) + assert.Equal(t, []string{"hello"}, cli.Ls.Paths) } func TestEnumArg(t *testing.T) { @@ -1030,9 +1029,9 @@ func TestEnumArg(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"nested", "a", "b"}) - require.NoError(t, err) - require.Equal(t, "a", cli.Nested.One) - require.Equal(t, "b", cli.Nested.Two) + assert.NoError(t, err) + assert.Equal(t, "a", cli.Nested.One) + assert.Equal(t, "b", cli.Nested.Two) } func TestDefaultCommand(t *testing.T) { @@ -1042,8 +1041,8 @@ func TestDefaultCommand(t *testing.T) { } p := mustNew(t, &cli) ctx, err := p.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "one", ctx.Command()) + assert.NoError(t, err) + assert.Equal(t, "one", ctx.Command()) } func TestMultipleDefaultCommands(t *testing.T) { @@ -1052,7 +1051,7 @@ func TestMultipleDefaultCommands(t *testing.T) { Two struct{} `cmd:"" default:"1"` } _, err := kong.New(&cli) - require.EqualError(t, err, ".Two: can't have more than one default command under ") + assert.EqualError(t, err, ".Two: can't have more than one default command under ") } func TestDefaultCommandWithSubCommand(t *testing.T) { @@ -1062,7 +1061,7 @@ func TestDefaultCommandWithSubCommand(t *testing.T) { } `cmd:"" default:"1"` } _, err := kong.New(&cli) - require.EqualError(t, err, ".One: default command one must not have subcommands or arguments") + assert.EqualError(t, err, ".One: default command one must not have subcommands or arguments") } func TestDefaultCommandWithAllowedSubCommand(t *testing.T) { @@ -1073,8 +1072,8 @@ func TestDefaultCommandWithAllowedSubCommand(t *testing.T) { } p := mustNew(t, &cli) ctx, err := p.Parse([]string{"two"}) - require.NoError(t, err) - require.Equal(t, "one two", ctx.Command()) + assert.NoError(t, err) + assert.Equal(t, "one two", ctx.Command()) } func TestDefaultCommandWithArgument(t *testing.T) { @@ -1084,7 +1083,7 @@ func TestDefaultCommandWithArgument(t *testing.T) { } `cmd:"" default:"1"` } _, err := kong.New(&cli) - require.EqualError(t, err, ".One: default command one must not have subcommands or arguments") + assert.EqualError(t, err, ".One: default command one must not have subcommands or arguments") } func TestDefaultCommandWithAllowedArgument(t *testing.T) { @@ -1096,9 +1095,9 @@ func TestDefaultCommandWithAllowedArgument(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"arg", "--flag=value"}) - require.NoError(t, err) - require.Equal(t, "arg", cli.One.Arg) - require.Equal(t, "value", cli.One.Flag) + assert.NoError(t, err) + assert.Equal(t, "arg", cli.One.Arg) + assert.Equal(t, "value", cli.One.Flag) } func TestDefaultCommandWithBranchingArgument(t *testing.T) { @@ -1110,7 +1109,7 @@ func TestDefaultCommandWithBranchingArgument(t *testing.T) { } `cmd:"" default:"1"` } _, err := kong.New(&cli) - require.EqualError(t, err, ".One: default command one must not have subcommands or arguments") + assert.EqualError(t, err, ".One: default command one must not have subcommands or arguments") } func TestDefaultCommandWithAllowedBranchingArgument(t *testing.T) { @@ -1124,9 +1123,9 @@ func TestDefaultCommandWithAllowedBranchingArgument(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"arg", "--flag=value"}) - require.NoError(t, err) - require.Equal(t, "arg", cli.One.Two.Two) - require.Equal(t, "value", cli.One.Two.Flag) + assert.NoError(t, err) + assert.Equal(t, "arg", cli.One.Two.Two) + assert.Equal(t, "value", cli.One.Two.Flag) } func TestDefaultCommandPrecedence(t *testing.T) { @@ -1141,22 +1140,22 @@ func TestDefaultCommandPrecedence(t *testing.T) { // A named command should take precedence over a default command with arg ctx, err := p.Parse([]string{"one"}) - require.NoError(t, err) - require.Equal(t, "one", ctx.Command()) + assert.NoError(t, err) + assert.Equal(t, "one", ctx.Command()) // An explicitly named command with arg should parse, even if labeled default:"witharg" ctx, err = p.Parse([]string{"two", "arg"}) - require.NoError(t, err) - require.Equal(t, "two ", ctx.Command()) + assert.NoError(t, err) + assert.Equal(t, "two ", ctx.Command()) // An arg to a default command that does not match another command should select the default ctx, err = p.Parse([]string{"arg"}) - require.NoError(t, err) - require.Equal(t, "two ", ctx.Command()) + assert.NoError(t, err) + assert.Equal(t, "two ", ctx.Command()) // A flag on a default command should not be valid on a sibling command _, err = p.Parse([]string{"one", "--flag"}) - require.EqualError(t, err, "unknown flag --flag") + assert.EqualError(t, err, "unknown flag --flag") } func TestLoneHpyhen(t *testing.T) { @@ -1167,12 +1166,12 @@ func TestLoneHpyhen(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"-"}) - require.NoError(t, err) - require.Equal(t, "-", cli.Arg) + assert.NoError(t, err) + assert.Equal(t, "-", cli.Arg) _, err = p.Parse([]string{"--flag", "-"}) - require.NoError(t, err) - require.Equal(t, "-", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "-", cli.Flag) } func TestPlugins(t *testing.T) { @@ -1190,10 +1189,10 @@ func TestPlugins(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"--base=base", "--one=one", "--two=two"}) - require.NoError(t, err) - require.Equal(t, "base", cli.Base) - require.Equal(t, "one", pluginOne.One) - require.Equal(t, "two", pluginTwo.Two) + assert.NoError(t, err) + assert.Equal(t, "base", cli.Base) + assert.Equal(t, "one", pluginOne.One) + assert.Equal(t, "two", pluginTwo.Two) } type validateCmd struct{} @@ -1214,7 +1213,7 @@ func TestValidateApp(t *testing.T) { cli := validateCli{} p := mustNew(t, &cli) _, err := p.Parse([]string{}) - require.EqualError(t, err, "test: app error") + assert.EqualError(t, err, "test: app error") } func TestValidateCmd(t *testing.T) { @@ -1223,7 +1222,7 @@ func TestValidateCmd(t *testing.T) { }{} p := mustNew(t, &cli) _, err := p.Parse([]string{"cmd"}) - require.EqualError(t, err, "cmd: cmd error") + assert.EqualError(t, err, "cmd: cmd error") } func TestValidateFlag(t *testing.T) { @@ -1232,7 +1231,7 @@ func TestValidateFlag(t *testing.T) { }{} p := mustNew(t, &cli) _, err := p.Parse([]string{"--flag=one"}) - require.EqualError(t, err, "--flag: flag error") + assert.EqualError(t, err, "--flag: flag error") } func TestValidateArg(t *testing.T) { @@ -1241,7 +1240,7 @@ func TestValidateArg(t *testing.T) { }{} p := mustNew(t, &cli) _, err := p.Parse([]string{"one"}) - require.EqualError(t, err, ": flag error") + assert.EqualError(t, err, ": flag error") } func TestPointers(t *testing.T) { @@ -1251,11 +1250,11 @@ func TestPointers(t *testing.T) { }{} p := mustNew(t, &cli) _, err := p.Parse([]string{"--mapped=mapped", "--json=\"foo\""}) - require.NoError(t, err) - require.NotNil(t, cli.Mapped) - require.Equal(t, "mapped", cli.Mapped.decoded) - require.NotNil(t, cli.JSON) - require.Equal(t, "FOO", string(*cli.JSON)) + assert.NoError(t, err) + assert.NotZero(t, cli.Mapped) + assert.Equal(t, "mapped", cli.Mapped.decoded) + assert.NotZero(t, cli.JSON) + assert.Equal(t, "FOO", string(*cli.JSON)) } type dynamicCommand struct { @@ -1282,16 +1281,16 @@ func TestDynamicCommands(t *testing.T) { kong.Writers(help, help), kong.Exit(func(int) {})) kctx, err := p.Parse([]string{"two", "--flag=flag"}) - require.NoError(t, err) - require.Equal(t, "flag", two.Flag) - require.False(t, two.ran) + assert.NoError(t, err) + assert.Equal(t, "flag", two.Flag) + assert.False(t, two.ran) err = kctx.Run() - require.NoError(t, err) - require.True(t, two.ran) + assert.NoError(t, err) + assert.True(t, two.ran) _, err = p.Parse([]string{"--help"}) - require.EqualError(t, err, `expected one of "one", "two"`) - require.NotContains(t, help.String(), "three", help.String()) + assert.EqualError(t, err, `expected one of "one", "two"`) + assert.NotContains(t, help.String(), "three", help.String()) } func TestDuplicateShortflags(t *testing.T) { @@ -1300,7 +1299,7 @@ func TestDuplicateShortflags(t *testing.T) { Flag2 bool `short:"t"` }{} _, err := kong.New(&cli) - require.EqualError(t, err, ".Flag2: duplicate short flag -t") + assert.EqualError(t, err, ".Flag2: duplicate short flag -t") } func TestDuplicateNestedShortFlags(t *testing.T) { @@ -1311,7 +1310,7 @@ func TestDuplicateNestedShortFlags(t *testing.T) { } `cmd:""` }{} _, err := kong.New(&cli) - require.EqualError(t, err, ".Flag2: duplicate short flag -t") + assert.EqualError(t, err, ".Flag2: duplicate short flag -t") } func TestHydratePointerCommandsAndEmbeds(t *testing.T) { @@ -1330,9 +1329,9 @@ func TestHydratePointerCommandsAndEmbeds(t *testing.T) { k := mustNew(t, &cli) _, err := k.Parse([]string{"--embed", "cmd", "--flag"}) - require.NoError(t, err) - require.Equal(t, &cmd{Flag: true}, cli.Cmd) - require.Equal(t, &embed{Embed: true}, cli.Embed) + assert.NoError(t, err) + assert.Equal(t, &cmd{Flag: true}, cli.Cmd) + assert.Equal(t, &embed{Embed: true}, cli.Embed) } // nolint @@ -1353,21 +1352,21 @@ func TestIgnoreRegex(t *testing.T) { cli := testIgnoreFields{} k, err := kong.New(&cli, kong.IgnoreFields(`.*\.XXX_.+`)) - require.NoError(t, err) + assert.NoError(t, err) _, err = k.Parse([]string{"foo", "sub"}) - require.NoError(t, err) + assert.NoError(t, err) _, err = k.Parse([]string{"foo", "sub", "--subflag1"}) - require.NoError(t, err) + assert.NoError(t, err) _, err = k.Parse([]string{"foo", "sub", "--subflag2"}) - require.Error(t, err) - require.Contains(t, err.Error(), "unknown flag --subflag2") + assert.Error(t, err) + assert.Contains(t, err.Error(), "unknown flag --subflag2") _, err = k.Parse([]string{"baz"}) - require.Error(t, err) - require.Contains(t, err.Error(), "unexpected argument baz") + assert.Error(t, err) + assert.Contains(t, err.Error(), "unexpected argument baz") } // Verify that passing a nil regex will work @@ -1375,8 +1374,8 @@ func TestIgnoreRegexEmpty(t *testing.T) { cli := testIgnoreFields{} _, err := kong.New(&cli, kong.IgnoreFields("")) - require.Error(t, err) - require.Contains(t, "regex input cannot be empty", err.Error()) + assert.Error(t, err) + assert.Contains(t, "regex input cannot be empty", err.Error()) } type optionWithErr struct{} @@ -1393,8 +1392,8 @@ func TestOptionReturnsErr(t *testing.T) { optWithError := &optionWithErr{} _, err := kong.New(cli, optWithError) - require.Error(t, err) - require.Equal(t, "option returned err", err.Error()) + assert.Error(t, err) + assert.Equal(t, "option returned err", err.Error()) } func TestEnumValidation(t *testing.T) { @@ -1458,9 +1457,9 @@ func TestEnumValidation(t *testing.T) { t.Run(test.name, func(t *testing.T) { _, err := kong.New(test.cli) if test.fail { - require.Error(t, err, repr.String(test.cli)) + assert.Error(t, err, repr.String(test.cli)) } else { - require.NoError(t, err, repr.String(test.cli)) + assert.NoError(t, err, repr.String(test.cli)) } }) } @@ -1515,9 +1514,9 @@ func TestPassthroughCmd(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(test.args) - require.NoError(t, err) - require.Equal(t, test.flag, cli.Flag) - require.Equal(t, test.cmdArgs, cli.Command.Args) + assert.NoError(t, err) + assert.Equal(t, test.flag, cli.Flag) + assert.Equal(t, test.cmdArgs, cli.Command.Args) }) } } @@ -1530,7 +1529,7 @@ func TestPassthroughCmdOnlyArgs(t *testing.T) { } `cmd:"" passthrough:""` } _, err := kong.New(&cli) - require.EqualError(t, err, ".Command: passthrough command command [ ...] must not have subcommands or flags") + assert.EqualError(t, err, ".Command: passthrough command command [ ...] must not have subcommands or flags") } func TestPassthroughCmdOnlyStringArgs(t *testing.T) { @@ -1540,7 +1539,7 @@ func TestPassthroughCmdOnlyStringArgs(t *testing.T) { } `cmd:"" passthrough:""` } _, err := kong.New(&cli) - require.EqualError(t, err, ".Command: passthrough command command [ ...] must contain exactly one positional argument of []string type") + assert.EqualError(t, err, ".Command: passthrough command command [ ...] must contain exactly one positional argument of []string type") } func TestHelpShouldStillWork(t *testing.T) { @@ -1557,11 +1556,11 @@ func TestHelpShouldStillWork(t *testing.T) { _, err := k.Parse([]string{"--help"}) t.Log(w.String()) // checking return code validates the help hook was called - require.Zero(t, rc) + assert.Zero(t, rc) // allow for error propagation from other validation (only for the // sake of this test, due to the exit function not actually exiting the // program; errors will not propagate in the real world). - require.Error(t, err) + assert.Error(t, err) } func TestSliceDecoderHelpfulErrorMsg(t *testing.T) { @@ -1609,7 +1608,7 @@ func TestSliceDecoderHelpfulErrorMsg(t *testing.T) { t.Run(test.name, func(t *testing.T) { p := mustNew(t, test.cli) _, err := p.Parse(test.args) - require.EqualError(t, err, test.err) + assert.EqualError(t, err, test.err) }) } } @@ -1659,7 +1658,7 @@ func TestMapDecoderHelpfulErrorMsg(t *testing.T) { t.Run(test.name, func(t *testing.T) { p := mustNew(t, test.cli) _, err := p.Parse(test.args) - require.EqualError(t, err, test.expected) + assert.EqualError(t, err, test.expected) }) } } diff --git a/mapper.go b/mapper.go index 231ce09..e93d2d4 100644 --- a/mapper.go +++ b/mapper.go @@ -53,9 +53,9 @@ type mapperValueAdapter struct { func (m *mapperValueAdapter) Decode(ctx *DecodeContext, target reflect.Value) error { if target.Type().Implements(mapperValueType) { - return target.Interface().(MapperValue).Decode(ctx) + return target.Interface().(MapperValue).Decode(ctx) // nolint } - return target.Addr().Interface().(MapperValue).Decode(ctx) + return target.Addr().Interface().(MapperValue).Decode(ctx) // nolint } func (m *mapperValueAdapter) IsBool() bool { @@ -71,9 +71,9 @@ func (m *textUnmarshalerAdapter) Decode(ctx *DecodeContext, target reflect.Value return err } if target.Type().Implements(textUnmarshalerType) { - return target.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value)) + return target.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value)) // nolint } - return target.Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value)) + return target.Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value)) // nolint } type binaryUnmarshalerAdapter struct{} @@ -85,9 +85,9 @@ func (m *binaryUnmarshalerAdapter) Decode(ctx *DecodeContext, target reflect.Val return err } if target.Type().Implements(binaryUnmarshalerType) { - return target.Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value)) + return target.Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value)) // nolint } - return target.Addr().Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value)) + return target.Addr().Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value)) // nolint } type jsonUnmarshalerAdapter struct{} @@ -99,9 +99,9 @@ func (j *jsonUnmarshalerAdapter) Decode(ctx *DecodeContext, target reflect.Value return err } if target.Type().Implements(jsonUnmarshalerType) { - return target.Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value)) + return target.Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value)) // nolint } - return target.Addr().Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value)) + return target.Addr().Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value)) // nolint } // A Mapper represents how a field is mapped from command-line values to Go. diff --git a/mapper_linux_test.go b/mapper_linux_test.go index 6cbd158..2b1d614 100644 --- a/mapper_linux_test.go +++ b/mapper_linux_test.go @@ -6,7 +6,7 @@ package kong_test import ( "testing" - "github.com/stretchr/testify/require" + require "github.com/alecthomas/assert/v2" ) func TestPathMapper(t *testing.T) { @@ -16,10 +16,10 @@ func TestPathMapper(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"/an/absolute/path"}) - require.NoError(t, err) - require.Equal(t, "/an/absolute/path", cli.Path) + assert.NoError(t, err) + assert.Equal(t, "/an/absolute/path", cli.Path) _, err = p.Parse([]string{"-"}) - require.NoError(t, err) - require.Equal(t, "-", cli.Path) + assert.NoError(t, err) + assert.Equal(t, "-", cli.Path) } diff --git a/mapper_test.go b/mapper_test.go index 43818ec..ae4c3f1 100644 --- a/mapper_test.go +++ b/mapper_test.go @@ -14,8 +14,7 @@ import ( "testing" "time" - "github.com/stretchr/testify/require" - + "github.com/alecthomas/assert/v2" "github.com/alecthomas/kong" ) @@ -25,11 +24,11 @@ func TestValueMapper(t *testing.T) { } k := mustNew(t, &cli, kong.ValueMapper(&cli.Flag, testMooMapper{})) _, err := k.Parse(nil) - require.NoError(t, err) - require.Equal(t, "", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "", cli.Flag) _, err = k.Parse([]string{"--flag"}) - require.NoError(t, err) - require.Equal(t, "MOO", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "MOO", cli.Flag) } type textUnmarshalerValue int @@ -50,10 +49,10 @@ func TestTextUnmarshaler(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--value=hello"}) - require.NoError(t, err) - require.Equal(t, 10, int(cli.Value)) + assert.NoError(t, err) + assert.Equal(t, 10, int(cli.Value)) _, err = p.Parse([]string{"--value=other"}) - require.Error(t, err) + assert.Error(t, err) } type jsonUnmarshalerValue string @@ -74,8 +73,8 @@ func TestJSONUnmarshaler(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--value=\"hello\""}) - require.NoError(t, err) - require.Equal(t, "HELLO", string(cli.Value)) + assert.NoError(t, err) + assert.Equal(t, "HELLO", string(cli.Value)) } func TestNamedMapper(t *testing.T) { @@ -84,11 +83,11 @@ func TestNamedMapper(t *testing.T) { } k := mustNew(t, &cli, kong.NamedMapper("moo", testMooMapper{})) _, err := k.Parse(nil) - require.NoError(t, err) - require.Equal(t, "", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "", cli.Flag) _, err = k.Parse([]string{"--flag"}) - require.NoError(t, err) - require.Equal(t, "MOO", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "MOO", cli.Flag) } type testMooMapper struct { @@ -111,11 +110,11 @@ func TestTimeMapper(t *testing.T) { } k := mustNew(t, &cli) _, err := k.Parse([]string{"--flag=2008"}) - require.NoError(t, err) + assert.NoError(t, err) expected, err := time.Parse("2006", "2008") - require.NoError(t, err) - require.Equal(t, 2008, expected.Year()) - require.Equal(t, expected, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, 2008, expected.Year()) + assert.Equal(t, expected, cli.Flag) } func TestDurationMapper(t *testing.T) { @@ -124,8 +123,8 @@ func TestDurationMapper(t *testing.T) { } k := mustNew(t, &cli) _, err := k.Parse([]string{"--flag=5s"}) - require.NoError(t, err) - require.Equal(t, time.Second*5, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, time.Second*5, cli.Flag) } func TestDurationMapperJSONResolver(t *testing.T) { @@ -133,23 +132,23 @@ func TestDurationMapperJSONResolver(t *testing.T) { Flag time.Duration } resolver, err := kong.JSON(strings.NewReader(`{"flag": 5000000000}`)) - require.NoError(t, err) + assert.NoError(t, err) k := mustNew(t, &cli, kong.Resolvers(resolver)) _, err = k.Parse(nil) - require.NoError(t, err) - require.Equal(t, time.Second*5, cli.Flag) + assert.NoError(t, err) + assert.Equal(t, time.Second*5, cli.Flag) } func TestSplitEscaped(t *testing.T) { - require.Equal(t, []string{"a", "b"}, kong.SplitEscaped("a,b", ',')) - require.Equal(t, []string{"a,b", "c"}, kong.SplitEscaped(`a\,b,c`, ',')) - require.Equal(t, []string{"a,b,c"}, kong.SplitEscaped(`a,b,c`, -1)) + assert.Equal(t, []string{"a", "b"}, kong.SplitEscaped("a,b", ',')) + assert.Equal(t, []string{"a,b", "c"}, kong.SplitEscaped(`a\,b,c`, ',')) + assert.Equal(t, []string{"a,b,c"}, kong.SplitEscaped(`a,b,c`, -1)) } func TestJoinEscaped(t *testing.T) { - require.Equal(t, `a,b`, kong.JoinEscaped([]string{"a", "b"}, ',')) - require.Equal(t, `a\,b,c`, kong.JoinEscaped([]string{`a,b`, `c`}, ',')) - require.Equal(t, kong.JoinEscaped(kong.SplitEscaped(`a\,b,c`, ','), ','), `a\,b,c`) + assert.Equal(t, `a,b`, kong.JoinEscaped([]string{"a", "b"}, ',')) + assert.Equal(t, `a\,b,c`, kong.JoinEscaped([]string{`a,b`, `c`}, ',')) + assert.Equal(t, kong.JoinEscaped(kong.SplitEscaped(`a\,b,c`, ','), ','), `a\,b,c`) } func TestMapWithNamedTypes(t *testing.T) { @@ -159,11 +158,11 @@ func TestMapWithNamedTypes(t *testing.T) { } k := mustNew(t, &cli, kong.NamedMapper("moo", testMooMapper{}), kong.NamedMapper("upper", testUppercaseMapper{})) _, err := k.Parse([]string{"--typed-value", "first=5s", "--typed-value", "second=10s"}) - require.NoError(t, err) - require.Equal(t, map[string]string{"first": "MOO", "second": "MOO"}, cli.TypedValue) + assert.NoError(t, err) + assert.Equal(t, map[string]string{"first": "MOO", "second": "MOO"}, cli.TypedValue) _, err = k.Parse([]string{"--typed-key", "first=5s", "--typed-key", "second=10s"}) - require.NoError(t, err) - require.Equal(t, map[string]string{"FIRST": "5s", "SECOND": "10s"}, cli.TypedKey) + assert.NoError(t, err) + assert.Equal(t, map[string]string{"FIRST": "5s", "SECOND": "10s"}, cli.TypedKey) } func TestMapWithMultipleValues(t *testing.T) { @@ -172,8 +171,8 @@ func TestMapWithMultipleValues(t *testing.T) { } k := mustNew(t, &cli) _, err := k.Parse([]string{"--value=a=b;c=d"}) - require.NoError(t, err) - require.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value) + assert.NoError(t, err) + assert.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value) } func TestMapWithDifferentSeparator(t *testing.T) { @@ -182,8 +181,8 @@ func TestMapWithDifferentSeparator(t *testing.T) { } k := mustNew(t, &cli) _, err := k.Parse([]string{"--value=a=b,c=d"}) - require.NoError(t, err) - require.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value) + assert.NoError(t, err) + assert.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value) } func TestMapWithNoSeparator(t *testing.T) { @@ -193,9 +192,9 @@ func TestMapWithNoSeparator(t *testing.T) { } k := mustNew(t, &cli) _, err := k.Parse([]string{"--slice=a,n,c", "--value=a=b;n=d"}) - require.NoError(t, err) - require.Equal(t, []string{"a,n,c"}, cli.Slice) - require.Equal(t, map[string]string{"a": "b;n=d"}, cli.Value) + assert.NoError(t, err) + assert.Equal(t, []string{"a,n,c"}, cli.Slice) + assert.Equal(t, map[string]string{"a": "b;n=d"}, cli.Value) } func TestURLMapper(t *testing.T) { @@ -204,10 +203,10 @@ func TestURLMapper(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"http://w3.org"}) - require.NoError(t, err) - require.Equal(t, "http://w3.org", cli.URL.String()) + assert.NoError(t, err) + assert.Equal(t, "http://w3.org", cli.URL.String()) _, err = p.Parse([]string{":foo"}) - require.Error(t, err) + assert.Error(t, err) } func TestSliceConsumesRemainingPositionalArgs(t *testing.T) { @@ -216,8 +215,8 @@ func TestSliceConsumesRemainingPositionalArgs(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"--", "ls", "-lart"}) - require.NoError(t, err) - require.Equal(t, []string{"ls", "-lart"}, cli.Remainder) + assert.NoError(t, err) + assert.Equal(t, []string{"ls", "-lart"}, cli.Remainder) } func TestPassthroughStopsParsing(t *testing.T) { @@ -231,16 +230,16 @@ func TestPassthroughStopsParsing(t *testing.T) { p := mustNew(t, &actual) _, err := p.Parse([]string{"alpine", "sudo", "-i", "true"}) - require.NoError(t, err) - require.Equal(t, cli{ + assert.NoError(t, err) + assert.Equal(t, cli{ Interactive: false, Image: "alpine", Argv: []string{"sudo", "-i", "true"}, }, actual) _, err = p.Parse([]string{"alpine", "-i", "sudo", "-i", "true"}) - require.NoError(t, err) - require.Equal(t, cli{ + assert.NoError(t, err) + assert.Equal(t, cli{ Interactive: true, Image: "alpine", Argv: []string{"sudo", "-i", "true"}, @@ -262,8 +261,8 @@ func TestMapperValue(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"foo"}) - require.NoError(t, err) - require.Equal(t, "foo", cli.Value.decoded) + assert.NoError(t, err) + assert.Equal(t, "foo", cli.Value.decoded) } func TestFileContentFlag(t *testing.T) { @@ -271,13 +270,13 @@ func TestFileContentFlag(t *testing.T) { File kong.FileContentFlag } f, err := ioutil.TempFile("", "") - require.NoError(t, err) + assert.NoError(t, err) defer os.Remove(f.Name()) fmt.Fprint(f, "hello world") f.Close() _, err = mustNew(t, &cli).Parse([]string{"--file", f.Name()}) - require.NoError(t, err) - require.Equal(t, []byte("hello world"), []byte(cli.File)) + assert.NoError(t, err) + assert.Equal(t, []byte("hello world"), []byte(cli.File)) } func TestNamedFileContentFlag(t *testing.T) { @@ -285,14 +284,14 @@ func TestNamedFileContentFlag(t *testing.T) { File kong.NamedFileContentFlag } f, err := ioutil.TempFile("", "") - require.NoError(t, err) + assert.NoError(t, err) defer os.Remove(f.Name()) fmt.Fprint(f, "hello world") f.Close() _, err = mustNew(t, &cli).Parse([]string{"--file", f.Name()}) - require.NoError(t, err) - require.Equal(t, []byte("hello world"), cli.File.Contents) - require.Equal(t, f.Name(), cli.File.Filename) + assert.NoError(t, err) + assert.Equal(t, []byte("hello world"), cli.File.Contents) + assert.Equal(t, f.Name(), cli.File.Filename) } func TestNamedSliceTypesDontHaveEllipsis(t *testing.T) { @@ -302,11 +301,11 @@ func TestNamedSliceTypesDontHaveEllipsis(t *testing.T) { b := bytes.NewBuffer(nil) parser := mustNew(t, &cli, kong.Writers(b, b), kong.Exit(func(int) { panic("exit") })) // Ensure that --help - require.Panics(t, func() { + assert.Panics(t, func() { _, err := parser.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.NotContains(t, b.String(), `--file=FILE-CONTENT-FLAG,...`) + assert.NotContains(t, b.String(), `--file=FILE-CONTENT-FLAG,...`) } func TestCounter(t *testing.T) { @@ -318,24 +317,24 @@ func TestCounter(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"--int", "--int", "--int"}) - require.NoError(t, err) - require.Equal(t, 3, cli.Int) + assert.NoError(t, err) + assert.Equal(t, 3, cli.Int) _, err = p.Parse([]string{"--int=5"}) - require.NoError(t, err) - require.Equal(t, 5, cli.Int) + assert.NoError(t, err) + assert.Equal(t, 5, cli.Int) _, err = p.Parse([]string{"-iii"}) - require.NoError(t, err) - require.Equal(t, 3, cli.Int) + assert.NoError(t, err) + assert.Equal(t, 3, cli.Int) _, err = p.Parse([]string{"-uuu"}) - require.NoError(t, err) - require.Equal(t, uint(3), cli.Uint) + assert.NoError(t, err) + assert.Equal(t, uint(3), cli.Uint) _, err = p.Parse([]string{"-fff"}) - require.NoError(t, err) - require.Equal(t, 3., cli.Float) + assert.NoError(t, err) + assert.Equal(t, 3., cli.Float) } func TestNumbers(t *testing.T) { @@ -366,8 +365,8 @@ func TestNumbers(t *testing.T) { "--u-32", fmt.Sprintf("%v", uint32(math.MaxUint32)), "--u-64", fmt.Sprintf("%v", uint64(math.MaxUint64)), }) - require.NoError(t, err) - require.Equal(t, CLI{ + assert.NoError(t, err) + assert.Equal(t, CLI{ F32: math.MaxFloat32, F64: math.MaxFloat64, I8: math.MaxInt8, @@ -391,8 +390,8 @@ func TestNumbers(t *testing.T) { fmt.Sprintf("--u-32=%v", 0), fmt.Sprintf("--u-64=%v", 0), }) - require.NoError(t, err) - require.Equal(t, CLI{ + assert.NoError(t, err) + assert.Equal(t, CLI{ I8: math.MinInt8, I16: math.MinInt16, I32: math.MinInt32, @@ -408,19 +407,19 @@ func TestFileMapper(t *testing.T) { var cli CLI p := mustNew(t, &cli) _, err := p.Parse([]string{"testdata/file.txt"}) - require.NoError(t, err) - require.NotNil(t, cli.File) + assert.NoError(t, err) + assert.NotZero(t, cli.File) _ = cli.File.Close() _, err = p.Parse([]string{"testdata/missing.txt"}) - require.Error(t, err) + assert.Error(t, err) if runtime.GOOS == "windows" { - require.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.") + assert.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.") } else { - require.Contains(t, err.Error(), "missing.txt: no such file or directory") + assert.Contains(t, err.Error(), "missing.txt: no such file or directory") } _, err = p.Parse([]string{"-"}) - require.NoError(t, err) - require.Equal(t, os.Stdin, cli.File) + assert.NoError(t, err) + assert.Equal(t, os.Stdin, cli.File) } //nolint:dupl @@ -431,16 +430,16 @@ func TestExistingFileMapper(t *testing.T) { var cli CLI p := mustNew(t, &cli) _, err := p.Parse([]string{"--file", "testdata/file.txt"}) - require.NoError(t, err) - require.NotNil(t, cli.File) + assert.NoError(t, err) + assert.NotZero(t, cli.File) p = mustNew(t, &cli) _, err = p.Parse([]string{"--file", "testdata/missing.txt"}) - require.Error(t, err) - require.Contains(t, err.Error(), "missing.txt: no such file or directory") + assert.Error(t, err) + assert.Contains(t, err.Error(), "missing.txt: no such file or directory") p = mustNew(t, &cli) _, err = p.Parse([]string{"--file", "testdata/"}) - require.Error(t, err) - require.Contains(t, err.Error(), "exists but is a directory") + assert.Error(t, err) + assert.Contains(t, err.Error(), "exists but is a directory") } func TestExistingFileMapperDefaultMissing(t *testing.T) { @@ -451,9 +450,9 @@ func TestExistingFileMapperDefaultMissing(t *testing.T) { p := mustNew(t, &cli) file := "testdata/file.txt" _, err := p.Parse([]string{"--file", file}) - require.NoError(t, err) - require.NotNil(t, cli.File) - require.Contains(t, cli.File, file) + assert.NoError(t, err) + assert.NotZero(t, cli.File) + assert.Contains(t, cli.File, file) } //nolint:dupl @@ -464,16 +463,16 @@ func TestExistingDirMapper(t *testing.T) { var cli CLI p := mustNew(t, &cli) _, err := p.Parse([]string{"--dir", "testdata/"}) - require.NoError(t, err) - require.NotNil(t, cli.Dir) + assert.NoError(t, err) + assert.NotZero(t, cli.Dir) p = mustNew(t, &cli) _, err = p.Parse([]string{"--dir", "missingdata/"}) - require.Error(t, err) - require.Contains(t, err.Error(), "missingdata: no such file or directory") + assert.Error(t, err) + assert.Contains(t, err.Error(), "missingdata: no such file or directory") p = mustNew(t, &cli) _, err = p.Parse([]string{"--dir", "testdata/file.txt"}) - require.Error(t, err) - require.Contains(t, err.Error(), "exists but is not a directory") + assert.Error(t, err) + assert.Contains(t, err.Error(), "exists but is not a directory") } func TestExistingDirMapperDefaultMissing(t *testing.T) { @@ -484,9 +483,9 @@ func TestExistingDirMapperDefaultMissing(t *testing.T) { p := mustNew(t, &cli) dir := "testdata" _, err := p.Parse([]string{"--dir", dir}) - require.NoError(t, err) - require.NotNil(t, cli.Dir) - require.Contains(t, cli.Dir, dir) + assert.NoError(t, err) + assert.NotZero(t, cli.Dir) + assert.Contains(t, cli.Dir, dir) } func TestMapperPlaceHolder(t *testing.T) { @@ -502,11 +501,11 @@ func TestMapperPlaceHolder(t *testing.T) { kong.Exit(func(int) { panic("exit") }), ) // Ensure that --help - require.Panics(t, func() { + assert.Panics(t, func() { _, err := k.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.Contains(t, b.String(), "--flag=/a/b/c") + assert.Contains(t, b.String(), "--flag=/a/b/c") } type testMapperWithPlaceHolder struct { @@ -534,11 +533,12 @@ func TestMapperVarsContributor(t *testing.T) { kong.Exit(func(int) { panic("exit") }), ) // Ensure that --help - require.Panics(t, func() { + assert.Panics(t, func() { _, err := k.Parse([]string{"--help"}) - require.NoError(t, err) + assert.NoError(t, err) }) - require.Regexp(t, "--flag=STRING\\s+Some help with a var", b.String()) + assert.Contains(t, b.String(), "--flag=STRING") + assert.Contains(t, b.String(), "Some help with a var", b.String()) } type testMapperVarsContributor struct{} @@ -559,13 +559,13 @@ func TestValuesThatLookLikeFlags(t *testing.T) { } k := mustNew(t, &cli) _, err := k.Parse([]string{"--slice", "-foo"}) - require.Error(t, err) + assert.Error(t, err) _, err = k.Parse([]string{"--map", "-foo=-bar"}) - require.Error(t, err) + assert.Error(t, err) _, err = k.Parse([]string{"--slice=-foo", "--slice=-bar"}) - require.NoError(t, err) - require.Equal(t, []string{"-foo", "-bar"}, cli.Slice) + assert.NoError(t, err) + assert.Equal(t, []string{"-foo", "-bar"}, cli.Slice) _, err = k.Parse([]string{"--map=-foo=-bar"}) - require.NoError(t, err) - require.Equal(t, map[string]string{"-foo": "-bar"}, cli.Map) + assert.NoError(t, err) + assert.Equal(t, map[string]string{"-foo": "-bar"}, cli.Map) } diff --git a/mapper_windows_test.go b/mapper_windows_test.go index 039e9ec..f9b092e 100644 --- a/mapper_windows_test.go +++ b/mapper_windows_test.go @@ -7,7 +7,7 @@ import ( "os" "testing" - "github.com/stretchr/testify/require" + require "github.com/alecthomas/assert/v2" ) func TestWindowsPathMapper(t *testing.T) { @@ -16,13 +16,13 @@ func TestWindowsPathMapper(t *testing.T) { Files []string `short:"f" type:"path"` } wd, err := os.Getwd() - require.NoError(t, err, "Getwd failed") + assert.NoError(t, err, "Getwd failed") p := mustNew(t, &cli) _, err = p.Parse([]string{`-p`, `c:\an\absolute\path`, `-f`, `c:\second\absolute\path\`, `-f`, `relative\path\file`}) - require.NoError(t, err) - require.Equal(t, `c:\an\absolute\path`, cli.Path) - require.Equal(t, []string{`c:\second\absolute\path\`, wd + `\relative\path\file`}, cli.Files) + assert.NoError(t, err) + assert.Equal(t, `c:\an\absolute\path`, cli.Path) + assert.Equal(t, []string{`c:\second\absolute\path\`, wd + `\relative\path\file`}, cli.Files) } func TestWindowsFileMapper(t *testing.T) { @@ -32,13 +32,13 @@ func TestWindowsFileMapper(t *testing.T) { var cli CLI p := mustNew(t, &cli) _, err := p.Parse([]string{"testdata\\file.txt"}) - require.NoError(t, err) - require.NotNil(t, cli.File) + assert.NoError(t, err) + assert.NotNil(t, cli.File) _ = cli.File.Close() _, err = p.Parse([]string{"testdata\\missing.txt"}) - require.Error(t, err) - require.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.") + assert.Error(t, err) + assert.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.") _, err = p.Parse([]string{"-"}) - require.NoError(t, err) - require.Equal(t, os.Stdin, cli.File) + assert.NoError(t, err) + assert.Equal(t, os.Stdin, cli.File) } diff --git a/model_test.go b/model_test.go index 1296f3d..37bd632 100644 --- a/model_test.go +++ b/model_test.go @@ -3,7 +3,7 @@ package kong_test import ( "testing" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func TestModelApplicationCommands(t *testing.T) { @@ -23,7 +23,7 @@ func TestModelApplicationCommands(t *testing.T) { for _, cmd := range p.Model.Leaves(false) { actual = append(actual, cmd.Path()) } - require.Equal(t, []string{"one two", "one three "}, actual) + assert.Equal(t, []string{"one two", "one three "}, actual) } func TestFlagString(t *testing.T) { @@ -66,7 +66,7 @@ func TestFlagString(t *testing.T) { p := mustNew(t, &cli) for _, flag := range p.Model.Flags { want, ok := tests[flag.Name] - require.Truef(t, ok, "unknown flag name: %s", flag.Name) - require.Equal(t, want, flag.String()) + assert.True(t, ok, "unknown flag name: %s", flag.Name) + assert.Equal(t, want, flag.String()) } } diff --git a/options_test.go b/options_test.go index 4d401d9..e79168b 100644 --- a/options_test.go +++ b/options_test.go @@ -4,18 +4,18 @@ import ( "reflect" "testing" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func TestOptions(t *testing.T) { var cli struct{} p, err := New(&cli, Name("name"), Description("description"), Writers(nil, nil), Exit(nil)) - require.NoError(t, err) - require.Equal(t, "name", p.Model.Name) - require.Equal(t, "description", p.Model.Help) - require.Nil(t, p.Stdout) - require.Nil(t, p.Stderr) - require.Nil(t, p.Exit) + assert.NoError(t, err) + assert.Equal(t, "name", p.Model.Name) + assert.Equal(t, "description", p.Model.Help) + assert.Zero(t, p.Stdout) + assert.Zero(t, p.Stderr) + assert.Zero(t, p.Exit) } type impl string @@ -29,17 +29,17 @@ func TestBindTo(t *testing.T) { saw := "" method := func(i iface) error { - saw = string(i.(impl)) + saw = string(i.(impl)) // nolint return nil } var cli struct{} p, err := New(&cli, BindTo(impl("foo"), (*iface)(nil))) - require.NoError(t, err) + assert.NoError(t, err) err = callMethod("method", reflect.ValueOf(impl("??")), reflect.ValueOf(method), p.bindings) - require.NoError(t, err) - require.Equal(t, "foo", saw) + assert.NoError(t, err) + assert.Equal(t, "foo", saw) } func TestInvalidCallback(t *testing.T) { @@ -49,16 +49,16 @@ func TestInvalidCallback(t *testing.T) { saw := "" method := func(i iface) string { - saw = string(i.(impl)) + saw = string(i.(impl)) // nolint return saw } var cli struct{} p, err := New(&cli, BindTo(impl("foo"), (*iface)(nil))) - require.NoError(t, err) + assert.NoError(t, err) err = callMethod("method", reflect.ValueOf(impl("??")), reflect.ValueOf(method), p.bindings) - require.EqualError(t, err, `return value of *reflect.rtype.method() must implement "error"`) + assert.EqualError(t, err, `return value of *reflect.rtype.method() must implement "error"`) } type zrror struct{} @@ -74,17 +74,17 @@ func TestCallbackCustomError(t *testing.T) { saw := "" method := func(i iface) *zrror { - saw = string(i.(impl)) + saw = string(i.(impl)) // nolint return nil } var cli struct{} p, err := New(&cli, BindTo(impl("foo"), (*iface)(nil))) - require.NoError(t, err) + assert.NoError(t, err) err = callMethod("method", reflect.ValueOf(impl("??")), reflect.ValueOf(method), p.bindings) - require.NoError(t, err) - require.Equal(t, "foo", saw) + assert.NoError(t, err) + assert.Equal(t, "foo", saw) } type bindToProviderCLI struct { @@ -105,10 +105,10 @@ func (*bindToProviderCmd) Run(cli *bindToProviderCLI, b *boundThing) error { func TestBindToProvider(t *testing.T) { var cli bindToProviderCLI app, err := New(&cli, BindToProvider(func() (*boundThing, error) { return &boundThing{}, nil })) - require.NoError(t, err) + assert.NoError(t, err) ctx, err := app.Parse([]string{"cmd"}) - require.NoError(t, err) + assert.NoError(t, err) err = ctx.Run() - require.NoError(t, err) - require.True(t, cli.Called) + assert.NoError(t, err) + assert.True(t, cli.Called) } diff --git a/resolver_test.go b/resolver_test.go index 81d64f1..bb3e2c6 100644 --- a/resolver_test.go +++ b/resolver_test.go @@ -7,8 +7,7 @@ import ( "strings" "testing" - "github.com/stretchr/testify/require" - + "github.com/alecthomas/assert/v2" "github.com/alecthomas/kong" ) @@ -53,10 +52,10 @@ func TestEnvarsFlagBasic(t *testing.T) { defer unsetEnvs() _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "bye", cli.String) - require.Equal(t, []int{5, 2, 9}, cli.Slice) - require.Equal(t, "foo", cli.Interp) + assert.NoError(t, err) + assert.Equal(t, "bye", cli.String) + assert.Equal(t, []int{5, 2, 9}, cli.Slice) + assert.Equal(t, "foo", cli.Interp) } func TestEnvarsFlagOverride(t *testing.T) { @@ -67,8 +66,8 @@ func TestEnvarsFlagOverride(t *testing.T) { defer restoreEnv() _, err := parser.Parse([]string{"--flag=hello"}) - require.NoError(t, err) - require.Equal(t, "hello", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "hello", cli.Flag) } func TestEnvarsTag(t *testing.T) { @@ -79,8 +78,8 @@ func TestEnvarsTag(t *testing.T) { defer restoreEnv() _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, []int{5, 2, 9}, cli.Slice) + assert.NoError(t, err) + assert.Equal(t, []int{5, 2, 9}, cli.Slice) } func TestEnvarsEnvPrefix(t *testing.T) { @@ -94,8 +93,8 @@ func TestEnvarsEnvPrefix(t *testing.T) { defer restoreEnv() _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, []int{1, 2, 3}, cli.Slice) + assert.NoError(t, err) + assert.Equal(t, []int{1, 2, 3}, cli.Slice) } func TestEnvarsNestedEnvPrefix(t *testing.T) { @@ -112,8 +111,8 @@ func TestEnvarsNestedEnvPrefix(t *testing.T) { defer restoreEnv() _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "abc", cli.String) + assert.NoError(t, err) + assert.Equal(t, "abc", cli.String) } func TestEnvarsWithDefault(t *testing.T) { @@ -124,14 +123,14 @@ func TestEnvarsWithDefault(t *testing.T) { defer restoreEnv() _, err := parser.Parse(nil) - require.NoError(t, err) - require.Equal(t, "default", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "default", cli.Flag) parser, restoreEnv = newEnvParser(t, &cli, envMap{"KONG_FLAG": "moo"}) defer restoreEnv() _, err = parser.Parse(nil) - require.NoError(t, err) - require.Equal(t, "moo", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "moo", cli.Flag) } func TestEnv(t *testing.T) { @@ -169,8 +168,8 @@ func TestEnv(t *testing.T) { defer unsetEnvs() _, err := parser.Parse(nil) - require.NoError(t, err) - require.Equal(t, expected, cli) + assert.NoError(t, err) + assert.Equal(t, expected, cli) // Without the prefix parser, unsetEnvs = newEnvParser(t, &cli, envMap{ @@ -184,8 +183,8 @@ func TestEnv(t *testing.T) { defer unsetEnvs() _, err = parser.Parse(nil) - require.NoError(t, err) - require.Equal(t, expected, cli) + assert.NoError(t, err) + assert.Equal(t, expected, cli) } func TestJSONBasic(t *testing.T) { @@ -215,17 +214,17 @@ func TestJSONBasic(t *testing.T) { }` r, err := kong.JSON(strings.NewReader(json)) - require.NoError(t, err) + assert.NoError(t, err) parser := mustNew(t, &cli, kong.Resolvers(r)) _, err = parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "🍕", cli.String) - require.Equal(t, []int{5, 8}, cli.Slice) - require.Equal(t, []string{"a,b", "c"}, cli.SliceWithCommas) - require.Equal(t, "one value", cli.One.String) - require.Equal(t, "two value", cli.Two.String) - require.True(t, cli.Bool) + assert.NoError(t, err) + assert.Equal(t, "🍕", cli.String) + assert.Equal(t, []int{5, 8}, cli.Slice) + assert.Equal(t, []string{"a,b", "c"}, cli.SliceWithCommas) + assert.Equal(t, "one value", cli.One.String) + assert.Equal(t, "two value", cli.Two.String) + assert.True(t, cli.Bool) } type testUppercaseMapper struct{} @@ -252,8 +251,8 @@ func TestResolversWithMappers(t *testing.T) { kong.NamedMapper("upper", testUppercaseMapper{}), ) _, err := parser.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "MEOW", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "MEOW", cli.Flag) } func TestResolverWithBool(t *testing.T) { @@ -271,8 +270,8 @@ func TestResolverWithBool(t *testing.T) { p := mustNew(t, &cli, kong.Resolvers(resolver)) _, err := p.Parse(nil) - require.NoError(t, err) - require.True(t, cli.Bool) + assert.NoError(t, err) + assert.True(t, cli.Bool) } func TestLastResolverWins(t *testing.T) { @@ -296,8 +295,8 @@ func TestLastResolverWins(t *testing.T) { p := mustNew(t, &cli, kong.Resolvers(first, second)) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, []int{2}, cli.Int) + assert.NoError(t, err) + assert.Equal(t, []int{2}, cli.Int) } func TestResolverSatisfiesRequired(t *testing.T) { @@ -311,8 +310,8 @@ func TestResolverSatisfiesRequired(t *testing.T) { return nil, nil } _, err := mustNew(t, &cli, kong.Resolvers(resolver)).Parse(nil) - require.NoError(t, err) - require.Equal(t, 1, cli.Int) + assert.NoError(t, err) + assert.Equal(t, 1, cli.Int) } func TestResolverTriggersHooks(t *testing.T) { @@ -330,10 +329,10 @@ func TestResolverTriggersHooks(t *testing.T) { } _, err := mustNew(t, &cli, kong.Bind(ctx), kong.Resolvers(first)).Parse(nil) - require.NoError(t, err) + assert.NoError(t, err) - require.Equal(t, "one", string(cli.Flag)) - require.Equal(t, []string{"before:", "after:one"}, ctx.values) + assert.Equal(t, "one", string(cli.Flag)) + assert.Equal(t, []string{"before:", "after:one"}, ctx.values) } type validatingResolver struct { @@ -349,5 +348,5 @@ func TestValidatingResolverErrors(t *testing.T) { resolver := &validatingResolver{err: errors.New("invalid")} var cli struct{} _, err := mustNew(t, &cli, kong.Resolvers(resolver)).Parse(nil) - require.EqualError(t, err, "invalid") + assert.EqualError(t, err, "invalid") } diff --git a/scanner_test.go b/scanner_test.go index 2b7d8d5..7d51860 100644 --- a/scanner_test.go +++ b/scanner_test.go @@ -3,26 +3,26 @@ package kong import ( "testing" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func TestScannerTake(t *testing.T) { s := Scan("a", "b", "c", "-") - require.Equal(t, "a", s.Pop().Value) - require.Equal(t, "b", s.Pop().Value) - require.Equal(t, "c", s.Pop().Value) + assert.Equal(t, "a", s.Pop().Value) + assert.Equal(t, "b", s.Pop().Value) + assert.Equal(t, "c", s.Pop().Value) hyphen := s.Pop() - require.Equal(t, PositionalArgumentToken, hyphen.InferredType()) - require.Equal(t, EOLToken, s.Pop().Type) + assert.Equal(t, PositionalArgumentToken, hyphen.InferredType()) + assert.Equal(t, EOLToken, s.Pop().Type) } func TestScannerPeek(t *testing.T) { s := Scan("a", "b", "c") - require.Equal(t, s.Peek().Value, "a") - require.Equal(t, s.Pop().Value, "a") - require.Equal(t, s.Peek().Value, "b") - require.Equal(t, s.Pop().Value, "b") - require.Equal(t, s.Peek().Value, "c") - require.Equal(t, s.Pop().Value, "c") - require.Equal(t, s.Peek().Type, EOLToken) + assert.Equal(t, s.Peek().Value, "a") + assert.Equal(t, s.Pop().Value, "a") + assert.Equal(t, s.Peek().Value, "b") + assert.Equal(t, s.Pop().Value, "b") + assert.Equal(t, s.Peek().Value, "c") + assert.Equal(t, s.Pop().Value, "c") + assert.Equal(t, s.Peek().Type, EOLToken) } diff --git a/tag_test.go b/tag_test.go index ca9f213..a34f7da 100644 --- a/tag_test.go +++ b/tag_test.go @@ -4,8 +4,7 @@ import ( "strings" "testing" - "github.com/stretchr/testify/require" - + "github.com/alecthomas/assert/v2" "github.com/alecthomas/kong" ) @@ -15,8 +14,8 @@ func TestDefaultValueForOptionalArg(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, "👌", cli.Arg) + assert.NoError(t, err) + assert.Equal(t, "👌", cli.Arg) } func TestNoValueInTag(t *testing.T) { @@ -26,9 +25,9 @@ func TestNoValueInTag(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, "", cli.Empty1) - require.Equal(t, "", cli.Empty2) + assert.NoError(t, err) + assert.Equal(t, "", cli.Empty1) + assert.Equal(t, "", cli.Empty2) } func TestCommaInQuotes(t *testing.T) { @@ -37,8 +36,8 @@ func TestCommaInQuotes(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, "1,2", cli.Numbers) + assert.NoError(t, err) + assert.Equal(t, "1,2", cli.Numbers) } func TestBadString(t *testing.T) { @@ -46,7 +45,7 @@ func TestBadString(t *testing.T) { Numbers string `kong:"default='yay'n"` } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestNoQuoteEnd(t *testing.T) { @@ -54,7 +53,7 @@ func TestNoQuoteEnd(t *testing.T) { Numbers string `kong:"default='yay"` } _, err := kong.New(&cli) - require.Error(t, err) + assert.Error(t, err) } func TestEscapedQuote(t *testing.T) { @@ -63,8 +62,8 @@ func TestEscapedQuote(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse(nil) - require.NoError(t, err) - require.Equal(t, "i don't know", cli.DoYouKnow) + assert.NoError(t, err) + assert.Equal(t, "i don't know", cli.DoYouKnow) } func TestBareTags(t *testing.T) { @@ -77,9 +76,9 @@ func TestBareTags(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"cmd", "arg", "--flag=hi"}) - require.NoError(t, err) - require.Equal(t, "hi", cli.Cmd.Flag) - require.Equal(t, "arg", cli.Cmd.Arg) + assert.NoError(t, err) + assert.Equal(t, "hi", cli.Cmd.Flag) + assert.Equal(t, "arg", cli.Cmd.Arg) } func TestBareTagsWithJsonTag(t *testing.T) { @@ -92,9 +91,9 @@ func TestBareTagsWithJsonTag(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{"cmd"}) - require.NoError(t, err) - require.Equal(t, "\"'👌'\"", cli.Cmd.Flag) - require.Equal(t, "", cli.Cmd.Arg) + assert.NoError(t, err) + assert.Equal(t, "\"'👌'\"", cli.Cmd.Flag) + assert.Equal(t, "", cli.Cmd.Arg) } func TestManySeps(t *testing.T) { @@ -104,8 +103,8 @@ func TestManySeps(t *testing.T) { p := mustNew(t, &cli) _, err := p.Parse([]string{}) - require.NoError(t, err) - require.Equal(t, "hi", cli.Arg) + assert.NoError(t, err) + assert.Equal(t, "hi", cli.Arg) } func TestTagSetOnEmbeddedStruct(t *testing.T) { @@ -118,8 +117,8 @@ func TestTagSetOnEmbeddedStruct(t *testing.T) { buf := &strings.Builder{} p := mustNew(t, &cli, kong.Writers(buf, buf), kong.Exit(func(int) {})) _, err := p.Parse([]string{"--help"}) - require.NoError(t, err) - require.Contains(t, buf.String(), `A key from somewhere.`) + assert.NoError(t, err) + assert.Contains(t, buf.String(), `A key from somewhere.`) } func TestTagSetOnCommand(t *testing.T) { @@ -132,8 +131,8 @@ func TestTagSetOnCommand(t *testing.T) { buf := &strings.Builder{} p := mustNew(t, &cli, kong.Writers(buf, buf), kong.Exit(func(int) {})) _, err := p.Parse([]string{"command", "--help"}) - require.NoError(t, err) - require.Contains(t, buf.String(), `A key from somewhere.`) + assert.NoError(t, err) + assert.Contains(t, buf.String(), `A key from somewhere.`) } func TestTagSetOnFlag(t *testing.T) { @@ -143,8 +142,8 @@ func TestTagSetOnFlag(t *testing.T) { buf := &strings.Builder{} p := mustNew(t, &cli, kong.Writers(buf, buf), kong.Exit(func(int) {})) _, err := p.Parse([]string{"--help"}) - require.NoError(t, err) - require.Contains(t, buf.String(), `A key from somewhere.`) + assert.NoError(t, err) + assert.Contains(t, buf.String(), `A key from somewhere.`) } func TestTagAliases(t *testing.T) { @@ -156,11 +155,11 @@ func TestTagAliases(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"alias1", "arg"}) - require.NoError(t, err) - require.Equal(t, "arg", cli.Cmd.Arg) + assert.NoError(t, err) + assert.Equal(t, "arg", cli.Cmd.Arg) _, err = p.Parse([]string{"alias2", "arg"}) - require.NoError(t, err) - require.Equal(t, "arg", cli.Cmd.Arg) + assert.NoError(t, err) + assert.Equal(t, "arg", cli.Cmd.Arg) } func TestTagAliasesConflict(t *testing.T) { @@ -173,8 +172,8 @@ func TestTagAliasesConflict(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"other-cmd", "arg"}) - require.NoError(t, err) - require.Equal(t, "arg", cli.OtherCmd.Arg) + assert.NoError(t, err) + assert.Equal(t, "arg", cli.OtherCmd.Arg) } func TestTagAliasesSub(t *testing.T) { @@ -189,8 +188,8 @@ func TestTagAliasesSub(t *testing.T) { } p := mustNew(t, &cli) _, err := p.Parse([]string{"cmd", "other-sub-cmd", "arg"}) - require.NoError(t, err) - require.Equal(t, "arg", cli.Cmd.SubCmd.Arg) + assert.NoError(t, err) + assert.Equal(t, "arg", cli.Cmd.SubCmd.Arg) } func TestInvalidRuneErrors(t *testing.T) { @@ -198,5 +197,5 @@ func TestInvalidRuneErrors(t *testing.T) { Flag bool `short:"invalid"` }{} _, err := kong.New(&cli) - require.EqualError(t, err, ".Flag: invalid short flag name \"invalid\": invalid rune") + assert.EqualError(t, err, ".Flag: invalid short flag name \"invalid\": invalid rune") } diff --git a/util.go b/util.go index 8c114af..9468ef5 100644 --- a/util.go +++ b/util.go @@ -17,7 +17,7 @@ func (c ConfigFlag) BeforeResolve(kong *Kong, ctx *Context, trace *Path) error { if kong.loader == nil { return fmt.Errorf("kong must be configured with kong.Configuration(...)") } - path := string(ctx.FlagValue(trace.Flag).(ConfigFlag)) + path := string(ctx.FlagValue(trace.Flag).(ConfigFlag)) // nolint resolver, err := kong.LoadConfig(path) if err != nil { return err diff --git a/util_test.go b/util_test.go index 77ccb99..2457ed8 100644 --- a/util_test.go +++ b/util_test.go @@ -8,7 +8,7 @@ import ( "strings" "testing" - "github.com/stretchr/testify/require" + "github.com/alecthomas/assert/v2" ) func TestConfigFlag(t *testing.T) { @@ -18,15 +18,15 @@ func TestConfigFlag(t *testing.T) { } w, err := ioutil.TempFile("", "") - require.NoError(t, err) + assert.NoError(t, err) defer os.Remove(w.Name()) w.WriteString(`{"flag": "hello world"}`) // nolint: errcheck w.Close() p := Must(&cli, Configuration(JSON)) _, err = p.Parse([]string{"--config", w.Name()}) - require.NoError(t, err) - require.Equal(t, "hello world", cli.Flag) + assert.NoError(t, err) + assert.Equal(t, "hello world", cli.Flag) } func TestVersionFlag(t *testing.T) { @@ -40,20 +40,20 @@ func TestVersionFlag(t *testing.T) { p.Exit = func(s int) { called = s } _, err := p.Parse([]string{"--version"}) - require.NoError(t, err) - require.Equal(t, "0.1.1", strings.TrimSpace(w.String())) - require.Equal(t, 0, called) + assert.NoError(t, err) + assert.Equal(t, "0.1.1", strings.TrimSpace(w.String())) + assert.Equal(t, 0, called) } func TestChangeDirFlag(t *testing.T) { cwd, err := os.Getwd() - require.NoError(t, err) + assert.NoError(t, err) defer os.Chdir(cwd) // nolint: errcheck dir := t.TempDir() file := filepath.Join(dir, "out.txt") err = os.WriteFile(file, []byte("foobar"), 0o600) - require.NoError(t, err) + assert.NoError(t, err) var cli struct { ChangeDir ChangeDirFlag `short:"C"` @@ -62,10 +62,10 @@ func TestChangeDirFlag(t *testing.T) { p := Must(&cli) _, err = p.Parse([]string{"-C", dir, "out.txt"}) - require.NoError(t, err) + assert.NoError(t, err) if runtime.GOOS != "windows" { file, err = filepath.EvalSymlinks(file) // Needed because OSX uses a symlinked tmp dir. - require.NoError(t, err) + assert.NoError(t, err) } - require.Equal(t, file, cli.Path) + assert.Equal(t, file, cli.Path) }