From dcfda7271999f8038dc66e1319fb382328f55fd5 Mon Sep 17 00:00:00 2001 From: Frederic BIDON Date: Mon, 4 Dec 2023 10:08:37 +0100 Subject: [PATCH] chore: relint * updated golangci rules & relinted tests * updated github actions * updated badge in README Signed-off-by: Frederic BIDON --- .github/workflows/ci.yaml | 46 ----------------- .github/workflows/go-test.yml | 50 +++++++++++++++++++ .golangci.yml | 92 +++++++++++++++++----------------- README.md | 5 +- bson.go | 4 +- bson_test.go | 15 +++--- conv/ulid_test.go | 3 +- date_test.go | 31 ++++++------ default_test.go | 51 +++++++++---------- duration_test.go | 39 ++++++++------- format.go | 2 +- format_test.go | 13 ++--- time_test.go | 63 ++++++++++++------------ ulid_test.go | 93 ++++++++++++++++++----------------- 14 files changed, 260 insertions(+), 247 deletions(-) delete mode 100644 .github/workflows/ci.yaml create mode 100644 .github/workflows/go-test.yml diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml deleted file mode 100644 index 7d0b2c9..0000000 --- a/.github/workflows/ci.yaml +++ /dev/null @@ -1,46 +0,0 @@ -name: Go - -on: [push, pull_request] - -jobs: - build: - runs-on: ${{ matrix.os }} - - strategy: - matrix: - os: [ ubuntu-latest, macos-latest, windows-latest ] - fail-fast: false - - steps: - - uses: actions/checkout@v2 - - - name: Set up Go - uses: actions/setup-go@v2 - with: - go-version: 1.17.1 - - - name: Setup gotestsum - uses: autero1/action-gotestsum@v1.0.0 - with: - gotestsum_version: 1.7.0 - - - name: Test - run: gotestsum --format short-verbose -- -race -timeout=20m -coverprofile=coverage_txt -covermode=atomic ./... - - - uses: codecov/codecov-action@v2 - with: - files: coverage_txt - - lint: - runs-on: ${{ matrix.os }} - - strategy: - matrix: - os: [ ubuntu-latest, macos-latest, windows-latest ] - fail-fast: false - - steps: - - uses: actions/checkout@v2 - - uses: golangci/golangci-lint-action@v2 - with: - args: --timeout=5m diff --git a/.github/workflows/go-test.yml b/.github/workflows/go-test.yml new file mode 100644 index 0000000..3808f40 --- /dev/null +++ b/.github/workflows/go-test.yml @@ -0,0 +1,50 @@ +name: go test + +on: [push, pull_request] + +jobs: + lint: + name: Lint + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-go@v4 + with: + go-version: stable + check-latest: true + cache: true + - name: golangci-lint + uses: golangci/golangci-lint-action@v3 + with: + version: latest + only-new-issues: true + + test: + name: Unit tests + runs-on: ${{ matrix.os }} + + strategy: + matrix: + os: [ ubuntu-latest, macos-latest, windows-latest ] + go_version: ['oldstable', 'stable' ] + + steps: + - name: Run unit tests + uses: actions/setup-go@v4 + with: + go-version: '${{ matrix.go_version }}' + check-latest: true + cache: true + - uses: actions/checkout@v3 + + - run: go test -v -race -coverprofile="coverage-${{ matrix.os }}.${{ matrix.go_version }}.out" -covermode=atomic ./... + + - name: Upload coverage to codecov + uses: codecov/codecov-action@v3 + with: + files: './coverage-${{ matrix.os }}.${{ matrix.go_version }}.out,./coverage-integration-${{ matrix.os }}.${{ matrix.go_version }}.out' + flags: '${{ matrix.go_version }}' + os: '${{ matrix.os }}' + fail_ci_if_error: false + verbose: true + diff --git a/.golangci.yml b/.golangci.yml index be4899c..22f8d21 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -4,56 +4,58 @@ linters-settings: golint: min-confidence: 0 gocyclo: - min-complexity: 31 + min-complexity: 45 maligned: suggest-new: true dupl: - threshold: 100 + threshold: 200 goconst: min-len: 2 - min-occurrences: 4 + min-occurrences: 3 linters: - enable: - - revive - - goimports - - gosec + enable-all: true + disable: + - maligned - unparam - - unconvert - - predeclared - - prealloc - - misspell - - # disable: - # - maligned - # - lll - # - gochecknoinits - # - gochecknoglobals - # - godox - # - gocognit - # - whitespace - # - wsl - # - funlen - # - wrapcheck - # - testpackage - # - nlreturn - # - gofumpt - # - goerr113 - # - gci - # - gomnd - # - godot - # - exhaustivestruct - # - paralleltest - # - varnamelen - # - ireturn - # - exhaustruct - # #- thelper - -issues: - exclude-rules: - - path: bson.go - text: "should be .*ObjectID" - linters: - - golint - - stylecheck - + - lll + - gochecknoinits + - gochecknoglobals + - funlen + - godox + - gocognit + - whitespace + - wsl + - wrapcheck + - testpackage + - nlreturn + - gomnd + - exhaustivestruct + - goerr113 + - errorlint + - nestif + - godot + - gofumpt + - paralleltest + - tparallel + - thelper + - ifshort + - exhaustruct + - varnamelen + - gci + - depguard + - errchkjson + - inamedparam + - nonamedreturns + - musttag + - ireturn + - forcetypeassert + - cyclop + # deprecated linters + - deadcode + - interfacer + - scopelint + - varcheck + - structcheck + - golint + - nosnakecase diff --git a/README.md b/README.md index 0cf89d7..ae82dad 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,7 @@ -# Strfmt [![Build Status](https://travis-ci.org/go-openapi/strfmt.svg?branch=master)](https://travis-ci.org/go-openapi/strfmt) [![codecov](https://codecov.io/gh/go-openapi/strfmt/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/strfmt) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) - +# Strfmt [![Build Status](https://github.com/go-openapi/strfmt/actions/workflows/go-test.yaml/badge.svg)](https://github.com/go-openapi/strfmt/actions?query=workflow%3A"go+test") [![codecov](https://codecov.io/gh/go-openapi/strfmt/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/strfmt) +[![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/strfmt/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/strfmt?status.svg)](http://godoc.org/github.com/go-openapi/strfmt) -[![GolangCI](https://golangci.com/badges/github.com/go-openapi/strfmt.svg)](https://golangci.com) [![Go Report Card](https://goreportcard.com/badge/github.com/go-openapi/strfmt)](https://goreportcard.com/report/github.com/go-openapi/strfmt) This package exposes a registry of data types to support string formats in the go-openapi toolkit. diff --git a/bson.go b/bson.go index a8a3604..ddae3fd 100644 --- a/bson.go +++ b/bson.go @@ -39,10 +39,10 @@ func IsBSONObjectID(str string) bool { // ObjectId represents a BSON object ID (alias to go.mongodb.org/mongo-driver/bson/primitive.ObjectID) // // swagger:strfmt bsonobjectid -type ObjectId bsonprim.ObjectID //nolint:revive +type ObjectId bsonprim.ObjectID //nolint:revive,stylecheck // NewObjectId creates a ObjectId from a Hex String -func NewObjectId(hex string) ObjectId { //nolint:revive +func NewObjectId(hex string) ObjectId { //nolint:revive,stylecheck oid, err := bsonprim.ObjectIDFromHex(hex) if err != nil { panic(err) diff --git a/bson_test.go b/bson_test.go index 0dd971e..7a367ad 100644 --- a/bson_test.go +++ b/bson_test.go @@ -18,36 +18,37 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) func TestBSONObjectId_fullCycle(t *testing.T) { id := NewObjectId("507f1f77bcf86cd799439011") bytes, err := id.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) var idCopy ObjectId err = idCopy.Scan(bytes) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, id, idCopy) err = idCopy.UnmarshalText(bytes) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, id, idCopy) jsonBytes, err := id.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) err = idCopy.UnmarshalJSON(jsonBytes) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, id, idCopy) bsonBytes, err := bson.Marshal(&id) - assert.NoError(t, err) + require.NoError(t, err) err = bson.Unmarshal(bsonBytes, &idCopy) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, id, idCopy) } diff --git a/conv/ulid_test.go b/conv/ulid_test.go index 62525f9..0bfb797 100644 --- a/conv/ulid_test.go +++ b/conv/ulid_test.go @@ -5,6 +5,7 @@ import ( "github.com/go-openapi/strfmt" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) const testUlid = string("01EYXZVGBHG26MFTG4JWR4K558") @@ -14,7 +15,7 @@ func TestULIDValue(t *testing.T) { value := strfmt.ULID{} err := value.UnmarshalText([]byte(testUlid)) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, value, ULIDValue(&value)) ulidRef := ULID(value) diff --git a/date_test.go b/date_test.go index 7d86989..6a16b73 100644 --- a/date_test.go +++ b/date_test.go @@ -23,6 +23,7 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) @@ -32,43 +33,43 @@ var _ driver.Valuer = Date{} func TestDate(t *testing.T) { pp := Date{} err := pp.UnmarshalText([]byte{}) - assert.NoError(t, err) + require.NoError(t, err) err = pp.UnmarshalText([]byte("yada")) - assert.Error(t, err) + require.Error(t, err) orig := "2014-12-15" bj := []byte("\"" + orig + "\"") err = pp.UnmarshalText([]byte(orig)) - assert.NoError(t, err) + require.NoError(t, err) txt, err := pp.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, orig, string(txt)) err = pp.UnmarshalJSON(bj) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, orig, pp.String()) err = pp.UnmarshalJSON([]byte(`"1972/01/01"`)) - assert.Error(t, err) + require.Error(t, err) b, err := pp.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, bj, b) dateOriginal := Date(time.Date(2014, 10, 10, 0, 0, 0, 0, time.UTC)) bsonData, err := bson.Marshal(&dateOriginal) - assert.NoError(t, err) + require.NoError(t, err) var dateCopy Date err = bson.Unmarshal(bsonData, &dateCopy) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, dateOriginal, dateCopy) var dateZero Date err = dateZero.UnmarshalJSON([]byte(jsonNull)) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, Date{}, dateZero) } @@ -85,18 +86,18 @@ func TestDate_Scan(t *testing.T) { dd := Date{} err := dd.Scan(nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, Date{}, dd) err = dd.Scan(19700101) - assert.Error(t, err) + require.Error(t, err) } func TestDate_Value(t *testing.T) { ref := time.Now().Truncate(24 * time.Hour).UTC() date := Date(ref) dbv, err := date.Value() - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, dbv, ref.Format("2006-01-02")) } @@ -148,14 +149,14 @@ func TestGobEncodingDate(t *testing.T) { b := bytes.Buffer{} enc := gob.NewEncoder(&b) err := enc.Encode(Date(now)) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, b.Bytes()) var result Date dec := gob.NewDecoder(&b) err = dec.Decode(&result) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, now.Year(), time.Time(result).Year()) assert.Equal(t, now.Month(), time.Time(result).Month()) assert.Equal(t, now.Day(), time.Time(result).Day()) diff --git a/default_test.go b/default_test.go index b1875c0..7a20b0f 100644 --- a/default_test.go +++ b/default_test.go @@ -27,6 +27,7 @@ import ( "github.com/google/uuid" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) @@ -181,7 +182,7 @@ func TestFormatUUID3(t *testing.T) { // special case for zero UUID var uuidZero UUID3 err := uuidZero.UnmarshalJSON([]byte(jsonNull)) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, UUID3(""), uuidZero) } @@ -195,7 +196,7 @@ func TestFormatUUID4(t *testing.T) { // special case for zero UUID var uuidZero UUID4 err := uuidZero.UnmarshalJSON([]byte(jsonNull)) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, UUID4(""), uuidZero) } @@ -209,7 +210,7 @@ func TestFormatUUID5(t *testing.T) { // special case for zero UUID var uuidZero UUID5 err := uuidZero.UnmarshalJSON([]byte(jsonNull)) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, UUID5(""), uuidZero) } @@ -223,7 +224,7 @@ func TestFormatUUID(t *testing.T) { // special case for zero UUID var uuidZero UUID err := uuidZero.UnmarshalJSON([]byte(jsonNull)) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, UUID(""), uuidZero) } @@ -283,28 +284,28 @@ func TestFormatBase64(t *testing.T) { var subj Base64 err := subj.UnmarshalText([]byte(str)) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, expected, subj) b, err = subj.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, []byte(str), b) var subj2 Base64 err = subj2.UnmarshalJSON(bj) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, expected, subj2) b, err = subj2.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, bj, b) bsonData, err := bson.Marshal(subj2) - assert.NoError(t, err) + require.NoError(t, err) var b64Copy Base64 err = bson.Unmarshal(bsonData, &b64Copy) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, subj2, b64Copy) testValid(t, "byte", str) @@ -312,7 +313,7 @@ func TestFormatBase64(t *testing.T) { // Valuer interface sqlvalue, err := subj2.Value() - assert.NoError(t, err) + require.NoError(t, err) sqlvalueAsString, ok := sqlvalue.(string) if assert.Truef(t, ok, "[%s]Value: expected driver value to be a string", "byte") { assert.EqualValuesf(t, str, sqlvalueAsString, "[%s]Value: expected %v and %v to be equal", "byte", sqlvalue, str) @@ -320,16 +321,16 @@ func TestFormatBase64(t *testing.T) { // Scanner interface var subj3 Base64 err = subj3.Scan([]byte(str)) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, str, subj3.String()) var subj4 Base64 err = subj4.Scan(str) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, str, subj4.String()) err = subj4.Scan(123) - assert.Error(t, err) + require.Error(t, err) } type testableFormat interface { @@ -350,14 +351,14 @@ func testStringFormat(t *testing.T, what testableFormat, format, with string, va // text encoding interface b := []byte(with) err := what.UnmarshalText(b) - assert.NoError(t, err) + require.NoError(t, err) val := reflect.Indirect(reflect.ValueOf(what)) strVal := val.String() assert.Equalf(t, with, strVal, "[%s]UnmarshalText: expected %v and %v to be value equal", format, strVal, with) b, err = what.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) assert.Equalf(t, []byte(with), b, "[%s]MarshalText: expected %v and %v to be value equal as []byte", format, string(b), with) // Stringer @@ -367,23 +368,23 @@ func testStringFormat(t *testing.T, what testableFormat, format, with string, va // JSON encoding interface bj := []byte("\"" + with + "\"") err = what.UnmarshalJSON(bj) - assert.NoError(t, err) + require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]UnmarshalJSON: expected %v and %v to be value equal", format, strVal, with) b, err = what.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) assert.Equalf(t, bj, b, "[%s]MarshalJSON: expected %v and %v to be value equal as []byte", format, string(b), with) // bson encoding interface bsonData, err := bson.Marshal(what) - assert.NoError(t, err) + require.NoError(t, err) resetValue(t, format, what) err = bson.Unmarshal(bsonData, what) - assert.NoError(t, err) + require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]bson.Unmarshal: expected %v and %v to be equal (reset value) ", format, what, with) @@ -391,23 +392,23 @@ func testStringFormat(t *testing.T, what testableFormat, format, with string, va // Scanner interface resetValue(t, format, what) err = what.Scan(with) - assert.NoError(t, err) + require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]Scan: expected %v and %v to be value equal", format, strVal, with) err = what.Scan([]byte(with)) - assert.NoError(t, err) + require.NoError(t, err) val = reflect.Indirect(reflect.ValueOf(what)) strVal = val.String() assert.EqualValuesf(t, with, strVal, "[%s]Scan: expected %v and %v to be value equal", format, strVal, with) err = what.Scan(123) - assert.Error(t, err) + require.Error(t, err) // Valuer interface sqlvalue, err := what.Value() - assert.NoError(t, err) + require.NoError(t, err) sqlvalueAsString, ok := sqlvalue.(string) if assert.Truef(t, ok, "[%s]Value: expected driver value to be a string", format) { assert.EqualValuesf(t, with, sqlvalueAsString, "[%s]Value: expected %v and %v to be equal", format, sqlvalue, with) @@ -427,7 +428,7 @@ func resetValue(t *testing.T, format string, what encoding.TextUnmarshaler) { t.Helper() err := what.UnmarshalText([]byte("reset value")) - assert.NoError(t, err) + require.NoError(t, err) val := reflect.Indirect(reflect.ValueOf(what)) strVal := val.String() assert.Equalf(t, "reset value", strVal, "[%s]UnmarshalText: expected %v and %v to be equal (reset value) ", format, strVal, "reset value") diff --git a/duration_test.go b/duration_test.go index 7180cbd..75562d2 100644 --- a/duration_test.go +++ b/duration_test.go @@ -19,6 +19,7 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) @@ -26,51 +27,51 @@ func TestDuration(t *testing.T) { pp := Duration(0) err := pp.UnmarshalText([]byte("0ms")) - assert.NoError(t, err) + require.NoError(t, err) err = pp.UnmarshalText([]byte("yada")) - assert.Error(t, err) + require.Error(t, err) orig := "2ms" b := []byte(orig) bj := []byte("\"" + orig + "\"") err = pp.UnmarshalText(b) - assert.NoError(t, err) + require.NoError(t, err) err = pp.UnmarshalText([]byte("three week")) - assert.Error(t, err) + require.Error(t, err) err = pp.UnmarshalText([]byte("9999999999999999999999999999999999999999999999999999999 weeks")) - assert.Error(t, err) + require.Error(t, err) txt, err := pp.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, orig, string(txt)) err = pp.UnmarshalJSON(bj) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, orig, pp.String()) err = pp.UnmarshalJSON([]byte("yada")) - assert.Error(t, err) + require.Error(t, err) err = pp.UnmarshalJSON([]byte(`"12 parsecs"`)) - assert.Error(t, err) + require.Error(t, err) err = pp.UnmarshalJSON([]byte(`"12 y"`)) - assert.Error(t, err) + require.Error(t, err) b, err = pp.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, bj, b) dur := Duration(42) bsonData, err := bson.Marshal(&dur) - assert.NoError(t, err) + require.NoError(t, err) var durCopy Duration err = bson.Unmarshal(bsonData, &durCopy) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, dur, durCopy) } @@ -78,13 +79,13 @@ func testDurationParser(t *testing.T, toParse string, expected time.Duration) { t.Helper() r, e := ParseDuration(toParse) - assert.NoError(t, e) + require.NoError(t, e) assert.Equal(t, expected, r) } func TestDurationParser_Failed(t *testing.T) { _, e := ParseDuration("45 wekk") - assert.Error(t, e) + require.Error(t, e) } func TestIsDuration_Failed(t *testing.T) { @@ -99,12 +100,12 @@ func testDurationSQLScanner(t *testing.T, dur time.Duration) { for _, value := range values { var result Duration err := result.Scan(value) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, dur, time.Duration(result)) // And the other way around resv, erv := result.Value() - assert.NoError(t, erv) + require.NoError(t, erv) assert.EqualValues(t, value, resv) } @@ -113,11 +114,11 @@ func testDurationSQLScanner(t *testing.T, dur time.Duration) { func TestDurationScanner_Nil(t *testing.T) { var result Duration err := result.Scan(nil) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, 0, time.Duration(result)) err = result.Scan("1 ms") - assert.Error(t, err) + require.Error(t, err) } func TestDurationParser(t *testing.T) { diff --git a/format.go b/format.go index ad3b3c3..ce99ce5 100644 --- a/format.go +++ b/format.go @@ -94,7 +94,7 @@ func NewSeededFormats(seeds []knownFormat, normalizer NameNormalizer) Registry { } // MapStructureHookFunc is a decode hook function for mapstructure -func (f *defaultFormats) MapStructureHookFunc() mapstructure.DecodeHookFunc { //nolint:gocyclo,cyclop +func (f *defaultFormats) MapStructureHookFunc() mapstructure.DecodeHookFunc { return func(from reflect.Type, to reflect.Type, obj interface{}) (interface{}, error) { if from.Kind() != reflect.String { return obj, nil diff --git a/format_test.go b/format_test.go index 525f19e..65882b5 100644 --- a/format_test.go +++ b/format_test.go @@ -21,6 +21,7 @@ import ( "github.com/mitchellh/mapstructure" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) type testFormat string @@ -223,9 +224,9 @@ func TestDecodeHook(t *testing.T) { Result: test, } d, err := mapstructure.NewDecoder(cfg) - assert.Nil(t, err) + require.NoError(t, err) err = d.Decode(m) - assert.Nil(t, err) + require.NoError(t, err) assert.Equal(t, exp, test) } @@ -257,11 +258,11 @@ func TestDecodeDateTimeHook(t *testing.T) { Result: test, } d, err := mapstructure.NewDecoder(cfg) - assert.Nil(t, err) + require.NoError(t, err) input := make(map[string]interface{}) input["datetime"] = tc.Input err = d.Decode(input) - assert.Error(t, err, "error expected got none") + require.Error(t, err, "error expected got none") }) } } @@ -296,11 +297,11 @@ func TestDecode_ULID_Hook_Negative(t *testing.T) { Result: test, } d, err := mapstructure.NewDecoder(cfg) - assert.NoError(t, err) + require.NoError(t, err) input := make(map[string]interface{}) input["ulid"] = tc.Input err = d.Decode(input) - assert.Error(t, err, "error expected got none") + require.Error(t, err, "error expected got none") }) } } diff --git a/time_test.go b/time_test.go index c2babb1..2dc4f2f 100644 --- a/time_test.go +++ b/time_test.go @@ -21,6 +21,7 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) @@ -83,7 +84,7 @@ func TestIsUnixZero(t *testing.T) { func TestParseDateTime_errorCases(t *testing.T) { _, err := ParseDateTime("yada") - assert.Error(t, err) + require.Error(t, err) } // TestParseDateTime tests the full cycle: @@ -93,11 +94,11 @@ func TestParseDateTime_fullCycle(t *testing.T) { t.Logf("Case #%d", caseNum) parsed, err := ParseDateTime(example.str) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, example.time, parsed) mt, err := parsed.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, []byte(example.str), mt) if example.str != "" { @@ -109,12 +110,12 @@ func TestParseDateTime_fullCycle(t *testing.T) { pp := NewDateTime() err = pp.UnmarshalText(mt) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, example.time, pp) pp = NewDateTime() err = pp.Scan(mt) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) } } @@ -145,9 +146,9 @@ func TestDateTime_IsDateTime_errorCases(t *testing.T) { func TestDateTime_UnmarshalText_errorCases(t *testing.T) { pp := NewDateTime() err := pp.UnmarshalText([]byte("yada")) - assert.Error(t, err) + require.Error(t, err) err = pp.UnmarshalJSON([]byte("yada")) - assert.Error(t, err) + require.Error(t, err) } func TestDateTime_UnmarshalText(t *testing.T) { @@ -155,12 +156,12 @@ func TestDateTime_UnmarshalText(t *testing.T) { t.Logf("Case #%d", caseNum) pp := NewDateTime() err := pp.UnmarshalText(example.in) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, example.time, pp) // Other way around val, erv := pp.Value() - assert.NoError(t, erv) + require.NoError(t, erv) assert.EqualValues(t, example.str, val) } @@ -170,22 +171,22 @@ func TestDateTime_UnmarshalJSON(t *testing.T) { t.Logf("Case #%d", caseNum) pp := NewDateTime() err := pp.UnmarshalJSON(esc(example.in)) - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, example.time, pp) } // Check UnmarshalJSON failure with no lexed items pp := NewDateTime() err := pp.UnmarshalJSON([]byte("zorg emperor")) - assert.Error(t, err) + require.Error(t, err) // Check lexer failure err = pp.UnmarshalJSON([]byte(`"zorg emperor"`)) - assert.Error(t, err) + require.Error(t, err) // Check null case err = pp.UnmarshalJSON([]byte("null")) - assert.Nil(t, err) + require.NoError(t, err) } func esc(v []byte) []byte { @@ -201,7 +202,7 @@ func TestDateTime_MarshalText(t *testing.T) { t.Logf("Case #%d", caseNum) dt := DateTime(example.time) mt, err := dt.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, []byte(example.str), mt) } } @@ -210,7 +211,7 @@ func TestDateTime_MarshalJSON(t *testing.T) { t.Logf("Case #%d", caseNum) dt := DateTime(example.time) bb, err := dt.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, esc([]byte(example.str)), bb) } } @@ -227,7 +228,7 @@ func TestDateTime_MarshalJSON_Override(t *testing.T) { t.Logf("Case #%d", caseNum) dt := DateTime(example.time.UTC()) bb, err := dt.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, esc([]byte(example.utcStr)), bb) } } @@ -238,17 +239,17 @@ func TestDateTime_Scan(t *testing.T) { pp := NewDateTime() err := pp.Scan(example.in) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) pp = NewDateTime() err = pp.Scan(string(example.in)) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) pp = NewDateTime() err = pp.Scan(example.time) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, DateTime(example.time), pp) } } @@ -258,20 +259,20 @@ func TestDateTime_Scan_Failed(t *testing.T) { zero := NewDateTime() err := pp.Scan(nil) - assert.NoError(t, err) + require.NoError(t, err) // Zero values differ... // assert.Equal(t, zero, pp) assert.Equal(t, DateTime{}, pp) err = pp.Scan("") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, zero, pp) err = pp.Scan(int64(0)) - assert.Error(t, err) + require.Error(t, err) err = pp.Scan(float64(0)) - assert.Error(t, err) + require.Error(t, err) } func TestDateTime_BSON(t *testing.T) { @@ -280,32 +281,32 @@ func TestDateTime_BSON(t *testing.T) { dt := DateTime(example.time) bsonData, err := bson.Marshal(&dt) - assert.NoError(t, err) + require.NoError(t, err) var dtCopy DateTime err = bson.Unmarshal(bsonData, &dtCopy) - assert.NoError(t, err) + require.NoError(t, err) // BSON DateTime type loses timezone information, so compare UTC() assert.Equal(t, time.Time(dt).UTC(), time.Time(dtCopy).UTC()) // Check value marshaling explicitly m := bson.M{"data": dt} bsonData, err = bson.Marshal(&m) - assert.NoError(t, err) + require.NoError(t, err) var mCopy bson.M err = bson.Unmarshal(bsonData, &mCopy) - assert.NoError(t, err) + require.NoError(t, err) data, ok := m["data"].(DateTime) - assert.Equal(t, true, ok) + assert.True(t, ok) assert.Equal(t, time.Time(dt).UTC(), time.Time(data).UTC()) } } func TestDeepCopyDateTime(t *testing.T) { p, err := ParseDateTime("2011-08-18T19:03:37.000000000+01:00") - assert.NoError(t, err) + require.NoError(t, err) in := &p out := new(DateTime) @@ -326,14 +327,14 @@ func TestGobEncodingDateTime(t *testing.T) { b := bytes.Buffer{} enc := gob.NewEncoder(&b) err := enc.Encode(DateTime(now)) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, b.Bytes()) var result DateTime dec := gob.NewDecoder(&b) err = dec.Decode(&result) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, now.Year(), time.Time(result).Year()) assert.Equal(t, now.Month(), time.Time(result).Month()) assert.Equal(t, now.Day(), time.Time(result).Day()) diff --git a/ulid_test.go b/ulid_test.go index 6f3f9b6..02f4879 100644 --- a/ulid_test.go +++ b/ulid_test.go @@ -9,6 +9,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.mongodb.org/mongo-driver/bson" ) @@ -24,29 +25,29 @@ func TestFormatULID_Text(t *testing.T) { t.Run("positive", func(t *testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) res, err := ulid.MarshalText() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, testUlid, string(res)) ulid2, _ := ParseULID(testUlidAlt) - assert.NoError(t, err) + require.NoError(t, err) what := []byte(testUlid) err = ulid2.UnmarshalText(what) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, testUlid, ulid2.String()) }) t.Run("negative", func(t *testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) what := []byte("00000000-0000-0000-0000-000000000000") err = ulid.UnmarshalText(what) - assert.Error(t, err) + require.Error(t, err) }) } @@ -57,35 +58,35 @@ func TestFormatULID_BSON(t *testing.T) { ulid, _ := ParseULID(testUlid) bsonData, err := bson.Marshal(&ulid) - assert.NoError(t, err) + require.NoError(t, err) var ulidUnmarshaled ULID err = bson.Unmarshal(bsonData, &ulidUnmarshaled) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, ulid, ulidUnmarshaled) // Check value marshaling explicitly m := bson.M{"data": ulid} bsonData, err = bson.Marshal(&m) - assert.NoError(t, err) + require.NoError(t, err) var mUnmarshaled bson.M err = bson.Unmarshal(bsonData, &mUnmarshaled) - assert.NoError(t, err) + require.NoError(t, err) data, ok := m["data"].(ULID) - assert.Equal(t, true, ok) + assert.True(t, ok) assert.Equal(t, ulid, data) }) t.Run("negative", func(t *testing.T) { t.Parallel() uuid := UUID("00000000-0000-0000-0000-000000000000") bsonData, err := bson.Marshal(&uuid) - assert.NoError(t, err) + require.NoError(t, err) var ulidUnmarshaled ULID err = bson.Unmarshal(bsonData, &ulidUnmarshaled) - assert.Error(t, err) + require.Error(t, err) }) } @@ -94,36 +95,36 @@ func TestFormatULID_JSON(t *testing.T) { t.Run("positive", func(t *testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) whatStr := fmt.Sprintf(`"%s"`, testUlidAlt) what := []byte(whatStr) err = ulid.UnmarshalJSON(what) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, testUlidAlt, ulid.String()) data, err := ulid.MarshalJSON() - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, whatStr, string(data)) }) t.Run("null", func(t *testing.T) { t.Parallel() ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) err = ulid.UnmarshalJSON([]byte("null")) - assert.Nil(t, err) + require.NoError(t, err) }) t.Run("negative", func(t *testing.T) { t.Parallel() // Check UnmarshalJSON failure with no lexed items ulid := NewULIDZero() err := ulid.UnmarshalJSON([]byte("zorg emperor")) - assert.Error(t, err) + require.Error(t, err) // Check lexer failure err = ulid.UnmarshalJSON([]byte(`"zorg emperor"`)) - assert.Error(t, err) + require.Error(t, err) }) } @@ -137,15 +138,15 @@ func TestFormatULID_Scan(t *testing.T) { srcUlid := testUlidAlt ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) err = ulid.Scan(srcUlid) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, srcUlid, ulid.String()) ulid, _ = ParseULID(testUlid) err = ulid.Scan([]byte(srcUlid)) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, srcUlid, ulid.String()) }) t.Run("db.Scan_Failed", func(t *testing.T) { @@ -155,21 +156,21 @@ func TestFormatULID_Scan(t *testing.T) { ulid, err := ParseULID(testUlid) zero := NewULIDZero() - assert.NoError(t, err) + require.NoError(t, err) err = ulid.Scan(nil) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, zero, ulid) err = ulid.Scan("") - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, zero, ulid) err = ulid.Scan(int64(0)) - assert.Error(t, err) + require.Error(t, err) err = ulid.Scan(float64(0)) - assert.Error(t, err) + require.Error(t, err) }) t.Run("db.Value", func(t *testing.T) { t.Parallel() @@ -177,10 +178,10 @@ func TestFormatULID_Scan(t *testing.T) { defer testUlidOverrideValMtx.Unlock() ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) val, err := ulid.Value() - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, testUlid, val) }) @@ -190,9 +191,9 @@ func TestFormatULID_Scan(t *testing.T) { defer testUlidOverrideMtx.Unlock() ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) ulid2, err := ParseULID(testUlidAlt) - assert.NoError(t, err) + require.NoError(t, err) ULIDScanOverrideFunc = func(raw interface{}) (ULID, error) { u := NewULIDZero() @@ -209,19 +210,19 @@ func TestFormatULID_Scan(t *testing.T) { bytes := [16]byte(ulid.ULID) err = ulid2.Scan(bytes) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, ulid2, ulid) assert.Equal(t, ulid2.String(), ulid.String()) // check other default cases became unreachable err = ulid2.Scan(testUlid) - assert.Error(t, err) + require.Error(t, err) // return default Scan method ULIDScanOverrideFunc = ULIDScanDefaultFunc err = ulid2.Scan(testUlid) - assert.NoError(t, err) - assert.Equal(t, ulid2.String(), testUlid) + require.NoError(t, err) + assert.Equal(t, testUlid, ulid2.String()) }) t.Run("override.Value", func(t *testing.T) { t.Parallel() @@ -229,9 +230,9 @@ func TestFormatULID_Scan(t *testing.T) { defer testUlidOverrideValMtx.Unlock() ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) ulid2, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) ULIDValueOverrideFunc = func(u ULID) (driver.Value, error) { bytes := [16]byte(u.ULID) @@ -240,7 +241,7 @@ func TestFormatULID_Scan(t *testing.T) { exp := [16]byte(ulid2.ULID) val, err := ulid.Value() - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, exp, val) @@ -248,7 +249,7 @@ func TestFormatULID_Scan(t *testing.T) { ULIDValueOverrideFunc = ULIDValueDefaultFunc val, err = ulid.Value() - assert.NoError(t, err) + require.NoError(t, err) assert.EqualValues(t, testUlid, val) }) @@ -256,7 +257,7 @@ func TestFormatULID_Scan(t *testing.T) { func TestFormatULID_DeepCopy(t *testing.T) { ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) in := &ulid out := new(ULID) @@ -273,19 +274,19 @@ func TestFormatULID_DeepCopy(t *testing.T) { func TestFormatULID_GobEncoding(t *testing.T) { ulid, err := ParseULID(testUlid) - assert.NoError(t, err) + require.NoError(t, err) b := bytes.Buffer{} enc := gob.NewEncoder(&b) err = enc.Encode(ulid) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, b.Bytes()) var result ULID dec := gob.NewDecoder(&b) err = dec.Decode(&result) - assert.NoError(t, err) + require.NoError(t, err) assert.Equal(t, ulid, result) assert.Equal(t, ulid.String(), result.String()) } @@ -294,10 +295,10 @@ func TestFormatULID_NewULID_and_Equal(t *testing.T) { t.Parallel() ulid1, err := NewULID() - assert.NoError(t, err) + require.NoError(t, err) ulid2, err := NewULID() - assert.NoError(t, err) + require.NoError(t, err) //nolint:gocritic assert.True(t, ulid1.Equal(ulid1), "ULID instances should be equal")