GODRIVER-2603 [master] - Revised error handling using Go 1.13 error APIs (#1474)

blink1073 · kumarlokesh · web-flow · commit d33301f67192 · 2023-11-20T14:27:49.000-06:00
Co-authored-by: Lokesh Kumar &lt;lkumar94@gmail.com&gt;
diff --git a/benchmark/harness_case.go b/benchmark/harness_case.go
@@ -8,6 +8,7 @@ package benchmark
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"reflect"
@@ -95,12 +96,12 @@ benchRepeat:
 		res.Duration = c.elapsed
 		c.cumulativeRuntime += res.Duration
 
-		switch res.Error {
-		case context.DeadlineExceeded:
+		switch {
+		case errors.Is(res.Error, context.DeadlineExceeded):
 			break benchRepeat
-		case context.Canceled:
+		case errors.Is(res.Error, context.Canceled):
 			break benchRepeat
-		case nil:
+		case res.Error == nil:
 			out.Trials++
 			c.elapsed = 0
 			out.Raw = append(out.Raw, res)
diff --git a/bson/bsoncodec/default_value_decoders.go b/bson/bsoncodec/default_value_decoders.go
@@ -41,7 +41,7 @@ func newDefaultStructCodec() *StructCodec {
 	if err != nil {
 		// This function is called from the codec registration path, so errors can't be propagated. If there's an error
 		// constructing the StructCodec, we panic to avoid losing it.
-		panic(fmt.Errorf("error creating default StructCodec: %v", err))
+		panic(fmt.Errorf("error creating default StructCodec: %w", err))
 	}
 	return codec
 }
@@ -178,7 +178,7 @@ func (dvd DefaultValueDecoders) DDecodeValue(dc DecodeContext, vr bsonrw.ValueRe
 
 	for {
 		key, elemVr, err := dr.ReadElement()
-		if err == bsonrw.ErrEOD {
+		if errors.Is(err, bsonrw.ErrEOD) {
 			break
 		} else if err != nil {
 			return err
@@ -1379,7 +1379,7 @@ func (dvd DefaultValueDecoders) MapDecodeValue(dc DecodeContext, vr bsonrw.Value
 	keyType := val.Type().Key()
 	for {
 		key, vr, err := dr.ReadElement()
-		if err == bsonrw.ErrEOD {
+		if errors.Is(err, bsonrw.ErrEOD) {
 			break
 		}
 		if err != nil {
@@ -1675,7 +1675,7 @@ func (dvd DefaultValueDecoders) decodeDefault(dc DecodeContext, vr bsonrw.ValueR
 	idx := 0
 	for {
 		vr, err := ar.ReadValue()
-		if err == bsonrw.ErrEOA {
+		if errors.Is(err, bsonrw.ErrEOA) {
 			break
 		}
 		if err != nil {
diff --git a/bson/bsoncodec/default_value_decoders_test.go b/bson/bsoncodec/default_value_decoders_test.go
@@ -2370,8 +2370,8 @@ func TestDefaultValueDecoders(t *testing.T) {
 						return
 					}
 					if rc.val == cansettest { // We're doing an IsValid and CanSet test
-						wanterr, ok := rc.err.(ValueDecoderError)
-						if !ok {
+						var wanterr ValueDecoderError
+						if !errors.As(rc.err, &wanterr) {
 							t.Fatalf("Error must be a DecodeValueError, but got a %T", rc.err)
 						}
 
@@ -3685,8 +3685,8 @@ func TestDefaultValueDecoders(t *testing.T) {
 			val := reflect.New(reflect.TypeOf(outer{})).Elem()
 			err := defaultTestStructCodec.DecodeValue(dc, vr, val)
 
-			decodeErr, ok := err.(*DecodeError)
-			assert.True(t, ok, "expected DecodeError, got %v of type %T", err, err)
+			var decodeErr *DecodeError
+			assert.True(t, errors.As(err, &decodeErr), "expected DecodeError, got %v of type %T", err, err)
 			expectedKeys := []string{"foo", "bar"}
 			assert.Equal(t, expectedKeys, decodeErr.Keys(), "expected keys slice %v, got %v", expectedKeys,
 				decodeErr.Keys())
diff --git a/bson/bsoncodec/default_value_encoders.go b/bson/bsoncodec/default_value_encoders.go
@@ -343,7 +343,7 @@ func (dve DefaultValueEncoders) mapEncodeValue(ec EncodeContext, dw bsonrw.Docum
 		}
 
 		currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.MapIndex(key))
-		if lookupErr != nil && lookupErr != errInvalidValue {
+		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
 			return lookupErr
 		}
 
@@ -418,7 +418,7 @@ func (dve DefaultValueEncoders) ArrayEncodeValue(ec EncodeContext, vw bsonrw.Val
 
 	for idx := 0; idx < val.Len(); idx++ {
 		currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
-		if lookupErr != nil && lookupErr != errInvalidValue {
+		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
 			return lookupErr
 		}
 
@@ -487,7 +487,7 @@ func (dve DefaultValueEncoders) SliceEncodeValue(ec EncodeContext, vw bsonrw.Val
 
 	for idx := 0; idx < val.Len(); idx++ {
 		currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
-		if lookupErr != nil && lookupErr != errInvalidValue {
+		if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {
 			return lookupErr
 		}
 
diff --git a/bson/bsoncodec/map_codec.go b/bson/bsoncodec/map_codec.go
@@ -313,7 +313,7 @@ func (mc *MapCodec) decodeKey(key string, keyType reflect.Type) (reflect.Value,
 			if mc.EncodeKeysWithStringer {
 				parsed, err := strconv.ParseFloat(key, 64)
 				if err != nil {
-					return keyVal, fmt.Errorf("Map key is defined to be a decimal type (%v) but got error %v", keyType.Kind(), err)
+					return keyVal, fmt.Errorf("Map key is defined to be a decimal type (%v) but got error %w", keyType.Kind(), err)
 				}
 				keyVal = reflect.ValueOf(parsed)
 				break
diff --git a/bson/bsoncodec/struct_codec.go b/bson/bsoncodec/struct_codec.go
@@ -239,8 +239,8 @@ func (sc *StructCodec) EncodeValue(ec EncodeContext, vw bsonrw.ValueWriter, val
 }
 
 func newDecodeError(key string, original error) error {
-	de, ok := original.(*DecodeError)
-	if !ok {
+	var de *DecodeError
+	if !errors.As(original, &de) {
 		return &DecodeError{
 			keys:    []string{key},
 			wrapped: original,
diff --git a/bson/decoder_example_test.go b/bson/decoder_example_test.go
@@ -8,6 +8,7 @@ package bson_test
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 
@@ -200,7 +201,7 @@ func ExampleDecoder_multipleExtendedJSONDocuments() {
 	for {
 		var res Coordinate
 		err = decoder.Decode(&res)
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			break
 		}
 		if err != nil {
diff --git a/bson/encoder_example_test.go b/bson/encoder_example_test.go
@@ -8,6 +8,7 @@ package bson_test
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 
@@ -162,7 +163,7 @@ func ExampleEncoder_multipleBSONDocuments() {
 	// Extended JSON by converting them to bson.Raw.
 	for {
 		doc, err := bson.ReadDocument(buf)
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			return
 		}
 		if err != nil {
diff --git a/bson/primitive/objectid.go b/bson/primitive/objectid.go
@@ -183,7 +183,7 @@ func processUniqueBytes() [5]byte {
 	var b [5]byte
 	_, err := io.ReadFull(rand.Reader, b[:])
 	if err != nil {
-		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %v", err))
+		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %w", err))
 	}
 
 	return b
@@ -193,7 +193,7 @@ func readRandomUint32() uint32 {
 	var b [4]byte
 	_, err := io.ReadFull(rand.Reader, b[:])
 	if err != nil {
-		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %v", err))
+		panic(fmt.Errorf("cannot initialize objectid package with crypto.rand.Reader: %w", err))
 	}
 
 	return (uint32(b[0]) << 0) | (uint32(b[1]) << 8) | (uint32(b[2]) << 16) | (uint32(b[3]) << 24)
diff --git a/cmd/testatlas/main.go b/cmd/testatlas/main.go
@@ -8,6 +8,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"fmt"
 	"time"
@@ -52,7 +53,7 @@ func main() {
 func runTest(ctx context.Context, clientOpts *options.ClientOptions) error {
 	client, err := mongo.Connect(ctx, clientOpts)
 	if err != nil {
-		return fmt.Errorf("Connect error: %v", err)
+		return fmt.Errorf("Connect error: %w", err)
 	}
 
 	defer func() {
@@ -63,12 +64,12 @@ func runTest(ctx context.Context, clientOpts *options.ClientOptions) error {
 	cmd := bson.D{{handshake.LegacyHello, 1}}
 	err = db.RunCommand(ctx, cmd).Err()
 	if err != nil {
-		return fmt.Errorf("legacy hello error: %v", err)
+		return fmt.Errorf("legacy hello error: %w", err)
 	}
 
 	coll := db.Collection("test")
-	if err = coll.FindOne(ctx, bson.D{{"x", 1}}).Err(); err != nil && err != mongo.ErrNoDocuments {
-		return fmt.Errorf("FindOne error: %v", err)
+	if err = coll.FindOne(ctx, bson.D{{"x", 1}}).Err(); err != nil && !errors.Is(err, mongo.ErrNoDocuments) {
+		return fmt.Errorf("FindOne error: %w", err)
 	}
 	return nil
 }
diff --git a/cmd/testaws/main.go b/cmd/testaws/main.go
@@ -8,6 +8,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 
@@ -33,7 +34,7 @@ func main() {
 
 	db := client.Database("aws")
 	coll := db.Collection("test")
-	if err = coll.FindOne(ctx, bson.D{{"x", 1}}).Err(); err != nil && err != mongo.ErrNoDocuments {
+	if err = coll.FindOne(ctx, bson.D{{"x", 1}}).Err(); err != nil && !errors.Is(err, mongo.ErrNoDocuments) {
 		panic(fmt.Sprintf("FindOne error: %v", err))
 	}
 }
diff --git a/internal/aws/awserr/types.go b/internal/aws/awserr/types.go
@@ -11,6 +11,7 @@
 package awserr
 
 import (
+	"errors"
 	"fmt"
 )
 
@@ -106,7 +107,8 @@ func (b baseError) OrigErr() error {
 	case 1:
 		return b.errs[0]
 	default:
-		if err, ok := b.errs[0].(Error); ok {
+		var err Error
+		if errors.As(b.errs[0], &err) {
 			return NewBatchError(err.Code(), err.Message(), b.errs[1:])
 		}
 		return NewBatchError("BatchedErrors",
diff --git a/internal/csfle/csfle.go b/internal/csfle/csfle.go
@@ -7,6 +7,7 @@
 package csfle
 
 import (
+	"errors"
 	"fmt"
 
 	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
@@ -23,7 +24,7 @@ func GetEncryptedStateCollectionName(efBSON bsoncore.Document, dataCollectionNam
 	fieldName := stateCollection + "Collection"
 	val, err := efBSON.LookupErr(fieldName)
 	if err != nil {
-		if err != bsoncore.ErrElementNotFound {
+		if !errors.Is(err, bsoncore.ErrElementNotFound) {
 			return "", err
 		}
 		// Return default name.
diff --git a/mongo/cursor.go b/mongo/cursor.go
@@ -160,13 +160,13 @@ func (c *Cursor) next(ctx context.Context, nonBlocking bool) bool {
 		ctx = context.Background()
 	}
 	doc, err := c.batch.Next()
-	switch err {
-	case nil:
+	switch {
+	case err == nil:
 		// Consume the next document in the current batch.
 		c.batchLength--
 		c.Current = bson.Raw(doc)
 		return true
-	case io.EOF: // Need to do a getMore
+	case errors.Is(err, io.EOF): // Need to do a getMore
 	default:
 		c.err = err
 		return false
@@ -204,12 +204,12 @@ func (c *Cursor) next(ctx context.Context, nonBlocking bool) bool {
 		c.batch = c.bc.Batch()
 		c.batchLength = c.batch.DocumentCount()
 		doc, err = c.batch.Next()
-		switch err {
-		case nil:
+		switch {
+		case err == nil:
 			c.batchLength--
 			c.Current = bson.Raw(doc)
 			return true
-		case io.EOF: // Empty batch so we continue
+		case errors.Is(err, io.EOF): // Empty batch so we continue
 		default:
 			c.err = err
 			return false
diff --git a/mongo/integration/errors_test.go b/mongo/integration/errors_test.go
@@ -12,6 +12,7 @@ package integration
 import (
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"net"
 	"testing"
@@ -45,18 +46,6 @@ func (n netErr) Temporary() bool {
 
 var _ net.Error = (*netErr)(nil)
 
-type wrappedError struct {
-	err error
-}
-
-func (we wrappedError) Error() string {
-	return we.err.Error()
-}
-
-func (we wrappedError) Unwrap() error {
-	return we.err
-}
-
 func TestErrors(t *testing.T) {
 	mt := mtest.New(t, noClientOpts)
 
@@ -478,7 +467,7 @@ func TestErrors(t *testing.T) {
 					},
 					false,
 				},
-				{"wrapped error", wrappedError{mongo.CommandError{11000, "", nil, "blah", nil, nil}}, true},
+				{"wrapped error", fmt.Errorf("%w", mongo.CommandError{11000, "", nil, "blah", nil, nil}), true},
 				{"other error type", errors.New("foo"), false},
 			}
 			for _, tc := range testCases {
@@ -499,7 +488,7 @@ func TestErrors(t *testing.T) {
 			}{
 				{"ServerError true", mongo.CommandError{100, "", []string{networkLabel}, "blah", nil, nil}, true},
 				{"ServerError false", mongo.CommandError{100, "", []string{otherLabel}, "blah", nil, nil}, false},
-				{"wrapped error", wrappedError{mongo.CommandError{100, "", []string{networkLabel}, "blah", nil, nil}}, true},
+				{"wrapped error", fmt.Errorf("%w", mongo.CommandError{100, "", []string{networkLabel}, "blah", nil, nil}), true},
 				{"other error type", errors.New("foo"), false},
 			}
 			for _, tc := range testCases {
@@ -533,8 +522,8 @@ func TestErrors(t *testing.T) {
 				{"net error true", mongo.CommandError{
 					100, "", []string{"other"}, "blah", netErr{true}, nil}, true},
 				{"net error false", netErr{false}, false},
-				{"wrapped error", wrappedError{mongo.CommandError{
-					100, "", []string{"other"}, "blah", context.DeadlineExceeded, nil}}, true},
+				{"wrapped error", fmt.Errorf("%w", mongo.CommandError{
+					100, "", []string{"other"}, "blah", context.DeadlineExceeded, nil}), true},
 				{"other error", errors.New("foo"), false},
 			}
 			for _, tc := range testCases {
diff --git a/mongo/integration/mtest/global_state.go b/mongo/integration/mtest/global_state.go
@@ -79,7 +79,7 @@ func ServerVersion() string {
 func SetFailPoint(fp FailPoint, client *mongo.Client) error {
 	admin := client.Database("admin")
 	if err := admin.RunCommand(context.Background(), fp).Err(); err != nil {
-		return fmt.Errorf("error creating fail point: %v", err)
+		return fmt.Errorf("error creating fail point: %w", err)
 	}
 	return nil
 }
@@ -89,7 +89,7 @@ func SetFailPoint(fp FailPoint, client *mongo.Client) error {
 func SetRawFailPoint(fp bson.Raw, client *mongo.Client) error {
 	admin := client.Database("admin")
 	if err := admin.RunCommand(context.Background(), fp).Err(); err != nil {
-		return fmt.Errorf("error creating fail point: %v", err)
+		return fmt.Errorf("error creating fail point: %w", err)
 	}
 	return nil
 }
diff --git a/mongo/integration/mtest/mongotest.go b/mongo/integration/mtest/mongotest.go
diff --git a/mongo/integration/mtest/options.go b/mongo/integration/mtest/options.go
diff --git a/mongo/with_transactions_test.go b/mongo/with_transactions_test.go
diff --git a/x/mongo/driver/batch_cursor.go b/x/mongo/driver/batch_cursor.go
diff --git a/x/mongo/driver/connstring/connstring.go b/x/mongo/driver/connstring/connstring.go
diff --git a/x/mongo/driver/ocsp/config.go b/x/mongo/driver/ocsp/config.go

Original file line number	Diff line number	Diff line change
`@@ -343,7 +343,7 @@ func (dve DefaultValueEncoders) mapEncodeValue(ec EncodeContext, dw bsonrw.Docum`
`343`	`343`	`}`
`344`	`344`
`345`	`345`	`currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.MapIndex(key))`
`346`		`- if lookupErr != nil && lookupErr != errInvalidValue {`
	`346`	`+ if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {`
`347`	`347`	`return lookupErr`
`348`	`348`	`}`
`349`	`349`
`@@ -418,7 +418,7 @@ func (dve DefaultValueEncoders) ArrayEncodeValue(ec EncodeContext, vw bsonrw.Val`
`418`	`418`
`419`	`419`	`for idx := 0; idx < val.Len(); idx++ {`
`420`	`420`	`currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.Index(idx))`
`421`		`- if lookupErr != nil && lookupErr != errInvalidValue {`
	`421`	`+ if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {`
`422`	`422`	`return lookupErr`
`423`	`423`	`}`
`424`	`424`
`@@ -487,7 +487,7 @@ func (dve DefaultValueEncoders) SliceEncodeValue(ec EncodeContext, vw bsonrw.Val`
`487`	`487`
`488`	`488`	`for idx := 0; idx < val.Len(); idx++ {`
`489`	`489`	`currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.Index(idx))`
`490`		`- if lookupErr != nil && lookupErr != errInvalidValue {`
	`490`	`+ if lookupErr != nil && !errors.Is(lookupErr, errInvalidValue) {`
`491`	`491`	`return lookupErr`
`492`	`492`	`}`
`493`	`493`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ func (mc *MapCodec) decodeKey(key string, keyType reflect.Type) (reflect.Value,`
`313`	`313`	`if mc.EncodeKeysWithStringer {`
`314`	`314`	`parsed, err := strconv.ParseFloat(key, 64)`
`315`	`315`	`if err != nil {`
`316`		`- return keyVal, fmt.Errorf("Map key is defined to be a decimal type (%v) but got error %v", keyType.Kind(), err)`
	`316`	`+ return keyVal, fmt.Errorf("Map key is defined to be a decimal type (%v) but got error %w", keyType.Kind(), err)`
`317`	`317`	`}`
`318`	`318`	`keyVal = reflect.ValueOf(parsed)`
`319`	`319`	`break`