Merge branch 'master' into godriver2775-replaceerrors

Author: matthewdale

bson/doc.go

@@ -4,30 +4,14 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 
-// Package bson is a library for reading, writing, and manipulating BSON. BSON is a binary serialization format used to
-// store documents and make remote procedure calls in MongoDB. The BSON specification is located at https://bsonspec.org.
-// The BSON library handles marshaling and unmarshaling of values through a configurable codec system. For a description
-// of the codec system and examples of registering custom codecs, see the bsoncodec package. For additional information
-// and usage examples, check out the [Work with BSON] page in the Go Driver docs site.
-//
-// # Raw BSON
-//
-// The Raw family of types is used to validate and retrieve elements from a slice of bytes. This
-// type is most useful when you want do lookups on BSON bytes without unmarshaling it into another
-// type.
-//
-// Example:
-//
-//	var raw bson.Raw = ... // bytes from somewhere
-//	err := raw.Validate()
-//	if err != nil { return err }
-//	val := raw.Lookup("foo")
-//	i32, ok := val.Int32OK()
-//	// do something with i32...
+// Package bson is a library for reading, writing, and manipulating BSON. BSON is a binary serialization
+// format used to store documents and make remote procedure calls in MongoDB. For more information about
+// the Go BSON library, including usage examples, check out the [Work with BSON] page in the Go Driver
+// docs site. For more information about BSON, see https://bsonspec.org.
 //
 // # Native Go Types
 //
-// The D and M types defined in this package can be used to build representations of BSON using native Go types. D is a
+// The [D] and [M] types defined in this package can be used to build representations of BSON using native Go types. D is a
 // slice and M is a map. For more information about the use cases for these types, see the documentation on the type
 // definitions.
 //
@@ -93,26 +77,16 @@
 //  5. When unmarshaling, a field of type interface{} will follow the D/M type mappings listed above. BSON documents
 //     unmarshaled into an interface{} field will be unmarshaled as a D.
 //
-// The encoding of each struct field can be customized by the "bson" struct tag.
-//
-// This tag behavior is configurable, and different struct tag behavior can be configured by initializing a new
-// bsoncodec.StructCodec with the desired tag parser and registering that StructCodec onto the Registry. By default, JSON
-// tags are not honored, but that can be enabled by creating a StructCodec with JSONFallbackStructTagParser, like below:
-//
-// Example:
-//
-//	structcodec, _ := bsoncodec.NewStructCodec(bsoncodec.JSONFallbackStructTagParser)
-//
-// The bson tag gives the name of the field, possibly followed by a comma-separated list of options.
-// The name may be empty in order to specify options without overriding the default field name. The following options can
-// be used to configure behavior:
+// The encoding of each struct field can be customized by the "bson" struct tag. The "bson" tag gives the name of the
+// field, followed by a comma-separated list of options. The name may be omitted in order to specify options without
+// overriding the default field name. The following options can be used to configure behavior:
 //
 //  1. omitempty: If the "omitempty" struct tag is specified on a field, the field will not be marshaled if it is set to
 //     an "empty" value. Numbers, booleans, and strings are considered empty if their value is equal to the zero value for
 //     the type (i.e. 0 for numbers, false for booleans, and "" for strings). Slices, maps, and arrays are considered
 //     empty if they are of length zero. Interfaces and pointers are considered empty if their value is nil. By default,
-//     structs are only considered empty if the struct type implements [bsoncodec.Zeroer] and the IsZero
-//     method returns true. Struct types that do not implement [bsoncodec.Zeroer] are never considered empty and will be
+//     structs are only considered empty if the struct type implements [Zeroer] and the "IsZero"
+//     method returns true. Struct types that do not implement [Zeroer] are never considered empty and will be
 //     marshaled as embedded documents. NOTE: It is recommended that this tag be used for all slice and map fields.
 //
 //  2. minsize: If the minsize struct tag is specified on a field of type int64, uint, uint32, or uint64 and the value of
@@ -134,22 +108,34 @@
 //     error will be returned. This tag can be used with fields that are pointers to structs. If an inlined pointer field
 //     is nil, it will not be marshaled. For fields that are not maps or structs, this tag is ignored.
 //
-// # Marshaling and Unmarshaling
+// # Raw BSON
 //
-// Manually marshaling and unmarshaling can be done with the Marshal and Unmarshal family of functions.
+// The Raw family of types is used to validate and retrieve elements from a slice of bytes. This
+// type is most useful when you want do lookups on BSON bytes without unmarshaling it into another
+// type.
 //
-// bsoncodec code provides a system for encoding values to BSON representations and decoding
-// values from BSON representations. This package considers both binary BSON and ExtendedJSON as
-// BSON representations. The types in this package enable a flexible system for handling this
-// encoding and decoding.
+// Example:
 //
-// The codec system is composed of two parts:
+//	var raw bson.Raw = ... // bytes from somewhere
+//	err := raw.Validate()
+//	if err != nil { return err }
+//	val := raw.Lookup("foo")
+//	i32, ok := val.Int32OK()
+//	// do something with i32...
+//
+// # Custom Registry
+//
+// The Go BSON library uses a [Registry] to define encoding and decoding behavior for different data types.
+// The default encoding and decoding behavior can be customized or extended by using a modified Registry.
+// The custom registry system is composed of two parts:
 //
 // 1) [ValueEncoder] and [ValueDecoder] that handle encoding and decoding Go values to and from BSON
 // representations.
 //
 // 2) A [Registry] that holds these ValueEncoders and ValueDecoders and provides methods for
 // retrieving them.
 //
+// To use a custom Registry, use [Encoder.SetRegistry] or [Decoder.SetRegistry].
+//
 // [Work with BSON]: https://www.mongodb.com/docs/drivers/go/current/fundamentals/bson/
 package bson

internal/httputil/httputil.go

@@ -10,9 +10,17 @@ import (
 	"net/http"
 )
 
-// DefaultHTTPClient is the default HTTP client used across the driver.
-var DefaultHTTPClient = &http.Client{
-	Transport: http.DefaultTransport.(*http.Transport).Clone(),
+var DefaultHTTPClient = &http.Client{}
+
+// NewHTTPClient will return the globally-defined DefaultHTTPClient, updating
+// the transport if it differs from the http package DefaultTransport.
+func NewHTTPClient() *http.Client {
+	client := DefaultHTTPClient
+	if _, ok := http.DefaultTransport.(*http.Transport); !ok {
+		client.Transport = http.DefaultTransport
+	}
+
+	return client
 }
 
 // CloseIdleHTTPConnections closes any connections which were previously

internal/httputil/httputil_test.go

@@ -0,0 +1,41 @@
+// Copyright (C) MongoDB, Inc. 2022-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package httputil
+
+import (
+	"net/http"
+	"testing"
+
+	"go.mongodb.org/mongo-driver/v2/internal/assert"
+)
+
+type nonDefaultTransport struct{}
+
+func (*nonDefaultTransport) RoundTrip(*http.Request) (*http.Response, error) { return nil, nil }
+
+func TestDefaultHTTPClientTransport(t *testing.T) {
+	t.Run("default", func(t *testing.T) {
+		client := NewHTTPClient()
+
+		val := assert.ObjectsAreEqual(http.DefaultClient, client)
+
+		assert.True(t, val)
+		assert.Equal(t, DefaultHTTPClient, client)
+	})
+
+	t.Run("non-default global transport", func(t *testing.T) {
+		http.DefaultTransport = &nonDefaultTransport{}
+
+		client := NewHTTPClient()
+
+		val := assert.ObjectsAreEqual(&nonDefaultTransport{}, client.Transport)
+
+		assert.True(t, val)
+		assert.Equal(t, DefaultHTTPClient, client)
+		assert.NotEqual(t, http.DefaultClient, client) // Sanity Check
+	})
+}

internal/integtest/integtest.go

@@ -223,6 +223,10 @@ func AddServerlessAuthCredentials(uri string) (string, error) {
 
 // ConnString gets the globally configured connection string.
 func ConnString(t *testing.T) *connstring.ConnString {
+	if testing.Short() {
+		t.Skip("skipping integration test in short mode")
+	}
+
 	connectionStringOnce.Do(func() {
 		uri, err := MongoDBURI()
 		require.NoError(t, err, "error constructing mongodb URI: %v", err)

internal/test/aws/aws_test.go

@@ -20,9 +20,11 @@ import (
 
 func TestAWS(t *testing.T) {
 	uri := os.Getenv("MONGODB_URI")
+	if uri == "" {
+		t.Skip("Skipping test: MONGODB_URI environment variable is not set")
+	}
 
 	client, err := mongo.Connect(options.Client().ApplyURI(uri))
-	require.NoError(t, err, "Connect error")
 
 	defer func() {
 		err = client.Disconnect(context.Background())

mongo/options/clientoptions.go

@@ -68,7 +68,7 @@ type ContextDialer interface {
 // Credential can be used to provide authentication options when configuring a Client.
 //
 // AuthMechanism: the mechanism to use for authentication. Supported values include "SCRAM-SHA-256", "SCRAM-SHA-1",
-// "MONGODB-CR", "PLAIN", "GSSAPI", "MONGODB-X509", and "MONGODB-AWS". This can also be set through the "authMechanism"
+// "PLAIN", "GSSAPI", "MONGODB-X509", and "MONGODB-AWS". This can also be set through the "authMechanism"
 // URI option. (e.g. "authMechanism=PLAIN"). For more information, see
 // https://www.mongodb.com/docs/manual/core/authentication-mechanisms/.
 //
@@ -311,7 +311,7 @@ type ClientOptions struct {
 // Client creates a new ClientOptions instance.
 func Client() *ClientOptions {
 	opts := &ClientOptions{}
-	opts = opts.SetHTTPClient(httputil.DefaultHTTPClient)
+	opts = opts.SetHTTPClient(httputil.NewHTTPClient())
 
 	return opts
 }

mongo/options/clientoptions_test.go

@@ -527,6 +527,22 @@ func TestClientOptions(t *testing.T) {
 	})
 }
 
+type nonDefaultTransport struct{}
+
+func (*nonDefaultTransport) RoundTrip(*http.Request) (*http.Response, error) { return nil, nil }
+
+func TestClientHTTPTransport(t *testing.T) {
+	t.Run("Default client", func(t *testing.T) {
+		got := Client().HTTPClient
+		assert.Equal(t, http.DefaultClient, got)
+	})
+	t.Run("Non-default global transport", func(t *testing.T) {
+		http.DefaultTransport = &nonDefaultTransport{}
+		got := Client().HTTPClient.Transport
+		assert.Equal(t, &nonDefaultTransport{}, got)
+	})
+}
+
 func createCertPool(t *testing.T, paths ...string) *x509.CertPool {
 	t.Helper()
 

testdata/specifications

@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"strings"
 
 	"go.mongodb.org/mongo-driver/v2/mongo/address"
 	"go.mongodb.org/mongo-driver/v2/x/mongo/driver"
@@ -31,7 +32,6 @@ func init() {
 	RegisterAuthenticatorFactory("", newDefaultAuthenticator)
 	RegisterAuthenticatorFactory(SCRAMSHA1, newScramSHA1Authenticator)
 	RegisterAuthenticatorFactory(SCRAMSHA256, newScramSHA256Authenticator)
-	RegisterAuthenticatorFactory(MONGODBCR, newMongoDBCRAuthenticator)
 	RegisterAuthenticatorFactory(PLAIN, newPlainAuthenticator)
 	RegisterAuthenticatorFactory(GSSAPI, newGSSAPIAuthenticator)
 	RegisterAuthenticatorFactory(MongoDBX509, newMongoDBX509Authenticator)
@@ -41,6 +41,12 @@ func init() {
 
 // CreateAuthenticator creates an authenticator.
 func CreateAuthenticator(name string, cred *Cred, httpClient *http.Client) (Authenticator, error) {
+	// Return a custom error to indicate why auth mechanism "MONGODB-CR" is
+	// missing, even though it was previously available.
+	if strings.EqualFold(name, "MONGODB-CR") {
+		return nil, errors.New(`auth mechanism "MONGODB-CR" is no longer available in any supported version of MongoDB`)
+	}
+
 	if f, ok := authFactories[name]; ok {
 		return f(cred, httpClient)
 	}

x/mongo/driver/auth/auth.go

@@ -8,6 +8,7 @@ package auth_test
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"testing"
@@ -29,11 +30,12 @@ func TestCreateAuthenticator(t *testing.T) {
 		name   string
 		source string
 		auth   auth.Authenticator
+		err    error
 	}{
 		{name: "", auth: &auth.DefaultAuthenticator{}},
 		{name: "SCRAM-SHA-1", auth: &auth.ScramAuthenticator{}},
 		{name: "SCRAM-SHA-256", auth: &auth.ScramAuthenticator{}},
-		{name: "MONGODB-CR", auth: &auth.MongoDBCRAuthenticator{}},
+		{name: "MONGODB-CR", err: errors.New(`auth mechanism "MONGODB-CR" is no longer available in any supported version of MongoDB`)},
 		{name: "PLAIN", auth: &auth.PlainAuthenticator{}},
 		{name: "MONGODB-X509", auth: &auth.MongoDBX509Authenticator{}},
 	}
@@ -47,6 +49,10 @@ func TestCreateAuthenticator(t *testing.T) {
 			}
 
 			a, err := auth.CreateAuthenticator(test.name, cred, &http.Client{})
+			if test.err != nil {
+				require.EqualError(t, err, test.err.Error())
+				return
+			}
 			require.NoError(t, err)
 			require.IsType(t, test.auth, a)
 		})