Merge branch 'master' into godriver3475-fix-createcoll-doc

Author: matthewdale

bson/bson_binary_vector_spec_test.go

@@ -9,7 +9,6 @@ package bson
 import (
 	"encoding/hex"
 	"encoding/json"
-	"fmt"
 	"math"
 	"os"
 	"path"
@@ -64,53 +63,13 @@ func TestBsonBinaryVectorSpec(t *testing.T) {
 		})
 	}
 
-	t.Run("FLOAT32 with padding", func(t *testing.T) {
-		t.Parallel()
-
-		t.Run("Unmarshaling", func(t *testing.T) {
-			val := D{{"vector", Binary{Subtype: TypeBinaryVector, Data: []byte{Float32Vector, 3}}}}
-			b, err := Marshal(val)
-			require.NoError(t, err, "marshaling test BSON")
-			var got struct {
-				Vector Vector
-			}
-			err = Unmarshal(b, &got)
-			require.ErrorContains(t, err, errNonZeroVectorPadding.Error())
-		})
-	})
-
-	t.Run("INT8 with padding", func(t *testing.T) {
-		t.Parallel()
-
-		t.Run("Unmarshaling", func(t *testing.T) {
-			val := D{{"vector", Binary{Subtype: TypeBinaryVector, Data: []byte{Int8Vector, 3}}}}
-			b, err := Marshal(val)
-			require.NoError(t, err, "marshaling test BSON")
-			var got struct {
-				Vector Vector
-			}
-			err = Unmarshal(b, &got)
-			require.ErrorContains(t, err, errNonZeroVectorPadding.Error())
-		})
-	})
-
 	t.Run("Padding specified with no vector data PACKED_BIT", func(t *testing.T) {
 		t.Parallel()
 
 		t.Run("Marshaling", func(t *testing.T) {
 			_, err := NewPackedBitVector(nil, 1)
 			require.EqualError(t, err, errNonZeroVectorPadding.Error())
 		})
-		t.Run("Unmarshaling", func(t *testing.T) {
-			val := D{{"vector", Binary{Subtype: TypeBinaryVector, Data: []byte{PackedBitVector, 1}}}}
-			b, err := Marshal(val)
-			require.NoError(t, err, "marshaling test BSON")
-			var got struct {
-				Vector Vector
-			}
-			err = Unmarshal(b, &got)
-			require.ErrorContains(t, err, errNonZeroVectorPadding.Error())
-		})
 	})
 
 	t.Run("Exceeding maximum padding PACKED_BIT", func(t *testing.T) {
@@ -120,47 +79,9 @@ func TestBsonBinaryVectorSpec(t *testing.T) {
 			_, err := NewPackedBitVector(nil, 8)
 			require.EqualError(t, err, errVectorPaddingTooLarge.Error())
 		})
-		t.Run("Unmarshaling", func(t *testing.T) {
-			val := D{{"vector", Binary{Subtype: TypeBinaryVector, Data: []byte{PackedBitVector, 8}}}}
-			b, err := Marshal(val)
-			require.NoError(t, err, "marshaling test BSON")
-			var got struct {
-				Vector Vector
-			}
-			err = Unmarshal(b, &got)
-			require.ErrorContains(t, err, errVectorPaddingTooLarge.Error())
-		})
 	})
 }
 
-// TODO: This test may be added into the spec tests.
-func TestFloat32VectorWithInsufficientData(t *testing.T) {
-	t.Parallel()
-
-	val := Binary{Subtype: TypeBinaryVector}
-
-	for _, tc := range [][]byte{
-		{Float32Vector, 0, 42},
-		{Float32Vector, 0, 42, 42},
-		{Float32Vector, 0, 42, 42, 42},
-
-		{Float32Vector, 0, 42, 42, 42, 42, 42},
-		{Float32Vector, 0, 42, 42, 42, 42, 42, 42},
-		{Float32Vector, 0, 42, 42, 42, 42, 42, 42, 42},
-	} {
-		t.Run(fmt.Sprintf("marshaling %d bytes", len(tc)-2), func(t *testing.T) {
-			val.Data = tc
-			b, err := Marshal(D{{"vector", val}})
-			require.NoError(t, err, "marshaling test BSON")
-			var got struct {
-				Vector Vector
-			}
-			err = Unmarshal(b, &got)
-			require.ErrorContains(t, err, errInsufficientVectorData.Error())
-		})
-	}
-}
-
 func convertSlice[T int8 | float32 | byte](s []interface{}) []T {
 	v := make([]T, len(s))
 	for i, e := range s {
@@ -208,33 +129,44 @@ func runBsonBinaryVectorTest(t *testing.T, testKey string, test bsonBinaryVector
 
 	t.Run("Unmarshaling", func(t *testing.T) {
 		skipCases := map[string]string{
-			"FLOAT32 with padding":                             "run in alternative case",
-			"Overflow Vector INT8":                             "compile-time restriction",
-			"Underflow Vector INT8":                            "compile-time restriction",
-			"INT8 with padding":                                "run in alternative case",
-			"INT8 with float inputs":                           "compile-time restriction",
-			"Overflow Vector PACKED_BIT":                       "compile-time restriction",
-			"Underflow Vector PACKED_BIT":                      "compile-time restriction",
-			"Vector with float values PACKED_BIT":              "compile-time restriction",
-			"Padding specified with no vector data PACKED_BIT": "run in alternative case",
-			"Exceeding maximum padding PACKED_BIT":             "run in alternative case",
-			"Negative padding PACKED_BIT":                      "compile-time restriction",
+			"Overflow Vector INT8":                "compile-time restriction",
+			"Underflow Vector INT8":               "compile-time restriction",
+			"INT8 with float inputs":              "compile-time restriction",
+			"Overflow Vector PACKED_BIT":          "compile-time restriction",
+			"Underflow Vector PACKED_BIT":         "compile-time restriction",
+			"Vector with float values PACKED_BIT": "compile-time restriction",
+			"Negative padding PACKED_BIT":         "compile-time restriction",
 		}
 		if reason, ok := skipCases[test.Description]; ok {
 			t.Skipf("skip test case %s: %s", test.Description, reason)
 		}
 
+		errMap := map[string]string{
+			"FLOAT32 with padding":                             "padding must be 0",
+			"INT8 with padding":                                "padding must be 0",
+			"Padding specified with no vector data PACKED_BIT": "padding must be 0",
+			"Exceeding maximum padding PACKED_BIT":             "padding cannot be larger than 7",
+		}
+
 		t.Parallel()
 
 		var got map[string]Vector
 		err := Unmarshal(testBSON, &got)
-		require.NoError(t, err)
-		require.Equal(t, testVector, got)
+		if test.Valid {
+			require.NoError(t, err)
+			require.Equal(t, testVector, got)
+		} else if errMsg, ok := errMap[test.Description]; ok {
+			require.ErrorContains(t, err, errMsg)
+		} else {
+			require.Error(t, err)
+		}
 	})
 
 	t.Run("Marshaling", func(t *testing.T) {
 		skipCases := map[string]string{
 			"FLOAT32 with padding":                             "private padding field",
+			"Insufficient vector data with 3 bytes FLOAT32":    "invalid case",
+			"Insufficient vector data with 5 bytes FLOAT32":    "invalid case",
 			"Overflow Vector INT8":                             "compile-time restriction",
 			"Underflow Vector INT8":                            "compile-time restriction",
 			"INT8 with padding":                                "private padding field",

bson/default_value_decoders.go

@@ -1221,7 +1221,13 @@ func valueUnmarshalerDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Va
 		return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
 	}
 
-	if vr.Type() == TypeNull {
+	// If BSON value is null and the go value is a pointer, then don't call
+	// UnmarshalBSONValue. Even if the Go pointer is already initialized (i.e.,
+	// non-nil), encountering null in BSON will result in the pointer being
+	// directly set to nil here. Since the pointer is being replaced with nil,
+	// there is no opportunity (or reason) for the custom UnmarshalBSONValue logic
+	// to be called.
+	if vr.Type() == TypeNull && val.Kind() == reflect.Ptr {
 		val.Set(reflect.Zero(val.Type()))
 
 		return vr.ReadNull()

bson/unmarshal.go

@@ -36,7 +36,11 @@ type ValueUnmarshaler interface {
 }
 
 // Unmarshal parses the BSON-encoded data and stores the result in the value
-// pointed to by val. If val is nil or not a pointer, Unmarshal returns an error.
+// pointed to by val. If val is nil or not a pointer, Unmarshal returns an
+// error.
+//
+// When unmarshaling BSON, if the BSON value is null and the Go value is a
+// pointer, the pointer is set to nil without calling UnmarshalBSONValue.
 func Unmarshal(data []byte, val interface{}) error {
 	vr := newDocumentReader(bytes.NewReader(data))
 	if l, err := vr.peekLength(); err != nil {

bson/unmarshal_value_test.go

@@ -13,6 +13,7 @@ import (
 	"testing"
 
 	"go.mongodb.org/mongo-driver/v2/internal/assert"
+	"go.mongodb.org/mongo-driver/v2/internal/require"
 	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
 )
 
@@ -33,6 +34,26 @@ func TestUnmarshalValue(t *testing.T) {
 	}
 }
 
+func TestInitializedPointerDataWithBSONNull(t *testing.T) {
+	// Set up the test case with initialized pointers.
+	tc := unmarshalBehaviorTestCase{
+		BSONValuePtrTracker: &unmarshalBSONValueCallTracker{},
+		BSONPtrTracker:      &unmarshalBSONCallTracker{},
+	}
+	// Create BSON data where the '*_ptr_tracker' fields are explicitly set to
+	// null.
+	bytes := docToBytes(D{
+		{Key: "bv_ptr_tracker", Value: nil},
+		{Key: "b_ptr_tracker", Value: nil},
+	})
+	// Unmarshal the BSON data into the test case struct. This should set the
+	// pointer fields to nil due to the BSON null value.
+	err := Unmarshal(bytes, &tc)
+	require.NoError(t, err)
+	assert.Nil(t, tc.BSONValuePtrTracker)
+	assert.Nil(t, tc.BSONPtrTracker)
+}
+
 // tests covering GODRIVER-2779
 func BenchmarkSliceCodecUnmarshal(b *testing.B) {
 	benchmarks := []struct {

bson/unmarshaling_cases_test.go

@@ -172,6 +172,70 @@ func unmarshalingTestCases() []unmarshalingTestCase {
 			want:  &valNonPtrStruct,
 			data:  docToBytes(valNonPtrStruct),
 		},
+		{
+			name:  "nil pointer and non-pointer type with literal null BSON",
+			sType: reflect.TypeOf(unmarshalBehaviorTestCase{}),
+			want: &unmarshalBehaviorTestCase{
+				BSONValueTracker: unmarshalBSONValueCallTracker{
+					called: true,
+				},
+				BSONValuePtrTracker: nil,
+				BSONTracker: unmarshalBSONCallTracker{
+					called: true,
+				},
+				BSONPtrTracker: nil,
+			},
+			data: docToBytes(D{
+				{Key: "bv_tracker", Value: nil},
+				{Key: "bv_ptr_tracker", Value: nil},
+				{Key: "b_tracker", Value: nil},
+				{Key: "b_ptr_tracker", Value: nil},
+			}),
+		},
+		{
+			name:  "nil pointer and non-pointer type with BSON minkey",
+			sType: reflect.TypeOf(unmarshalBehaviorTestCase{}),
+			want: &unmarshalBehaviorTestCase{
+				BSONValueTracker: unmarshalBSONValueCallTracker{
+					called: true,
+				},
+				BSONValuePtrTracker: &unmarshalBSONValueCallTracker{
+					called: true,
+				},
+				BSONTracker: unmarshalBSONCallTracker{
+					called: true,
+				},
+				BSONPtrTracker: nil,
+			},
+			data: docToBytes(D{
+				{Key: "bv_tracker", Value: MinKey{}},
+				{Key: "bv_ptr_tracker", Value: MinKey{}},
+				{Key: "b_tracker", Value: MinKey{}},
+				{Key: "b_ptr_tracker", Value: MinKey{}},
+			}),
+		},
+		{
+			name:  "nil pointer and non-pointer type with BSON maxkey",
+			sType: reflect.TypeOf(unmarshalBehaviorTestCase{}),
+			want: &unmarshalBehaviorTestCase{
+				BSONValueTracker: unmarshalBSONValueCallTracker{
+					called: true,
+				},
+				BSONValuePtrTracker: &unmarshalBSONValueCallTracker{
+					called: true,
+				},
+				BSONTracker: unmarshalBSONCallTracker{
+					called: true,
+				},
+				BSONPtrTracker: nil,
+			},
+			data: docToBytes(D{
+				{Key: "bv_tracker", Value: MaxKey{}},
+				{Key: "bv_ptr_tracker", Value: MaxKey{}},
+				{Key: "b_tracker", Value: MaxKey{}},
+				{Key: "b_ptr_tracker", Value: MaxKey{}},
+			}),
+		},
 	}
 }
 
@@ -267,3 +331,39 @@ func (ms *myString) UnmarshalBSON(b []byte) error {
 	*ms = myString(s)
 	return nil
 }
+
+// unmarshalBSONValueCallTracker is a test struct that tracks whether the
+// UnmarshalBSONValue method has been called.
+type unmarshalBSONValueCallTracker struct {
+	called bool // called is set to true when UnmarshalBSONValue is invoked.
+}
+
+var _ ValueUnmarshaler = &unmarshalBSONValueCallTracker{}
+
+// unmarshalBSONCallTracker is a test struct that tracks whether the
+// UnmarshalBSON method has been called.
+type unmarshalBSONCallTracker struct {
+	called bool // called is set to true when UnmarshalBSON is invoked.
+}
+
+// Ensure unmarshalBSONCallTracker implements the Unmarshaler interface.
+var _ Unmarshaler = &unmarshalBSONCallTracker{}
+
+// unmarshalBehaviorTestCase holds instances of call trackers for testing BSON
+// unmarshaling behavior.
+type unmarshalBehaviorTestCase struct {
+	BSONValueTracker    unmarshalBSONValueCallTracker  `bson:"bv_tracker"`     // BSON value unmarshaling by value.
+	BSONValuePtrTracker *unmarshalBSONValueCallTracker `bson:"bv_ptr_tracker"` // BSON value unmarshaling by pointer.
+	BSONTracker         unmarshalBSONCallTracker       `bson:"b_tracker"`      // BSON unmarshaling by value.
+	BSONPtrTracker      *unmarshalBSONCallTracker      `bson:"b_ptr_tracker"`  // BSON unmarshaling by pointer.
+}
+
+func (tracker *unmarshalBSONValueCallTracker) UnmarshalBSONValue(byte, []byte) error {
+	tracker.called = true
+	return nil
+}
+
+func (tracker *unmarshalBSONCallTracker) UnmarshalBSON([]byte) error {
+	tracker.called = true
+	return nil
+}

etc/run-fuzz.sh

@@ -35,7 +35,7 @@ do
 			done
 		fi
 
-		go test ${PARENTDIR} -run=${FUNC} -fuzz=${FUNC} -fuzztime=${FUZZTIME} || true
+		GOMAXPROCS=2 go test ${PARENTDIR} -run=${FUNC} -fuzz=${FUNC} -fuzztime=${FUZZTIME} || true
 
 		# Check if any new corpus files were generated for the fuzzer. If there are new corpus files, move them
 		# to $PROJECT_DIRECTORY/fuzz/$FUNC/* so they can be tarred up and uploaded to S3.

examples/_logger/logrus/go.mod

@@ -18,8 +18,8 @@ require (
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/crypto v0.32.0 // indirect
-	golang.org/x/sync v0.10.0 // indirect
-	golang.org/x/sys v0.29.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
 )