From 1f211aad5719d8c5315b87296d3326903ed0f8f2 Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Thu, 8 Oct 2020 12:42:32 +0100 Subject: [PATCH] types: keep migrating tests to test suites (#7478) Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> --- types/dec_coin_test.go | 6 +- types/errors/abci_test.go | 99 +++++++++++++++------------------ types/errors/errors_test.go | 75 ++++++++++++------------- types/errors/stacktrace_test.go | 57 ++++++------------- 4 files changed, 100 insertions(+), 137 deletions(-) diff --git a/types/dec_coin_test.go b/types/dec_coin_test.go index 13ec1b3ecb..e0f4a66b23 100644 --- a/types/dec_coin_test.go +++ b/types/dec_coin_test.go @@ -13,14 +13,10 @@ type decCoinTestSuite struct { suite.Suite } -func NewDecCoinTestSuite(t *testing.T) { +func TestDecCoinTestSuite(t *testing.T) { suite.Run(t, new(decCoinTestSuite)) } -func (s *decCoinTestSuite) SetupSuite() { - s.T().Parallel() -} - func (s *decCoinTestSuite) TestNewDecCoin() { s.Require().NotPanics(func() { sdk.NewInt64DecCoin(testDenom1, 5) diff --git a/types/errors/abci_test.go b/types/errors/abci_test.go index 39c1a0fd6f..18d6b1f2e6 100644 --- a/types/errors/abci_test.go +++ b/types/errors/abci_test.go @@ -6,10 +6,22 @@ import ( "strings" "testing" - "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" ) -func TestABCInfo(t *testing.T) { +type abciTestSuite struct { + suite.Suite +} + +func TestABCITestSuite(t *testing.T) { + suite.Run(t, new(abciTestSuite)) +} + +func (s *abciTestSuite) SetupSuite() { + s.T().Parallel() +} + +func (s *abciTestSuite) TestABCInfo() { cases := map[string]struct { err error debug bool @@ -91,23 +103,14 @@ func TestABCInfo(t *testing.T) { } for testName, tc := range cases { - tc := tc - t.Run(testName, func(t *testing.T) { - space, code, log := ABCIInfo(tc.err, tc.debug) - if space != tc.wantSpace { - t.Errorf("want %s space, got %s", tc.wantSpace, space) - } - if code != tc.wantCode { - t.Errorf("want %d code, got %d", tc.wantCode, code) - } - if log != tc.wantLog { - t.Errorf("want %q log, got %q", tc.wantLog, log) - } - }) + space, code, log := ABCIInfo(tc.err, tc.debug) + s.Require().Equal(tc.wantSpace, space, testName) + s.Require().Equal(tc.wantCode, code, testName) + s.Require().Equal(tc.wantLog, log, testName) } } -func TestABCIInfoStacktrace(t *testing.T) { +func (s *abciTestSuite) TestABCIInfoStacktrace() { cases := map[string]struct { err error debug bool @@ -140,37 +143,27 @@ func TestABCIInfoStacktrace(t *testing.T) { }, } - const thisTestSrc = "github.com/cosmos/cosmos-sdk/types/errors.TestABCIInfoStacktrace" + const thisTestSrc = "github.com/cosmos/cosmos-sdk/types/errors.(*abciTestSuite).TestABCIInfoStacktrace" for testName, tc := range cases { - tc := tc - t.Run(testName, func(t *testing.T) { - _, _, log := ABCIInfo(tc.err, tc.debug) - if tc.wantStacktrace { - if !strings.Contains(log, thisTestSrc) { - t.Errorf("log does not contain this file stack trace: %s", log) - } + _, _, log := ABCIInfo(tc.err, tc.debug) + if !tc.wantStacktrace { + s.Require().Equal(tc.wantErrMsg, log, testName) + continue + } - if !strings.Contains(log, tc.wantErrMsg) { - t.Errorf("log does not contain expected error message: %s", log) - } - } else if log != tc.wantErrMsg { - t.Fatalf("unexpected log message: %s", log) - } - }) + s.Require().True(strings.Contains(log, thisTestSrc), testName) + s.Require().True(strings.Contains(log, tc.wantErrMsg), testName) } } -func TestABCIInfoHidesStacktrace(t *testing.T) { +func (s *abciTestSuite) TestABCIInfoHidesStacktrace() { err := Wrap(ErrUnauthorized, "wrapped") _, _, log := ABCIInfo(err, false) - - if log != "wrapped: unauthorized" { - t.Fatalf("unexpected message in non debug mode: %s", log) - } + s.Require().Equal("wrapped: unauthorized", log) } -func TestRedact(t *testing.T) { +func (s *abciTestSuite) TestRedact() { cases := map[string]struct { err error untouched bool // if true we expect the same error after redact @@ -196,21 +189,21 @@ func TestRedact(t *testing.T) { for name, tc := range cases { spec := tc - t.Run(name, func(t *testing.T) { - redacted := Redact(spec.err) - if spec.untouched { - require.Equal(t, spec.err, redacted) - } else { - // see if we got the expected redact - require.Equal(t, spec.changed, redacted) - // make sure the ABCI code did not change - require.Equal(t, abciCode(spec.err), abciCode(redacted)) - } - }) + redacted := Redact(spec.err) + if spec.untouched { + s.Require().Equal(spec.err, redacted, name) + continue + } + + // see if we got the expected redact + s.Require().Equal(spec.changed, redacted, name) + // make sure the ABCI code did not change + s.Require().Equal(abciCode(spec.err), abciCode(redacted), name) + } } -func TestABCIInfoSerializeErr(t *testing.T) { +func (s *abciTestSuite) TestABCIInfoSerializeErr() { var ( // Create errors with stacktrace for equal comparison. myErrDecode = Wrap(ErrTxDecode, "test") @@ -250,12 +243,8 @@ func TestABCIInfoSerializeErr(t *testing.T) { } for msg, spec := range specs { spec := spec - t.Run(msg, func(t *testing.T) { - _, _, log := ABCIInfo(spec.src, spec.debug) - if exp, got := spec.exp, log; exp != got { - t.Errorf("expected %v but got %v", exp, got) - } - }) + _, _, log := ABCIInfo(spec.src, spec.debug) + s.Require().Equal(spec.exp, log, msg) } } diff --git a/types/errors/errors_test.go b/types/errors/errors_test.go index d618902c55..7852f8168a 100644 --- a/types/errors/errors_test.go +++ b/types/errors/errors_test.go @@ -5,12 +5,23 @@ import ( "fmt" "testing" - "github.com/stretchr/testify/require" - "github.com/pkg/errors" + "github.com/stretchr/testify/suite" ) -func TestCause(t *testing.T) { +type errorsTestSuite struct { + suite.Suite +} + +func TestErrorsTestSuite(t *testing.T) { + suite.Run(t, new(errorsTestSuite)) +} + +func (s *errorsTestSuite) SetupSuite() { + s.T().Parallel() +} + +func (s *errorsTestSuite) TestCause() { std := stdlib.New("this is a stdlib error") cases := map[string]struct { @@ -32,16 +43,11 @@ func TestCause(t *testing.T) { } for testName, tc := range cases { - tc := tc - t.Run(testName, func(t *testing.T) { - if got := errors.Cause(tc.err); got != tc.root { - t.Fatal("unexpected result") - } - }) + s.Require().Equal(tc.root, errors.Cause(tc.err), testName) } } -func TestErrorIs(t *testing.T) { +func (s *errorsTestSuite) TestErrorIs() { cases := map[string]struct { a *Error b error @@ -139,12 +145,7 @@ func TestErrorIs(t *testing.T) { // }, } for testName, tc := range cases { - tc := tc - t.Run(testName, func(t *testing.T) { - if got := tc.a.Is(tc.b); got != tc.wantIs { - t.Fatalf("unexpected result - got:%v want: %v", got, tc.wantIs) - } - }) + s.Require().Equal(tc.wantIs, tc.a.Is(tc.b), testName) } } @@ -155,63 +156,61 @@ func (customError) Error() string { return "custom error" } -func TestWrapEmpty(t *testing.T) { - if err := Wrap(nil, "wrapping "); err != nil { - t.Fatal(err) - } +func (s *errorsTestSuite) TestWrapEmpty() { + s.Require().Nil(Wrap(nil, "wrapping ")) } -func TestWrappedIs(t *testing.T) { +func (s *errorsTestSuite) TestWrappedIs() { err := Wrap(ErrTxTooLarge, "context") - require.True(t, stdlib.Is(err, ErrTxTooLarge)) + s.Require().True(stdlib.Is(err, ErrTxTooLarge)) err = Wrap(err, "more context") - require.True(t, stdlib.Is(err, ErrTxTooLarge)) + s.Require().True(stdlib.Is(err, ErrTxTooLarge)) err = Wrap(err, "even more context") - require.True(t, stdlib.Is(err, ErrTxTooLarge)) + s.Require().True(stdlib.Is(err, ErrTxTooLarge)) err = Wrap(ErrInsufficientFee, "...") - require.False(t, stdlib.Is(err, ErrTxTooLarge)) + s.Require().False(stdlib.Is(err, ErrTxTooLarge)) } -func TestWrappedIsMultiple(t *testing.T) { +func (s *errorsTestSuite) TestWrappedIsMultiple() { var errTest = errors.New("test error") var errTest2 = errors.New("test error 2") err := Wrap(errTest2, Wrap(errTest, "some random description").Error()) - require.True(t, stdlib.Is(err, errTest2)) + s.Require().True(stdlib.Is(err, errTest2)) } -func TestWrappedIsFail(t *testing.T) { +func (s *errorsTestSuite) TestWrappedIsFail() { var errTest = errors.New("test error") var errTest2 = errors.New("test error 2") err := Wrap(errTest2, Wrap(errTest, "some random description").Error()) - require.False(t, stdlib.Is(err, errTest)) + s.Require().False(stdlib.Is(err, errTest)) } -func TestWrappedUnwrap(t *testing.T) { +func (s *errorsTestSuite) TestWrappedUnwrap() { var errTest = errors.New("test error") err := Wrap(errTest, "some random description") - require.Equal(t, errTest, stdlib.Unwrap(err)) + s.Require().Equal(errTest, stdlib.Unwrap(err)) } -func TestWrappedUnwrapMultiple(t *testing.T) { +func (s *errorsTestSuite) TestWrappedUnwrapMultiple() { var errTest = errors.New("test error") var errTest2 = errors.New("test error 2") err := Wrap(errTest2, Wrap(errTest, "some random description").Error()) - require.Equal(t, errTest2, stdlib.Unwrap(err)) + s.Require().Equal(errTest2, stdlib.Unwrap(err)) } -func TestWrappedUnwrapFail(t *testing.T) { +func (s *errorsTestSuite) TestWrappedUnwrapFail() { var errTest = errors.New("test error") var errTest2 = errors.New("test error 2") err := Wrap(errTest2, Wrap(errTest, "some random description").Error()) - require.NotEqual(t, errTest, stdlib.Unwrap(err)) + s.Require().NotEqual(errTest, stdlib.Unwrap(err)) } -func TestABCIError(t *testing.T) { - require.Equal(t, "custom: tx parse error", ABCIError(RootCodespace, 2, "custom").Error()) - require.Equal(t, "custom: unknown", ABCIError("unknown", 1, "custom").Error()) +func (s *errorsTestSuite) TestABCIError() { + s.Require().Equal("custom: tx parse error", ABCIError(RootCodespace, 2, "custom").Error()) + s.Require().Equal("custom: unknown", ABCIError("unknown", 1, "custom").Error()) } func ExampleWrap() { diff --git a/types/errors/stacktrace_test.go b/types/errors/stacktrace_test.go index bef4bccb70..06eb829f0f 100644 --- a/types/errors/stacktrace_test.go +++ b/types/errors/stacktrace_test.go @@ -5,10 +5,9 @@ import ( "fmt" "reflect" "strings" - "testing" ) -func TestStackTrace(t *testing.T) { +func (s *errorsTestSuite) TestStackTrace() { cases := map[string]struct { err error wantError string @@ -39,45 +38,25 @@ func TestStackTrace(t *testing.T) { } const thisTestSrc = "types/errors/stacktrace_test.go" - for testName, tc := range cases { - tc := tc - t.Run(testName, func(t *testing.T) { - if !reflect.DeepEqual(tc.err.Error(), tc.wantError) { - t.Fatalf("errors not equal, got '%s', want '%s'", tc.err.Error(), tc.wantError) - } + for _, tc := range cases { + s.Require().True(reflect.DeepEqual(tc.err.Error(), tc.wantError)) + s.Require().NotNil(stackTrace(tc.err)) + fullStack := fmt.Sprintf("%+v", tc.err) + s.Require().True(strings.Contains(fullStack, thisTestSrc)) + s.Require().True(strings.Contains(fullStack, tc.wantError)) - if stackTrace(tc.err) == nil { - t.Fatal("expected a stack trace to be present") + for _, src := range unwantedSrc { + if strings.Contains(fullStack, src) { + s.T().Logf("Stack trace below\n----%s\n----", fullStack) + s.T().Logf("full stack contains unwanted source file path: %q", src) } + } - fullStack := fmt.Sprintf("%+v", tc.err) - if !strings.Contains(fullStack, thisTestSrc) { - t.Logf("Stack trace below\n----%s\n----", fullStack) - t.Error("full stack trace should contain this test source code information") - } - if !strings.Contains(fullStack, tc.wantError) { - t.Logf("Stack trace below\n----%s\n----", fullStack) - t.Error("full stack trace should contain the error description") - } - for _, src := range unwantedSrc { - if strings.Contains(fullStack, src) { - t.Logf("Stack trace below\n----%s\n----", fullStack) - t.Logf("full stack contains unwanted source file path: %q", src) - } - } - - tinyStack := fmt.Sprintf("%v", tc.err) - if !strings.HasPrefix(tinyStack, tc.wantError) { - t.Fatalf("prefix mimssing: %s", tinyStack) - } - if strings.Contains(tinyStack, "\n") { - t.Fatal("only one stack line is expected") - } - // contains a link to where it was created, which must - // be here, not the Wrap() function - if !strings.Contains(tinyStack, thisTestSrc) { - t.Fatalf("this file missing in stack info:\n %s", tinyStack) - } - }) + tinyStack := fmt.Sprintf("%v", tc.err) + s.Require().True(strings.HasPrefix(tinyStack, tc.wantError)) + s.Require().False(strings.Contains(tinyStack, "\n")) + // contains a link to where it was created, which must + // be here, not the Wrap() function + s.Require().True(strings.Contains(tinyStack, thisTestSrc)) } }