Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 benchmark_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "compress/gzip" "encoding/json" "fmt" "io" "io/ioutil" "os" "path" "sync" "testing" ) type encodetest struct { Field1String string Field1Int64 int64 Field1Float64 float64 Field2String string Field2Int64 int64 Field2Float64 float64 Field3String string Field3Int64 int64 Field3Float64 float64 Field4String string Field4Int64 int64 Field4Float64 float64 } type nestedtest1 struct { Nested nestedtest2 } type nestedtest2 struct { Nested nestedtest3 } type nestedtest3 struct { Nested nestedtest4 } type nestedtest4 struct { Nested nestedtest5 } type nestedtest5 struct { Nested nestedtest6 } type nestedtest6 struct { Nested nestedtest7 } type nestedtest7 struct { Nested nestedtest8 } type nestedtest8 struct { Nested nestedtest9 } type nestedtest9 struct { Nested nestedtest10 } type nestedtest10 struct { Nested nestedtest11 } type nestedtest11 struct { Nested encodetest } var encodetestInstance = encodetest{ Field1String: "foo", Field1Int64: 1, Field1Float64: 3.0, Field2String: "bar", Field2Int64: 2, Field2Float64: 3.1, Field3String: "baz", Field3Int64: 3, Field3Float64: 3.14, Field4String: "qux", Field4Int64: 4, Field4Float64: 3.141, } var nestedInstance = nestedtest1{ nestedtest2{ nestedtest3{ nestedtest4{ nestedtest5{ nestedtest6{ nestedtest7{ nestedtest8{ nestedtest9{ nestedtest10{ nestedtest11{ encodetest{ Field1String: "foo", Field1Int64: 1, Field1Float64: 3.0, Field2String: "bar", Field2Int64: 2, Field2Float64: 3.1, Field3String: "baz", Field3Int64: 3, Field3Float64: 3.14, Field4String: "qux", Field4Int64: 4, Field4Float64: 3.141, }, }, }, }, }, }, }, }, }, }, }, } const extendedBSONDir = "../testdata/extended_bson" var ( extJSONFiles map[string]map[string]interface{} extJSONFilesMu sync.Mutex ) // readExtJSONFile reads the GZIP-compressed extended JSON document from the given filename in the // "extended BSON" test data directory (../testdata/extended_bson) and returns it as a // map[string]interface{}. It panics on any errors. func readExtJSONFile(filename string) map[string]interface{} { extJSONFilesMu.Lock() defer extJSONFilesMu.Unlock() if v, ok := extJSONFiles[filename]; ok { return v } filePath := path.Join(extendedBSONDir, filename) file, err := os.Open(filePath) if err != nil { panic(fmt.Sprintf("error opening file %q: %s", filePath, err)) } defer func() { _ = file.Close() }() gz, err := gzip.NewReader(file) if err != nil { panic(fmt.Sprintf("error creating GZIP reader: %s", err)) } defer func() { _ = gz.Close() }() data, err := ioutil.ReadAll(gz) if err != nil { panic(fmt.Sprintf("error reading GZIP contents of file: %s", err)) } var v map[string]interface{} err = UnmarshalExtJSON(data, false, &v) if err != nil { panic(fmt.Sprintf("error unmarshalling extended JSON: %s", err)) } if extJSONFiles == nil { extJSONFiles = make(map[string]map[string]interface{}) } extJSONFiles[filename] = v return v } func BenchmarkMarshal(b testing.B) { cases := []struct { desc string value interface{} }{ { desc: "simple struct", value: encodetestInstance, }, { desc: "nested struct", value: nestedInstance, }, { desc: "deep_bson.json.gz", value: readExtJSONFile("deep_bson.json.gz"), }, { desc: "flat_bson.json.gz", value: readExtJSONFile("flat_bson.json.gz"), }, { desc: "full_bson.json.gz", value: readExtJSONFile("full_bson.json.gz"), }, } for _, tc := range cases { b.Run(tc.desc, func(b testing.B) { b.Run("BSON", func(b testing.B) { for i := 0; i < b.N; i++ { _, err := Marshal(tc.value) if err != nil { b.Errorf("error marshalling BSON: %s", err) } } }) b.Run("extJSON", func(b testing.B) { for i := 0; i < b.N; i++ { _, err := MarshalExtJSON(tc.value, true, false) if err != nil { b.Errorf("error marshalling extended JSON: %s", err) } } }) b.Run("JSON", func(b testing.B) { for i := 0; i < b.N; i++ { _, err := json.Marshal(tc.value) if err != nil { b.Errorf("error marshalling JSON: %s", err) } } }) }) } } func BenchmarkUnmarshal(b testing.B) { cases := []struct { desc string value interface{} }{ { desc: "simple struct", value: encodetestInstance, }, { desc: "nested struct", value: nestedInstance, }, { desc: "deep_bson.json.gz", value: readExtJSONFile("deep_bson.json.gz"), }, { desc: "flat_bson.json.gz", value: readExtJSONFile("flat_bson.json.gz"), }, { desc: "full_bson.json.gz", value: readExtJSONFile("full_bson.json.gz"), }, } for _, tc := range cases { b.Run(tc.desc, func(b testing.B) { b.Run("BSON", func(b testing.B) { data, err := Marshal(tc.value) if err != nil { b.Errorf("error marshalling BSON: %s", err) return } b.ResetTimer() var v2 map[string]interface{} for i := 0; i < b.N; i++ { err := Unmarshal(data, &v2) if err != nil { b.Errorf("error unmarshalling BSON: %s", err) } } }) b.Run("extJSON", func(b testing.B) { data, err := MarshalExtJSON(tc.value, true, false) if err != nil { b.Errorf("error marshalling extended JSON: %s", err) return } b.ResetTimer() var v2 map[string]interface{} for i := 0; i < b.N; i++ { err := UnmarshalExtJSON(data, true, &v2) if err != nil { b.Errorf("error unmarshalling extended JSON: %s", err) } } }) b.Run("JSON", func(b testing.B) { data, err := json.Marshal(tc.value) if err != nil { b.Errorf("error marshalling JSON: %s", err) return } b.ResetTimer() var v2 map[string]interface{} for i := 0; i < b.N; i++ { err := json.Unmarshal(data, &v2) if err != nil { b.Errorf("error unmarshalling JSON: %s", err) } } }) }) } } // The following benchmarks are copied from the Go standard library's // encoding/json package. type codeResponse struct { Tree codeNode `json:"tree"` Username string `json:"username"` } type codeNode struct { Name string `json:"name"` Kids []codeNode `json:"kids"` CLWeight float64 `json:"cl_weight"` Touches int `json:"touches"` MinT int64 `json:"min_t"` MaxT int64 `json:"max_t"` MeanT int64 `json:"mean_t"` } var codeJSON []byte var codeBSON []byte var codeStruct codeResponse func codeInit() { f, err := os.Open("testdata/code.json.gz") if err != nil { panic(err) } defer f.Close() gz, err := gzip.NewReader(f) if err != nil { panic(err) } data, err := io.ReadAll(gz) if err != nil { panic(err) } codeJSON = data if err := json.Unmarshal(codeJSON, &codeStruct); err != nil { panic("json.Unmarshal code.json: " + err.Error()) } if data, err = json.Marshal(&codeStruct); err != nil { panic("json.Marshal code.json: " + err.Error()) } if codeBSON, err = Marshal(&codeStruct); err != nil { panic("Marshal code.json: " + err.Error()) } if !bytes.Equal(data, codeJSON) { println("different lengths", len(data), len(codeJSON)) for i := 0; i < len(data) && i < len(codeJSON); i++ { if data[i] != codeJSON[i] { println("re-marshal: changed at byte", i) println("orig: ", string(codeJSON[i-10:i+10])) println("new: ", string(data[i-10:i+10])) break } } panic("re-marshal code.json: different result") } } func BenchmarkCodeUnmarshal(b testing.B) { b.ReportAllocs() if codeJSON == nil { b.StopTimer() codeInit() b.StartTimer() } b.Run("BSON", func(b testing.B) { b.RunParallel(func(pb testing.PB) { for pb.Next() { var r codeResponse if err := Unmarshal(codeBSON, &r); err != nil { b.Fatal("Unmarshal:", err) } } }) b.SetBytes(int64(len(codeBSON))) }) b.Run("JSON", func(b testing.B) { b.RunParallel(func(pb testing.PB) { for pb.Next() { var r codeResponse if err := json.Unmarshal(codeJSON, &r); err != nil { b.Fatal("json.Unmarshal:", err) } } }) b.SetBytes(int64(len(codeJSON))) }) } func BenchmarkCodeMarshal(b testing.B) { b.ReportAllocs() if codeJSON == nil { b.StopTimer() codeInit() b.StartTimer() } b.Run("BSON", func(b testing.B) { b.RunParallel(func(pb testing.PB) { for pb.Next() { if _, err := Marshal(&codeStruct); err != nil { b.Fatal("Marshal:", err) } } }) b.SetBytes(int64(len(codeBSON))) }) b.Run("JSON", func(b testing.B) { b.RunParallel(func(pb testing.PB) { for pb.Next() { if _, err := json.Marshal(&codeStruct); err != nil { b.Fatal("json.Marshal:", err) } } }) b.SetBytes(int64(len(codeJSON))) }) }	9.1 KB	2025-05-25 12:27
📄 bson.go // Copyright (C) MongoDB, Inc. 2017-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 // // Based on gopkg.in/mgo.v2/bson by Gustavo Niemeyer // See THIRD-PARTY-NOTICES for original license terms. package bson // import "go.mongodb.org/mongo-driver/bson" import ( "go.mongodb.org/mongo-driver/bson/primitive" ) // Zeroer allows custom struct types to implement a report of zero // state. All struct types that don't implement Zeroer or where IsZero // returns false are considered to be not zero. type Zeroer interface { IsZero() bool } // D is an ordered representation of a BSON document. This type should be used when the order of the elements matters, // such as MongoDB command documents. If the order of the elements does not matter, an M should be used instead. // // A D should not be constructed with duplicate key names, as that can cause undefined server behavior. // // Example usage: // // bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}} type D = primitive.D // E represents a BSON element for a D. It is usually used inside a D. type E = primitive.E // M is an unordered representation of a BSON document. This type should be used when the order of the elements does not // matter. This type is handled as a regular map[string]interface{} when encoding and decoding. Elements will be // serialized in an undefined, random order. If the order of the elements matters, a D should be used instead. // // Example usage: // // bson.M{"foo": "bar", "hello": "world", "pi": 3.14159} type M = primitive.M // An A is an ordered representation of a BSON array. // // Example usage: // // bson.A{"bar", "world", 3.14159, bson.D{{"qux", 12345}}} type A = primitive.A	1.83 KB	2025-05-25 12:27
📄 bson_corpus_spec_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "encoding/hex" "encoding/json" "fmt" "math" "os" "path" "reflect" "strconv" "strings" "testing" "unicode" "unicode/utf8" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" ) type testCase struct { Description string `json:"description"` BsonType string `json:"bson_type"` TestKey string `json:"test_key"` Valid []validityTestCase `json:"valid"` DecodeErrors []decodeErrorTestCase `json:"decodeErrors"` ParseErrors []parseErrorTestCase `json:"parseErrors"` Deprecated bool `json:"deprecated"` } type validityTestCase struct { Description string `json:"description"` CanonicalBson string `json:"canonical_bson"` CanonicalExtJSON string `json:"canonical_extjson"` RelaxedExtJSON string `json:"relaxed_extjson"` DegenerateBSON string `json:"degenerate_bson"` DegenerateExtJSON string `json:"degenerate_extjson"` ConvertedBSON string `json:"converted_bson"` ConvertedExtJSON string `json:"converted_extjson"` Lossy bool `json:"lossy"` } type decodeErrorTestCase struct { Description string `json:"description"` Bson string `json:"bson"` } type parseErrorTestCase struct { Description string `json:"description"` String string `json:"string"` } const dataDir = "../testdata/bson-corpus/" func findJSONFilesInDir(dir string) ([]string, error) { files := make([]string, 0) entries, err := os.ReadDir(dir) if err != nil { return nil, err } for _, entry := range entries { if entry.IsDir() \|\| path.Ext(entry.Name()) != ".json" { continue } files = append(files, entry.Name()) } return files, nil } // seedExtJSON will add the byte representation of the "extJSON" string to the fuzzer's coprus. func seedExtJSON(f testing.F, extJSON string, extJSONType string, desc string) { jbytes, err := jsonToBytes(extJSON, extJSONType, desc) if err != nil { f.Fatalf("failed to convert JSON to bytes: %v", err) } f.Add(jbytes) } // seedTestCase will add the byte representation for each "extJSON" string of each valid test case to the fuzzer's // corpus. func seedTestCase(f testing.F, tcase testCase) { for _, vtc := range tcase.Valid { seedExtJSON(f, vtc.CanonicalExtJSON, "canonical", vtc.Description) // Seed the relaxed extended JSON. if vtc.RelaxedExtJSON != nil { seedExtJSON(f, vtc.RelaxedExtJSON, "relaxed", vtc.Description) } // Seed the degenerate extended JSON. if vtc.DegenerateExtJSON != nil { seedExtJSON(f, vtc.DegenerateExtJSON, "degenerate", vtc.Description) } // Seed the converted extended JSON. if vtc.ConvertedExtJSON != nil { seedExtJSON(f, vtc.ConvertedExtJSON, "converted", vtc.Description) } } } // seedBSONCorpus will unmarshal the data from "testdata/bson-corpus" into a slice of "testCase" structs and then // marshal the "_extjson" field of each "validityTestCase" into a slice of bytes to seed the fuzz corpus. func seedBSONCorpus(f testing.F) { fileNames, err := findJSONFilesInDir(dataDir) if err != nil { f.Fatalf("failed to find JSON files in directory %q: %v", dataDir, err) } for _, fileName := range fileNames { filePath := path.Join(dataDir, fileName) file, err := os.Open(filePath) if err != nil { f.Fatalf("failed to open file %q: %v", filePath, err) } var tcase testCase if err := json.NewDecoder(file).Decode(&tcase); err != nil { f.Fatal(err) } seedTestCase(f, &tcase) } } func needsEscapedUnicode(bsonType string) bool { return bsonType == "0x02" \|\| bsonType == "0x0D" \|\| bsonType == "0x0E" \|\| bsonType == "0x0F" } func unescapeUnicode(s, bsonType string) string { if !needsEscapedUnicode(bsonType) { return s } newS := "" for i := 0; i < len(s); i++ { c := s[i] switch c { case '\\': switch s[i+1] { case 'u': us := s[i : i+6] u, err := strconv.Unquote(strings.Replace(strconv.Quote(us), `\\u`, `\u`, 1)) if err != nil { return "" } for _, r := range u { if r < ' ' { newS += fmt.Sprintf(`\u%04x`, r) } else { newS += string(r) } } i += 5 default: newS += string(c) } default: if c > unicode.MaxASCII { r, size := utf8.DecodeRune([]byte(s[i:])) newS += string(r) i += size - 1 } else { newS += string(c) } } } return newS } func formatDouble(f float64) string { var s string if math.IsInf(f, 1) { s = "Infinity" } else if math.IsInf(f, -1) { s = "-Infinity" } else if math.IsNaN(f) { s = "NaN" } else { // Print exactly one decimalType place for integers; otherwise, print as many are necessary to // perfectly represent it. s = strconv.FormatFloat(f, 'G', -1, 64) if !strings.ContainsRune(s, 'E') && !strings.ContainsRune(s, '.') { s += ".0" } } return s } func normalizeCanonicalDouble(t testing.T, key string, cEJ string) string { // Unmarshal string into map cEJMap := make(map[string]map[string]string) err := json.Unmarshal([]byte(cEJ), &cEJMap) require.NoError(t, err) // Parse the float contained by the map. expectedString := cEJMap[key]["$numberDouble"] expectedFloat, err := strconv.ParseFloat(expectedString, 64) require.NoError(t, err) // Normalize the string return fmt.Sprintf(`{"%s":{"$numberDouble":"%s"}}`, key, formatDouble(expectedFloat)) } func normalizeRelaxedDouble(t testing.T, key string, rEJ string) string { // Unmarshal string into map rEJMap := make(map[string]float64) err := json.Unmarshal([]byte(rEJ), &rEJMap) if err != nil { return normalizeCanonicalDouble(t, key, rEJ) } // Parse the float contained by the map. expectedFloat := rEJMap[key] // Normalize the string return fmt.Sprintf(`{"%s":%s}`, key, formatDouble(expectedFloat)) } // bsonToNative decodes the BSON bytes (b) into a native Document func bsonToNative(t testing.T, b []byte, bType, testDesc string) D { var doc D err := Unmarshal(b, &doc) expectNoError(t, err, fmt.Sprintf("%s: decoding %s BSON", testDesc, bType)) return doc } // nativeToBSON encodes the native Document (doc) into canonical BSON and compares it to the expected // canonical BSON (cB) func nativeToBSON(t testing.T, cB []byte, doc D, testDesc, bType, docSrcDesc string) { actual, err := Marshal(doc) expectNoError(t, err, fmt.Sprintf("%s: encoding %s BSON", testDesc, bType)) if diff := cmp.Diff(cB, actual); diff != "" { t.Errorf("%s: 'native_to_bson(%s) = cB' failed (-want, +got):\n-%v\n+%v\n", testDesc, docSrcDesc, cB, actual) t.FailNow() } } // jsonToNative decodes the extended JSON string (ej) into a native Document func jsonToNative(ej, ejType, testDesc string) (D, error) { var doc D if err := UnmarshalExtJSON([]byte(ej), ejType != "relaxed", &doc); err != nil { return nil, fmt.Errorf("%s: decoding %s extended JSON: %w", testDesc, ejType, err) } return doc, nil } // jsonToBytes decodes the extended JSON string (ej) into canonical BSON and then encodes it into a byte slice. func jsonToBytes(ej, ejType, testDesc string) ([]byte, error) { native, err := jsonToNative(ej, ejType, testDesc) if err != nil { return nil, err } b, err := Marshal(native) if err != nil { return nil, fmt.Errorf("%s: encoding %s BSON: %w", testDesc, ejType, err) } return b, nil } // nativeToJSON encodes the native Document (doc) into an extended JSON string func nativeToJSON(t testing.T, ej string, doc D, testDesc, ejType, ejShortName, docSrcDesc string) { actualEJ, err := MarshalExtJSON(doc, ejType != "relaxed", true) expectNoError(t, err, fmt.Sprintf("%s: encoding %s extended JSON", testDesc, ejType)) if diff := cmp.Diff(ej, string(actualEJ)); diff != "" { t.Errorf("%s: 'native_to_%s_extended_json(%s) = %s' failed (-want, +got):\n%s\n", testDesc, ejType, docSrcDesc, ejShortName, diff) t.FailNow() } } func runTest(t testing.T, file string) { filepath := path.Join(dataDir, file) content, err := os.ReadFile(filepath) require.NoError(t, err) // Remove ".json" from filename. file = file[:len(file)-5] testName := "bson_corpus--" + file t.Run(testName, func(t testing.T) { var test testCase require.NoError(t, json.Unmarshal(content, &test)) t.Run("valid", func(t testing.T) { for _, v := range test.Valid { t.Run(v.Description, func(t testing.T) { // get canonical BSON cB, err := hex.DecodeString(v.CanonicalBson) expectNoError(t, err, fmt.Sprintf("%s: reading canonical BSON", v.Description)) // get canonical extended JSON var compactEJ bytes.Buffer require.NoError(t, json.Compact(&compactEJ, []byte(v.CanonicalExtJSON))) cEJ := unescapeUnicode(compactEJ.String(), test.BsonType) if test.BsonType == "0x01" { cEJ = normalizeCanonicalDouble(t, test.TestKey, cEJ) } /* canonical BSON round-trip tests / doc := bsonToNative(t, cB, "canonical", v.Description) // native_to_bson(bson_to_native(cB)) = cB nativeToBSON(t, cB, doc, v.Description, "canonical", "bson_to_native(cB)") // native_to_canonical_extended_json(bson_to_native(cB)) = cEJ nativeToJSON(t, cEJ, doc, v.Description, "canonical", "cEJ", "bson_to_native(cB)") // native_to_relaxed_extended_json(bson_to_native(cB)) = rEJ (if rEJ exists) if v.RelaxedExtJSON != nil { var compactEJ bytes.Buffer require.NoError(t, json.Compact(&compactEJ, []byte(v.RelaxedExtJSON))) rEJ := unescapeUnicode(compactEJ.String(), test.BsonType) if test.BsonType == "0x01" { rEJ = normalizeRelaxedDouble(t, test.TestKey, rEJ) } nativeToJSON(t, rEJ, doc, v.Description, "relaxed", "rEJ", "bson_to_native(cB)") / relaxed extended JSON round-trip tests (if exists) / doc, err = jsonToNative(rEJ, "relaxed", v.Description) require.NoError(t, err) // native_to_relaxed_extended_json(json_to_native(rEJ)) = rEJ nativeToJSON(t, rEJ, doc, v.Description, "relaxed", "eJR", "json_to_native(rEJ)") } / canonical extended JSON round-trip tests / doc, err = jsonToNative(cEJ, "canonical", v.Description) require.NoError(t, err) // native_to_canonical_extended_json(json_to_native(cEJ)) = cEJ nativeToJSON(t, cEJ, doc, v.Description, "canonical", "cEJ", "json_to_native(cEJ)") // native_to_bson(json_to_native(cEJ)) = cb (unless lossy) if v.Lossy == nil \|\| !v.Lossy { nativeToBSON(t, cB, doc, v.Description, "canonical", "json_to_native(cEJ)") } /* degenerate BSON round-trip tests (if exists) / if v.DegenerateBSON != nil { dB, err := hex.DecodeString(v.DegenerateBSON) expectNoError(t, err, fmt.Sprintf("%s: reading degenerate BSON", v.Description)) doc = bsonToNative(t, dB, "degenerate", v.Description) // native_to_bson(bson_to_native(dB)) = cB nativeToBSON(t, cB, doc, v.Description, "degenerate", "bson_to_native(dB)") } /* degenerate JSON round-trip tests (if exists) / if v.DegenerateExtJSON != nil { var compactEJ bytes.Buffer require.NoError(t, json.Compact(&compactEJ, []byte(v.DegenerateExtJSON))) dEJ := unescapeUnicode(compactEJ.String(), test.BsonType) if test.BsonType == "0x01" { dEJ = normalizeCanonicalDouble(t, test.TestKey, dEJ) } doc, err = jsonToNative(dEJ, "degenerate canonical", v.Description) require.NoError(t, err) // native_to_canonical_extended_json(json_to_native(dEJ)) = cEJ nativeToJSON(t, cEJ, doc, v.Description, "degenerate canonical", "cEJ", "json_to_native(dEJ)") // native_to_bson(json_to_native(dEJ)) = cB (unless lossy) if v.Lossy == nil \|\| !v.Lossy { nativeToBSON(t, cB, doc, v.Description, "canonical", "json_to_native(dEJ)") } } }) } }) t.Run("decode error", func(t testing.T) { for _, d := range test.DecodeErrors { t.Run(d.Description, func(t testing.T) { b, err := hex.DecodeString(d.Bson) expectNoError(t, err, d.Description) var doc D err = Unmarshal(b, &doc) // The driver unmarshals invalid UTF-8 strings without error. Loop over the unmarshalled elements // and assert that there was no error if any of the string or DBPointer values contain invalid UTF-8 // characters. for _, elem := range doc { value := reflect.ValueOf(elem.Value) invalidString := (value.Kind() == reflect.String) && !utf8.ValidString(value.String()) dbPtr, ok := elem.Value.(primitive.DBPointer) invalidDBPtr := ok && !utf8.ValidString(dbPtr.DB) if invalidString \|\| invalidDBPtr { expectNoError(t, err, d.Description) return } } expectError(t, err, fmt.Sprintf("%s: expected decode error", d.Description)) }) } }) t.Run("parse error", func(t testing.T) { for _, p := range test.ParseErrors { t.Run(p.Description, func(t testing.T) { s := unescapeUnicode(p.String, test.BsonType) if test.BsonType == "0x13" { s = fmt.Sprintf(`{"decimal128": {"$numberDecimal": "%s"}}`, s) } switch test.BsonType { case "0x00", "0x05", "0x13": var doc D err := UnmarshalExtJSON([]byte(s), true, &doc) // Null bytes are validated when marshaling to BSON if strings.Contains(p.Description, "Null") { _, err = Marshal(doc) } expectError(t, err, fmt.Sprintf("%s: expected parse error", p.Description)) default: t.Errorf("Update test to check for parse errors for type %s", test.BsonType) t.Fail() } }) } }) }) } func Test_BsonCorpus(t testing.T) { jsonFiles, err := findJSONFilesInDir(dataDir) if err != nil { t.Fatalf("error finding JSON files in %s: %v", dataDir, err) } for _, file := range jsonFiles { runTest(t, file) } } func expectNoError(t testing.T, err error, desc string) { if err != nil { t.Helper() t.Errorf("%s: Unepexted error: %v", desc, err) t.FailNow() } } func expectError(t testing.T, err error, desc string) { if err == nil { t.Helper() t.Errorf("%s: Expected error", desc) t.FailNow() } } func TestRelaxedUUIDValidation(t testing.T) { testCases := []struct { description string canonicalExtJSON string degenerateExtJSON string expectedErr string }{ { "valid uuid", "{\"x\" : { \"$binary\" : {\"base64\" : \"c//SZESzTGmQ6OfR38A11A==\", \"subType\" : \"04\"}}}", "{\"x\" : { \"$uuid\" : \"73ffd264-44b3-4c69-90e8-e7d1dfc035d4\"}}", "", }, { "invalid uuid--no hyphens", "", "{\"x\" : { \"$uuid\" : \"73ffd26444b34c6990e8e7d1dfc035d4\"}}", "$uuid value does not follow RFC 4122 format regarding length and hyphens", }, { "invalid uuid--trailing hyphens", "", "{\"x\" : { \"$uuid\" : \"73ffd264-44b3-4c69-90e8-e7d1dfc035--\"}}", "$uuid value does not follow RFC 4122 format regarding length and hyphens", }, { "invalid uuid--malformed hex", "", "{\"x\" : { \"$uuid\" : \"q3@fd26l-44b3-4c69-90e8-e7d1dfc035d4\"}}", "$uuid value does not follow RFC 4122 format regarding hex bytes: encoding/hex: invalid byte: U+0071 'q'", }, } for _, tc := range testCases { t.Run(tc.description, func(t *testing.T) { // get canonical extended JSON (if provided) cEJ := "" if tc.canonicalExtJSON != "" { var compactCEJ bytes.Buffer require.NoError(t, json.Compact(&compactCEJ, []byte(tc.canonicalExtJSON))) cEJ = unescapeUnicode(compactCEJ.String(), "0x05") } // get degenerate extended JSON var compactDEJ bytes.Buffer require.NoError(t, json.Compact(&compactDEJ, []byte(tc.degenerateExtJSON))) dEJ := unescapeUnicode(compactDEJ.String(), "0x05") // convert dEJ to native doc var doc D err := UnmarshalExtJSON([]byte(dEJ), true, &doc) if tc.expectedErr != "" { assert.Equal(t, tc.expectedErr, err.Error(), "expected error %v, got %v", tc.expectedErr, err) } else { assert.Nil(t, err, "expected no error, got error: %v", err) // Marshal doc into extended JSON and compare with cEJ nativeToJSON(t, cEJ, doc, tc.description, "degenerate canonical", "cEJ", "json_to_native(dEJ)") } }) } }	16.17 KB	2025-05-25 12:27
📄 bson_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "fmt" "reflect" "strconv" "strings" "testing" "time" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonoptions" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func noerr(t testing.T, err error) { if err != nil { t.Helper() t.Errorf("Unexpected error: (%T)%v", err, err) t.FailNow() } } func TestTimeRoundTrip(t testing.T) { val := struct { Value time.Time ID string }{ ID: "time-rt-test", } if !val.Value.IsZero() { t.Errorf("Did not get zero time as expected.") } bsonOut, err := Marshal(val) noerr(t, err) rtval := struct { Value time.Time ID string }{} err = Unmarshal(bsonOut, &rtval) noerr(t, err) if !cmp.Equal(val, rtval) { t.Errorf("Did not round trip properly. got %v; want %v", val, rtval) } if !rtval.Value.IsZero() { t.Errorf("Did not get zero time as expected.") } } func TestNonNullTimeRoundTrip(t testing.T) { now := time.Now() now = time.Unix(now.Unix(), 0) val := struct { Value time.Time ID string }{ ID: "time-rt-test", Value: now, } bsonOut, err := Marshal(val) noerr(t, err) rtval := struct { Value time.Time ID string }{} err = Unmarshal(bsonOut, &rtval) noerr(t, err) if !cmp.Equal(val, rtval) { t.Errorf("Did not round trip properly. got %v; want %v", val, rtval) } } func TestD(t testing.T) { t.Run("can marshal", func(t testing.T) { d := D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}} idx, want := bsoncore.AppendDocumentStart(nil) want = bsoncore.AppendStringElement(want, "foo", "bar") want = bsoncore.AppendStringElement(want, "hello", "world") want = bsoncore.AppendDoubleElement(want, "pi", 3.14159) want, err := bsoncore.AppendDocumentEnd(want, idx) noerr(t, err) got, err := Marshal(d) noerr(t, err) if !bytes.Equal(got, want) { t.Errorf("Marshaled documents do not match. got %v; want %v", Raw(got), Raw(want)) } }) t.Run("can unmarshal", func(t testing.T) { want := D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}} idx, doc := bsoncore.AppendDocumentStart(nil) doc = bsoncore.AppendStringElement(doc, "foo", "bar") doc = bsoncore.AppendStringElement(doc, "hello", "world") doc = bsoncore.AppendDoubleElement(doc, "pi", 3.14159) doc, err := bsoncore.AppendDocumentEnd(doc, idx) noerr(t, err) var got D err = Unmarshal(doc, &got) noerr(t, err) if !cmp.Equal(got, want) { t.Errorf("Unmarshaled documents do not match. got %v; want %v", got, want) } }) } type stringerString string func (ss stringerString) String() string { return "bar" } type keyBool bool func (kb keyBool) MarshalKey() (string, error) { return fmt.Sprintf("%v", kb), nil } func (kb keyBool) UnmarshalKey(key string) error { switch key { case "true": kb = true case "false": kb = false default: return fmt.Errorf("invalid bool value %v", key) } return nil } type keyStruct struct { val int64 } func (k keyStruct) MarshalText() (text []byte, err error) { str := strconv.FormatInt(k.val, 10) return []byte(str), nil } func (k keyStruct) UnmarshalText(text []byte) error { val, err := strconv.ParseInt(string(text), 10, 64) if err != nil { return err } k = keyStruct{ val: val, } return nil } func TestMapCodec(t testing.T) { t.Run("EncodeKeysWithStringer", func(t testing.T) { strstr := stringerString("foo") mapObj := map[stringerString]int{strstr: 1} testCases := []struct { name string opts bsonoptions.MapCodecOptions key string }{ {"default", bsonoptions.MapCodec(), "foo"}, {"true", bsonoptions.MapCodec().SetEncodeKeysWithStringer(true), "bar"}, {"false", bsonoptions.MapCodec().SetEncodeKeysWithStringer(false), "foo"}, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { mapCodec := bsoncodec.NewMapCodec(tc.opts) mapRegistry := NewRegistryBuilder().RegisterDefaultEncoder(reflect.Map, mapCodec).Build() val, err := MarshalWithRegistry(mapRegistry, mapObj) assert.Nil(t, err, "Marshal error: %v", err) assert.True(t, strings.Contains(string(val), tc.key), "expected result to contain %v, got: %v", tc.key, string(val)) }) } }) t.Run("keys implements keyMarshaler and keyUnmarshaler", func(t testing.T) { mapObj := map[keyBool]int{keyBool(true): 1} doc, err := Marshal(mapObj) assert.Nil(t, err, "Marshal error: %v", err) idx, want := bsoncore.AppendDocumentStart(nil) want = bsoncore.AppendInt32Element(want, "true", 1) want, _ = bsoncore.AppendDocumentEnd(want, idx) assert.Equal(t, want, doc, "expected result %v, got %v", string(want), string(doc)) var got map[keyBool]int err = Unmarshal(doc, &got) assert.Nil(t, err, "Unmarshal error: %v", err) assert.Equal(t, mapObj, got, "expected result %v, got %v", mapObj, got) }) t.Run("keys implements encoding.TextMarshaler and encoding.TextUnmarshaler", func(t testing.T) { mapObj := map[keyStruct]int{ {val: 10}: 100, } doc, err := Marshal(mapObj) assert.Nil(t, err, "Marshal error: %v", err) idx, want := bsoncore.AppendDocumentStart(nil) want = bsoncore.AppendInt32Element(want, "10", 100) want, _ = bsoncore.AppendDocumentEnd(want, idx) assert.Equal(t, want, doc, "expected result %v, got %v", string(want), string(doc)) var got map[keyStruct]int err = Unmarshal(doc, &got) assert.Nil(t, err, "Unmarshal error: %v", err) assert.Equal(t, mapObj, got, "expected result %v, got %v", mapObj, got) }) } func TestExtJSONEscapeKey(t testing.T) { doc := D{{Key: "\\usb#", Value: int32(1)}} b, err := MarshalExtJSON(&doc, false, false) noerr(t, err) want := "{\"\\\\usb#\":1}" if diff := cmp.Diff(want, string(b)); diff != "" { t.Errorf("Marshaled documents do not match. got %v, want %v", string(b), want) } var got D err = UnmarshalExtJSON(b, false, &got) noerr(t, err) if !cmp.Equal(got, doc) { t.Errorf("Unmarshaled documents do not match. got %v; want %v", got, doc) } } func TestBsoncoreArray(t *testing.T) { type BSONDocumentArray struct { Array []D `bson:"array"` } type BSONArray struct { Array bsoncore.Array `bson:"array"` } bda := BSONDocumentArray{ Array: []D{ {{"x", 1}}, {{"x", 2}}, {{"x", 3}}, }, } expectedBSON, err := Marshal(bda) assert.Nil(t, err, "Marshal bsoncore.Document array error: %v", err) var ba BSONArray err = Unmarshal(expectedBSON, &ba) assert.Nil(t, err, "Unmarshal error: %v", err) actualBSON, err := Marshal(ba) assert.Nil(t, err, "Marshal bsoncore.Array error: %v", err) assert.Equal(t, expectedBSON, actualBSON, "expected BSON to be %v after Marshalling again; got %v", expectedBSON, actualBSON) doc := bsoncore.Document(actualBSON) v := doc.Lookup("array") assert.Equal(t, bsontype.Array, v.Type, "expected type array, got %v", v.Type) }	7.05 KB	2025-05-25 12:27
📁 bsoncodec	-	2025-05-25 12:27
📁 bsonoptions	-	2025-05-25 12:27
📁 bsonrw	-	2025-05-25 12:27
📁 bsontype	-	2025-05-25 12:27
📄 decoder.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "errors" "fmt" "reflect" "sync" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" ) // ErrDecodeToNil is the error returned when trying to decode to a nil value var ErrDecodeToNil = errors.New("cannot Decode to nil value") // This pool is used to keep the allocations of Decoders down. This is only used for the Marshal* // methods and is not consumable from outside of this package. The Decoders retrieved from this pool // must have both Reset and SetRegistry called on them. var decPool = sync.Pool{ New: func() interface{} { return new(Decoder) }, } // A Decoder reads and decodes BSON documents from a stream. It reads from a bsonrw.ValueReader as // the source of BSON data. type Decoder struct { dc bsoncodec.DecodeContext vr bsonrw.ValueReader // We persist defaultDocumentM and defaultDocumentD on the Decoder to prevent overwriting from // (Decoder).SetContext. defaultDocumentM bool defaultDocumentD bool binaryAsSlice bool useJSONStructTags bool useLocalTimeZone bool zeroMaps bool zeroStructs bool } // NewDecoder returns a new decoder that uses the DefaultRegistry to read from vr. func NewDecoder(vr bsonrw.ValueReader) (Decoder, error) { if vr == nil { return nil, errors.New("cannot create a new Decoder with a nil ValueReader") } return &Decoder{ dc: bsoncodec.DecodeContext{Registry: DefaultRegistry}, vr: vr, }, nil } // NewDecoderWithContext returns a new decoder that uses DecodeContext dc to read from vr. // // Deprecated: Use [NewDecoder] and use the Decoder configuration methods set the desired unmarshal // behavior instead. func NewDecoderWithContext(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader) (Decoder, error) { if dc.Registry == nil { dc.Registry = DefaultRegistry } if vr == nil { return nil, errors.New("cannot create a new Decoder with a nil ValueReader") } return &Decoder{ dc: dc, vr: vr, }, nil } // Decode reads the next BSON document from the stream and decodes it into the // value pointed to by val. // // See [Unmarshal] for details about BSON unmarshaling behavior. func (d Decoder) Decode(val interface{}) error { if unmarshaler, ok := val.(Unmarshaler); ok { // TODO(skriptble): Reuse a []byte here and use the AppendDocumentBytes method. buf, err := bsonrw.Copier{}.CopyDocumentToBytes(d.vr) if err != nil { return err } return unmarshaler.UnmarshalBSON(buf) } rval := reflect.ValueOf(val) switch rval.Kind() { case reflect.Ptr: if rval.IsNil() { return ErrDecodeToNil } rval = rval.Elem() case reflect.Map: if rval.IsNil() { return ErrDecodeToNil } default: return fmt.Errorf("argument to Decode must be a pointer or a map, but got %v", rval) } decoder, err := d.dc.LookupDecoder(rval.Type()) if err != nil { return err } if d.defaultDocumentM { d.dc.DefaultDocumentM() } if d.defaultDocumentD { d.dc.DefaultDocumentD() } if d.binaryAsSlice { d.dc.BinaryAsSlice() } if d.useJSONStructTags { d.dc.UseJSONStructTags() } if d.useLocalTimeZone { d.dc.UseLocalTimeZone() } if d.zeroMaps { d.dc.ZeroMaps() } if d.zeroStructs { d.dc.ZeroStructs() } return decoder.DecodeValue(d.dc, d.vr, rval) } // Reset will reset the state of the decoder, using the same DecodeContext used in // the original construction but using vr for reading. func (d Decoder) Reset(vr bsonrw.ValueReader) error { // TODO:(GODRIVER-2719): Remove error return value. d.vr = vr return nil } // SetRegistry replaces the current registry of the decoder with r. func (d Decoder) SetRegistry(r bsoncodec.Registry) error { // TODO:(GODRIVER-2719): Remove error return value. d.dc.Registry = r return nil } // SetContext replaces the current registry of the decoder with dc. // // Deprecated: Use the Decoder configuration methods to set the desired unmarshal behavior instead. func (d Decoder) SetContext(dc bsoncodec.DecodeContext) error { // TODO:(GODRIVER-2719): Remove error return value. d.dc = dc return nil } // DefaultDocumentM causes the Decoder to always unmarshal documents into the primitive.M type. This // behavior is restricted to data typed as "interface{}" or "map[string]interface{}". func (d Decoder) DefaultDocumentM() { d.defaultDocumentM = true } // DefaultDocumentD causes the Decoder to always unmarshal documents into the primitive.D type. This // behavior is restricted to data typed as "interface{}" or "map[string]interface{}". func (d Decoder) DefaultDocumentD() { d.defaultDocumentD = true } // AllowTruncatingDoubles causes the Decoder to truncate the fractional part of BSON "double" values // when attempting to unmarshal them into a Go integer (int, int8, int16, int32, or int64) struct // field. The truncation logic does not apply to BSON "decimal128" values. func (d Decoder) AllowTruncatingDoubles() { d.dc.Truncate = true } // BinaryAsSlice causes the Decoder to unmarshal BSON binary field values that are the "Generic" or // "Old" BSON binary subtype as a Go byte slice instead of a primitive.Binary. func (d Decoder) BinaryAsSlice() { d.binaryAsSlice = true } // UseJSONStructTags causes the Decoder to fall back to using the "json" struct tag if a "bson" // struct tag is not specified. func (d Decoder) UseJSONStructTags() { d.useJSONStructTags = true } // UseLocalTimeZone causes the Decoder to unmarshal time.Time values in the local timezone instead // of the UTC timezone. func (d Decoder) UseLocalTimeZone() { d.useLocalTimeZone = true } // ZeroMaps causes the Decoder to delete any existing values from Go maps in the destination value // passed to Decode before unmarshaling BSON documents into them. func (d Decoder) ZeroMaps() { d.zeroMaps = true } // ZeroStructs causes the Decoder to delete any existing values from Go structs in the destination // value passed to Decode before unmarshaling BSON documents into them. func (d *Decoder) ZeroStructs() { d.zeroStructs = true }	6.12 KB	2025-05-25 12:27
📄 decoder_example_test.go // Copyright (C) MongoDB, Inc. 2023-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 bson_test import ( "bytes" "errors" "fmt" "io" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsonrw" ) func ExampleDecoder() { // Marshal a BSON document that contains the name, SKU, and price (in cents) // of a product. doc := bson.D{ {Key: "name", Value: "Cereal Rounds"}, {Key: "sku", Value: "AB12345"}, {Key: "price_cents", Value: 399}, } data, err := bson.Marshal(doc) if err != nil { panic(err) } // Create a Decoder that reads the marshaled BSON document and use it to // unmarshal the document into a Product struct. decoder, err := bson.NewDecoder(bsonrw.NewBSONDocumentReader(data)) if err != nil { panic(err) } type Product struct { Name string `bson:"name"` SKU string `bson:"sku"` Price int64 `bson:"price_cents"` } var res Product err = decoder.Decode(&res) if err != nil { panic(err) } fmt.Printf("%+v\n", res) // Output: {Name:Cereal Rounds SKU:AB12345 Price:399} } func ExampleDecoder_DefaultDocumentM() { // Marshal a BSON document that contains a city name and a nested document // with various city properties. doc := bson.D{ {Key: "name", Value: "New York"}, {Key: "properties", Value: bson.D{ {Key: "state", Value: "NY"}, {Key: "population", Value: 8_804_190}, {Key: "elevation", Value: 10}, }}, } data, err := bson.Marshal(doc) if err != nil { panic(err) } // Create a Decoder that reads the marshaled BSON document and use it to unmarshal the document // into a City struct. decoder, err := bson.NewDecoder(bsonrw.NewBSONDocumentReader(data)) if err != nil { panic(err) } type City struct { Name string `bson:"name"` Properties interface{} `bson:"properties"` } // Configure the Decoder to default to decoding BSON documents as the bson.M // type if the decode destination has no type information. The Properties // field in the City struct will be decoded as a "bson.M" (i.e. map) instead // of the default "bson.D". decoder.DefaultDocumentM() var res City err = decoder.Decode(&res) if err != nil { panic(err) } fmt.Printf("%+v\n", res) // Output: {Name:New York Properties:map[elevation:10 population:8804190 state:NY]} } func ExampleDecoder_UseJSONStructTags() { // Marshal a BSON document that contains the name, SKU, and price (in cents) // of a product. doc := bson.D{ {Key: "name", Value: "Cereal Rounds"}, {Key: "sku", Value: "AB12345"}, {Key: "price_cents", Value: 399}, } data, err := bson.Marshal(doc) if err != nil { panic(err) } // Create a Decoder that reads the marshaled BSON document and use it to // unmarshal the document into a Product struct. decoder, err := bson.NewDecoder(bsonrw.NewBSONDocumentReader(data)) if err != nil { panic(err) } type Product struct { Name string `json:"name"` SKU string `json:"sku"` Price int64 `json:"price_cents"` } // Configure the Decoder to use "json" struct tags when decoding if "bson" // struct tags are not present. decoder.UseJSONStructTags() var res Product err = decoder.Decode(&res) if err != nil { panic(err) } fmt.Printf("%+v\n", res) // Output: {Name:Cereal Rounds SKU:AB12345 Price:399} } func ExampleDecoder_extendedJSON() { // Define an Extended JSON document that contains the name, SKU, and price // (in cents) of a product. data := []byte(`{"name":"Cereal Rounds","sku":"AB12345","price_cents":{"$numberLong":"399"}}`) // Create a Decoder that reads the Extended JSON document and use it to // unmarshal the document into a Product struct. vr, err := bsonrw.NewExtJSONValueReader(bytes.NewReader(data), true) if err != nil { panic(err) } decoder, err := bson.NewDecoder(vr) if err != nil { panic(err) } type Product struct { Name string `bson:"name"` SKU string `bson:"sku"` Price int64 `bson:"price_cents"` } var res Product err = decoder.Decode(&res) if err != nil { panic(err) } fmt.Printf("%+v\n", res) // Output: {Name:Cereal Rounds SKU:AB12345 Price:399} } func ExampleDecoder_multipleExtendedJSONDocuments() { // Define a newline-separated sequence of Extended JSON documents that // contain X,Y coordinates. data := []byte(` {"x":{"$numberInt":"0"},"y":{"$numberInt":"0"}} {"x":{"$numberInt":"1"},"y":{"$numberInt":"1"}} {"x":{"$numberInt":"2"},"y":{"$numberInt":"2"}} {"x":{"$numberInt":"3"},"y":{"$numberInt":"3"}} {"x":{"$numberInt":"4"},"y":{"$numberInt":"4"}} `) // Create a Decoder that reads the Extended JSON documents and use it to // unmarshal the documents Coordinate structs. vr, err := bsonrw.NewExtJSONValueReader(bytes.NewReader(data), true) if err != nil { panic(err) } decoder, err := bson.NewDecoder(vr) if err != nil { panic(err) } type Coordinate struct { X int Y int } // Read and unmarshal each Extended JSON document from the sequence. If // Decode returns error io.EOF, that means the Decoder has reached the end // of the input, so break the loop. for { var res Coordinate err = decoder.Decode(&res) if errors.Is(err, io.EOF) { break } if err != nil { panic(err) } fmt.Printf("%+v\n", res) } // Output: // {X:0 Y:0} // {X:1 Y:1} // {X:2 Y:2} // {X:3 Y:3} // {X:4 Y:4} }	5.34 KB	2025-05-25 12:27
📄 decoder_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "errors" "reflect" "testing" "time" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsonrw/bsonrwtest" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func TestBasicDecode(t testing.T) { t.Parallel() for _, tc := range unmarshalingTestCases() { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() got := reflect.New(tc.sType).Elem() vr := bsonrw.NewBSONDocumentReader(tc.data) reg := DefaultRegistry decoder, err := reg.LookupDecoder(reflect.TypeOf(got)) noerr(t, err) err = decoder.DecodeValue(bsoncodec.DecodeContext{Registry: reg}, vr, got) noerr(t, err) assert.Equal(t, tc.want, got.Addr().Interface(), "Results do not match.") }) } } func TestDecoderv2(t testing.T) { t.Parallel() t.Run("Decode", func(t testing.T) { t.Parallel() for _, tc := range unmarshalingTestCases() { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() got := reflect.New(tc.sType).Interface() vr := bsonrw.NewBSONDocumentReader(tc.data) dec, err := NewDecoderWithContext(bsoncodec.DecodeContext{Registry: DefaultRegistry}, vr) noerr(t, err) err = dec.Decode(got) noerr(t, err) assert.Equal(t, tc.want, got, "Results do not match.") }) } t.Run("lookup error", func(t testing.T) { t.Parallel() type certainlydoesntexistelsewhereihope func(string, string) string // Avoid unused code lint error. _ = certainlydoesntexistelsewhereihope(func(string, string) string { return "" }) cdeih := func(string, string) string { return "certainlydoesntexistelsewhereihope" } dec, err := NewDecoder(bsonrw.NewBSONDocumentReader([]byte{})) noerr(t, err) want := bsoncodec.ErrNoDecoder{Type: reflect.TypeOf(cdeih)} got := dec.Decode(&cdeih) assert.Equal(t, want, got, "Received unexpected error.") }) t.Run("Unmarshaler", func(t testing.T) { t.Parallel() testCases := []struct { name string err error vr bsonrw.ValueReader invoked bool }{ { "error", errors.New("Unmarshaler error"), &bsonrwtest.ValueReaderWriter{BSONType: bsontype.EmbeddedDocument, Err: bsonrw.ErrEOD, ErrAfter: bsonrwtest.ReadElement}, true, }, { "copy error", errors.New("copy error"), &bsonrwtest.ValueReaderWriter{Err: errors.New("copy error"), ErrAfter: bsonrwtest.ReadDocument}, false, }, { "success", nil, &bsonrwtest.ValueReaderWriter{BSONType: bsontype.EmbeddedDocument, Err: bsonrw.ErrEOD, ErrAfter: bsonrwtest.ReadElement}, true, }, } for _, tc := range testCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() unmarshaler := &testUnmarshaler{err: tc.err} dec, err := NewDecoder(tc.vr) noerr(t, err) got := dec.Decode(unmarshaler) want := tc.err if !compareErrors(got, want) { t.Errorf("Did not receive expected error. got %v; want %v", got, want) } if unmarshaler.invoked != tc.invoked { if tc.invoked { t.Error("Expected to have UnmarshalBSON invoked, but it wasn't.") } else { t.Error("Expected UnmarshalBSON to not be invoked, but it was.") } } }) } t.Run("Unmarshaler/success bsonrw.ValueReader", func(t testing.T) { t.Parallel() want := bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159)) unmarshaler := &testUnmarshaler{} vr := bsonrw.NewBSONDocumentReader(want) dec, err := NewDecoder(vr) noerr(t, err) err = dec.Decode(unmarshaler) noerr(t, err) got := unmarshaler.data if !bytes.Equal(got, want) { t.Errorf("Did not unmarshal properly. got %v; want %v", got, want) } }) }) }) t.Run("NewDecoder", func(t testing.T) { t.Parallel() t.Run("error", func(t testing.T) { t.Parallel() _, got := NewDecoder(nil) want := errors.New("cannot create a new Decoder with a nil ValueReader") if !cmp.Equal(got, want, cmp.Comparer(compareErrors)) { t.Errorf("Was expecting error but got different error. got %v; want %v", got, want) } }) t.Run("success", func(t testing.T) { t.Parallel() got, err := NewDecoder(bsonrw.NewBSONDocumentReader([]byte{})) noerr(t, err) if got == nil { t.Errorf("Was expecting a non-nil Decoder, but got <nil>") } }) }) t.Run("NewDecoderWithContext", func(t testing.T) { t.Parallel() t.Run("errors", func(t testing.T) { t.Parallel() dc := bsoncodec.DecodeContext{Registry: DefaultRegistry} _, got := NewDecoderWithContext(dc, nil) want := errors.New("cannot create a new Decoder with a nil ValueReader") if !cmp.Equal(got, want, cmp.Comparer(compareErrors)) { t.Errorf("Was expecting error but got different error. got %v; want %v", got, want) } }) t.Run("success", func(t testing.T) { t.Parallel() got, err := NewDecoderWithContext(bsoncodec.DecodeContext{}, bsonrw.NewBSONDocumentReader([]byte{})) noerr(t, err) if got == nil { t.Errorf("Was expecting a non-nil Decoder, but got <nil>") } dc := bsoncodec.DecodeContext{Registry: DefaultRegistry} got, err = NewDecoderWithContext(dc, bsonrw.NewBSONDocumentReader([]byte{})) noerr(t, err) if got == nil { t.Errorf("Was expecting a non-nil Decoder, but got <nil>") } }) }) t.Run("Decode doesn't zero struct", func(t testing.T) { t.Parallel() type foo struct { Item string Qty int Bonus int } var got foo got.Item = "apple" got.Bonus = 2 data := docToBytes(D{{"item", "canvas"}, {"qty", 4}}) vr := bsonrw.NewBSONDocumentReader(data) dec, err := NewDecoder(vr) noerr(t, err) err = dec.Decode(&got) noerr(t, err) want := foo{Item: "canvas", Qty: 4, Bonus: 2} assert.Equal(t, want, got, "Results do not match.") }) t.Run("Reset", func(t testing.T) { t.Parallel() vr1, vr2 := bsonrw.NewBSONDocumentReader([]byte{}), bsonrw.NewBSONDocumentReader([]byte{}) dc := bsoncodec.DecodeContext{Registry: DefaultRegistry} dec, err := NewDecoderWithContext(dc, vr1) noerr(t, err) if dec.vr != vr1 { t.Errorf("Decoder should use the value reader provided. got %v; want %v", dec.vr, vr1) } err = dec.Reset(vr2) noerr(t, err) if dec.vr != vr2 { t.Errorf("Decoder should use the value reader provided. got %v; want %v", dec.vr, vr2) } }) t.Run("SetContext", func(t testing.T) { t.Parallel() dc1 := bsoncodec.DecodeContext{Registry: DefaultRegistry} dc2 := bsoncodec.DecodeContext{Registry: NewRegistryBuilder().Build()} dec, err := NewDecoderWithContext(dc1, bsonrw.NewBSONDocumentReader([]byte{})) noerr(t, err) if !reflect.DeepEqual(dec.dc, dc1) { t.Errorf("Decoder should use the Registry provided. got %v; want %v", dec.dc, dc1) } err = dec.SetContext(dc2) noerr(t, err) if !reflect.DeepEqual(dec.dc, dc2) { t.Errorf("Decoder should use the Registry provided. got %v; want %v", dec.dc, dc2) } }) t.Run("SetRegistry", func(t testing.T) { t.Parallel() r1, r2 := DefaultRegistry, NewRegistryBuilder().Build() dc1 := bsoncodec.DecodeContext{Registry: r1} dc2 := bsoncodec.DecodeContext{Registry: r2} dec, err := NewDecoder(bsonrw.NewBSONDocumentReader([]byte{})) noerr(t, err) if !reflect.DeepEqual(dec.dc, dc1) { t.Errorf("Decoder should use the Registry provided. got %v; want %v", dec.dc, dc1) } err = dec.SetRegistry(r2) noerr(t, err) if !reflect.DeepEqual(dec.dc, dc2) { t.Errorf("Decoder should use the Registry provided. got %v; want %v", dec.dc, dc2) } }) t.Run("DecodeToNil", func(t testing.T) { t.Parallel() data := docToBytes(D{{"item", "canvas"}, {"qty", 4}}) vr := bsonrw.NewBSONDocumentReader(data) dec, err := NewDecoder(vr) noerr(t, err) var got D err = dec.Decode(got) if !errors.Is(err, ErrDecodeToNil) { t.Fatalf("Decode error mismatch; expected %v, got %v", ErrDecodeToNil, err) } }) } type testUnmarshaler struct { invoked bool err error data []byte } func (tu testUnmarshaler) UnmarshalBSON(d []byte) error { tu.invoked = true tu.data = d return tu.err } func TestDecoderConfiguration(t testing.T) { type truncateDoublesTest struct { MyInt int MyInt8 int8 MyInt16 int16 MyInt32 int32 MyInt64 int64 MyUint uint MyUint8 uint8 MyUint16 uint16 MyUint32 uint32 MyUint64 uint64 } type jsonStructTest struct { StructFieldName string `json:"jsonFieldName"` } type localTimeZoneTest struct { MyTime time.Time } type zeroMapsTest struct { MyMap map[string]string } type zeroStructsTest struct { MyString string MyInt int } testCases := []struct { description string configure func(Decoder) input []byte decodeInto func() interface{} want interface{} }{ // Test that AllowTruncatingDoubles causes the Decoder to unmarshal BSON doubles with // fractional parts into Go integer types by truncating the fractional part. { description: "AllowTruncatingDoubles", configure: func(dec Decoder) { dec.AllowTruncatingDoubles() }, input: bsoncore.NewDocumentBuilder(). AppendDouble("myInt", 1.999). AppendDouble("myInt8", 1.999). AppendDouble("myInt16", 1.999). AppendDouble("myInt32", 1.999). AppendDouble("myInt64", 1.999). AppendDouble("myUint", 1.999). AppendDouble("myUint8", 1.999). AppendDouble("myUint16", 1.999). AppendDouble("myUint32", 1.999). AppendDouble("myUint64", 1.999). Build(), decodeInto: func() interface{} { return &truncateDoublesTest{} }, want: &truncateDoublesTest{ MyInt: 1, MyInt8: 1, MyInt16: 1, MyInt32: 1, MyInt64: 1, MyUint: 1, MyUint8: 1, MyUint16: 1, MyUint32: 1, MyUint64: 1, }, }, // Test that BinaryAsSlice causes the Decoder to unmarshal BSON binary fields into Go byte // slices when there is no type information (e.g when unmarshaling into a bson.D). { description: "BinaryAsSlice", configure: func(dec Decoder) { dec.BinaryAsSlice() }, input: bsoncore.NewDocumentBuilder(). AppendBinary("myBinary", bsontype.BinaryGeneric, []byte{}). Build(), decodeInto: func() interface{} { return &D{} }, want: &D{{Key: "myBinary", Value: []byte{}}}, }, // Test that DefaultDocumentD overrides the default "ancestor" logic and always decodes BSON // documents into bson.D values, independent of the top-level Go value type. { description: "DefaultDocumentD nested", configure: func(dec Decoder) { dec.DefaultDocumentD() }, input: bsoncore.NewDocumentBuilder(). AppendDocument("myDocument", bsoncore.NewDocumentBuilder(). AppendString("myString", "test value"). Build()). Build(), decodeInto: func() interface{} { return M{} }, want: M{ "myDocument": D{{Key: "myString", Value: "test value"}}, }, }, // Test that DefaultDocumentM overrides the default "ancestor" logic and always decodes BSON // documents into bson.M values, independent of the top-level Go value type. { description: "DefaultDocumentM nested", configure: func(dec Decoder) { dec.DefaultDocumentM() }, input: bsoncore.NewDocumentBuilder(). AppendDocument("myDocument", bsoncore.NewDocumentBuilder(). AppendString("myString", "test value"). Build()). Build(), decodeInto: func() interface{} { return &D{} }, want: &D{ {Key: "myDocument", Value: M{"myString": "test value"}}, }, }, // Test that UseJSONStructTags causes the Decoder to fall back to "json" struct tags if // "bson" struct tags are not available. { description: "UseJSONStructTags", configure: func(dec Decoder) { dec.UseJSONStructTags() }, input: bsoncore.NewDocumentBuilder(). AppendString("jsonFieldName", "test value"). Build(), decodeInto: func() interface{} { return &jsonStructTest{} }, want: &jsonStructTest{StructFieldName: "test value"}, }, // Test that UseLocalTimeZone causes the Decoder to use the local time zone for decoded // time.Time values instead of UTC. { description: "UseLocalTimeZone", configure: func(dec Decoder) { dec.UseLocalTimeZone() }, input: bsoncore.NewDocumentBuilder(). AppendDateTime("myTime", 1684349179939). Build(), decodeInto: func() interface{} { return &localTimeZoneTest{} }, want: &localTimeZoneTest{MyTime: time.UnixMilli(1684349179939)}, }, // Test that ZeroMaps causes the Decoder to empty any Go map values before decoding BSON // documents into them. { description: "ZeroMaps", configure: func(dec Decoder) { dec.ZeroMaps() }, input: bsoncore.NewDocumentBuilder(). AppendDocument("myMap", bsoncore.NewDocumentBuilder(). AppendString("myString", "test value"). Build()). Build(), decodeInto: func() interface{} { return &zeroMapsTest{MyMap: map[string]string{"myExtraValue": "extra value"}} }, want: &zeroMapsTest{MyMap: map[string]string{"myString": "test value"}}, }, // Test that ZeroStructs causes the Decoder to empty any Go struct values before decoding // BSON documents into them. { description: "ZeroStructs", configure: func(dec Decoder) { dec.ZeroStructs() }, input: bsoncore.NewDocumentBuilder(). AppendString("myString", "test value"). Build(), decodeInto: func() interface{} { return &zeroStructsTest{MyInt: 1} }, want: &zeroStructsTest{MyString: "test value"}, }, } for _, tc := range testCases { tc := tc // Capture range variable. t.Run(tc.description, func(t testing.T) { t.Parallel() dec, err := NewDecoder(bsonrw.NewBSONDocumentReader(tc.input)) require.NoError(t, err, "NewDecoder error") tc.configure(dec) got := tc.decodeInto() err = dec.Decode(got) require.NoError(t, err, "Decode error") assert.Equal(t, tc.want, got, "expected and actual decode results do not match") }) } t.Run("DefaultDocumentM top-level", func(t testing.T) { t.Parallel() input := bsoncore.NewDocumentBuilder(). AppendDocument("myDocument", bsoncore.NewDocumentBuilder(). AppendString("myString", "test value"). Build()). Build() dec, err := NewDecoder(bsonrw.NewBSONDocumentReader(input)) require.NoError(t, err, "NewDecoder error") dec.DefaultDocumentM() var got interface{} err = dec.Decode(&got) require.NoError(t, err, "Decode error") want := M{ "myDocument": M{ "myString": "test value", }, } assert.Equal(t, want, got, "expected and actual decode results do not match") }) t.Run("DefaultDocumentD top-level", func(t *testing.T) { t.Parallel() input := bsoncore.NewDocumentBuilder(). AppendDocument("myDocument", bsoncore.NewDocumentBuilder(). AppendString("myString", "test value"). Build()). Build() dec, err := NewDecoder(bsonrw.NewBSONDocumentReader(input)) require.NoError(t, err, "NewDecoder error") dec.DefaultDocumentD() var got interface{} err = dec.Decode(&got) require.NoError(t, err, "Decode error") want := D{ {Key: "myDocument", Value: D{ {Key: "myString", Value: "test value"}, }}, } assert.Equal(t, want, got, "expected and actual decode results do not match") }) }	15.38 KB	2025-05-25 12:27
📄 doc.go // Copyright (C) MongoDB, Inc. 2017-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 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... // // # 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 // slice and M is a map. For more information about the use cases for these types, see the documentation on the type // definitions. // // Note that a D should not be constructed with duplicate key names, as that can cause undefined server behavior. // // Example: // // bson.D{{"foo", "bar"}, {"hello", "world"}, {"pi", 3.14159}} // bson.M{"foo": "bar", "hello": "world", "pi": 3.14159} // // When decoding BSON to a D or M, the following type mappings apply when unmarshaling: // // 1. BSON int32 unmarshals to an int32. // 2. BSON int64 unmarshals to an int64. // 3. BSON double unmarshals to a float64. // 4. BSON string unmarshals to a string. // 5. BSON boolean unmarshals to a bool. // 6. BSON embedded document unmarshals to the parent type (i.e. D for a D, M for an M). // 7. BSON array unmarshals to a bson.A. // 8. BSON ObjectId unmarshals to a primitive.ObjectID. // 9. BSON datetime unmarshals to a primitive.DateTime. // 10. BSON binary unmarshals to a primitive.Binary. // 11. BSON regular expression unmarshals to a primitive.Regex. // 12. BSON JavaScript unmarshals to a primitive.JavaScript. // 13. BSON code with scope unmarshals to a primitive.CodeWithScope. // 14. BSON timestamp unmarshals to an primitive.Timestamp. // 15. BSON 128-bit decimal unmarshals to an primitive.Decimal128. // 16. BSON min key unmarshals to an primitive.MinKey. // 17. BSON max key unmarshals to an primitive.MaxKey. // 18. BSON undefined unmarshals to a primitive.Undefined. // 19. BSON null unmarshals to nil. // 20. BSON DBPointer unmarshals to a primitive.DBPointer. // 21. BSON symbol unmarshals to a primitive.Symbol. // // The above mappings also apply when marshaling a D or M to BSON. Some other useful marshaling mappings are: // // 1. time.Time marshals to a BSON datetime. // 2. int8, int16, and int32 marshal to a BSON int32. // 3. int marshals to a BSON int32 if the value is between math.MinInt32 and math.MaxInt32, inclusive, and a BSON int64 // otherwise. // 4. int64 marshals to BSON int64 (unless [Encoder.IntMinSize] is set). // 5. uint8 and uint16 marshal to a BSON int32. // 6. uint, uint32, and uint64 marshal to a BSON int64 (unless [Encoder.IntMinSize] is set). // 7. BSON null and undefined values will unmarshal into the zero value of a field (e.g. unmarshaling a BSON null or // undefined value into a string will yield the empty string.). // // # Structs // // Structs can be marshaled/unmarshaled to/from BSON or Extended JSON. When transforming structs to/from BSON or Extended // JSON, the following rules apply: // // 1. Only exported fields in structs will be marshaled or unmarshaled. // // 2. When marshaling a struct, each field will be lowercased to generate the key for the corresponding BSON element. // For example, a struct field named "Foo" will generate key "foo". This can be overridden via a struct tag (e.g. // `bson:"fooField"` to generate key "fooField" instead). // // 3. An embedded struct field is marshaled as a subdocument. The key will be the lowercased name of the field's type. // // 4. A pointer field is marshaled as the underlying type if the pointer is non-nil. If the pointer is nil, it is // marshaled as a BSON null value. // // 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: // // 1. omitempty: If the omitempty struct tag is specified on a field, the field will be omitted from the marshaling if // the field has an empty value, defined as false, 0, a nil pointer, a nil interface value, and any empty array, // slice, map, or string. // 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 // the field can fit in a signed int32, the field will be serialized as a BSON int32 rather than a BSON int64. For // other types, this tag is ignored. // // 3. truncate: If the truncate struct tag is specified on a field with a non-float numeric type, BSON doubles // unmarshaled into that field will be truncated at the decimal point. For example, if 3.14 is unmarshaled into a // field of type int, it will be unmarshaled as 3. If this tag is not specified, the decoder will throw an error if // the value cannot be decoded without losing precision. For float64 or non-numeric types, this tag is ignored. // // 4. inline: If the inline struct tag is specified for a struct or map field, the field will be "flattened" when // marshaling and "un-flattened" when unmarshaling. This means that all of the fields in that struct/map will be // pulled up one level and will become top-level fields rather than being fields in a nested document. For example, // if a map field named "Map" with value map[string]interface{}{"foo": "bar"} is inlined, the resulting document will // be {"foo": "bar"} instead of {"map": {"foo": "bar"}}. There can only be one inlined map field in a struct. If // there are duplicated fields in the resulting document when an inlined struct is marshaled, the inlined field will // be overwritten. If there are duplicated fields in the resulting document when an inlined map is marshaled, an // 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 // // Manually marshaling and unmarshaling can be done with the Marshal and Unmarshal family of functions. // // [Work with BSON]: https://www.mongodb.com/docs/drivers/go/current/fundamentals/bson/ package bson	7.88 KB	2025-05-25 12:27
📄 encoder.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "errors" "reflect" "sync" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" ) // This pool is used to keep the allocations of Encoders down. This is only used for the Marshal* // methods and is not consumable from outside of this package. The Encoders retrieved from this pool // must have both Reset and SetRegistry called on them. var encPool = sync.Pool{ New: func() interface{} { return new(Encoder) }, } // An Encoder writes a serialization format to an output stream. It writes to a bsonrw.ValueWriter // as the destination of BSON data. type Encoder struct { ec bsoncodec.EncodeContext vw bsonrw.ValueWriter errorOnInlineDuplicates bool intMinSize bool stringifyMapKeysWithFmt bool nilMapAsEmpty bool nilSliceAsEmpty bool nilByteSliceAsEmpty bool omitZeroStruct bool useJSONStructTags bool } // NewEncoder returns a new encoder that uses the DefaultRegistry to write to vw. func NewEncoder(vw bsonrw.ValueWriter) (Encoder, error) { // TODO:(GODRIVER-2719): Remove error return value. if vw == nil { return nil, errors.New("cannot create a new Encoder with a nil ValueWriter") } return &Encoder{ ec: bsoncodec.EncodeContext{Registry: DefaultRegistry}, vw: vw, }, nil } // NewEncoderWithContext returns a new encoder that uses EncodeContext ec to write to vw. // // Deprecated: Use [NewEncoder] and use the Encoder configuration methods to set the desired marshal // behavior instead. func NewEncoderWithContext(ec bsoncodec.EncodeContext, vw bsonrw.ValueWriter) (Encoder, error) { if ec.Registry == nil { ec = bsoncodec.EncodeContext{Registry: DefaultRegistry} } if vw == nil { return nil, errors.New("cannot create a new Encoder with a nil ValueWriter") } return &Encoder{ ec: ec, vw: vw, }, nil } // Encode writes the BSON encoding of val to the stream. // // See [Marshal] for details about BSON marshaling behavior. func (e Encoder) Encode(val interface{}) error { if marshaler, ok := val.(Marshaler); ok { // TODO(skriptble): Should we have a MarshalAppender interface so that we can have []byte reuse? buf, err := marshaler.MarshalBSON() if err != nil { return err } return bsonrw.Copier{}.CopyDocumentFromBytes(e.vw, buf) } encoder, err := e.ec.LookupEncoder(reflect.TypeOf(val)) if err != nil { return err } // Copy the configurations applied to the Encoder over to the EncodeContext, which actually // communicates those configurations to the default ValueEncoders. if e.errorOnInlineDuplicates { e.ec.ErrorOnInlineDuplicates() } if e.intMinSize { e.ec.MinSize = true } if e.stringifyMapKeysWithFmt { e.ec.StringifyMapKeysWithFmt() } if e.nilMapAsEmpty { e.ec.NilMapAsEmpty() } if e.nilSliceAsEmpty { e.ec.NilSliceAsEmpty() } if e.nilByteSliceAsEmpty { e.ec.NilByteSliceAsEmpty() } if e.omitZeroStruct { e.ec.OmitZeroStruct() } if e.useJSONStructTags { e.ec.UseJSONStructTags() } return encoder.EncodeValue(e.ec, e.vw, reflect.ValueOf(val)) } // Reset will reset the state of the Encoder, using the same EncodeContext used in // the original construction but using vw. func (e Encoder) Reset(vw bsonrw.ValueWriter) error { // TODO:(GODRIVER-2719): Remove error return value. e.vw = vw return nil } // SetRegistry replaces the current registry of the Encoder with r. func (e Encoder) SetRegistry(r bsoncodec.Registry) error { // TODO:(GODRIVER-2719): Remove error return value. e.ec.Registry = r return nil } // SetContext replaces the current EncodeContext of the encoder with ec. // // Deprecated: Use the Encoder configuration methods set the desired marshal behavior instead. func (e Encoder) SetContext(ec bsoncodec.EncodeContext) error { // TODO:(GODRIVER-2719): Remove error return value. e.ec = ec return nil } // ErrorOnInlineDuplicates causes the Encoder to return an error if there is a duplicate field in // the marshaled BSON when the "inline" struct tag option is set. func (e Encoder) ErrorOnInlineDuplicates() { e.errorOnInlineDuplicates = true } // IntMinSize causes the Encoder to marshal Go integer values (int, int8, int16, int32, int64, uint, // uint8, uint16, uint32, or uint64) as the minimum BSON int size (either 32 or 64 bits) that can // represent the integer value. func (e Encoder) IntMinSize() { e.intMinSize = true } // StringifyMapKeysWithFmt causes the Encoder to convert Go map keys to BSON document field name // strings using fmt.Sprint instead of the default string conversion logic. func (e Encoder) StringifyMapKeysWithFmt() { e.stringifyMapKeysWithFmt = true } // NilMapAsEmpty causes the Encoder to marshal nil Go maps as empty BSON documents instead of BSON // null. func (e Encoder) NilMapAsEmpty() { e.nilMapAsEmpty = true } // NilSliceAsEmpty causes the Encoder to marshal nil Go slices as empty BSON arrays instead of BSON // null. func (e Encoder) NilSliceAsEmpty() { e.nilSliceAsEmpty = true } // NilByteSliceAsEmpty causes the Encoder to marshal nil Go byte slices as empty BSON binary values // instead of BSON null. func (e Encoder) NilByteSliceAsEmpty() { e.nilByteSliceAsEmpty = true } // TODO(GODRIVER-2820): Update the description to remove the note about only examining exported // TODO struct fields once the logic is updated to also inspect private struct fields. // OmitZeroStruct causes the Encoder to consider the zero value for a struct (e.g. MyStruct{}) // as empty and omit it from the marshaled BSON when the "omitempty" struct tag option is set. // // Note that the Encoder only examines exported struct fields when determining if a struct is the // zero value. It considers pointers to a zero struct value (e.g. &MyStruct{}) not empty. func (e Encoder) OmitZeroStruct() { e.omitZeroStruct = true } // UseJSONStructTags causes the Encoder to fall back to using the "json" struct tag if a "bson" // struct tag is not specified. func (e Encoder) UseJSONStructTags() { e.useJSONStructTags = true }	6.16 KB	2025-05-25 12:27
📄 encoder_example_test.go // Copyright (C) MongoDB, Inc. 2023-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 bson_test import ( "bytes" "errors" "fmt" "io" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/bson/bsonrw" ) func ExampleEncoder() { // Create an Encoder that writes BSON values to a bytes.Buffer. buf := new(bytes.Buffer) vw, err := bsonrw.NewBSONValueWriter(buf) if err != nil { panic(err) } encoder, err := bson.NewEncoder(vw) if err != nil { panic(err) } type Product struct { Name string `bson:"name"` SKU string `bson:"sku"` Price int64 `bson:"price_cents"` } // Use the Encoder to marshal a BSON document that contains the name, SKU, // and price (in cents) of a product. product := Product{ Name: "Cereal Rounds", SKU: "AB12345", Price: 399, } err = encoder.Encode(product) if err != nil { panic(err) } // Print the BSON document as Extended JSON by converting it to bson.Raw. fmt.Println(bson.Raw(buf.Bytes()).String()) // Output: {"name": "Cereal Rounds","sku": "AB12345","price_cents": {"$numberLong":"399"}} } type CityState struct { City string State string } func (k CityState) String() string { return fmt.Sprintf("%s, %s", k.City, k.State) } func ExampleEncoder_StringifyMapKeysWithFmt() { // Create an Encoder that writes BSON values to a bytes.Buffer. buf := new(bytes.Buffer) vw, err := bsonrw.NewBSONValueWriter(buf) if err != nil { panic(err) } encoder, err := bson.NewEncoder(vw) if err != nil { panic(err) } // Configure the Encoder to convert Go map keys to BSON document field names // using fmt.Sprintf instead of the default string conversion logic. encoder.StringifyMapKeysWithFmt() // Use the Encoder to marshal a BSON document that contains is a map of // city and state to a list of zip codes in that city. zipCodes := map[CityState][]int{ {City: "New York", State: "NY"}: {10001, 10301, 10451}, } err = encoder.Encode(zipCodes) if err != nil { panic(err) } // Print the BSON document as Extended JSON by converting it to bson.Raw. fmt.Println(bson.Raw(buf.Bytes()).String()) // Output: {"New York, NY": [{"$numberInt":"10001"},{"$numberInt":"10301"},{"$numberInt":"10451"}]} } func ExampleEncoder_UseJSONStructTags() { // Create an Encoder that writes BSON values to a bytes.Buffer. buf := new(bytes.Buffer) vw, err := bsonrw.NewBSONValueWriter(buf) if err != nil { panic(err) } encoder, err := bson.NewEncoder(vw) if err != nil { panic(err) } type Product struct { Name string `json:"name"` SKU string `json:"sku"` Price int64 `json:"price_cents"` } // Configure the Encoder to use "json" struct tags when decoding if "bson" // struct tags are not present. encoder.UseJSONStructTags() // Use the Encoder to marshal a BSON document that contains the name, SKU, // and price (in cents) of a product. product := Product{ Name: "Cereal Rounds", SKU: "AB12345", Price: 399, } err = encoder.Encode(product) if err != nil { panic(err) } // Print the BSON document as Extended JSON by converting it to bson.Raw. fmt.Println(bson.Raw(buf.Bytes()).String()) // Output: {"name": "Cereal Rounds","sku": "AB12345","price_cents": {"$numberLong":"399"}} } func ExampleEncoder_multipleBSONDocuments() { // Create an Encoder that writes BSON values to a bytes.Buffer. buf := new(bytes.Buffer) vw, err := bsonrw.NewBSONValueWriter(buf) if err != nil { panic(err) } encoder, err := bson.NewEncoder(vw) if err != nil { panic(err) } type Coordinate struct { X int Y int } // Use the encoder to marshal 5 Coordinate values as a sequence of BSON // documents. for i := 0; i < 5; i++ { err := encoder.Encode(Coordinate{ X: i, Y: i + 1, }) if err != nil { panic(err) } } // Read each marshaled BSON document from the buffer and print them as // Extended JSON by converting them to bson.Raw. for { doc, err := bson.ReadDocument(buf) if errors.Is(err, io.EOF) { return } if err != nil { panic(err) } fmt.Println(doc.String()) } // Output: // {"x": {"$numberInt":"0"},"y": {"$numberInt":"1"}} // {"x": {"$numberInt":"1"},"y": {"$numberInt":"2"}} // {"x": {"$numberInt":"2"},"y": {"$numberInt":"3"}} // {"x": {"$numberInt":"3"},"y": {"$numberInt":"4"}} // {"x": {"$numberInt":"4"},"y": {"$numberInt":"5"}} } func ExampleEncoder_extendedJSON() { // Create an Encoder that writes canonical Extended JSON values to a // bytes.Buffer. buf := new(bytes.Buffer) vw, err := bsonrw.NewExtJSONValueWriter(buf, true, false) if err != nil { panic(err) } encoder, err := bson.NewEncoder(vw) if err != nil { panic(err) } type Product struct { Name string `bson:"name"` SKU string `bson:"sku"` Price int64 `bson:"price_cents"` } // Use the Encoder to marshal a BSON document that contains the name, SKU, // and price (in cents) of a product. product := Product{ Name: "Cereal Rounds", SKU: "AB12345", Price: 399, } err = encoder.Encode(product) if err != nil { panic(err) } fmt.Println(buf.String()) // Output: {"name":"Cereal Rounds","sku":"AB12345","price_cents":{"$numberLong":"399"}} } func ExampleEncoder_multipleExtendedJSONDocuments() { // Create an Encoder that writes canonical Extended JSON values to a // bytes.Buffer. buf := new(bytes.Buffer) vw, err := bsonrw.NewExtJSONValueWriter(buf, true, false) if err != nil { panic(err) } encoder, err := bson.NewEncoder(vw) if err != nil { panic(err) } type Coordinate struct { X int Y int } // Use the encoder to marshal 5 Coordinate values as a sequence of Extended // JSON documents. for i := 0; i < 5; i++ { err := encoder.Encode(Coordinate{ X: i, Y: i + 1, }) if err != nil { panic(err) } } fmt.Println(buf.String()) // Output: // {"x":{"$numberInt":"0"},"y":{"$numberInt":"1"}} // {"x":{"$numberInt":"1"},"y":{"$numberInt":"2"}} // {"x":{"$numberInt":"2"},"y":{"$numberInt":"3"}} // {"x":{"$numberInt":"3"},"y":{"$numberInt":"4"}} // {"x":{"$numberInt":"4"},"y":{"$numberInt":"5"}} } func ExampleEncoder_IntMinSize() { // Create an encoder that will marshal integers as the minimum BSON int size // (either 32 or 64 bits) that can represent the integer value. type foo struct { Bar uint32 } buf := new(bytes.Buffer) vw, err := bsonrw.NewBSONValueWriter(buf) if err != nil { panic(err) } enc, err := bson.NewEncoder(vw) if err != nil { panic(err) } enc.IntMinSize() err = enc.Encode(foo{2}) if err != nil { panic(err) } fmt.Println(bson.Raw(buf.Bytes()).String()) // Output: // {"bar": {"$numberInt":"2"}} }	6.64 KB	2025-05-25 12:27
📄 encoder_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "errors" "reflect" "testing" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsonrw/bsonrwtest" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func TestBasicEncode(t testing.T) { for _, tc := range marshalingTestCases { t.Run(tc.name, func(t testing.T) { got := make(bsonrw.SliceWriter, 0, 1024) vw, err := bsonrw.NewBSONValueWriter(&got) noerr(t, err) reg := DefaultRegistry encoder, err := reg.LookupEncoder(reflect.TypeOf(tc.val)) noerr(t, err) err = encoder.EncodeValue(bsoncodec.EncodeContext{Registry: reg}, vw, reflect.ValueOf(tc.val)) noerr(t, err) if !bytes.Equal(got, tc.want) { t.Errorf("Bytes are not equal. got %v; want %v", got, tc.want) t.Errorf("Bytes:\n%v\n%v", got, tc.want) } }) } } func TestEncoderEncode(t testing.T) { for _, tc := range marshalingTestCases { t.Run(tc.name, func(t testing.T) { got := make(bsonrw.SliceWriter, 0, 1024) vw, err := bsonrw.NewBSONValueWriter(&got) noerr(t, err) enc, err := NewEncoder(vw) noerr(t, err) err = enc.Encode(tc.val) noerr(t, err) if !bytes.Equal(got, tc.want) { t.Errorf("Bytes are not equal. got %v; want %v", got, tc.want) t.Errorf("Bytes:\n%v\n%v", got, tc.want) } }) } t.Run("Marshaler", func(t testing.T) { testCases := []struct { name string buf []byte err error wanterr error vw bsonrw.ValueWriter }{ { "error", nil, errors.New("Marshaler error"), errors.New("Marshaler error"), &bsonrwtest.ValueReaderWriter{}, }, { "copy error", []byte{0x05, 0x00, 0x00, 0x00, 0x00}, nil, errors.New("copy error"), &bsonrwtest.ValueReaderWriter{Err: errors.New("copy error"), ErrAfter: bsonrwtest.WriteDocument}, }, { "success", []byte{0x07, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00}, nil, nil, nil, }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { marshaler := testMarshaler{buf: tc.buf, err: tc.err} var vw bsonrw.ValueWriter var err error b := make(bsonrw.SliceWriter, 0, 100) compareVW := false if tc.vw != nil { vw = tc.vw } else { compareVW = true vw, err = bsonrw.NewBSONValueWriter(&b) noerr(t, err) } enc, err := NewEncoder(vw) noerr(t, err) got := enc.Encode(marshaler) want := tc.wanterr if !compareErrors(got, want) { t.Errorf("Did not receive expected error. got %v; want %v", got, want) } if compareVW { buf := b if !bytes.Equal(buf, tc.buf) { t.Errorf("Copied bytes do not match. got %v; want %v", buf, tc.buf) } } }) } }) } type testMarshaler struct { buf []byte err error } func (tm testMarshaler) MarshalBSON() ([]byte, error) { return tm.buf, tm.err } func docToBytes(d interface{}) []byte { b, err := Marshal(d) if err != nil { panic(err) } return b } type stringerTest struct{} func (stringerTest) String() string { return "test key" } func TestEncoderConfiguration(t testing.T) { type inlineDuplicateInner struct { Duplicate string } type inlineDuplicateOuter struct { Inline inlineDuplicateInner `bson:",inline"` Duplicate string } type zeroStruct struct { MyString string } testCases := []struct { description string configure func(Encoder) input interface{} want []byte wantErr error }{ // Test that ErrorOnInlineDuplicates causes the Encoder to return an error if there are any // duplicate fields in the marshaled document caused by using the "inline" struct tag. { description: "ErrorOnInlineDuplicates", configure: func(enc Encoder) { enc.ErrorOnInlineDuplicates() }, input: inlineDuplicateOuter{ Inline: inlineDuplicateInner{Duplicate: "inner"}, Duplicate: "outer", }, wantErr: errors.New("struct bson.inlineDuplicateOuter has duplicated key duplicate"), }, // Test that IntMinSize encodes Go int and int64 values as BSON int32 if the value is small // enough. { description: "IntMinSize", configure: func(enc Encoder) { enc.IntMinSize() }, input: D{ {Key: "myInt", Value: int(1)}, {Key: "myInt64", Value: int64(1)}, {Key: "myUint", Value: uint(1)}, {Key: "myUint32", Value: uint32(1)}, {Key: "myUint64", Value: uint64(1)}, }, want: bsoncore.NewDocumentBuilder(). AppendInt32("myInt", 1). AppendInt32("myInt64", 1). AppendInt32("myUint", 1). AppendInt32("myUint32", 1). AppendInt32("myUint64", 1). Build(), }, // Test that StringifyMapKeysWithFmt uses fmt.Sprint to convert map keys to BSON field names. { description: "StringifyMapKeysWithFmt", configure: func(enc Encoder) { enc.StringifyMapKeysWithFmt() }, input: map[stringerTest]string{ {}: "test value", }, want: bsoncore.NewDocumentBuilder(). AppendString("test key", "test value"). Build(), }, // Test that NilMapAsEmpty encodes nil Go maps as empty BSON documents. { description: "NilMapAsEmpty", configure: func(enc Encoder) { enc.NilMapAsEmpty() }, input: D{{Key: "myMap", Value: map[string]string(nil)}}, want: bsoncore.NewDocumentBuilder(). AppendDocument("myMap", bsoncore.NewDocumentBuilder().Build()). Build(), }, // Test that NilSliceAsEmpty encodes nil Go slices as empty BSON arrays. { description: "NilSliceAsEmpty", configure: func(enc Encoder) { enc.NilSliceAsEmpty() }, input: D{{Key: "mySlice", Value: []string(nil)}}, want: bsoncore.NewDocumentBuilder(). AppendArray("mySlice", bsoncore.NewArrayBuilder().Build()). Build(), }, // Test that NilByteSliceAsEmpty encodes nil Go byte slices as empty BSON binary elements. { description: "NilByteSliceAsEmpty", configure: func(enc Encoder) { enc.NilByteSliceAsEmpty() }, input: D{{Key: "myBytes", Value: []byte(nil)}}, want: bsoncore.NewDocumentBuilder(). AppendBinary("myBytes", bsontype.BinaryGeneric, []byte{}). Build(), }, // Test that OmitZeroStruct omits empty structs from the marshaled document if the // "omitempty" struct tag is used. { description: "OmitZeroStruct", configure: func(enc Encoder) { enc.OmitZeroStruct() }, input: struct { Zero zeroStruct `bson:",omitempty"` }{}, want: bsoncore.NewDocumentBuilder().Build(), }, // Test that UseJSONStructTags causes the Encoder to fall back to "json" struct tags if // "bson" struct tags are not available. { description: "UseJSONStructTags", configure: func(enc Encoder) { enc.UseJSONStructTags() }, input: struct { StructFieldName string `json:"jsonFieldName"` }{ StructFieldName: "test value", }, want: bsoncore.NewDocumentBuilder(). AppendString("jsonFieldName", "test value"). Build(), }, } for _, tc := range testCases { tc := tc // Capture range variable. t.Run(tc.description, func(t *testing.T) { t.Parallel() got := new(bytes.Buffer) vw, err := bsonrw.NewBSONValueWriter(got) require.NoError(t, err, "bsonrw.NewBSONValueWriter error") enc, err := NewEncoder(vw) require.NoError(t, err, "NewEncoder error") tc.configure(enc) err = enc.Encode(tc.input) if tc.wantErr != nil { assert.Equal(t, tc.wantErr, err, "expected and actual errors do not match") return } require.NoError(t, err, "Encode error") assert.Equal(t, tc.want, got.Bytes(), "expected and actual encoded BSON do not match") // After we compare the raw bytes, also decode the expected and actual BSON as a bson.D // and compare them. The goal is to make assertion failures easier to debug because // binary diffs are very difficult to understand. var wantDoc D err = Unmarshal(tc.want, &wantDoc) require.NoError(t, err, "Unmarshal error") var gotDoc D err = Unmarshal(got.Bytes(), &gotDoc) require.NoError(t, err, "Unmarshal error") assert.Equal(t, wantDoc, gotDoc, "expected and actual decoded documents do not match") }) } }	8.34 KB	2025-05-25 12:27
📄 example_test.go // Copyright (C) MongoDB, Inc. 2023-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 bson_test import ( "fmt" "time" "go.mongodb.org/mongo-driver/bson" ) // This example uses Raw to skip parsing a nested document in a BSON message. func ExampleRaw_unmarshal() { b, err := bson.Marshal(bson.M{ "Word": "beach", "Synonyms": bson.A{"coast", "shore", "waterfront"}, }) if err != nil { panic(err) } var res struct { Word string Synonyms bson.Raw // Don't parse the whole list, we just want to count the elements. } err = bson.Unmarshal(b, &res) if err != nil { panic(err) } elems, err := res.Synonyms.Elements() if err != nil { panic(err) } fmt.Printf("%s, synonyms count: %d\n", res.Word, len(elems)) // Output: beach, synonyms count: 3 } // This example uses Raw to add a precomputed BSON document during marshal. func ExampleRaw_marshal() { precomputed, err := bson.Marshal(bson.M{"Precomputed": true}) if err != nil { panic(err) } msg := struct { Message string Metadata bson.Raw }{ Message: "Hello World!", Metadata: precomputed, } b, err := bson.Marshal(msg) if err != nil { panic(err) } // Print the Extended JSON by converting BSON to bson.Raw. fmt.Println(bson.Raw(b).String()) // Output: {"message": "Hello World!","metadata": {"Precomputed": true}} } // This example uses RawValue to delay parsing a value in a BSON message. func ExampleRawValue_unmarshal() { b1, err := bson.Marshal(bson.M{ "Format": "UNIX", "Timestamp": 1675282389, }) if err != nil { panic(err) } b2, err := bson.Marshal(bson.M{ "Format": "RFC3339", "Timestamp": time.Unix(1675282389, 0).Format(time.RFC3339), }) if err != nil { panic(err) } for _, b := range [][]byte{b1, b2} { var res struct { Format string Timestamp bson.RawValue // Delay parsing until we know the timestamp format. } err = bson.Unmarshal(b, &res) if err != nil { panic(err) } var t time.Time switch res.Format { case "UNIX": t = time.Unix(res.Timestamp.AsInt64(), 0) case "RFC3339": t, err = time.Parse(time.RFC3339, res.Timestamp.StringValue()) if err != nil { panic(err) } } fmt.Println(res.Format, t.Unix()) } // Output: // UNIX 1675282389 // RFC3339 1675282389 } // This example uses RawValue to add a precomputed BSON string value during marshal. func ExampleRawValue_marshal() { t, val, err := bson.MarshalValue("Precomputed message!") if err != nil { panic(err) } precomputed := bson.RawValue{ Type: t, Value: val, } msg := struct { Message bson.RawValue Time time.Time }{ Message: precomputed, Time: time.Unix(1675282389, 0), } b, err := bson.Marshal(msg) if err != nil { panic(err) } // Print the Extended JSON by converting BSON to bson.Raw. fmt.Println(bson.Raw(b).String()) // Output: {"message": "Precomputed message!","time": {"$date":{"$numberLong":"1675282389000"}}} }	3.06 KB	2025-05-25 12:27
📄 extjson_prose_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "fmt" "testing" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/internal/assert" ) func TestExtJSON(t testing.T) { timestampNegativeInt32Err := fmt.Errorf("$timestamp i number should be uint32: -1") timestampNegativeInt64Err := fmt.Errorf("$timestamp i number should be uint32: -2147483649") timestampLargeValueErr := fmt.Errorf("$timestamp i number should be uint32: 4294967296") testCases := []struct { name string input string canonical bool err error }{ {"timestamp - negative int32 value", `{"":{"$timestamp":{"t":0,"i":-1}}}`, false, timestampNegativeInt32Err}, {"timestamp - negative int64 value", `{"":{"$timestamp":{"t":0,"i":-2147483649}}}`, false, timestampNegativeInt64Err}, {"timestamp - value overflows uint32", `{"":{"$timestamp":{"t":0,"i":4294967296}}}`, false, timestampLargeValueErr}, {"top level key is not treated as special", `{"$code": "foo"}`, false, nil}, {"escaped single quote errors", `{"f\'oo": "bar"}`, false, bsonrw.ErrInvalidJSON}, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { var res Raw err := UnmarshalExtJSON([]byte(tc.input), tc.canonical, &res) if tc.err == nil { assert.Nil(t, err, "UnmarshalExtJSON error: %v", err) return } assert.NotNil(t, err, "expected error %v, got nil", tc.err) assert.Equal(t, tc.err.Error(), err.Error(), "expected error %v, got %v", tc.err, err) }) } }	1.7 KB	2025-05-25 12:27
📄 fuzz_test.go // 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 bson import ( "testing" ) func FuzzDecode(f testing.F) { seedBSONCorpus(f) f.Fuzz(func(t testing.T, data []byte) { for _, typ := range []func() interface{}{ func() interface{} { return new(D) }, func() interface{} { return new([]E) }, func() interface{} { return new(M) }, func() interface{} { return new(interface{}) }, func() interface{} { return make(map[string]interface{}) }, func() interface{} { return new([]interface{}) }, } { i := typ() if err := Unmarshal(data, i); err != nil { return } encoded, err := Marshal(i) if err != nil { t.Fatal("failed to marshal", err) } if err := Unmarshal(encoded, i); err != nil { t.Fatal("failed to unmarshal", err) } } }) }	1017 B	2025-05-25 12:27
📄 marshal.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "encoding/json" "sync" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsontype" ) const defaultDstCap = 256 var bvwPool = bsonrw.NewBSONValueWriterPool() var extjPool = bsonrw.NewExtJSONValueWriterPool() // Marshaler is the interface implemented by types that can marshal themselves // into a valid BSON document. // // Implementations of Marshaler must return a full BSON document. To create // custom BSON marshaling behavior for individual values in a BSON document, // implement the ValueMarshaler interface instead. type Marshaler interface { MarshalBSON() ([]byte, error) } // ValueMarshaler is the interface implemented by types that can marshal // themselves into a valid BSON value. The format of the returned bytes must // match the returned type. // // Implementations of ValueMarshaler must return an individual BSON value. To // create custom BSON marshaling behavior for an entire BSON document, implement // the Marshaler interface instead. type ValueMarshaler interface { MarshalBSONValue() (bsontype.Type, []byte, error) } // Marshal returns the BSON encoding of val as a BSON document. If val is not a type that can be transformed into a // document, MarshalValue should be used instead. // // Marshal will use the default registry created by NewRegistry to recursively // marshal val into a []byte. Marshal will inspect struct tags and alter the // marshaling process accordingly. func Marshal(val interface{}) ([]byte, error) { return MarshalWithRegistry(DefaultRegistry, val) } // MarshalAppend will encode val as a BSON document and append the bytes to dst. If dst is not large enough to hold the // bytes, it will be grown. If val is not a type that can be transformed into a document, MarshalValueAppend should be // used instead. // // Deprecated: Use [NewEncoder] and pass the dst byte slice (wrapped by a bytes.Buffer) into // [bsonrw.NewBSONValueWriter]: // // buf := bytes.NewBuffer(dst) // vw, err := bsonrw.NewBSONValueWriter(buf) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // // See [Encoder] for more examples. func MarshalAppend(dst []byte, val interface{}) ([]byte, error) { return MarshalAppendWithRegistry(DefaultRegistry, dst, val) } // MarshalWithRegistry returns the BSON encoding of val as a BSON document. If val is not a type that can be transformed // into a document, MarshalValueWithRegistry should be used instead. // // Deprecated: Use [NewEncoder] and specify the Registry by calling [Encoder.SetRegistry] instead: // // buf := new(bytes.Buffer) // vw, err := bsonrw.NewBSONValueWriter(buf) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // enc.SetRegistry(reg) // // See [Encoder] for more examples. func MarshalWithRegistry(r bsoncodec.Registry, val interface{}) ([]byte, error) { dst := make([]byte, 0) return MarshalAppendWithRegistry(r, dst, val) } // MarshalWithContext returns the BSON encoding of val as a BSON document using EncodeContext ec. If val is not a type // that can be transformed into a document, MarshalValueWithContext should be used instead. // // Deprecated: Use [NewEncoder] and use the Encoder configuration methods to set the desired marshal // behavior instead: // // buf := bytes.NewBuffer(dst) // vw, err := bsonrw.NewBSONValueWriter(buf) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // enc.IntMinSize() // // See [Encoder] for more examples. func MarshalWithContext(ec bsoncodec.EncodeContext, val interface{}) ([]byte, error) { dst := make([]byte, 0) return MarshalAppendWithContext(ec, dst, val) } // MarshalAppendWithRegistry will encode val as a BSON document using Registry r and append the bytes to dst. If dst is // not large enough to hold the bytes, it will be grown. If val is not a type that can be transformed into a document, // MarshalValueAppendWithRegistry should be used instead. // // Deprecated: Use [NewEncoder], and pass the dst byte slice (wrapped by a bytes.Buffer) into // [bsonrw.NewBSONValueWriter], and specify the Registry by calling [Encoder.SetRegistry] instead: // // buf := bytes.NewBuffer(dst) // vw, err := bsonrw.NewBSONValueWriter(buf) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // enc.SetRegistry(reg) // // See [Encoder] for more examples. func MarshalAppendWithRegistry(r bsoncodec.Registry, dst []byte, val interface{}) ([]byte, error) { return MarshalAppendWithContext(bsoncodec.EncodeContext{Registry: r}, dst, val) } // Pool of buffers for marshalling BSON. var bufPool = sync.Pool{ New: func() interface{} { return new(bytes.Buffer) }, } // MarshalAppendWithContext will encode val as a BSON document using Registry r and EncodeContext ec and append the // bytes to dst. If dst is not large enough to hold the bytes, it will be grown. If val is not a type that can be // transformed into a document, MarshalValueAppendWithContext should be used instead. // // Deprecated: Use [NewEncoder], pass the dst byte slice (wrapped by a bytes.Buffer) into // [bsonrw.NewBSONValueWriter], and use the Encoder configuration methods to set the desired marshal // behavior instead: // // buf := bytes.NewBuffer(dst) // vw, err := bsonrw.NewBSONValueWriter(buf) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // enc.IntMinSize() // // See [Encoder] for more examples. func MarshalAppendWithContext(ec bsoncodec.EncodeContext, dst []byte, val interface{}) ([]byte, error) { sw := bufPool.Get().(bytes.Buffer) defer func() { // Proper usage of a sync.Pool requires each entry to have approximately // the same memory cost. To obtain this property when the stored type // contains a variably-sized buffer, we add a hard limit on the maximum // buffer to place back in the pool. We limit the size to 16MiB because // that's the maximum wire message size supported by any current MongoDB // server. // // Comment based on // https://cs.opensource.google/go/go/+/refs/tags/go1.19:src/fmt/print.go;l=147 // // Recycle byte slices that are smaller than 16MiB and at least half // occupied. if sw.Cap() < 1610241024 && sw.Cap()/2 < sw.Len() { bufPool.Put(sw) } }() sw.Reset() vw := bvwPool.Get(sw) defer bvwPool.Put(vw) enc := encPool.Get().(Encoder) defer encPool.Put(enc) err := enc.Reset(vw) if err != nil { return nil, err } err = enc.SetContext(ec) if err != nil { return nil, err } err = enc.Encode(val) if err != nil { return nil, err } return append(dst, sw.Bytes()...), nil } // MarshalValue returns the BSON encoding of val. // // MarshalValue will use bson.DefaultRegistry to transform val into a BSON value. If val is a struct, this function will // inspect struct tags and alter the marshalling process accordingly. func MarshalValue(val interface{}) (bsontype.Type, []byte, error) { return MarshalValueWithRegistry(DefaultRegistry, val) } // MarshalValueAppend will append the BSON encoding of val to dst. If dst is not large enough to hold the BSON encoding // of val, dst will be grown. // // Deprecated: Appending individual BSON elements to an existing slice will not be supported in Go // Driver 2.0. func MarshalValueAppend(dst []byte, val interface{}) (bsontype.Type, []byte, error) { return MarshalValueAppendWithRegistry(DefaultRegistry, dst, val) } // MarshalValueWithRegistry returns the BSON encoding of val using Registry r. // // Deprecated: Using a custom registry to marshal individual BSON values will not be supported in Go // Driver 2.0. func MarshalValueWithRegistry(r bsoncodec.Registry, val interface{}) (bsontype.Type, []byte, error) { dst := make([]byte, 0) return MarshalValueAppendWithRegistry(r, dst, val) } // MarshalValueWithContext returns the BSON encoding of val using EncodeContext ec. // // Deprecated: Using a custom EncodeContext to marshal individual BSON elements will not be // supported in Go Driver 2.0. func MarshalValueWithContext(ec bsoncodec.EncodeContext, val interface{}) (bsontype.Type, []byte, error) { dst := make([]byte, 0) return MarshalValueAppendWithContext(ec, dst, val) } // MarshalValueAppendWithRegistry will append the BSON encoding of val to dst using Registry r. If dst is not large // enough to hold the BSON encoding of val, dst will be grown. // // Deprecated: Appending individual BSON elements to an existing slice will not be supported in Go // Driver 2.0. func MarshalValueAppendWithRegistry(r bsoncodec.Registry, dst []byte, val interface{}) (bsontype.Type, []byte, error) { return MarshalValueAppendWithContext(bsoncodec.EncodeContext{Registry: r}, dst, val) } // MarshalValueAppendWithContext will append the BSON encoding of val to dst using EncodeContext ec. If dst is not large // enough to hold the BSON encoding of val, dst will be grown. // // Deprecated: Appending individual BSON elements to an existing slice will not be supported in Go // Driver 2.0. func MarshalValueAppendWithContext(ec bsoncodec.EncodeContext, dst []byte, val interface{}) (bsontype.Type, []byte, error) { // get a ValueWriter configured to write to dst sw := new(bsonrw.SliceWriter) sw = dst vwFlusher := bvwPool.GetAtModeElement(sw) // get an Encoder and encode the value enc := encPool.Get().(Encoder) defer encPool.Put(enc) if err := enc.Reset(vwFlusher); err != nil { return 0, nil, err } if err := enc.SetContext(ec); err != nil { return 0, nil, err } if err := enc.Encode(val); err != nil { return 0, nil, err } // flush the bytes written because we cannot guarantee that a full document has been written // after the flush, sw will be in the format // [value type, 0 (null byte to indicate end of empty element name), value bytes..] if err := vwFlusher.Flush(); err != nil { return 0, nil, err } buffer := sw return bsontype.Type(buffer[0]), buffer[2:], nil } // MarshalExtJSON returns the extended JSON encoding of val. func MarshalExtJSON(val interface{}, canonical, escapeHTML bool) ([]byte, error) { return MarshalExtJSONWithRegistry(DefaultRegistry, val, canonical, escapeHTML) } // MarshalExtJSONAppend will append the extended JSON encoding of val to dst. // If dst is not large enough to hold the extended JSON encoding of val, dst // will be grown. // // Deprecated: Use [NewEncoder] and pass the dst byte slice (wrapped by a bytes.Buffer) into // [bsonrw.NewExtJSONValueWriter] instead: // // buf := bytes.NewBuffer(dst) // vw, err := bsonrw.NewExtJSONValueWriter(buf, true, false) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // // See [Encoder] for more examples. func MarshalExtJSONAppend(dst []byte, val interface{}, canonical, escapeHTML bool) ([]byte, error) { return MarshalExtJSONAppendWithRegistry(DefaultRegistry, dst, val, canonical, escapeHTML) } // MarshalExtJSONWithRegistry returns the extended JSON encoding of val using Registry r. // // Deprecated: Use [NewEncoder] and specify the Registry by calling [Encoder.SetRegistry] instead: // // buf := new(bytes.Buffer) // vw, err := bsonrw.NewBSONValueWriter(buf) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // enc.SetRegistry(reg) // // See [Encoder] for more examples. func MarshalExtJSONWithRegistry(r bsoncodec.Registry, val interface{}, canonical, escapeHTML bool) ([]byte, error) { dst := make([]byte, 0, defaultDstCap) return MarshalExtJSONAppendWithContext(bsoncodec.EncodeContext{Registry: r}, dst, val, canonical, escapeHTML) } // MarshalExtJSONWithContext returns the extended JSON encoding of val using Registry r. // // Deprecated: Use [NewEncoder] and use the Encoder configuration methods to set the desired marshal // behavior instead: // // buf := new(bytes.Buffer) // vw, err := bsonrw.NewBSONValueWriter(buf) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // enc.IntMinSize() // // See [Encoder] for more examples. func MarshalExtJSONWithContext(ec bsoncodec.EncodeContext, val interface{}, canonical, escapeHTML bool) ([]byte, error) { dst := make([]byte, 0, defaultDstCap) return MarshalExtJSONAppendWithContext(ec, dst, val, canonical, escapeHTML) } // MarshalExtJSONAppendWithRegistry will append the extended JSON encoding of // val to dst using Registry r. If dst is not large enough to hold the BSON // encoding of val, dst will be grown. // // Deprecated: Use [NewEncoder], pass the dst byte slice (wrapped by a bytes.Buffer) into // [bsonrw.NewExtJSONValueWriter], and specify the Registry by calling [Encoder.SetRegistry] // instead: // // buf := bytes.NewBuffer(dst) // vw, err := bsonrw.NewExtJSONValueWriter(buf, true, false) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // // See [Encoder] for more examples. func MarshalExtJSONAppendWithRegistry(r bsoncodec.Registry, dst []byte, val interface{}, canonical, escapeHTML bool) ([]byte, error) { return MarshalExtJSONAppendWithContext(bsoncodec.EncodeContext{Registry: r}, dst, val, canonical, escapeHTML) } // MarshalExtJSONAppendWithContext will append the extended JSON encoding of // val to dst using Registry r. If dst is not large enough to hold the BSON // encoding of val, dst will be grown. // // Deprecated: Use [NewEncoder], pass the dst byte slice (wrapped by a bytes.Buffer) into // [bsonrw.NewExtJSONValueWriter], and use the Encoder configuration methods to set the desired marshal // behavior instead: // // buf := bytes.NewBuffer(dst) // vw, err := bsonrw.NewExtJSONValueWriter(buf, true, false) // if err != nil { // panic(err) // } // enc, err := bson.NewEncoder(vw) // if err != nil { // panic(err) // } // enc.IntMinSize() // // See [Encoder] for more examples. func MarshalExtJSONAppendWithContext(ec bsoncodec.EncodeContext, dst []byte, val interface{}, canonical, escapeHTML bool) ([]byte, error) { sw := new(bsonrw.SliceWriter) sw = dst ejvw := extjPool.Get(sw, canonical, escapeHTML) defer extjPool.Put(ejvw) enc := encPool.Get().(Encoder) defer encPool.Put(enc) err := enc.Reset(ejvw) if err != nil { return nil, err } err = enc.SetContext(ec) if err != nil { return nil, err } err = enc.Encode(val) if err != nil { return nil, err } return sw, nil } // IndentExtJSON will prefix and indent the provided extended JSON src and append it to dst. func IndentExtJSON(dst bytes.Buffer, src []byte, prefix, indent string) error { return json.Indent(dst, src, prefix, indent) } // MarshalExtJSONIndent returns the extended JSON encoding of val with each line with prefixed // and indented. func MarshalExtJSONIndent(val interface{}, canonical, escapeHTML bool, prefix, indent string) ([]byte, error) { marshaled, err := MarshalExtJSON(val, canonical, escapeHTML) if err != nil { return nil, err } var buf bytes.Buffer err = IndentExtJSON(&buf, marshaled, prefix, indent) if err != nil { return nil, err } return buf.Bytes(), nil }	15.21 KB	2025-05-25 12:27
📄 marshal_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "errors" "fmt" "reflect" "sync" "testing" "time" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) var tInt32 = reflect.TypeOf(int32(0)) func TestMarshalAppendWithRegistry(t testing.T) { for _, tc := range marshalingTestCases { t.Run(tc.name, func(t testing.T) { dst := make([]byte, 0, 1024) var reg bsoncodec.Registry if tc.reg != nil { reg = tc.reg } else { reg = DefaultRegistry } got, err := MarshalAppendWithRegistry(reg, dst, tc.val) noerr(t, err) if !bytes.Equal(got, tc.want) { t.Errorf("Bytes are not equal. got %v; want %v", got, tc.want) t.Errorf("Bytes:\n%v\n%v", got, tc.want) } }) } } func TestMarshalAppendWithContext(t testing.T) { for _, tc := range marshalingTestCases { t.Run(tc.name, func(t testing.T) { dst := make([]byte, 0, 1024) var reg bsoncodec.Registry if tc.reg != nil { reg = tc.reg } else { reg = DefaultRegistry } ec := bsoncodec.EncodeContext{Registry: reg} got, err := MarshalAppendWithContext(ec, dst, tc.val) noerr(t, err) if !bytes.Equal(got, tc.want) { t.Errorf("Bytes are not equal. got %v; want %v", got, tc.want) t.Errorf("Bytes:\n%v\n%v", got, tc.want) } }) } } func TestMarshalWithRegistry(t testing.T) { for _, tc := range marshalingTestCases { t.Run(tc.name, func(t testing.T) { var reg bsoncodec.Registry if tc.reg != nil { reg = tc.reg } else { reg = DefaultRegistry } got, err := MarshalWithRegistry(reg, tc.val) noerr(t, err) if !bytes.Equal(got, tc.want) { t.Errorf("Bytes are not equal. got %v; want %v", got, tc.want) t.Errorf("Bytes:\n%v\n%v", got, tc.want) } }) } } func TestMarshalWithContext(t testing.T) { for _, tc := range marshalingTestCases { t.Run(tc.name, func(t testing.T) { var reg bsoncodec.Registry if tc.reg != nil { reg = tc.reg } else { reg = DefaultRegistry } ec := bsoncodec.EncodeContext{Registry: reg} got, err := MarshalWithContext(ec, tc.val) noerr(t, err) if !bytes.Equal(got, tc.want) { t.Errorf("Bytes are not equal. got %v; want %v", got, tc.want) t.Errorf("Bytes:\n%v\n%v", got, tc.want) } }) } } func TestMarshalAppend(t testing.T) { for _, tc := range marshalingTestCases { t.Run(tc.name, func(t testing.T) { if tc.reg != nil { t.Skip() // test requires custom registry } dst := make([]byte, 0, 1024) got, err := MarshalAppend(dst, tc.val) noerr(t, err) if !bytes.Equal(got, tc.want) { t.Errorf("Bytes are not equal. got %v; want %v", got, tc.want) t.Errorf("Bytes:\n%v\n%v", got, tc.want) } }) } } func TestMarshalExtJSONAppendWithContext(t testing.T) { t.Run("MarshalExtJSONAppendWithContext", func(t testing.T) { dst := make([]byte, 0, 1024) type teststruct struct{ Foo int } val := teststruct{1} ec := bsoncodec.EncodeContext{Registry: DefaultRegistry} got, err := MarshalExtJSONAppendWithContext(ec, dst, val, true, false) noerr(t, err) want := []byte(`{"foo":{"$numberInt":"1"}}`) if !bytes.Equal(got, want) { t.Errorf("Bytes are not equal. got %v; want %v", got, want) t.Errorf("Bytes:\n%s\n%s", got, want) } }) } func TestMarshalExtJSONWithContext(t testing.T) { t.Run("MarshalExtJSONWithContext", func(t testing.T) { type teststruct struct{ Foo int } val := teststruct{1} ec := bsoncodec.EncodeContext{Registry: DefaultRegistry} got, err := MarshalExtJSONWithContext(ec, val, true, false) noerr(t, err) want := []byte(`{"foo":{"$numberInt":"1"}}`) if !bytes.Equal(got, want) { t.Errorf("Bytes are not equal. got %v; want %v", got, want) t.Errorf("Bytes:\n%s\n%s", got, want) } }) } func TestMarshal_roundtripFromBytes(t testing.T) { before := []byte{ // length 0x1c, 0x0, 0x0, 0x0, // --- begin array --- // type - document 0x3, // key - "foo" 0x66, 0x6f, 0x6f, 0x0, // length 0x12, 0x0, 0x0, 0x0, // type - string 0x2, // key - "bar" 0x62, 0x61, 0x72, 0x0, // value - string length 0x4, 0x0, 0x0, 0x0, // value - "baz" 0x62, 0x61, 0x7a, 0x0, // null terminator 0x0, // --- end array --- // null terminator 0x0, } var doc D require.NoError(t, Unmarshal(before, &doc)) after, err := Marshal(doc) require.NoError(t, err) require.True(t, bytes.Equal(before, after)) } func TestMarshal_roundtripFromDoc(t testing.T) { before := D{ {"foo", "bar"}, {"baz", int64(-27)}, {"bing", A{nil, primitive.Regex{Pattern: "word", Options: "i"}}}, } b, err := Marshal(before) require.NoError(t, err) var after D require.NoError(t, Unmarshal(b, &after)) if !cmp.Equal(after, before) { t.Errorf("Documents to not match. got %v; want %v", after, before) } } func TestCachingEncodersNotSharedAcrossRegistries(t testing.T) { // Encoders that have caches for recursive encoder lookup should not be shared across Registry instances. Otherwise, // the first EncodeValue call would cache an encoder and a subsequent call would see that encoder even if a // different Registry is used. // Create a custom Registry that negates int32 values when encoding. var encodeInt32 bsoncodec.ValueEncoderFunc = func(_ bsoncodec.EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error { if val.Kind() != reflect.Int32 { return fmt.Errorf("expected kind to be int32, got %v", val.Kind()) } return vw.WriteInt32(int32(val.Int()) -1) } customReg := NewRegistryBuilder(). RegisterTypeEncoder(tInt32, encodeInt32). Build() // Helper function to run the test and make assertions. The provided original value should result in the document // {"x": {$numberInt: 1}} when marshalled with the default registry. verifyResults := func(t testing.T, original interface{}) { // Marshal using the default and custom registries. Assert that the result is {x: 1} and {x: -1}, respectively. first, err := Marshal(original) assert.Nil(t, err, "Marshal error: %v", err) expectedFirst := Raw(bsoncore.BuildDocumentFromElements( nil, bsoncore.AppendInt32Element(nil, "x", 1), )) assert.Equal(t, expectedFirst, Raw(first), "expected document %v, got %v", expectedFirst, Raw(first)) second, err := MarshalWithRegistry(customReg, original) assert.Nil(t, err, "Marshal error: %v", err) expectedSecond := Raw(bsoncore.BuildDocumentFromElements( nil, bsoncore.AppendInt32Element(nil, "x", -1), )) assert.Equal(t, expectedSecond, Raw(second), "expected document %v, got %v", expectedSecond, Raw(second)) } t.Run("struct", func(t testing.T) { type Struct struct { X int32 } verifyResults(t, Struct{ X: 1, }) }) t.Run("pointer", func(t testing.T) { i32 := int32(1) verifyResults(t, M{ "x": &i32, }) }) } func TestNullBytes(t testing.T) { t.Run("element keys", func(t testing.T) { doc := D{{"a\x00", "foobar"}} res, err := Marshal(doc) want := errors.New("BSON element key cannot contain null bytes") assert.Equal(t, want, err, "expected Marshal error %v, got error %v with result %q", want, err, Raw(res)) }) t.Run("regex values", func(t testing.T) { wantErr := errors.New("BSON regex values cannot contain null bytes") testCases := []struct { name string pattern string options string }{ {"null bytes in pattern", "a\x00", "i"}, {"null bytes in options", "pattern", "i\x00"}, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { regex := primitive.Regex{ Pattern: tc.pattern, Options: tc.options, } res, err := Marshal(D{{"foo", regex}}) assert.Equal(t, wantErr, err, "expected Marshal error %v, got error %v with result %q", wantErr, err, Raw(res)) }) } }) t.Run("sub document field name", func(t testing.T) { doc := D{{"foo", D{{"foobar", D{{"a\x00", "foobar"}}}}}} res, err := Marshal(doc) wantErr := errors.New("BSON element key cannot contain null bytes") assert.Equal(t, wantErr, err, "expected Marshal error %v, got error %v with result %q", wantErr, err, Raw(res)) }) } func TestMarshalExtJSONIndent(t testing.T) { type indentTestCase struct { name string val interface{} expectedExtJSON string } // expectedExtJSON must be written as below because single-quoted // literal strings capture undesired code formatting tabs testCases := []indentTestCase{ { "empty val", struct{}{}, `{}`, }, { "embedded struct", struct { Embedded interface{} `json:"embedded"` Foo string `json:"foo"` }{ Embedded: struct { Name string `json:"name"` Word string `json:"word"` }{ Name: "test", Word: "word", }, Foo: "bar", }, "{\n\t\"embedded\": {\n\t\t\"name\": \"test\",\n\t\t\"word\": \"word\"\n\t},\n\t\"foo\": \"bar\"\n}", }, { "date struct", struct { Foo string `json:"foo"` Date time.Time `json:"date"` }{ Foo: "bar", Date: time.Date(2000, time.January, 1, 12, 0, 0, 0, time.UTC), }, "{\n\t\"foo\": \"bar\",\n\t\"date\": {\n\t\t\"$date\": {\n\t\t\t\"$numberLong\": \"946728000000\"\n\t\t}\n\t}\n}", }, { "float struct", struct { Foo string `json:"foo"` Float float32 `json:"float"` }{ Foo: "bar", Float: 3.14, }, "{\n\t\"foo\": \"bar\",\n\t\"float\": {\n\t\t\"$numberDouble\": \"3.140000104904175\"\n\t}\n}", }, } for _, tc := range testCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() extJSONBytes, err := MarshalExtJSONIndent(tc.val, true, false, "", "\t") assert.Nil(t, err, "Marshal indent error: %v", err) expectedExtJSONBytes := []byte(tc.expectedExtJSON) assert.Equal(t, expectedExtJSONBytes, extJSONBytes, "expected:\n%s\ngot:\n%s", expectedExtJSONBytes, extJSONBytes) }) } } func TestMarshalConcurrently(t *testing.T) { t.Parallel() const size = 10_000 wg := sync.WaitGroup{} wg.Add(size) for i := 0; i < size; i++ { go func() { defer wg.Done() _, _ = Marshal(struct{ LastError error }{}) }() } wg.Wait() }	10.33 KB	2025-05-25 12:27
📄 marshal_value_cases_test.go // Copyright (C) MongoDB, Inc. 2023-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 bson import ( "io" "testing" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) // helper type for testing MarshalValue that implements io.Reader type marshalValueInterfaceInner struct { Foo int } var _ io.Reader = marshalValueInterfaceInner{} func (marshalValueInterfaceInner) Read([]byte) (int, error) { return 0, nil } // helper type for testing MarshalValue that contains an interface type marshalValueInterfaceOuter struct { Reader io.Reader } // helper type for testing MarshalValue that implements ValueMarshaler type marshalValueMarshaler struct { Foo int } var _ ValueMarshaler = marshalValueMarshaler{} func (mvi marshalValueMarshaler) MarshalBSONValue() (bsontype.Type, []byte, error) { return bsontype.Int32, bsoncore.AppendInt32(nil, int32(mvi.Foo)), nil } var _ ValueUnmarshaler = &marshalValueMarshaler{} func (mvi marshalValueMarshaler) UnmarshalBSONValue(_ bsontype.Type, b []byte) error { v, _, _ := bsoncore.ReadInt32(b) mvi.Foo = int(v) return nil } type marshalValueStruct struct { Foo int } type marshalValueTestCase struct { name string val interface{} bsontype bsontype.Type bytes []byte } func newMarshalValueTestCases(t testing.T) []marshalValueTestCase { t.Helper() var ( oid = primitive.NewObjectID() regex = primitive.Regex{Pattern: "pattern", Options: "imx"} dbPointer = primitive.DBPointer{DB: "db", Pointer: primitive.NewObjectID()} codeWithScope = primitive.CodeWithScope{Code: "code", Scope: D{{"a", "b"}}} decimal128 = primitive.NewDecimal128(5, 10) structTest = marshalValueStruct{Foo: 10} ) idx, scopeCore := bsoncore.AppendDocumentStart(nil) scopeCore = bsoncore.AppendStringElement(scopeCore, "a", "b") scopeCore, err := bsoncore.AppendDocumentEnd(scopeCore, idx) assert.Nil(t, err, "Document error: %v", err) structCore, err := Marshal(structTest) assert.Nil(t, err, "Marshal error: %v", err) return []marshalValueTestCase{ {"double", 3.14, bsontype.Double, bsoncore.AppendDouble(nil, 3.14)}, {"string", "hello world", bsontype.String, bsoncore.AppendString(nil, "hello world")}, {"binary", primitive.Binary{1, []byte{1, 2}}, bsontype.Binary, bsoncore.AppendBinary(nil, 1, []byte{1, 2})}, {"undefined", primitive.Undefined{}, bsontype.Undefined, []byte{}}, {"object id", oid, bsontype.ObjectID, bsoncore.AppendObjectID(nil, oid)}, {"boolean", true, bsontype.Boolean, bsoncore.AppendBoolean(nil, true)}, {"datetime", primitive.DateTime(5), bsontype.DateTime, bsoncore.AppendDateTime(nil, 5)}, {"null", primitive.Null{}, bsontype.Null, []byte{}}, {"regex", regex, bsontype.Regex, bsoncore.AppendRegex(nil, regex.Pattern, regex.Options)}, {"dbpointer", dbPointer, bsontype.DBPointer, bsoncore.AppendDBPointer(nil, dbPointer.DB, dbPointer.Pointer)}, {"javascript", primitive.JavaScript("js"), bsontype.JavaScript, bsoncore.AppendJavaScript(nil, "js")}, {"symbol", primitive.Symbol("symbol"), bsontype.Symbol, bsoncore.AppendSymbol(nil, "symbol")}, {"code with scope", codeWithScope, bsontype.CodeWithScope, bsoncore.AppendCodeWithScope(nil, "code", scopeCore)}, {"int32", 5, bsontype.Int32, bsoncore.AppendInt32(nil, 5)}, {"int64", int64(5), bsontype.Int64, bsoncore.AppendInt64(nil, 5)}, {"timestamp", primitive.Timestamp{T: 1, I: 5}, bsontype.Timestamp, bsoncore.AppendTimestamp(nil, 1, 5)}, {"decimal128", decimal128, bsontype.Decimal128, bsoncore.AppendDecimal128(nil, decimal128)}, {"min key", primitive.MinKey{}, bsontype.MinKey, []byte{}}, {"max key", primitive.MaxKey{}, bsontype.MaxKey, []byte{}}, {"struct", structTest, bsontype.EmbeddedDocument, structCore}, {"D", D{{"foo", int32(10)}}, bsontype.EmbeddedDocument, structCore}, {"M", M{"foo": int32(10)}, bsontype.EmbeddedDocument, structCore}, {"ValueMarshaler", marshalValueMarshaler{Foo: 10}, bsontype.Int32, bsoncore.AppendInt32(nil, 10)}, } } func newMarshalValueTestCasesWithInterfaceCore(t *testing.T) []marshalValueTestCase { t.Helper() marshalValueTestCases := newMarshalValueTestCases(t) interfaceTest := marshalValueInterfaceOuter{ Reader: marshalValueInterfaceInner{ Foo: 10, }, } interfaceCore, err := Marshal(interfaceTest) assert.Nil(t, err, "Marshal error: %v", err) marshalValueTestCases = append( marshalValueTestCases, marshalValueTestCase{"interface", interfaceTest, bsontype.EmbeddedDocument, interfaceCore}, ) return marshalValueTestCases }	4.73 KB	2025-05-25 12:27
📄 marshal_value_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "strings" "testing" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/internal/assert" ) func TestMarshalValue(t testing.T) { t.Parallel() marshalValueTestCases := newMarshalValueTestCasesWithInterfaceCore(t) t.Run("MarshalValue", func(t testing.T) { t.Parallel() for _, tc := range marshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() valueType, valueBytes, err := MarshalValue(tc.val) assert.Nil(t, err, "MarshalValue error: %v", err) compareMarshalValueResults(t, tc, valueType, valueBytes) }) } }) t.Run("MarshalValueAppend", func(t testing.T) { t.Parallel() for _, tc := range marshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() valueType, valueBytes, err := MarshalValueAppend(nil, tc.val) assert.Nil(t, err, "MarshalValueAppend error: %v", err) compareMarshalValueResults(t, tc, valueType, valueBytes) }) } }) t.Run("MarshalValueWithRegistry", func(t testing.T) { t.Parallel() for _, tc := range marshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() valueType, valueBytes, err := MarshalValueWithRegistry(DefaultRegistry, tc.val) assert.Nil(t, err, "MarshalValueWithRegistry error: %v", err) compareMarshalValueResults(t, tc, valueType, valueBytes) }) } }) t.Run("MarshalValueWithContext", func(t testing.T) { t.Parallel() ec := bsoncodec.EncodeContext{Registry: DefaultRegistry} for _, tc := range marshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() valueType, valueBytes, err := MarshalValueWithContext(ec, tc.val) assert.Nil(t, err, "MarshalValueWithContext error: %v", err) compareMarshalValueResults(t, tc, valueType, valueBytes) }) } }) t.Run("MarshalValueAppendWithRegistry", func(t testing.T) { t.Parallel() for _, tc := range marshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() valueType, valueBytes, err := MarshalValueAppendWithRegistry(DefaultRegistry, nil, tc.val) assert.Nil(t, err, "MarshalValueAppendWithRegistry error: %v", err) compareMarshalValueResults(t, tc, valueType, valueBytes) }) } }) t.Run("MarshalValueAppendWithContext", func(t testing.T) { t.Parallel() ec := bsoncodec.EncodeContext{Registry: DefaultRegistry} for _, tc := range marshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() valueType, valueBytes, err := MarshalValueAppendWithContext(ec, nil, tc.val) assert.Nil(t, err, "MarshalValueWithContext error: %v", err) compareMarshalValueResults(t, tc, valueType, valueBytes) }) } }) } func compareMarshalValueResults(t testing.T, tc marshalValueTestCase, gotType bsontype.Type, gotBytes []byte) { t.Helper() expectedValue := RawValue{Type: tc.bsontype, Value: tc.bytes} gotValue := RawValue{Type: gotType, Value: gotBytes} assert.Equal(t, expectedValue, gotValue, "value mismatch; expected %s, got %s", expectedValue, gotValue) } // benchmark covering GODRIVER-2779 func BenchmarkSliceCodecMarshal(b testing.B) { testStruct := unmarshalerNonPtrStruct{B: []byte(strings.Repeat("t", 4096))} b.ResetTimer() b.RunParallel(func(pb testing.PB) { for pb.Next() { _, _, err := MarshalValue(testStruct) if err != nil { b.Fatal(err) } } }) }	3.69 KB	2025-05-25 12:27
📄 marshaling_cases_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "go.mongodb.org/mongo-driver/bson/bsoncodec" ) type marshalingTestCase struct { name string reg *bsoncodec.Registry val interface{} want []byte } var marshalingTestCases = []marshalingTestCase{ { "small struct", nil, struct { Foo bool }{Foo: true}, docToBytes(D{{"foo", true}}), }, }	601 B	2025-05-25 12:27
📁 mgocompat	-	2025-05-25 12:27
📁 primitive	-	2025-05-25 12:27
📄 primitive_codecs.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "errors" "fmt" "reflect" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" ) var tRawValue = reflect.TypeOf(RawValue{}) var tRaw = reflect.TypeOf(Raw(nil)) var primitiveCodecs PrimitiveCodecs // PrimitiveCodecs is a namespace for all of the default bsoncodec.Codecs for the primitive types // defined in this package. // // Deprecated: Use bson.NewRegistry to get a registry with all primitive encoders and decoders // registered. type PrimitiveCodecs struct{} // RegisterPrimitiveCodecs will register the encode and decode methods attached to PrimitiveCodecs // with the provided RegistryBuilder. if rb is nil, a new empty RegistryBuilder will be created. // // Deprecated: Use bson.NewRegistry to get a registry with all primitive encoders and decoders // registered. func (pc PrimitiveCodecs) RegisterPrimitiveCodecs(rb *bsoncodec.RegistryBuilder) { if rb == nil { panic(errors.New("argument to RegisterPrimitiveCodecs must not be nil")) } rb. RegisterTypeEncoder(tRawValue, bsoncodec.ValueEncoderFunc(pc.RawValueEncodeValue)). RegisterTypeEncoder(tRaw, bsoncodec.ValueEncoderFunc(pc.RawEncodeValue)). RegisterTypeDecoder(tRawValue, bsoncodec.ValueDecoderFunc(pc.RawValueDecodeValue)). RegisterTypeDecoder(tRaw, bsoncodec.ValueDecoderFunc(pc.RawDecodeValue)) } // RawValueEncodeValue is the ValueEncoderFunc for RawValue. // // If the RawValue's Type is "invalid" and the RawValue's Value is not empty or // nil, then this method will return an error. // // Deprecated: Use bson.NewRegistry to get a registry with all primitive // encoders and decoders registered. func (PrimitiveCodecs) RawValueEncodeValue(_ bsoncodec.EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error { if !val.IsValid() \|\| val.Type() != tRawValue { return bsoncodec.ValueEncoderError{ Name: "RawValueEncodeValue", Types: []reflect.Type{tRawValue}, Received: val, } } rawvalue := val.Interface().(RawValue) if !rawvalue.Type.IsValid() { return fmt.Errorf("the RawValue Type specifies an invalid BSON type: %#x", byte(rawvalue.Type)) } return bsonrw.Copier{}.CopyValueFromBytes(vw, rawvalue.Type, rawvalue.Value) } // RawValueDecodeValue is the ValueDecoderFunc for RawValue. // // Deprecated: Use bson.NewRegistry to get a registry with all primitive encoders and decoders // registered. func (PrimitiveCodecs) RawValueDecodeValue(_ bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error { if !val.CanSet() \|\| val.Type() != tRawValue { return bsoncodec.ValueDecoderError{Name: "RawValueDecodeValue", Types: []reflect.Type{tRawValue}, Received: val} } t, value, err := bsonrw.Copier{}.CopyValueToBytes(vr) if err != nil { return err } val.Set(reflect.ValueOf(RawValue{Type: t, Value: value})) return nil } // RawEncodeValue is the ValueEncoderFunc for Reader. // // Deprecated: Use bson.NewRegistry to get a registry with all primitive encoders and decoders // registered. func (PrimitiveCodecs) RawEncodeValue(_ bsoncodec.EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error { if !val.IsValid() \|\| val.Type() != tRaw { return bsoncodec.ValueEncoderError{Name: "RawEncodeValue", Types: []reflect.Type{tRaw}, Received: val} } rdr := val.Interface().(Raw) return bsonrw.Copier{}.CopyDocumentFromBytes(vw, rdr) } // RawDecodeValue is the ValueDecoderFunc for Reader. // // Deprecated: Use bson.NewRegistry to get a registry with all primitive encoders and decoders // registered. func (PrimitiveCodecs) RawDecodeValue(_ bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error { if !val.CanSet() \|\| val.Type() != tRaw { return bsoncodec.ValueDecoderError{Name: "RawDecodeValue", Types: []reflect.Type{tRaw}, Received: val} } if val.IsNil() { val.Set(reflect.MakeSlice(val.Type(), 0, 0)) } val.SetLen(0) rdr, err := bsonrw.Copier{}.AppendDocumentBytes(val.Interface().(Raw), vr) val.Set(reflect.ValueOf(rdr)) return err }	4.17 KB	2025-05-25 12:27
📄 primitive_codecs_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "encoding/json" "errors" "fmt" "net/url" "reflect" "testing" "time" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsonrw/bsonrwtest" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func bytesFromDoc(doc interface{}) []byte { b, err := Marshal(doc) if err != nil { panic(fmt.Errorf("Couldn't marshal BSON document: %w", err)) } return b } func compareDecimal128(d1, d2 primitive.Decimal128) bool { d1H, d1L := d1.GetBytes() d2H, d2L := d2.GetBytes() if d1H != d2H { return false } if d1L != d2L { return false } return true } func compareErrors(err1, err2 error) bool { if err1 == nil && err2 == nil { return true } if err1 == nil \|\| err2 == nil { return false } if err1.Error() != err2.Error() { return false } return true } func TestDefaultValueEncoders(t testing.T) { t.Parallel() var pc PrimitiveCodecs var wrong = func(string, string) string { return "wrong" } type subtest struct { name string val interface{} ectx bsoncodec.EncodeContext llvrw bsonrwtest.ValueReaderWriter invoke bsonrwtest.Invoked err error } testCases := []struct { name string ve bsoncodec.ValueEncoder subtests []subtest }{ { "RawValueEncodeValue", bsoncodec.ValueEncoderFunc(pc.RawValueEncodeValue), []subtest{ { "wrong type", wrong, nil, nil, bsonrwtest.Nothing, bsoncodec.ValueEncoderError{ Name: "RawValueEncodeValue", Types: []reflect.Type{tRawValue}, Received: reflect.ValueOf(wrong), }, }, { "RawValue/success", RawValue{Type: bsontype.Double, Value: bsoncore.AppendDouble(nil, 3.14159)}, nil, nil, bsonrwtest.WriteDouble, nil, }, { "RawValue Type is zero with non-zero value", RawValue{ Type: 0x00, Value: bsoncore.AppendDouble(nil, 3.14159), }, nil, nil, bsonrwtest.Nothing, fmt.Errorf("the RawValue Type specifies an invalid BSON type: 0x0"), }, { "RawValue Type is invalid", RawValue{ Type: 0x8F, Value: bsoncore.AppendDouble(nil, 3.14159), }, nil, nil, bsonrwtest.Nothing, fmt.Errorf("the RawValue Type specifies an invalid BSON type: 0x8f"), }, }, }, { "RawEncodeValue", bsoncodec.ValueEncoderFunc(pc.RawEncodeValue), []subtest{ { "wrong type", wrong, nil, nil, bsonrwtest.Nothing, bsoncodec.ValueEncoderError{Name: "RawEncodeValue", Types: []reflect.Type{tRaw}, Received: reflect.ValueOf(wrong)}, }, { "WriteDocument Error", Raw{}, nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("wd error"), ErrAfter: bsonrwtest.WriteDocument}, bsonrwtest.WriteDocument, errors.New("wd error"), }, { "Raw.Elements Error", Raw{0xFF, 0x00, 0x00, 0x00, 0x00}, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.WriteDocument, errors.New("length read exceeds number of bytes available. length=5 bytes=255"), }, { "WriteDocumentElement Error", Raw(bytesFromDoc(D{{"foo", nil}})), nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("wde error"), ErrAfter: bsonrwtest.WriteDocumentElement}, bsonrwtest.WriteDocumentElement, errors.New("wde error"), }, { "encodeValue error", Raw(bytesFromDoc(D{{"foo", nil}})), nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("ev error"), ErrAfter: bsonrwtest.WriteNull}, bsonrwtest.WriteNull, errors.New("ev error"), }, { "iterator error", Raw{0x0C, 0x00, 0x00, 0x00, 0x01, 'f', 'o', 'o', 0x00, 0x01, 0x02, 0x03}, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.WriteDocumentElement, errors.New("not enough bytes available to read type. bytes=3 type=double"), }, }, }, } for _, tc := range testCases { tc := tc // Capture the range variable t.Run(tc.name, func(t testing.T) { t.Parallel() for _, subtest := range tc.subtests { subtest := subtest // Capture the range variable t.Run(subtest.name, func(t testing.T) { t.Parallel() var ec bsoncodec.EncodeContext if subtest.ectx != nil { ec = subtest.ectx } llvrw := new(bsonrwtest.ValueReaderWriter) if subtest.llvrw != nil { llvrw = subtest.llvrw } llvrw.T = t err := tc.ve.EncodeValue(ec, llvrw, reflect.ValueOf(subtest.val)) if !compareErrors(err, subtest.err) { t.Errorf("Errors do not match. got %v; want %v", err, subtest.err) } invoked := llvrw.Invoked if !cmp.Equal(invoked, subtest.invoke) { t.Errorf("Incorrect method invoked. got %v; want %v", invoked, subtest.invoke) } }) } }) } t.Run("success path", func(t testing.T) { t.Parallel() oid := primitive.NewObjectID() oids := []primitive.ObjectID{primitive.NewObjectID(), primitive.NewObjectID(), primitive.NewObjectID()} var str = new(string) str = "bar" now := time.Now().Truncate(time.Millisecond) murl, err := url.Parse("https://mongodb.com/random-url?hello=world") if err != nil { t.Errorf("Error parsing URL: %v", err) t.FailNow() } decimal128, err := primitive.ParseDecimal128("1.5e10") if err != nil { t.Errorf("Error parsing decimal128: %v", err) t.FailNow() } testCases := []struct { name string value interface{} b []byte err error }{ { "D to JavaScript", D{{"a", primitive.JavaScript(`function() { var hello = "world"; }`)}}, docToBytes(D{{"a", primitive.JavaScript(`function() { var hello = "world"; }`)}}), nil, }, { "D to Symbol", D{{"a", primitive.Symbol("foobarbaz")}}, docToBytes(D{{"a", primitive.Symbol("foobarbaz")}}), nil, }, { "omitempty map", struct { T map[string]string `bson:",omitempty"` }{ T: map[string]string{}, }, docToBytes(D{}), nil, }, { "omitempty slice", struct { T []struct{} `bson:",omitempty"` }{ T: []struct{}{}, }, docToBytes(D{}), nil, }, { "omitempty string", struct { T string `bson:",omitempty"` }{ T: "", }, docToBytes(D{}), nil, }, { "struct{}", struct { A bool B int32 C int64 D uint16 E uint64 F float64 G string H map[string]string I []byte K [2]string L struct { M string } P Raw Q primitive.ObjectID T []struct{} Y json.Number Z time.Time AA json.Number AB url.URL AC primitive.Decimal128 AD time.Time AE testValueMarshaler AF RawValue AG RawValue AH D AI D AJ D }{ A: true, B: 123, C: 456, D: 789, E: 101112, F: 3.14159, G: "Hello, world", H: map[string]string{"foo": "bar"}, I: []byte{0x01, 0x02, 0x03}, K: [2]string{"baz", "qux"}, L: struct { M string }{ M: "foobar", }, P: Raw{0x05, 0x00, 0x00, 0x00, 0x00}, Q: oid, T: nil, Y: json.Number("5"), Z: now, AA: json.Number("10.1"), AB: murl, AC: decimal128, AD: &now, AE: testValueMarshaler{t: TypeString, buf: bsoncore.AppendString(nil, "hello, world")}, AF: RawValue{Type: bsontype.String, Value: bsoncore.AppendString(nil, "hello, raw value")}, AG: &RawValue{Type: bsontype.Double, Value: bsoncore.AppendDouble(nil, 3.14159)}, AH: D{{"foo", "bar"}}, AI: &D{{"pi", 3.14159}}, AJ: nil, }, docToBytes(D{ {"a", true}, {"b", int32(123)}, {"c", int64(456)}, {"d", int32(789)}, {"e", int64(101112)}, {"f", float64(3.14159)}, {"g", "Hello, world"}, {"h", D{{"foo", "bar"}}}, {"i", primitive.Binary{Subtype: 0x00, Data: []byte{0x01, 0x02, 0x03}}}, {"k", A{"baz", "qux"}}, {"l", D{{"m", "foobar"}}}, {"p", D{}}, {"q", oid}, {"t", nil}, {"y", int64(5)}, {"z", primitive.DateTime(now.UnixNano() / int64(time.Millisecond))}, {"aa", float64(10.1)}, {"ab", murl.String()}, {"ac", decimal128}, {"ad", primitive.DateTime(now.UnixNano() / int64(time.Millisecond))}, {"ae", "hello, world"}, {"af", "hello, raw value"}, {"ag", 3.14159}, {"ah", D{{"foo", "bar"}}}, {"ai", D{{"pi", float64(3.14159)}}}, {"aj", nil}, }), nil, }, { "struct{[]interface{}}", struct { A []bool B []int32 C []int64 D []uint16 E []uint64 F []float64 G []string H []map[string]string I [][]byte K [1][2]string L []struct { M string } N [][]string Q []Raw R []primitive.ObjectID T []struct{} W []map[string]struct{} X []map[string]struct{} Y []map[string]struct{} Z []time.Time AA []json.Number AB []url.URL AC []primitive.Decimal128 AD []time.Time AE []testValueMarshaler AF []D AG []D }{ A: []bool{true}, B: []int32{123}, C: []int64{456}, D: []uint16{789}, E: []uint64{101112}, F: []float64{3.14159}, G: []string{"Hello, world"}, H: []map[string]string{{"foo": "bar"}}, I: [][]byte{{0x01, 0x02, 0x03}}, K: [1][2]string{{"baz", "qux"}}, L: []struct { M string }{ { M: "foobar", }, }, N: [][]string{{"foo", "bar"}}, Q: []Raw{{0x05, 0x00, 0x00, 0x00, 0x00}}, R: oids, T: nil, W: nil, X: []map[string]struct{}{}, // Should be empty BSON Array Y: []map[string]struct{}{{}}, // Should be BSON array with one element, an empty BSON SubDocument Z: []time.Time{now, now}, AA: []json.Number{json.Number("5"), json.Number("10.1")}, AB: []url.URL{murl}, AC: []primitive.Decimal128{decimal128}, AD: []time.Time{&now, &now}, AE: []testValueMarshaler{ {t: TypeString, buf: bsoncore.AppendString(nil, "hello")}, {t: TypeString, buf: bsoncore.AppendString(nil, "world")}, }, AF: []D{{{"foo", "bar"}}, {{"hello", "world"}, {"number", 12345}}}, AG: []D{{{"pi", 3.14159}}, nil}, }, docToBytes(D{ {"a", A{true}}, {"b", A{int32(123)}}, {"c", A{int64(456)}}, {"d", A{int32(789)}}, {"e", A{int64(101112)}}, {"f", A{float64(3.14159)}}, {"g", A{"Hello, world"}}, {"h", A{D{{"foo", "bar"}}}}, {"i", A{primitive.Binary{Subtype: 0x00, Data: []byte{0x01, 0x02, 0x03}}}}, {"k", A{A{"baz", "qux"}}}, {"l", A{D{{"m", "foobar"}}}}, {"n", A{A{"foo", "bar"}}}, {"q", A{D{}}}, {"r", A{oids[0], oids[1], oids[2]}}, {"t", nil}, {"w", nil}, {"x", A{}}, {"y", A{D{}}}, {"z", A{ primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), }}, {"aa", A{int64(5), float64(10.10)}}, {"ab", A{murl.String()}}, {"ac", A{decimal128}}, {"ad", A{ primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), }}, {"ae", A{"hello", "world"}}, {"af", A{D{{"foo", "bar"}}, D{{"hello", "world"}, {"number", int32(12345)}}}}, {"ag", A{D{{"pi", float64(3.14159)}}, nil}}, }), nil, }, } for _, tc := range testCases { tc := tc // Capture the range variable t.Run(tc.name, func(t testing.T) { t.Parallel() b := make(bsonrw.SliceWriter, 0, 512) vw, err := bsonrw.NewBSONValueWriter(&b) noerr(t, err) enc, err := NewEncoder(vw) noerr(t, err) err = enc.Encode(tc.value) if !errors.Is(err, tc.err) { t.Errorf("Did not receive expected error. got %v; want %v", err, tc.err) } if diff := cmp.Diff([]byte(b), tc.b); diff != "" { t.Errorf("Bytes written differ: (-got +want)\n%s", diff) t.Errorf("Bytes\ngot: %v\nwant:%v\n", b, tc.b) t.Errorf("Readers\ngot: %v\nwant:%v\n", Raw(b), Raw(tc.b)) } }) } }) } func TestDefaultValueDecoders(t testing.T) { var pc PrimitiveCodecs var wrong = func(string, string) string { return "wrong" } const cansetreflectiontest = "cansetreflectiontest" type subtest struct { name string val interface{} dctx bsoncodec.DecodeContext llvrw bsonrwtest.ValueReaderWriter invoke bsonrwtest.Invoked err error } testCases := []struct { name string vd bsoncodec.ValueDecoder subtests []subtest }{ { "RawValueDecodeValue", bsoncodec.ValueDecoderFunc(pc.RawValueDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, bsoncodec.ValueDecoderError{ Name: "RawValueDecodeValue", Types: []reflect.Type{tRawValue}, Received: reflect.ValueOf(wrong), }, }, { "ReadValue Error", RawValue{}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.Binary, Err: errors.New("rb error"), ErrAfter: bsonrwtest.ReadBinary, }, bsonrwtest.ReadBinary, errors.New("rb error"), }, { "RawValue/success", RawValue{Type: bsontype.Binary, Value: bsoncore.AppendBinary(nil, 0xFF, []byte{0x01, 0x02, 0x03})}, nil, &bsonrwtest.ValueReaderWriter{ BSONType: bsontype.Binary, Return: bsoncore.Value{ Type: bsontype.Binary, Data: bsoncore.AppendBinary(nil, 0xFF, []byte{0x01, 0x02, 0x03}), }, }, bsonrwtest.ReadBinary, nil, }, }, }, { "RawDecodeValue", bsoncodec.ValueDecoderFunc(pc.RawDecodeValue), []subtest{ { "wrong type", wrong, nil, &bsonrwtest.ValueReaderWriter{}, bsonrwtest.Nothing, bsoncodec.ValueDecoderError{Name: "RawDecodeValue", Types: []reflect.Type{tRaw}, Received: reflect.ValueOf(wrong)}, }, { "Raw is nil", (Raw)(nil), nil, nil, bsonrwtest.Nothing, bsoncodec.ValueDecoderError{ Name: "RawDecodeValue", Types: []reflect.Type{tRaw}, Received: reflect.ValueOf((Raw)(nil)), }, }, { "Copy error", Raw{}, nil, &bsonrwtest.ValueReaderWriter{Err: errors.New("copy error"), ErrAfter: bsonrwtest.ReadDocument}, bsonrwtest.ReadDocument, errors.New("copy error"), }, }, }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { for _, rc := range tc.subtests { t.Run(rc.name, func(t testing.T) { var dc bsoncodec.DecodeContext if rc.dctx != nil { dc = rc.dctx } llvrw := new(bsonrwtest.ValueReaderWriter) if rc.llvrw != nil { llvrw = rc.llvrw } llvrw.T = t if rc.val == cansetreflectiontest { // We're doing a CanSet reflection test err := tc.vd.DecodeValue(dc, llvrw, reflect.Value{}) if !compareErrors(err, rc.err) { t.Errorf("Errors do not match. got %v; want %v", err, rc.err) } val := reflect.New(reflect.TypeOf(rc.val)).Elem() err = tc.vd.DecodeValue(dc, llvrw, val) if !compareErrors(err, rc.err) { t.Errorf("Errors do not match. got %v; want %v", err, rc.err) } return } var val reflect.Value if rtype := reflect.TypeOf(rc.val); rtype != nil { val = reflect.New(rtype).Elem() } want := rc.val defer func() { if err := recover(); err != nil { fmt.Println(t.Name()) panic(err) } }() err := tc.vd.DecodeValue(dc, llvrw, val) if !compareErrors(err, rc.err) { t.Errorf("Errors do not match. got %v; want %v", err, rc.err) } invoked := llvrw.Invoked if !cmp.Equal(invoked, rc.invoke) { t.Errorf("Incorrect method invoked. got %v; want %v", invoked, rc.invoke) } var got interface{} if val.IsValid() && val.CanInterface() { got = val.Interface() } if rc.err == nil && !cmp.Equal(got, want) { t.Errorf("Values do not match. got (%T)%v; want (%T)%v", got, got, want, want) } }) } }) } t.Run("success path", func(t testing.T) { oid := primitive.NewObjectID() oids := []primitive.ObjectID{primitive.NewObjectID(), primitive.NewObjectID(), primitive.NewObjectID()} var str = new(string) str = "bar" now := time.Now().Truncate(time.Millisecond) murl, err := url.Parse("https://mongodb.com/random-url?hello=world") if err != nil { t.Errorf("Error parsing URL: %v", err) t.FailNow() } decimal128, err := primitive.ParseDecimal128("1.5e10") if err != nil { t.Errorf("Error parsing decimal128: %v", err) t.FailNow() } testCases := []struct { name string value interface{} b []byte err error }{ { "map[string]int", map[string]int32{"foo": 1}, []byte{ 0x0E, 0x00, 0x00, 0x00, 0x10, 'f', 'o', 'o', 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, }, nil, }, { "map[string]primitive.ObjectID", map[string]primitive.ObjectID{"foo": oid}, docToBytes(D{{"foo", oid}}), nil, }, { "map[string]Reader", map[string]Raw{"Z": {0x05, 0x00, 0x00, 0x00, 0x00}}, docToBytes(D{{"Z", Raw{0x05, 0x00, 0x00, 0x00, 0x00}}}), nil, }, { "map[string][]int32", map[string][]int32{"Z": {1, 2, 3}}, docToBytes(D{{"Z", A{int32(1), int32(2), int32(3)}}}), nil, }, { "map[string][]primitive.ObjectID", map[string][]primitive.ObjectID{"Z": oids}, docToBytes(D{{"Z", A{oids[0], oids[1], oids[2]}}}), nil, }, { "map[string][]json.Number(int64)", map[string][]json.Number{"Z": {json.Number("5"), json.Number("10")}}, docToBytes(D{{"Z", A{int64(5), int64(10)}}}), nil, }, { "map[string][]json.Number(float64)", map[string][]json.Number{"Z": {json.Number("5"), json.Number("10.1")}}, docToBytes(D{{"Z", A{int64(5), float64(10.1)}}}), nil, }, { "map[string][]url.URL", map[string][]url.URL{"Z": {murl}}, docToBytes(D{{"Z", A{murl.String()}}}), nil, }, { "map[string][]primitive.Decimal128", map[string][]primitive.Decimal128{"Z": {decimal128}}, docToBytes(D{{"Z", A{decimal128}}}), nil, }, { "-", struct { A string `bson:"-"` }{ A: "", }, docToBytes(D{}), nil, }, { "omitempty", struct { A string `bson:",omitempty"` }{ A: "", }, docToBytes(D{}), nil, }, { "omitempty, empty time", struct { A time.Time `bson:",omitempty"` }{ A: time.Time{}, }, docToBytes(D{}), nil, }, { "no private fields", noPrivateFields{a: "should be empty"}, docToBytes(D{}), nil, }, { "minsize", struct { A int64 `bson:",minsize"` }{ A: 12345, }, docToBytes(D{{"a", int32(12345)}}), nil, }, { "inline", struct { Foo struct { A int64 `bson:",minsize"` } `bson:",inline"` }{ Foo: struct { A int64 `bson:",minsize"` }{ A: 12345, }, }, docToBytes(D{{"a", int32(12345)}}), nil, }, { "inline map", struct { Foo map[string]string `bson:",inline"` }{ Foo: map[string]string{"foo": "bar"}, }, docToBytes(D{{"foo", "bar"}}), nil, }, { "alternate name bson:name", struct { A string `bson:"foo"` }{ A: "bar", }, docToBytes(D{{"foo", "bar"}}), nil, }, { "alternate name", struct { A string `bson:"foo"` }{ A: "bar", }, docToBytes(D{{"foo", "bar"}}), nil, }, { "inline, omitempty", struct { A string Foo zeroTest `bson:"omitempty,inline"` }{ A: "bar", Foo: zeroTest{true}, }, docToBytes(D{{"a", "bar"}}), nil, }, { "JavaScript to D", D{{"a", primitive.JavaScript(`function() { var hello = "world"; }`)}}, docToBytes(D{{"a", primitive.JavaScript(`function() { var hello = "world"; }`)}}), nil, }, { "Symbol to D", D{{"a", primitive.Symbol("foobarbaz")}}, docToBytes(D{{"a", primitive.Symbol("foobarbaz")}}), nil, }, { "struct{}", struct { A bool B int32 C int64 D uint16 E uint64 F float64 G string H map[string]string I []byte K [2]string L struct { M string } P Raw Q primitive.ObjectID T []struct{} Y json.Number Z time.Time AA json.Number AB url.URL AC primitive.Decimal128 AD time.Time AE testValueUnmarshaler AF RawValue AG RawValue AH D AI D AJ D }{ A: true, B: 123, C: 456, D: 789, E: 101112, F: 3.14159, G: "Hello, world", H: map[string]string{"foo": "bar"}, I: []byte{0x01, 0x02, 0x03}, K: [2]string{"baz", "qux"}, L: struct { M string }{ M: "foobar", }, P: Raw{0x05, 0x00, 0x00, 0x00, 0x00}, Q: oid, T: nil, Y: json.Number("5"), Z: now, AA: json.Number("10.1"), AB: murl, AC: decimal128, AD: &now, AE: &testValueUnmarshaler{t: bsontype.String, val: bsoncore.AppendString(nil, "hello, world!")}, AF: RawValue{Type: bsontype.Double, Value: bsoncore.AppendDouble(nil, 3.14159)}, AG: &RawValue{Type: bsontype.Binary, Value: bsoncore.AppendBinary(nil, 0xFF, []byte{0x01, 0x02, 0x03})}, AH: D{{"foo", "bar"}}, AI: &D{{"pi", 3.14159}}, AJ: nil, }, docToBytes(D{ {"a", true}, {"b", int32(123)}, {"c", int64(456)}, {"d", int32(789)}, {"e", int64(101112)}, {"f", float64(3.14159)}, {"g", "Hello, world"}, {"h", D{{"foo", "bar"}}}, {"i", primitive.Binary{Subtype: 0x00, Data: []byte{0x01, 0x02, 0x03}}}, {"k", A{"baz", "qux"}}, {"l", D{{"m", "foobar"}}}, {"p", D{}}, {"q", oid}, {"t", nil}, {"y", int64(5)}, {"z", primitive.DateTime(now.UnixNano() / int64(time.Millisecond))}, {"aa", float64(10.1)}, {"ab", murl.String()}, {"ac", decimal128}, {"ad", primitive.DateTime(now.UnixNano() / int64(time.Millisecond))}, {"ae", "hello, world!"}, {"af", float64(3.14159)}, {"ag", primitive.Binary{Subtype: 0xFF, Data: []byte{0x01, 0x02, 0x03}}}, {"ah", D{{"foo", "bar"}}}, {"ai", D{{"pi", float64(3.14159)}}}, {"aj", nil}, }), nil, }, { "struct{[]interface{}}", struct { A []bool B []int32 C []int64 D []uint16 E []uint64 F []float64 G []string H []map[string]string I [][]byte K [1][2]string L []struct { M string } N [][]string Q []Raw R []primitive.ObjectID T []struct{} W []map[string]struct{} X []map[string]struct{} Y []map[string]struct{} Z []time.Time AA []json.Number AB []url.URL AC []primitive.Decimal128 AD []time.Time AE []testValueUnmarshaler AF []D AG []D }{ A: []bool{true}, B: []int32{123}, C: []int64{456}, D: []uint16{789}, E: []uint64{101112}, F: []float64{3.14159}, G: []string{"Hello, world"}, H: []map[string]string{{"foo": "bar"}}, I: [][]byte{{0x01, 0x02, 0x03}}, K: [1][2]string{{"baz", "qux"}}, L: []struct { M string }{ { M: "foobar", }, }, N: [][]string{{"foo", "bar"}}, Q: []Raw{{0x05, 0x00, 0x00, 0x00, 0x00}}, R: oids, T: nil, W: nil, X: []map[string]struct{}{}, // Should be empty BSON Array Y: []map[string]struct{}{{}}, // Should be BSON array with one element, an empty BSON SubDocument Z: []time.Time{now, now}, AA: []json.Number{json.Number("5"), json.Number("10.1")}, AB: []url.URL{murl}, AC: []primitive.Decimal128{decimal128}, AD: []time.Time{&now, &now}, AE: []testValueUnmarshaler{ {t: bsontype.String, val: bsoncore.AppendString(nil, "hello")}, {t: bsontype.String, val: bsoncore.AppendString(nil, "world")}, }, AF: []D{{{"foo", "bar"}}, {{"hello", "world"}, {"number", int64(12345)}}}, AG: []D{{{"pi", 3.14159}}, nil}, }, docToBytes(D{ {"a", A{true}}, {"b", A{int32(123)}}, {"c", A{int64(456)}}, {"d", A{int32(789)}}, {"e", A{int64(101112)}}, {"f", A{float64(3.14159)}}, {"g", A{"Hello, world"}}, {"h", A{D{{"foo", "bar"}}}}, {"i", A{primitive.Binary{Subtype: 0x00, Data: []byte{0x01, 0x02, 0x03}}}}, {"k", A{A{"baz", "qux"}}}, {"l", A{D{{"m", "foobar"}}}}, {"n", A{A{"foo", "bar"}}}, {"q", A{D{}}}, {"r", A{oids[0], oids[1], oids[2]}}, {"t", nil}, {"w", nil}, {"x", A{}}, {"y", A{D{}}}, {"z", A{ primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), }}, {"aa", A{int64(5), float64(10.10)}}, {"ab", A{murl.String()}}, {"ac", A{decimal128}}, {"ad", A{ primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), primitive.DateTime(now.UnixNano() / int64(time.Millisecond)), }}, {"ae", A{"hello", "world"}}, {"af", A{ D{{"foo", "bar"}}, D{{"hello", "world"}, {"number", int64(12345)}}, }}, {"ag", A{D{{"pi", float64(3.14159)}}, nil}}, }), nil, }, } t.Run("Decode", func(t testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { vr := bsonrw.NewBSONDocumentReader(tc.b) dec, err := NewDecoder(vr) noerr(t, err) gotVal := reflect.New(reflect.TypeOf(tc.value)) err = dec.Decode(gotVal.Interface()) noerr(t, err) got := gotVal.Elem().Interface() want := tc.value if diff := cmp.Diff( got, want, cmp.Comparer(compareDecimal128), cmp.Comparer(compareNoPrivateFields), cmp.Comparer(compareZeroTest), ); diff != "" { t.Errorf("difference:\n%s", diff) t.Errorf("Values are not equal.\ngot: %#v\nwant:%#v", got, want) } }) } }) }) } type testValueMarshaler struct { t bsontype.Type buf []byte err error } func (tvm testValueMarshaler) MarshalBSONValue() (bsontype.Type, []byte, error) { return tvm.t, tvm.buf, tvm.err } type testValueUnmarshaler struct { t bsontype.Type val []byte err error } func (tvu testValueUnmarshaler) UnmarshalBSONValue(t bsontype.Type, val []byte) error { tvu.t, tvu.val = t, val return tvu.err } func (tvu testValueUnmarshaler) Equal(tvu2 testValueUnmarshaler) bool { return tvu.t == tvu2.t && bytes.Equal(tvu.val, tvu2.val) } type noPrivateFields struct { a string } func compareNoPrivateFields(npf1, npf2 noPrivateFields) bool { return npf1.a != npf2.a // We don't want these to be equal } type zeroTest struct { reportZero bool } func (z zeroTest) IsZero() bool { return z.reportZero } func compareZeroTest(_, _ zeroTest) bool { return true }	26.95 KB	2025-05-25 12:27
📄 raw.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "errors" "io" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) // ErrNilReader indicates that an operation was attempted on a nil bson.Reader. var ErrNilReader = errors.New("nil reader") // Raw is a raw encoded BSON document. It can be used to delay BSON document decoding or precompute // a BSON encoded document. // // A Raw must be a full BSON document. Use the RawValue type for individual BSON values. type Raw []byte // ReadDocument reads a BSON document from the io.Reader and returns it as a bson.Raw. If the // reader contains multiple BSON documents, only the first document is read. func ReadDocument(r io.Reader) (Raw, error) { doc, err := bsoncore.NewDocumentFromReader(r) return Raw(doc), err } // NewFromIOReader reads a BSON document from the io.Reader and returns it as a bson.Raw. If the // reader contains multiple BSON documents, only the first document is read. // // Deprecated: Use ReadDocument instead. func NewFromIOReader(r io.Reader) (Raw, error) { return ReadDocument(r) } // Validate validates the document. This method only validates the first document in // the slice, to validate other documents, the slice must be resliced. func (r Raw) Validate() (err error) { return bsoncore.Document(r).Validate() } // Lookup search the document, potentially recursively, for the given key. If // there are multiple keys provided, this method will recurse down, as long as // the top and intermediate nodes are either documents or arrays.If an error // occurs or if the value doesn't exist, an empty RawValue is returned. func (r Raw) Lookup(key ...string) RawValue { return convertFromCoreValue(bsoncore.Document(r).Lookup(key...)) } // LookupErr searches the document and potentially subdocuments or arrays for the // provided key. Each key provided to this method represents a layer of depth. func (r Raw) LookupErr(key ...string) (RawValue, error) { val, err := bsoncore.Document(r).LookupErr(key...) return convertFromCoreValue(val), err } // Elements returns this document as a slice of elements. The returned slice will contain valid // elements. If the document is not valid, the elements up to the invalid point will be returned // along with an error. func (r Raw) Elements() ([]RawElement, error) { doc := bsoncore.Document(r) if len(doc) == 0 { return nil, nil } elems, err := doc.Elements() if err != nil { return nil, err } relems := make([]RawElement, 0, len(elems)) for _, elem := range elems { relems = append(relems, RawElement(elem)) } return relems, nil } // Values returns this document as a slice of values. The returned slice will contain valid values. // If the document is not valid, the values up to the invalid point will be returned along with an // error. func (r Raw) Values() ([]RawValue, error) { vals, err := bsoncore.Document(r).Values() rvals := make([]RawValue, 0, len(vals)) for _, val := range vals { rvals = append(rvals, convertFromCoreValue(val)) } return rvals, err } // Index searches for and retrieves the element at the given index. This method will panic if // the document is invalid or if the index is out of bounds. func (r Raw) Index(index uint) RawElement { return RawElement(bsoncore.Document(r).Index(index)) } // IndexErr searches for and retrieves the element at the given index. func (r Raw) IndexErr(index uint) (RawElement, error) { elem, err := bsoncore.Document(r).IndexErr(index) return RawElement(elem), err } // String returns the BSON document encoded as Extended JSON. func (r Raw) String() string { return bsoncore.Document(r).String() }	3.77 KB	2025-05-25 12:27
📄 raw_element.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) // RawElement is a raw encoded BSON document or array element. type RawElement []byte // Key returns the key for this element. If the element is not valid, this method returns an empty // string. If knowing if the element is valid is important, use KeyErr. func (re RawElement) Key() string { return bsoncore.Element(re).Key() } // KeyErr returns the key for this element, returning an error if the element is not valid. func (re RawElement) KeyErr() (string, error) { return bsoncore.Element(re).KeyErr() } // Value returns the value of this element. If the element is not valid, this method returns an // empty Value. If knowing if the element is valid is important, use ValueErr. func (re RawElement) Value() RawValue { return convertFromCoreValue(bsoncore.Element(re).Value()) } // ValueErr returns the value for this element, returning an error if the element is not valid. func (re RawElement) ValueErr() (RawValue, error) { val, err := bsoncore.Element(re).ValueErr() return convertFromCoreValue(val), err } // Validate ensures re is a valid BSON element. func (re RawElement) Validate() error { return bsoncore.Element(re).Validate() } // String returns the BSON element encoded as Extended JSON. func (re RawElement) String() string { doc := bsoncore.BuildDocument(nil, re) j, err := MarshalExtJSON(Raw(doc), true, false) if err != nil { return "<malformed>" } return string(j) } // DebugString outputs a human readable version of RawElement. It will attempt to stringify the // valid components of the element even if the entire element is not valid. func (re RawElement) DebugString() string { return bsoncore.Element(re).DebugString() }	1.96 KB	2025-05-25 12:27
📄 raw_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "encoding/binary" "errors" "fmt" "io" "strings" "testing" "github.com/google/go-cmp/cmp" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/internal/require" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func ExampleRaw_Validate() { rdr := make(Raw, 500) rdr[250], rdr[251], rdr[252], rdr[253], rdr[254] = '\x05', '\x00', '\x00', '\x00', '\x00' err := rdr[250:].Validate() fmt.Println(err) // Output: <nil> } func BenchmarkRawValidate(b testing.B) { for i := 0; i < b.N; i++ { rdr := make(Raw, 500) rdr[250], rdr[251], rdr[252], rdr[253], rdr[254] = '\x05', '\x00', '\x00', '\x00', '\x00' _ = rdr[250:].Validate() } } func TestRaw(t testing.T) { t.Run("Validate", func(t testing.T) { t.Run("TooShort", func(t testing.T) { want := bsoncore.NewInsufficientBytesError(nil, nil) got := Raw{'\x00', '\x00'}.Validate() if !compareErrors(got, want) { t.Errorf("Did not get expected error. got %v; want %v", got, want) } }) t.Run("InvalidLength", func(t testing.T) { want := bsoncore.ValidationError("document length exceeds available bytes. length=200 remainingBytes=5") r := make(Raw, 5) binary.LittleEndian.PutUint32(r[0:4], 200) got := r.Validate() if !errors.Is(got, want) { t.Errorf("Did not get expected error. got %v; want %v", got, want) } }) t.Run("keyLength-error", func(t testing.T) { want := bsoncore.ErrMissingNull r := make(Raw, 8) binary.LittleEndian.PutUint32(r[0:4], 8) r[4], r[5], r[6], r[7] = '\x02', 'f', 'o', 'o' got := r.Validate() if !errors.Is(got, want) { t.Errorf("Did not get expected error. got %v; want %v", got, want) } }) t.Run("Missing-Null-Terminator", func(t testing.T) { want := bsoncore.ErrMissingNull r := make(Raw, 9) binary.LittleEndian.PutUint32(r[0:4], 9) r[4], r[5], r[6], r[7], r[8] = '\x0A', 'f', 'o', 'o', '\x00' got := r.Validate() if !errors.Is(got, want) { t.Errorf("Did not get expected error. got %v; want %v", got, want) } }) t.Run("validateValue-error", func(t testing.T) { want := bsoncore.ErrMissingNull r := make(Raw, 11) binary.LittleEndian.PutUint32(r[0:4], 11) r[4], r[5], r[6], r[7], r[8], r[9], r[10] = '\x01', 'f', 'o', 'o', '\x00', '\x01', '\x02' got := r.Validate() if !compareErrors(got, want) { t.Errorf("Did not get expected error. got %v; want %v", got, want) } }) testCases := []struct { name string r Raw err error }{ {"null", Raw{'\x08', '\x00', '\x00', '\x00', '\x0A', 'x', '\x00', '\x00'}, nil}, {"subdocument", Raw{ '\x15', '\x00', '\x00', '\x00', '\x03', 'f', 'o', 'o', '\x00', '\x0B', '\x00', '\x00', '\x00', '\x0A', 'a', '\x00', '\x0A', 'b', '\x00', '\x00', '\x00', }, nil, }, {"array", Raw{ '\x15', '\x00', '\x00', '\x00', '\x04', 'f', 'o', 'o', '\x00', '\x0B', '\x00', '\x00', '\x00', '\x0A', '1', '\x00', '\x0A', '2', '\x00', '\x00', '\x00', }, nil, }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { err := tc.r.Validate() if !errors.Is(err, tc.err) { t.Errorf("Returned error does not match. got %v; want %v", err, tc.err) } }) } }) t.Run("Lookup", func(t testing.T) { t.Run("empty-key", func(t testing.T) { rdr := Raw{'\x05', '\x00', '\x00', '\x00', '\x00'} _, err := rdr.LookupErr() if !errors.Is(err, bsoncore.ErrEmptyKey) { t.Errorf("Empty key lookup did not return expected result. got %v; want %v", err, bsoncore.ErrEmptyKey) } }) t.Run("corrupted-subdocument", func(t testing.T) { rdr := Raw{ '\x0D', '\x00', '\x00', '\x00', '\x03', 'x', '\x00', '\x06', '\x00', '\x00', '\x00', '\x01', '\x00', '\x00', } _, err := rdr.LookupErr("x", "y") want := bsoncore.NewInsufficientBytesError(nil, nil) if !compareErrors(err, want) { t.Errorf("Empty key lookup did not return expected result. got %v; want %v", err, want) } }) t.Run("corrupted-array", func(t testing.T) { rdr := Raw{ '\x0D', '\x00', '\x00', '\x00', '\x04', 'x', '\x00', '\x06', '\x00', '\x00', '\x00', '\x01', '\x00', '\x00', } _, err := rdr.LookupErr("x", "y") want := bsoncore.NewInsufficientBytesError(nil, nil) if !compareErrors(err, want) { t.Errorf("Empty key lookup did not return expected result. got %v; want %v", err, want) } }) t.Run("invalid-traversal", func(t testing.T) { rdr := Raw{'\x08', '\x00', '\x00', '\x00', '\x0A', 'x', '\x00', '\x00'} _, err := rdr.LookupErr("x", "y") want := bsoncore.InvalidDepthTraversalError{Key: "x", Type: bsontype.Null} if !compareErrors(err, want) { t.Errorf("Empty key lookup did not return expected result. got %v; want %v", err, want) } }) testCases := []struct { name string r Raw key []string want RawValue err error }{ {"first", Raw{ '\x08', '\x00', '\x00', '\x00', '\x0A', 'x', '\x00', '\x00', }, []string{"x"}, RawValue{Type: bsontype.Null}, nil, }, {"first-second", Raw{ '\x15', '\x00', '\x00', '\x00', '\x03', 'f', 'o', 'o', '\x00', '\x0B', '\x00', '\x00', '\x00', '\x0A', 'a', '\x00', '\x0A', 'b', '\x00', '\x00', '\x00', }, []string{"foo", "b"}, RawValue{Type: bsontype.Null}, nil, }, {"first-second-array", Raw{ '\x15', '\x00', '\x00', '\x00', '\x04', 'f', 'o', 'o', '\x00', '\x0B', '\x00', '\x00', '\x00', '\x0A', '1', '\x00', '\x0A', '2', '\x00', '\x00', '\x00', }, []string{"foo", "2"}, RawValue{Type: bsontype.Null}, nil, }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { got, err := tc.r.LookupErr(tc.key...) if !errors.Is(err, tc.err) { t.Errorf("Returned error does not match. got %v; want %v", err, tc.err) } if !cmp.Equal(got, tc.want) { t.Errorf("Returned element does not match expected element. got %v; want %v", got, tc.want) } }) } }) t.Run("ElementAt", func(t testing.T) { t.Run("Out of bounds", func(t testing.T) { rdr := Raw{0xe, 0x0, 0x0, 0x0, 0xa, 0x78, 0x0, 0xa, 0x79, 0x0, 0xa, 0x7a, 0x0, 0x0} _, err := rdr.IndexErr(3) if !errors.Is(err, bsoncore.ErrOutOfBounds) { t.Errorf("Out of bounds should be returned when accessing element beyond end of document. got %v; want %v", err, bsoncore.ErrOutOfBounds) } }) t.Run("Validation Error", func(t testing.T) { rdr := Raw{0x07, 0x00, 0x00, 0x00, 0x00} _, err := rdr.IndexErr(1) want := bsoncore.NewInsufficientBytesError(nil, nil) if !compareErrors(err, want) { t.Errorf("Did not receive expected error. got %v; want %v", err, want) } }) testCases := []struct { name string rdr Raw index uint want RawElement }{ {"first", Raw{0xe, 0x0, 0x0, 0x0, 0xa, 0x78, 0x0, 0xa, 0x79, 0x0, 0xa, 0x7a, 0x0, 0x0}, 0, bsoncore.AppendNullElement(nil, "x")}, {"second", Raw{0xe, 0x0, 0x0, 0x0, 0xa, 0x78, 0x0, 0xa, 0x79, 0x0, 0xa, 0x7a, 0x0, 0x0}, 1, bsoncore.AppendNullElement(nil, "y")}, {"third", Raw{0xe, 0x0, 0x0, 0x0, 0xa, 0x78, 0x0, 0xa, 0x79, 0x0, 0xa, 0x7a, 0x0, 0x0}, 2, bsoncore.AppendNullElement(nil, "z")}, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { got, err := tc.rdr.IndexErr(tc.index) if err != nil { t.Errorf("Unexpected error from ElementAt: %s", err) } if diff := cmp.Diff(got, tc.want); diff != "" { t.Errorf("Documents differ: (-got +want)\n%s", diff) } }) } }) t.Run("ReadDocument", func(t testing.T) { t.Parallel() testCases := []struct { name string ioReader io.Reader bsonReader Raw err error }{ { "nil reader", nil, nil, ErrNilReader, }, { "premature end of reader", bytes.NewBuffer([]byte{}), nil, io.EOF, }, { "empty document", bytes.NewBuffer([]byte{5, 0, 0, 0, 0}), []byte{5, 0, 0, 0, 0}, nil, }, { "non-empty document", bytes.NewBuffer([]byte{ // length 0x17, 0x0, 0x0, 0x0, // type - string 0x2, // key - "foo" 0x66, 0x6f, 0x6f, 0x0, // value - string length 0x4, 0x0, 0x0, 0x0, // value - string "bar" 0x62, 0x61, 0x72, 0x0, // type - null 0xa, // key - "baz" 0x62, 0x61, 0x7a, 0x0, // null terminator 0x0, }), []byte{ // length 0x17, 0x0, 0x0, 0x0, // type - string 0x2, // key - "foo" 0x66, 0x6f, 0x6f, 0x0, // value - string length 0x4, 0x0, 0x0, 0x0, // value - string "bar" 0x62, 0x61, 0x72, 0x0, // type - null 0xa, // key - "baz" 0x62, 0x61, 0x7a, 0x0, // null terminator 0x0, }, nil, }, } for _, tc := range testCases { tc := tc // Capture range variable. t.Run(tc.name, func(t testing.T) { t.Parallel() reader, err := ReadDocument(tc.ioReader) require.Equal(t, err, tc.err) require.True(t, bytes.Equal(tc.bsonReader, reader)) }) } }) } func BenchmarkRawString(b testing.B) { // Create 1KiB and 128B strings to exercise the string-heavy call paths in // the "Raw.String" method. var buf strings.Builder for i := 0; i < 128; i++ { buf.WriteString("abcdefgh") } str1k := buf.String() str128 := str1k[:128] cases := []struct { description string value interface{} }{ { description: "string", value: D{{Key: "key", Value: str128}}, }, { description: "integer", value: D{{Key: "key", Value: int64(1234567890)}}, }, { description: "float", value: D{{Key: "key", Value: float64(1234567890.123456789)}}, }, { description: "nested document", value: D{{ Key: "key", Value: D{{ Key: "key", Value: D{{ Key: "key", Value: str128, }}, }}, }}, }, { description: "array of strings", value: D{{ Key: "key", Value: []string{str128, str128, str128, str128}, }}, }, { description: "mixed struct", value: struct { Key1 struct { Nested string } Key2 string Key3 int64 Key4 float64 }{ Key1: struct{ Nested string }{Nested: str1k}, Key2: str1k, Key3: 1234567890, Key4: 1234567890.123456789, }, }, } for _, tc := range cases { b.Run(tc.description, func(b *testing.B) { bs, err := Marshal(tc.value) require.NoError(b, err) b.ResetTimer() for i := 0; i < b.N; i++ { _ = Raw(bs).String() } }) } }	10.65 KB	2025-05-25 12:27
📄 raw_value.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "errors" "fmt" "reflect" "time" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) // ErrNilContext is returned when the provided DecodeContext is nil. var ErrNilContext = errors.New("DecodeContext cannot be nil") // ErrNilRegistry is returned when the provided registry is nil. var ErrNilRegistry = errors.New("Registry cannot be nil") // RawValue is a raw encoded BSON value. It can be used to delay BSON value decoding or precompute // BSON encoded value. Type is the BSON type of the value and Value is the raw encoded BSON value. // // A RawValue must be an individual BSON value. Use the Raw type for full BSON documents. type RawValue struct { Type bsontype.Type Value []byte r bsoncodec.Registry } // IsZero reports whether the RawValue is zero, i.e. no data is present on // the RawValue. It returns true if Type is 0 and Value is empty or nil. func (rv RawValue) IsZero() bool { return rv.Type == 0x00 && len(rv.Value) == 0 } // Unmarshal deserializes BSON into the provided val. If RawValue cannot be unmarshaled into val, an // error is returned. This method will use the registry used to create the RawValue, if the RawValue // was created from partial BSON processing, or it will use the default registry. Users wishing to // specify the registry to use should use UnmarshalWithRegistry. func (rv RawValue) Unmarshal(val interface{}) error { reg := rv.r if reg == nil { reg = DefaultRegistry } return rv.UnmarshalWithRegistry(reg, val) } // Equal compares rv and rv2 and returns true if they are equal. func (rv RawValue) Equal(rv2 RawValue) bool { if rv.Type != rv2.Type { return false } if !bytes.Equal(rv.Value, rv2.Value) { return false } return true } // UnmarshalWithRegistry performs the same unmarshalling as Unmarshal but uses the provided registry // instead of the one attached or the default registry. func (rv RawValue) UnmarshalWithRegistry(r bsoncodec.Registry, val interface{}) error { if r == nil { return ErrNilRegistry } vr := bsonrw.NewBSONValueReader(rv.Type, rv.Value) rval := reflect.ValueOf(val) if rval.Kind() != reflect.Ptr { return fmt.Errorf("argument to Unmarshal* must be a pointer to a type, but got %v", rval) } rval = rval.Elem() dec, err := r.LookupDecoder(rval.Type()) if err != nil { return err } return dec.DecodeValue(bsoncodec.DecodeContext{Registry: r}, vr, rval) } // UnmarshalWithContext performs the same unmarshalling as Unmarshal but uses the provided DecodeContext // instead of the one attached or the default registry. func (rv RawValue) UnmarshalWithContext(dc bsoncodec.DecodeContext, val interface{}) error { if dc == nil { return ErrNilContext } vr := bsonrw.NewBSONValueReader(rv.Type, rv.Value) rval := reflect.ValueOf(val) if rval.Kind() != reflect.Ptr { return fmt.Errorf("argument to Unmarshal must be a pointer to a type, but got %v", rval) } rval = rval.Elem() dec, err := dc.LookupDecoder(rval.Type()) if err != nil { return err } return dec.DecodeValue(*dc, vr, rval) } func convertFromCoreValue(v bsoncore.Value) RawValue { return RawValue{Type: v.Type, Value: v.Data} } func convertToCoreValue(v RawValue) bsoncore.Value { return bsoncore.Value{Type: v.Type, Data: v.Value} } // Validate ensures the value is a valid BSON value. func (rv RawValue) Validate() error { return convertToCoreValue(rv).Validate() } // IsNumber returns true if the type of v is a numeric BSON type. func (rv RawValue) IsNumber() bool { return convertToCoreValue(rv).IsNumber() } // String implements the fmt.String interface. This method will return values in extended JSON // format. If the value is not valid, this returns an empty string func (rv RawValue) String() string { return convertToCoreValue(rv).String() } // DebugString outputs a human readable version of Document. It will attempt to stringify the // valid components of the document even if the entire document is not valid. func (rv RawValue) DebugString() string { return convertToCoreValue(rv).DebugString() } // Double returns the float64 value for this element. // It panics if e's BSON type is not bsontype.Double. func (rv RawValue) Double() float64 { return convertToCoreValue(rv).Double() } // DoubleOK is the same as Double, but returns a boolean instead of panicking. func (rv RawValue) DoubleOK() (float64, bool) { return convertToCoreValue(rv).DoubleOK() } // StringValue returns the string value for this element. // It panics if e's BSON type is not bsontype.String. // // NOTE: This method is called StringValue to avoid a collision with the String method which // implements the fmt.Stringer interface. func (rv RawValue) StringValue() string { return convertToCoreValue(rv).StringValue() } // StringValueOK is the same as StringValue, but returns a boolean instead of // panicking. func (rv RawValue) StringValueOK() (string, bool) { return convertToCoreValue(rv).StringValueOK() } // Document returns the BSON document the Value represents as a Document. It panics if the // value is a BSON type other than document. func (rv RawValue) Document() Raw { return Raw(convertToCoreValue(rv).Document()) } // DocumentOK is the same as Document, except it returns a boolean // instead of panicking. func (rv RawValue) DocumentOK() (Raw, bool) { doc, ok := convertToCoreValue(rv).DocumentOK() return Raw(doc), ok } // Array returns the BSON array the Value represents as an Array. It panics if the // value is a BSON type other than array. func (rv RawValue) Array() Raw { return Raw(convertToCoreValue(rv).Array()) } // ArrayOK is the same as Array, except it returns a boolean instead // of panicking. func (rv RawValue) ArrayOK() (Raw, bool) { doc, ok := convertToCoreValue(rv).ArrayOK() return Raw(doc), ok } // Binary returns the BSON binary value the Value represents. It panics if the value is a BSON type // other than binary. func (rv RawValue) Binary() (subtype byte, data []byte) { return convertToCoreValue(rv).Binary() } // BinaryOK is the same as Binary, except it returns a boolean instead of // panicking. func (rv RawValue) BinaryOK() (subtype byte, data []byte, ok bool) { return convertToCoreValue(rv).BinaryOK() } // ObjectID returns the BSON objectid value the Value represents. It panics if the value is a BSON // type other than objectid. func (rv RawValue) ObjectID() primitive.ObjectID { return convertToCoreValue(rv).ObjectID() } // ObjectIDOK is the same as ObjectID, except it returns a boolean instead of // panicking. func (rv RawValue) ObjectIDOK() (primitive.ObjectID, bool) { return convertToCoreValue(rv).ObjectIDOK() } // Boolean returns the boolean value the Value represents. It panics if the // value is a BSON type other than boolean. func (rv RawValue) Boolean() bool { return convertToCoreValue(rv).Boolean() } // BooleanOK is the same as Boolean, except it returns a boolean instead of // panicking. func (rv RawValue) BooleanOK() (bool, bool) { return convertToCoreValue(rv).BooleanOK() } // DateTime returns the BSON datetime value the Value represents as a // unix timestamp. It panics if the value is a BSON type other than datetime. func (rv RawValue) DateTime() int64 { return convertToCoreValue(rv).DateTime() } // DateTimeOK is the same as DateTime, except it returns a boolean instead of // panicking. func (rv RawValue) DateTimeOK() (int64, bool) { return convertToCoreValue(rv).DateTimeOK() } // Time returns the BSON datetime value the Value represents. It panics if the value is a BSON // type other than datetime. func (rv RawValue) Time() time.Time { return convertToCoreValue(rv).Time() } // TimeOK is the same as Time, except it returns a boolean instead of // panicking. func (rv RawValue) TimeOK() (time.Time, bool) { return convertToCoreValue(rv).TimeOK() } // Regex returns the BSON regex value the Value represents. It panics if the value is a BSON // type other than regex. func (rv RawValue) Regex() (pattern, options string) { return convertToCoreValue(rv).Regex() } // RegexOK is the same as Regex, except it returns a boolean instead of // panicking. func (rv RawValue) RegexOK() (pattern, options string, ok bool) { return convertToCoreValue(rv).RegexOK() } // DBPointer returns the BSON dbpointer value the Value represents. It panics if the value is a BSON // type other than DBPointer. func (rv RawValue) DBPointer() (string, primitive.ObjectID) { return convertToCoreValue(rv).DBPointer() } // DBPointerOK is the same as DBPoitner, except that it returns a boolean // instead of panicking. func (rv RawValue) DBPointerOK() (string, primitive.ObjectID, bool) { return convertToCoreValue(rv).DBPointerOK() } // JavaScript returns the BSON JavaScript code value the Value represents. It panics if the value is // a BSON type other than JavaScript code. func (rv RawValue) JavaScript() string { return convertToCoreValue(rv).JavaScript() } // JavaScriptOK is the same as Javascript, excepti that it returns a boolean // instead of panicking. func (rv RawValue) JavaScriptOK() (string, bool) { return convertToCoreValue(rv).JavaScriptOK() } // Symbol returns the BSON symbol value the Value represents. It panics if the value is a BSON // type other than symbol. func (rv RawValue) Symbol() string { return convertToCoreValue(rv).Symbol() } // SymbolOK is the same as Symbol, excepti that it returns a boolean // instead of panicking. func (rv RawValue) SymbolOK() (string, bool) { return convertToCoreValue(rv).SymbolOK() } // CodeWithScope returns the BSON JavaScript code with scope the Value represents. // It panics if the value is a BSON type other than JavaScript code with scope. func (rv RawValue) CodeWithScope() (string, Raw) { code, scope := convertToCoreValue(rv).CodeWithScope() return code, Raw(scope) } // CodeWithScopeOK is the same as CodeWithScope, except that it returns a boolean instead of // panicking. func (rv RawValue) CodeWithScopeOK() (string, Raw, bool) { code, scope, ok := convertToCoreValue(rv).CodeWithScopeOK() return code, Raw(scope), ok } // Int32 returns the int32 the Value represents. It panics if the value is a BSON type other than // int32. func (rv RawValue) Int32() int32 { return convertToCoreValue(rv).Int32() } // Int32OK is the same as Int32, except that it returns a boolean instead of // panicking. func (rv RawValue) Int32OK() (int32, bool) { return convertToCoreValue(rv).Int32OK() } // AsInt32 returns a BSON number as an int32. If the BSON type is not a numeric one, this method // will panic. // // Deprecated: Use AsInt64 instead. If an int32 is required, convert the returned value to an int32 // and perform any required overflow/underflow checking. func (rv RawValue) AsInt32() int32 { return convertToCoreValue(rv).AsInt32() } // AsInt32OK is the same as AsInt32, except that it returns a boolean instead of // panicking. // // Deprecated: Use AsInt64OK instead. If an int32 is required, convert the returned value to an // int32 and perform any required overflow/underflow checking. func (rv RawValue) AsInt32OK() (int32, bool) { return convertToCoreValue(rv).AsInt32OK() } // Timestamp returns the BSON timestamp value the Value represents. It panics if the value is a // BSON type other than timestamp. func (rv RawValue) Timestamp() (t, i uint32) { return convertToCoreValue(rv).Timestamp() } // TimestampOK is the same as Timestamp, except that it returns a boolean // instead of panicking. func (rv RawValue) TimestampOK() (t, i uint32, ok bool) { return convertToCoreValue(rv).TimestampOK() } // Int64 returns the int64 the Value represents. It panics if the value is a BSON type other than // int64. func (rv RawValue) Int64() int64 { return convertToCoreValue(rv).Int64() } // Int64OK is the same as Int64, except that it returns a boolean instead of // panicking. func (rv RawValue) Int64OK() (int64, bool) { return convertToCoreValue(rv).Int64OK() } // AsInt64 returns a BSON number as an int64. If the BSON type is not a numeric one, this method // will panic. func (rv RawValue) AsInt64() int64 { return convertToCoreValue(rv).AsInt64() } // AsInt64OK is the same as AsInt64, except that it returns a boolean instead of // panicking. func (rv RawValue) AsInt64OK() (int64, bool) { return convertToCoreValue(rv).AsInt64OK() } // Decimal128 returns the decimal the Value represents. It panics if the value is a BSON type other than // decimal. func (rv RawValue) Decimal128() primitive.Decimal128 { return convertToCoreValue(rv).Decimal128() } // Decimal128OK is the same as Decimal128, except that it returns a boolean // instead of panicking. func (rv RawValue) Decimal128OK() (primitive.Decimal128, bool) { return convertToCoreValue(rv).Decimal128OK() }	12.84 KB	2025-05-25 12:27
📄 raw_value_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "errors" "fmt" "reflect" "testing" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func TestRawValue(t testing.T) { t.Parallel() t.Run("Unmarshal", func(t testing.T) { t.Parallel() t.Run("Uses registry attached to value", func(t testing.T) { t.Parallel() reg := bsoncodec.NewRegistryBuilder().Build() val := RawValue{Type: bsontype.String, Value: bsoncore.AppendString(nil, "foobar"), r: reg} var s string want := bsoncodec.ErrNoDecoder{Type: reflect.TypeOf(s)} got := val.Unmarshal(&s) if !compareErrors(got, want) { t.Errorf("Expected errors to match. got %v; want %v", got, want) } }) t.Run("Uses default registry if no registry attached", func(t testing.T) { t.Parallel() want := "foobar" val := RawValue{Type: bsontype.String, Value: bsoncore.AppendString(nil, want)} var got string err := val.Unmarshal(&got) noerr(t, err) if got != want { t.Errorf("Expected strings to match. got %s; want %s", got, want) } }) }) t.Run("UnmarshalWithRegistry", func(t testing.T) { t.Parallel() t.Run("Returns error when registry is nil", func(t testing.T) { t.Parallel() want := ErrNilRegistry var val RawValue got := val.UnmarshalWithRegistry(nil, &D{}) if !errors.Is(got, want) { t.Errorf("Expected errors to match. got %v; want %v", got, want) } }) t.Run("Returns lookup error", func(t testing.T) { t.Parallel() reg := bsoncodec.NewRegistryBuilder().Build() var val RawValue var s string want := bsoncodec.ErrNoDecoder{Type: reflect.TypeOf(s)} got := val.UnmarshalWithRegistry(reg, &s) if !compareErrors(got, want) { t.Errorf("Expected errors to match. got %v; want %v", got, want) } }) t.Run("Returns DecodeValue error", func(t testing.T) { t.Parallel() reg := NewRegistryBuilder().Build() val := RawValue{Type: bsontype.Double, Value: bsoncore.AppendDouble(nil, 3.14159)} var s string want := fmt.Errorf("cannot decode %v into a string type", bsontype.Double) got := val.UnmarshalWithRegistry(reg, &s) if !compareErrors(got, want) { t.Errorf("Expected errors to match. got %v; want %v", got, want) } }) t.Run("Success", func(t testing.T) { t.Parallel() reg := NewRegistryBuilder().Build() want := float64(3.14159) val := RawValue{Type: bsontype.Double, Value: bsoncore.AppendDouble(nil, want)} var got float64 err := val.UnmarshalWithRegistry(reg, &got) noerr(t, err) if got != want { t.Errorf("Expected results to match. got %g; want %g", got, want) } }) }) t.Run("UnmarshalWithContext", func(t testing.T) { t.Parallel() t.Run("Returns error when DecodeContext is nil", func(t testing.T) { t.Parallel() want := ErrNilContext var val RawValue got := val.UnmarshalWithContext(nil, &D{}) if !errors.Is(got, want) { t.Errorf("Expected errors to match. got %v; want %v", got, want) } }) t.Run("Returns lookup error", func(t testing.T) { t.Parallel() dc := bsoncodec.DecodeContext{Registry: bsoncodec.NewRegistryBuilder().Build()} var val RawValue var s string want := bsoncodec.ErrNoDecoder{Type: reflect.TypeOf(s)} got := val.UnmarshalWithContext(&dc, &s) if !compareErrors(got, want) { t.Errorf("Expected errors to match. got %v; want %v", got, want) } }) t.Run("Returns DecodeValue error", func(t testing.T) { t.Parallel() dc := bsoncodec.DecodeContext{Registry: NewRegistryBuilder().Build()} val := RawValue{Type: bsontype.Double, Value: bsoncore.AppendDouble(nil, 3.14159)} var s string want := fmt.Errorf("cannot decode %v into a string type", bsontype.Double) got := val.UnmarshalWithContext(&dc, &s) if !compareErrors(got, want) { t.Errorf("Expected errors to match. got %v; want %v", got, want) } }) t.Run("Success", func(t testing.T) { t.Parallel() dc := bsoncodec.DecodeContext{Registry: NewRegistryBuilder().Build()} want := float64(3.14159) val := RawValue{Type: bsontype.Double, Value: bsoncore.AppendDouble(nil, want)} var got float64 err := val.UnmarshalWithContext(&dc, &got) noerr(t, err) if got != want { t.Errorf("Expected results to match. got %g; want %g", got, want) } }) }) t.Run("IsZero", func(t testing.T) { t.Parallel() tests := []struct { name string val RawValue want bool }{ { name: "empty", val: RawValue{}, want: true, }, { name: "zero type but non-zero value", val: RawValue{ Type: 0x00, Value: bsoncore.AppendInt32(nil, 0), }, want: false, }, { name: "zero type and zero value", val: RawValue{ Type: 0x00, Value: bsoncore.AppendInt32(nil, 0), }, }, { name: "non-zero type and non-zero value", val: RawValue{ Type: bsontype.String, Value: bsoncore.AppendString(nil, "foobar"), }, want: false, }, { name: "non-zero type and zero value", val: RawValue{ Type: bsontype.String, Value: bsoncore.AppendString(nil, "foobar"), }, }, } for _, tt := range tests { tt := tt // Capture the range variable t.Run(tt.name, func(t testing.T) { t.Parallel() assert.Equal(t, tt.want, tt.val.IsZero()) }) } }) }	5.57 KB	2025-05-25 12:27
📄 registry.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "go.mongodb.org/mongo-driver/bson/bsoncodec" ) // DefaultRegistry is the default bsoncodec.Registry. It contains the default codecs and the // primitive codecs. var DefaultRegistry = NewRegistry() // NewRegistryBuilder creates a new RegistryBuilder configured with the default encoders and // decoders from the bsoncodec.DefaultValueEncoders and bsoncodec.DefaultValueDecoders types and the // PrimitiveCodecs type in this package. // // Deprecated: Use NewRegistry instead. func NewRegistryBuilder() bsoncodec.RegistryBuilder { rb := bsoncodec.NewRegistryBuilder() bsoncodec.DefaultValueEncoders{}.RegisterDefaultEncoders(rb) bsoncodec.DefaultValueDecoders{}.RegisterDefaultDecoders(rb) primitiveCodecs.RegisterPrimitiveCodecs(rb) return rb } // NewRegistry creates a new Registry configured with the default encoders and decoders from the // bsoncodec.DefaultValueEncoders and bsoncodec.DefaultValueDecoders types and the PrimitiveCodecs // type in this package. func NewRegistry() bsoncodec.Registry { return NewRegistryBuilder().Build() }	1.32 KB	2025-05-25 12:27
📁 testdata	-	2025-05-25 12:27
📄 truncation_test.go // 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 bson import ( "testing" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/internal/assert" ) type inputArgs struct { Name string Val float64 } type outputArgs struct { Name string Val int64 } func TestTruncation(t testing.T) { t.Run("truncation", func(t testing.T) { inputName := "truncation" inputVal := 4.7892 input := inputArgs{Name: inputName, Val: &inputVal} ec := bsoncodec.EncodeContext{Registry: DefaultRegistry} doc, err := MarshalWithContext(ec, &input) assert.Nil(t, err) var output outputArgs dc := bsoncodec.DecodeContext{ Registry: DefaultRegistry, Truncate: true, } err = UnmarshalWithContext(dc, doc, &output) assert.Nil(t, err) assert.Equal(t, inputName, output.Name) assert.Equal(t, int64(inputVal), output.Val) }) t.Run("no truncation", func(t testing.T) { inputName := "no truncation" inputVal := 7.382 input := inputArgs{Name: inputName, Val: &inputVal} ec := bsoncodec.EncodeContext{Registry: DefaultRegistry} doc, err := MarshalWithContext(ec, &input) assert.Nil(t, err) var output outputArgs dc := bsoncodec.DecodeContext{ Registry: DefaultRegistry, Truncate: false, } // case throws an error when truncation is disabled err = UnmarshalWithContext(dc, doc, &output) assert.NotNil(t, err) }) }	1.58 KB	2025-05-25 12:27
📄 types.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "go.mongodb.org/mongo-driver/bson/bsontype" ) // BSON element types as described in https://bsonspec.org/spec.html. const ( TypeDouble = bsontype.Double TypeString = bsontype.String TypeEmbeddedDocument = bsontype.EmbeddedDocument TypeArray = bsontype.Array TypeBinary = bsontype.Binary TypeUndefined = bsontype.Undefined TypeObjectID = bsontype.ObjectID TypeBoolean = bsontype.Boolean TypeDateTime = bsontype.DateTime TypeNull = bsontype.Null TypeRegex = bsontype.Regex TypeDBPointer = bsontype.DBPointer TypeJavaScript = bsontype.JavaScript TypeSymbol = bsontype.Symbol TypeCodeWithScope = bsontype.CodeWithScope TypeInt32 = bsontype.Int32 TypeTimestamp = bsontype.Timestamp TypeInt64 = bsontype.Int64 TypeDecimal128 = bsontype.Decimal128 TypeMinKey = bsontype.MinKey TypeMaxKey = bsontype.MaxKey ) // BSON binary element subtypes as described in https://bsonspec.org/spec.html. const ( TypeBinaryGeneric = bsontype.BinaryGeneric TypeBinaryFunction = bsontype.BinaryFunction TypeBinaryBinaryOld = bsontype.BinaryBinaryOld TypeBinaryUUIDOld = bsontype.BinaryUUIDOld TypeBinaryUUID = bsontype.BinaryUUID TypeBinaryMD5 = bsontype.BinaryMD5 TypeBinaryEncrypted = bsontype.BinaryEncrypted TypeBinaryColumn = bsontype.BinaryColumn TypeBinarySensitive = bsontype.BinarySensitive TypeBinaryUserDefined = bsontype.BinaryUserDefined )	1.82 KB	2025-05-25 12:27
📄 unmarshal.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "bytes" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsontype" ) // Unmarshaler is the interface implemented by types that can unmarshal a BSON // document representation of themselves. The input can be assumed to be a valid // encoding of a BSON document. UnmarshalBSON must copy the JSON data if it // wishes to retain the data after returning. // // Unmarshaler is only used to unmarshal full BSON documents. To create custom // BSON unmarshaling behavior for individual values in a BSON document, // implement the ValueUnmarshaler interface instead. type Unmarshaler interface { UnmarshalBSON([]byte) error } // ValueUnmarshaler is the interface implemented by types that can unmarshal a // BSON value representation of themselves. The input can be assumed to be a // valid encoding of a BSON value. UnmarshalBSONValue must copy the BSON value // bytes if it wishes to retain the data after returning. // // ValueUnmarshaler is only used to unmarshal individual values in a BSON // document. To create custom BSON unmarshaling behavior for an entire BSON // document, implement the Unmarshaler interface instead. type ValueUnmarshaler interface { UnmarshalBSONValue(bsontype.Type, []byte) error } // 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 // InvalidUnmarshalError. func Unmarshal(data []byte, val interface{}) error { return UnmarshalWithRegistry(DefaultRegistry, data, val) } // UnmarshalWithRegistry parses the BSON-encoded data using Registry r and // stores the result in the value pointed to by val. If val is nil or not // a pointer, UnmarshalWithRegistry returns InvalidUnmarshalError. // // Deprecated: Use [NewDecoder] and specify the Registry by calling [Decoder.SetRegistry] instead: // // dec, err := bson.NewDecoder(bsonrw.NewBSONDocumentReader(data)) // if err != nil { // panic(err) // } // dec.SetRegistry(reg) // // See [Decoder] for more examples. func UnmarshalWithRegistry(r bsoncodec.Registry, data []byte, val interface{}) error { vr := bsonrw.NewBSONDocumentReader(data) return unmarshalFromReader(bsoncodec.DecodeContext{Registry: r}, vr, val) } // UnmarshalWithContext parses the BSON-encoded data using DecodeContext dc and // stores the result in the value pointed to by val. If val is nil or not // a pointer, UnmarshalWithRegistry returns InvalidUnmarshalError. // // Deprecated: Use [NewDecoder] and use the Decoder configuration methods to set the desired unmarshal // behavior instead: // // dec, err := bson.NewDecoder(bsonrw.NewBSONDocumentReader(data)) // if err != nil { // panic(err) // } // dec.DefaultDocumentM() // // See [Decoder] for more examples. func UnmarshalWithContext(dc bsoncodec.DecodeContext, data []byte, val interface{}) error { vr := bsonrw.NewBSONDocumentReader(data) return unmarshalFromReader(dc, vr, val) } // UnmarshalValue parses the BSON value of type t with bson.DefaultRegistry and // stores the result in the value pointed to by val. If val is nil or not a pointer, // UnmarshalValue returns an error. func UnmarshalValue(t bsontype.Type, data []byte, val interface{}) error { return UnmarshalValueWithRegistry(DefaultRegistry, t, data, val) } // UnmarshalValueWithRegistry parses the BSON value of type t with registry r and // stores the result in the value pointed to by val. If val is nil or not a pointer, // UnmarshalValue returns an error. // // Deprecated: Using a custom registry to unmarshal individual BSON values will not be supported in // Go Driver 2.0. func UnmarshalValueWithRegistry(r bsoncodec.Registry, t bsontype.Type, data []byte, val interface{}) error { vr := bsonrw.NewBSONValueReader(t, data) return unmarshalFromReader(bsoncodec.DecodeContext{Registry: r}, vr, val) } // UnmarshalExtJSON parses the extended JSON-encoded data and stores the result // in the value pointed to by val. If val is nil or not a pointer, Unmarshal // returns InvalidUnmarshalError. func UnmarshalExtJSON(data []byte, canonical bool, val interface{}) error { return UnmarshalExtJSONWithRegistry(DefaultRegistry, data, canonical, val) } // UnmarshalExtJSONWithRegistry parses the extended JSON-encoded data using // Registry r and stores the result in the value pointed to by val. If val is // nil or not a pointer, UnmarshalWithRegistry returns InvalidUnmarshalError. // // Deprecated: Use [NewDecoder] and specify the Registry by calling [Decoder.SetRegistry] instead: // // vr, err := bsonrw.NewExtJSONValueReader(bytes.NewReader(data), true) // if err != nil { // panic(err) // } // dec, err := bson.NewDecoder(vr) // if err != nil { // panic(err) // } // dec.SetRegistry(reg) // // See [Decoder] for more examples. func UnmarshalExtJSONWithRegistry(r bsoncodec.Registry, data []byte, canonical bool, val interface{}) error { ejvr, err := bsonrw.NewExtJSONValueReader(bytes.NewReader(data), canonical) if err != nil { return err } return unmarshalFromReader(bsoncodec.DecodeContext{Registry: r}, ejvr, val) } // UnmarshalExtJSONWithContext parses the extended JSON-encoded data using // DecodeContext dc and stores the result in the value pointed to by val. If val is // nil or not a pointer, UnmarshalWithRegistry returns InvalidUnmarshalError. // // Deprecated: Use [NewDecoder] and use the Decoder configuration methods to set the desired unmarshal // behavior instead: // // vr, err := bsonrw.NewExtJSONValueReader(bytes.NewReader(data), true) // if err != nil { // panic(err) // } // dec, err := bson.NewDecoder(vr) // if err != nil { // panic(err) // } // dec.DefaultDocumentM() // // See [Decoder] for more examples. func UnmarshalExtJSONWithContext(dc bsoncodec.DecodeContext, data []byte, canonical bool, val interface{}) error { ejvr, err := bsonrw.NewExtJSONValueReader(bytes.NewReader(data), canonical) if err != nil { return err } return unmarshalFromReader(dc, ejvr, val) } func unmarshalFromReader(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val interface{}) error { dec := decPool.Get().(Decoder) defer decPool.Put(dec) err := dec.Reset(vr) if err != nil { return err } err = dec.SetContext(dc) if err != nil { return err } return dec.Decode(val) }	6.43 KB	2025-05-25 12:27
📄 unmarshal_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "errors" "math/rand" "reflect" "sync" "testing" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/primitive" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func TestUnmarshal(t testing.T) { for _, tc := range unmarshalingTestCases() { t.Run(tc.name, func(t testing.T) { // Make a copy of the test data so we can modify it later. data := make([]byte, len(tc.data)) copy(data, tc.data) // Assert that unmarshaling the input data results in the expected value. got := reflect.New(tc.sType).Interface() err := Unmarshal(data, got) noerr(t, err) assert.Equal(t, tc.want, got, "Did not unmarshal as expected.") // Fill the input data slice with random bytes and then assert that the result still // matches the expected value. _, err = rand.Read(data) noerr(t, err) assert.Equal(t, tc.want, got, "unmarshaled value does not match expected after modifying the input bytes") }) } } func TestUnmarshalWithRegistry(t testing.T) { for _, tc := range unmarshalingTestCases() { t.Run(tc.name, func(t testing.T) { // Make a copy of the test data so we can modify it later. data := make([]byte, len(tc.data)) copy(data, tc.data) // Assert that unmarshaling the input data results in the expected value. got := reflect.New(tc.sType).Interface() err := UnmarshalWithRegistry(DefaultRegistry, data, got) noerr(t, err) assert.Equal(t, tc.want, got, "Did not unmarshal as expected.") // Fill the input data slice with random bytes and then assert that the result still // matches the expected value. _, err = rand.Read(data) noerr(t, err) assert.Equal(t, tc.want, got, "unmarshaled value does not match expected after modifying the input bytes") }) } } func TestUnmarshalWithContext(t testing.T) { for _, tc := range unmarshalingTestCases() { t.Run(tc.name, func(t testing.T) { // Make a copy of the test data so we can modify it later. data := make([]byte, len(tc.data)) copy(data, tc.data) // Assert that unmarshaling the input data results in the expected value. dc := bsoncodec.DecodeContext{Registry: DefaultRegistry} got := reflect.New(tc.sType).Interface() err := UnmarshalWithContext(dc, data, got) noerr(t, err) assert.Equal(t, tc.want, got, "Did not unmarshal as expected.") // Fill the input data slice with random bytes and then assert that the result still // matches the expected value. _, err = rand.Read(data) noerr(t, err) assert.Equal(t, tc.want, got, "unmarshaled value does not match expected after modifying the input bytes") }) } } func TestUnmarshalExtJSONWithRegistry(t testing.T) { t.Run("UnmarshalExtJSONWithContext", func(t testing.T) { type teststruct struct{ Foo int } var got teststruct data := []byte("{\"foo\":1}") err := UnmarshalExtJSONWithRegistry(DefaultRegistry, data, true, &got) noerr(t, err) want := teststruct{1} assert.Equal(t, want, got, "Did not unmarshal as expected.") }) t.Run("UnmarshalExtJSONInvalidInput", func(t testing.T) { data := []byte("invalid") err := UnmarshalExtJSONWithRegistry(DefaultRegistry, data, true, &M{}) if !errors.Is(err, bsonrw.ErrInvalidJSON) { t.Fatalf("wanted ErrInvalidJSON, got %v", err) } }) } func TestUnmarshalExtJSONWithContext(t testing.T) { type fooInt struct { Foo int } type fooString struct { Foo string } type fooBytes struct { Foo []byte } var cases = []struct { name string sType reflect.Type want interface{} data []byte }{ { name: "Small struct", sType: reflect.TypeOf(fooInt{}), data: []byte(`{"foo":1}`), want: &fooInt{Foo: 1}, }, { name: "Valid surrogate pair", sType: reflect.TypeOf(fooString{}), data: []byte(`{"foo":"\uD834\uDd1e"}`), want: &fooString{Foo: "𝄞"}, }, { name: "Valid surrogate pair with other values", sType: reflect.TypeOf(fooString{}), data: []byte(`{"foo":"abc \uD834\uDd1e 123"}`), want: &fooString{Foo: "abc 𝄞 123"}, }, { name: "High surrogate value with no following low surrogate value", sType: reflect.TypeOf(fooString{}), data: []byte(`{"foo":"abc \uD834 123"}`), want: &fooString{Foo: "abc � 123"}, }, { name: "High surrogate value at end of string", sType: reflect.TypeOf(fooString{}), data: []byte(`{"foo":"\uD834"}`), want: &fooString{Foo: "�"}, }, { name: "Low surrogate value with no preceding high surrogate value", sType: reflect.TypeOf(fooString{}), data: []byte(`{"foo":"abc \uDd1e 123"}`), want: &fooString{Foo: "abc � 123"}, }, { name: "Low surrogate value at end of string", sType: reflect.TypeOf(fooString{}), data: []byte(`{"foo":"\uDd1e"}`), want: &fooString{Foo: "�"}, }, { name: "High surrogate value with non-surrogate unicode value", sType: reflect.TypeOf(fooString{}), data: []byte(`{"foo":"\uD834\u00BF"}`), want: &fooString{Foo: "�¿"}, }, // GODRIVER-2311 // Test that ExtJSON-encoded binary unmarshals correctly to a bson.D and that the // unmarshaled value does not reference the same underlying byte array as the input. { name: "bson.D with binary", sType: reflect.TypeOf(D{}), data: []byte(`{"foo": {"$binary": {"subType": "0", "base64": "AAECAwQF"}}}`), want: &D{{"foo", primitive.Binary{Subtype: 0, Data: []byte{0, 1, 2, 3, 4, 5}}}}, }, // GODRIVER-2311 // Test that ExtJSON-encoded binary unmarshals correctly to a struct and that the // unmarshaled value does not reference thesame underlying byte array as the input. { name: "struct with binary", sType: reflect.TypeOf(fooBytes{}), data: []byte(`{"foo": {"$binary": {"subType": "0", "base64": "AAECAwQF"}}}`), want: &fooBytes{Foo: []byte{0, 1, 2, 3, 4, 5}}, }, } for _, tc := range cases { t.Run(tc.name, func(t testing.T) { // Make a copy of the test data so we can modify it later. data := make([]byte, len(tc.data)) copy(data, tc.data) // Assert that unmarshaling the input data results in the expected value. got := reflect.New(tc.sType).Interface() dc := bsoncodec.DecodeContext{Registry: DefaultRegistry} err := UnmarshalExtJSONWithContext(dc, data, true, got) noerr(t, err) assert.Equal(t, tc.want, got, "Did not unmarshal as expected.") // Fill the input data slice with random bytes and then assert that the result still // matches the expected value. _, err = rand.Read(data) noerr(t, err) assert.Equal(t, tc.want, got, "unmarshaled value does not match expected after modifying the input bytes") }) } } func TestCachingDecodersNotSharedAcrossRegistries(t testing.T) { // Decoders that have caches for recursive decoder lookup should not be shared across Registry instances. Otherwise, // the first DecodeValue call would cache an decoder and a subsequent call would see that decoder even if a // different Registry is used. // Create a custom Registry that negates BSON int32 values when decoding. var decodeInt32 bsoncodec.ValueDecoderFunc = func(_ bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error { i32, err := vr.ReadInt32() if err != nil { return err } val.SetInt(int64(-1 * i32)) return nil } customReg := NewRegistryBuilder(). RegisterTypeDecoder(tInt32, decodeInt32). Build() docBytes := bsoncore.BuildDocumentFromElements( nil, bsoncore.AppendInt32Element(nil, "x", 1), ) // For all sub-tests, unmarshal docBytes into a struct and assert that value for "x" is 1 when using the default // registry and -1 when using the custom registry. t.Run("struct", func(t testing.T) { type Struct struct { X int32 } var first Struct err := Unmarshal(docBytes, &first) assert.Nil(t, err, "Unmarshal error: %v", err) assert.Equal(t, int32(1), first.X, "expected X value to be 1, got %v", first.X) var second Struct err = UnmarshalWithRegistry(customReg, docBytes, &second) assert.Nil(t, err, "Unmarshal error: %v", err) assert.Equal(t, int32(-1), second.X, "expected X value to be -1, got %v", second.X) }) t.Run("pointer", func(t testing.T) { type Struct struct { X int32 } var first Struct err := Unmarshal(docBytes, &first) assert.Nil(t, err, "Unmarshal error: %v", err) assert.Equal(t, int32(1), first.X, "expected X value to be 1, got %v", first.X) var second Struct err = UnmarshalWithRegistry(customReg, docBytes, &second) assert.Nil(t, err, "Unmarshal error: %v", err) assert.Equal(t, int32(-1), second.X, "expected X value to be -1, got %v", second.X) }) } func TestUnmarshalExtJSONWithUndefinedField(t testing.T) { // When unmarshalling extJSON, fields that are undefined in the destination struct are skipped. // This process must not skip other, defined fields and must not raise errors. type expectedResponse struct { DefinedField interface{} } unmarshalExpectedResponse := func(t testing.T, extJSON string) expectedResponse { t.Helper() responseDoc := expectedResponse{} err := UnmarshalExtJSON([]byte(extJSON), false, &responseDoc) assert.Nil(t, err, "UnmarshalExtJSON error: %v", err) return &responseDoc } testCases := []struct { name string testJSON string expectedValue interface{} }{ { "no array", `{ "UndefinedField": {"key": 1}, "DefinedField": "value" }`, "value", }, { "outer array", `{ "UndefinedField": [{"key": 1}], "DefinedField": "value" }`, "value", }, { "embedded array", `{ "UndefinedField": {"keys": [2]}, "DefinedField": "value" }`, "value", }, { "outer array and embedded array", `{ "UndefinedField": [{"keys": [2]}], "DefinedField": "value" }`, "value", }, { "embedded document", `{ "UndefinedField": {"key": {"one": "two"}}, "DefinedField": "value" }`, "value", }, { "doubly embedded document", `{ "UndefinedField": {"key": {"one": {"two": "three"}}}, "DefinedField": "value" }`, "value", }, { "embedded document and embedded array", `{ "UndefinedField": {"key": {"one": {"two": [3]}}}, "DefinedField": "value" }`, "value", }, { "embedded document and embedded array in outer array", `{ "UndefinedField": [{"key": {"one": [3]}}], "DefinedField": "value" }`, "value", }, { "code with scope", `{ "UndefinedField": {"logic": {"$code": "foo", "$scope": {"bar": 1}}}, "DefinedField": "value" }`, "value", }, { "embedded array of code with scope", `{ "UndefinedField": {"logic": [{"$code": "foo", "$scope": {"bar": 1}}]}, "DefinedField": "value" }`, "value", }, { "type definition embedded document", `{ "UndefinedField": {"myDouble": {"$numberDouble": "1.24"}}, "DefinedField": "value" }`, "value", }, { "empty embedded document", `{ "UndefinedField": {"empty": {}, "key": 1}, "DefinedField": "value" }`, "value", }, { "empty object before", `{ "UndefinedField": {}, "DefinedField": {"value": "a"} }`, D{{"value", "a"}}, }, { "empty object after", `{ "DefinedField": {"value": "a"}, "UndefinedField": {} }`, D{{"value", "a"}}, }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { responseDoc := unmarshalExpectedResponse(t, tc.testJSON) assert.Equal(t, tc.expectedValue, responseDoc.DefinedField, "expected DefinedField to be %v, got %q", tc.expectedValue, responseDoc.DefinedField) }) } } func TestUnmarshalBSONWithUndefinedField(t testing.T) { // When unmarshalling BSON, fields that are undefined in the destination struct are skipped. // This process must not skip other, defined fields and must not raise errors. type expectedResponse struct { DefinedField string `bson:"DefinedField"` } createExpectedResponse := func(t testing.T, doc D) expectedResponse { t.Helper() marshalledBSON, err := Marshal(doc) assert.Nil(t, err, "error marshalling BSON: %v", err) responseDoc := expectedResponse{} err = Unmarshal(marshalledBSON, &responseDoc) assert.Nil(t, err, "error unmarshalling BSON: %v", err) return &responseDoc } testCases := []struct { name string testBSON D }{ { "no array", D{ {"UndefinedField", D{ {"key", 1}, }}, {"DefinedField", "value"}, }, }, { "outer array", D{ {"UndefinedField", A{D{ {"key", 1}, }}}, {"DefinedField", "value"}, }, }, { "embedded array", D{ {"UndefinedField", D{ {"key", A{1}}, }}, {"DefinedField", "value"}, }, }, { "outer array and embedded array", D{ {"UndefinedField", A{D{ {"key", A{1}}, }}}, {"DefinedField", "value"}, }, }, { "embedded document", D{ {"UndefinedField", D{ {"key", D{ {"one", "two"}, }}, }}, {"DefinedField", "value"}, }, }, { "doubly embedded document", D{ {"UndefinedField", D{ {"key", D{ {"one", D{ {"two", "three"}, }}, }}, }}, {"DefinedField", "value"}, }, }, { "embedded document and embedded array", D{ {"UndefinedField", D{ {"key", D{ {"one", D{ {"two", A{3}}, }}, }}, }}, {"DefinedField", "value"}, }, }, { "embedded document and embedded array in outer array", D{ {"UndefinedField", A{D{ {"key", D{ {"one", A{3}}, }}, }}}, {"DefinedField", "value"}, }, }, { "code with scope", D{ {"UndefinedField", D{ {"logic", D{ {"$code", "foo"}, {"$scope", D{ {"bar", 1}, }}, }}, }}, {"DefinedField", "value"}, }, }, { "embedded array of code with scope", D{ {"UndefinedField", D{ {"logic", A{D{ {"$code", "foo"}, {"$scope", D{ {"bar", 1}, }}, }}}, }}, {"DefinedField", "value"}, }, }, { "empty embedded document", D{ {"UndefinedField", D{}}, {"DefinedField", "value"}, }, }, } for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { responseDoc := createExpectedResponse(t, tc.testBSON) assert.Equal(t, "value", responseDoc.DefinedField, "expected DefinedField to be 'value', got %q", responseDoc.DefinedField) }) } } // GODRIVER-2311 // Assert that unmarshaled values containing byte slices do not reference the same underlying byte // array as the BSON input data byte slice. func TestUnmarshalByteSlicesUseDistinctArrays(t testing.T) { type fooBytes struct { Foo []byte } type myBytes []byte type fooMyBytes struct { Foo myBytes } type fooBinary struct { Foo primitive.Binary } type fooObjectID struct { Foo primitive.ObjectID } type fooDBPointer struct { Foo primitive.DBPointer } testCases := []struct { description string data []byte sType reflect.Type want interface{} // getByteSlice returns the byte slice from the unmarshaled value, allowing the test to // inspect the addresses of the underlying byte array. getByteSlice func(interface{}) []byte }{ { description: "struct with byte slice", data: docToBytes(fooBytes{ Foo: []byte{0, 1, 2, 3, 4, 5}, }), sType: reflect.TypeOf(fooBytes{}), want: &fooBytes{ Foo: []byte{0, 1, 2, 3, 4, 5}, }, getByteSlice: func(val interface{}) []byte { return ((val.(fooBytes))).Foo }, }, { description: "bson.D with byte slice", data: docToBytes(D{ {"foo", []byte{0, 1, 2, 3, 4, 5}}, }), sType: reflect.TypeOf(D{}), want: &D{ {"foo", primitive.Binary{Subtype: 0, Data: []byte{0, 1, 2, 3, 4, 5}}}, }, getByteSlice: func(val interface{}) []byte { return ((val.(D)))[0].Value.(primitive.Binary).Data }, }, { description: "struct with custom byte slice type", data: docToBytes(fooMyBytes{ Foo: myBytes{0, 1, 2, 3, 4, 5}, }), sType: reflect.TypeOf(fooMyBytes{}), want: &fooMyBytes{ Foo: myBytes{0, 1, 2, 3, 4, 5}, }, getByteSlice: func(val interface{}) []byte { return ((val.(fooMyBytes))).Foo }, }, { description: "bson.D with custom byte slice type", data: docToBytes(D{ {"foo", myBytes{0, 1, 2, 3, 4, 5}}, }), sType: reflect.TypeOf(D{}), want: &D{ {"foo", primitive.Binary{Subtype: 0, Data: myBytes{0, 1, 2, 3, 4, 5}}}, }, getByteSlice: func(val interface{}) []byte { return ((val.(D)))[0].Value.(primitive.Binary).Data }, }, { description: "struct with primitive.Binary", data: docToBytes(fooBinary{ Foo: primitive.Binary{Subtype: 0, Data: []byte{0, 1, 2, 3, 4, 5}}, }), sType: reflect.TypeOf(fooBinary{}), want: &fooBinary{ Foo: primitive.Binary{Subtype: 0, Data: []byte{0, 1, 2, 3, 4, 5}}, }, getByteSlice: func(val interface{}) []byte { return ((val.(fooBinary))).Foo.Data }, }, { description: "bson.D with primitive.Binary", data: docToBytes(D{ {"foo", primitive.Binary{Subtype: 0, Data: []byte{0, 1, 2, 3, 4, 5}}}, }), sType: reflect.TypeOf(D{}), want: &D{ {"foo", primitive.Binary{Subtype: 0, Data: []byte{0, 1, 2, 3, 4, 5}}}, }, getByteSlice: func(val interface{}) []byte { return ((val.(D)))[0].Value.(primitive.Binary).Data }, }, { description: "struct with primitive.ObjectID", data: docToBytes(fooObjectID{ Foo: primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, }), sType: reflect.TypeOf(fooObjectID{}), want: &fooObjectID{ Foo: primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, }, getByteSlice: func(val interface{}) []byte { return ((val.(fooObjectID))).Foo[:] }, }, { description: "bson.D with primitive.ObjectID", data: docToBytes(D{ {"foo", primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}, }), sType: reflect.TypeOf(D{}), want: &D{ {"foo", primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}}, }, getByteSlice: func(val interface{}) []byte { oid := ((val.(D)))[0].Value.(primitive.ObjectID) return oid[:] }, }, { description: "struct with primitive.DBPointer", data: docToBytes(fooDBPointer{ Foo: primitive.DBPointer{ DB: "test", Pointer: primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, }, }), sType: reflect.TypeOf(fooDBPointer{}), want: &fooDBPointer{ Foo: primitive.DBPointer{ DB: "test", Pointer: primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, }, }, getByteSlice: func(val interface{}) []byte { return ((val.(fooDBPointer))).Foo.Pointer[:] }, }, { description: "bson.D with primitive.DBPointer", data: docToBytes(D{ {"foo", primitive.DBPointer{ DB: "test", Pointer: primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, }}, }), sType: reflect.TypeOf(D{}), want: &D{ {"foo", primitive.DBPointer{ DB: "test", Pointer: primitive.ObjectID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, }}, }, getByteSlice: func(val interface{}) []byte { oid := ((val.(D)))[0].Value.(primitive.DBPointer).Pointer return oid[:] }, }, } for _, tc := range testCases { tc := tc // Capture range variable. t.Run(tc.description, func(t testing.T) { t.Parallel() // Make a copy of the test data so we can modify it later. data := make([]byte, len(tc.data)) copy(data, tc.data) // Assert that unmarshaling the input data results in the expected value. got := reflect.New(tc.sType).Interface() err := Unmarshal(data, got) noerr(t, err) assert.Equal(t, tc.want, got, "unmarshaled value does not match the expected value") // Fill the input data slice with random bytes and then assert that the result still // matches the expected value. _, err = rand.Read(data) noerr(t, err) assert.Equal(t, tc.want, got, "unmarshaled value does not match expected after modifying the input bytes") // Assert that the byte slice in the unmarshaled value does not share any memory // addresses with the input byte slice. assert.DifferentAddressRanges(t, data, tc.getByteSlice(got)) }) } } func TestUnmarshalConcurrently(t testing.T) { t.Parallel() const size = 10_000 data := []byte{16, 0, 0, 0, 10, 108, 97, 115, 116, 101, 114, 114, 111, 114, 0, 0} wg := sync.WaitGroup{} wg.Add(size) for i := 0; i < size; i++ { go func() { defer wg.Done() var res struct{ LastError error } _ = Unmarshal(data, &res) }() } wg.Wait() }	20.49 KB	2025-05-25 12:27
📄 unmarshal_value_test.go // Copyright (C) MongoDB, Inc. 2023-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 bson import ( "reflect" "strings" "testing" "go.mongodb.org/mongo-driver/bson/bsoncodec" "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/internal/assert" "go.mongodb.org/mongo-driver/x/bsonx/bsoncore" ) func TestUnmarshalValue(t testing.T) { t.Parallel() unmarshalValueTestCases := newMarshalValueTestCases(t) t.Run("UnmarshalValue", func(t testing.T) { t.Parallel() for _, tc := range unmarshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() gotValue := reflect.New(reflect.TypeOf(tc.val)) err := UnmarshalValue(tc.bsontype, tc.bytes, gotValue.Interface()) assert.Nil(t, err, "UnmarshalValueWithRegistry error: %v", err) assert.Equal(t, tc.val, gotValue.Elem().Interface(), "value mismatch; expected %s, got %s", tc.val, gotValue.Elem()) }) } }) t.Run("UnmarshalValueWithRegistry with DefaultRegistry", func(t testing.T) { t.Parallel() for _, tc := range unmarshalValueTestCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() gotValue := reflect.New(reflect.TypeOf(tc.val)) err := UnmarshalValueWithRegistry(DefaultRegistry, tc.bsontype, tc.bytes, gotValue.Interface()) assert.Nil(t, err, "UnmarshalValueWithRegistry error: %v", err) assert.Equal(t, tc.val, gotValue.Elem().Interface(), "value mismatch; expected %s, got %s", tc.val, gotValue.Elem()) }) } }) // tests covering GODRIVER-2779 t.Run("UnmarshalValueWithRegistry with custom registry", func(t testing.T) { t.Parallel() testCases := []struct { name string val interface{} bsontype bsontype.Type bytes []byte }{ { name: "SliceCodec binary", val: []byte("hello world"), bsontype: bsontype.Binary, bytes: bsoncore.AppendBinary(nil, bsontype.BinaryGeneric, []byte("hello world")), }, { name: "SliceCodec string", val: []byte("hello world"), bsontype: bsontype.String, bytes: bsoncore.AppendString(nil, "hello world"), }, } rb := NewRegistryBuilder().RegisterTypeDecoder(reflect.TypeOf([]byte{}), bsoncodec.NewSliceCodec()).Build() for _, tc := range testCases { tc := tc t.Run(tc.name, func(t testing.T) { t.Parallel() gotValue := reflect.New(reflect.TypeOf(tc.val)) err := UnmarshalValueWithRegistry(rb, tc.bsontype, tc.bytes, gotValue.Interface()) assert.Nil(t, err, "UnmarshalValueWithRegistry error: %v", err) assert.Equal(t, tc.val, gotValue.Elem().Interface(), "value mismatch; expected %s, got %s", tc.val, gotValue.Elem()) }) } }) } // tests covering GODRIVER-2779 func BenchmarkSliceCodecUnmarshal(b testing.B) { benchmarks := []struct { name string bsontype bsontype.Type bytes []byte }{ { name: "SliceCodec binary", bsontype: bsontype.Binary, bytes: bsoncore.AppendBinary(nil, bsontype.BinaryGeneric, []byte(strings.Repeat("t", 4096))), }, { name: "SliceCodec string", bsontype: bsontype.String, bytes: bsoncore.AppendString(nil, strings.Repeat("t", 4096)), }, } rb := NewRegistryBuilder().RegisterTypeDecoder(reflect.TypeOf([]byte{}), bsoncodec.NewSliceCodec()).Build() for _, bm := range benchmarks { b.Run(bm.name, func(b testing.B) { b.RunParallel(func(pb testing.PB) { for pb.Next() { err := UnmarshalValueWithRegistry(rb, bm.bsontype, bm.bytes, &[]byte{}) if err != nil { b.Fatal(err) } } }) }) } }	3.67 KB	2025-05-25 12:27
📄 unmarshaling_cases_test.go // Copyright (C) MongoDB, Inc. 2017-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 bson import ( "reflect" "go.mongodb.org/mongo-driver/bson/bsonrw" "go.mongodb.org/mongo-driver/bson/bsontype" ) type unmarshalingTestCase struct { name string sType reflect.Type want interface{} data []byte } func unmarshalingTestCases() []unmarshalingTestCase { var zeroPtrStruct unmarshalerPtrStruct { i := myInt64(0) m := myMap{} b := myBytes{} s := myString("") zeroPtrStruct = unmarshalerPtrStruct{I: &i, M: &m, B: &b, S: &s} } var zeroNonPtrStruct unmarshalerNonPtrStruct { i := myInt64(0) m := myMap{} b := myBytes{} s := myString("") zeroNonPtrStruct = unmarshalerNonPtrStruct{I: i, M: m, B: b, S: s} } var valPtrStruct unmarshalerPtrStruct { i := myInt64(5) m := myMap{"key": "value"} b := myBytes{0x00, 0x01} s := myString("test") valPtrStruct = unmarshalerPtrStruct{I: &i, M: &m, B: &b, S: &s} } var valNonPtrStruct unmarshalerNonPtrStruct { i := myInt64(5) m := myMap{"key": "value"} b := myBytes{0x00, 0x01} s := myString("test") valNonPtrStruct = unmarshalerNonPtrStruct{I: i, M: m, B: b, S: s} } type fooBytes struct { Foo []byte } return []unmarshalingTestCase{ { name: "small struct", sType: reflect.TypeOf(struct { Foo bool }{}), want: &struct { Foo bool }{Foo: true}, data: docToBytes(D{{"foo", true}}), }, { name: "nested document", sType: reflect.TypeOf(struct { Foo struct { Bar bool } }{}), want: &struct { Foo struct { Bar bool } }{ Foo: struct { Bar bool }{Bar: true}, }, data: docToBytes(D{{"foo", D{{"bar", true}}}}), }, { name: "simple array", sType: reflect.TypeOf(struct { Foo []bool }{}), want: &struct { Foo []bool }{ Foo: []bool{true}, }, data: docToBytes(D{{"foo", A{true}}}), }, { name: "struct with mixed case fields", sType: reflect.TypeOf(struct { FooBar int32 }{}), want: &struct { FooBar int32 }{ FooBar: 10, }, data: docToBytes(D{{"fooBar", int32(10)}}), }, // GODRIVER-2252 // Test that a struct of pointer types with UnmarshalBSON functions defined marshal and // unmarshal to the same Go values when the pointer values are "nil". { name: "nil pointer fields with UnmarshalBSON function should marshal and unmarshal to the same values", sType: reflect.TypeOf(unmarshalerPtrStruct{}), want: &unmarshalerPtrStruct{}, data: docToBytes(unmarshalerPtrStruct{}), }, // GODRIVER-2252 // Test that a struct of pointer types with UnmarshalBSON functions defined marshal and // unmarshal to the same Go values when the pointer values are the respective zero values. { name: "zero-value pointer fields with UnmarshalBSON function should marshal and unmarshal to the same values", sType: reflect.TypeOf(unmarshalerPtrStruct{}), want: &zeroPtrStruct, data: docToBytes(zeroPtrStruct), }, // GODRIVER-2252 // Test that a struct of pointer types with UnmarshalBSON functions defined marshal and // unmarshal to the same Go values when the pointer values are non-zero values. { name: "non-zero-value pointer fields with UnmarshalBSON function should marshal and unmarshal to the same values", sType: reflect.TypeOf(unmarshalerPtrStruct{}), want: &valPtrStruct, data: docToBytes(valPtrStruct), }, // GODRIVER-2311 // Test that an unmarshaled struct that has a byte slice value does not reference the same // underlying array as the input. { name: "struct with byte slice", sType: reflect.TypeOf(fooBytes{}), want: &fooBytes{ Foo: []byte{0, 1, 2, 3, 4, 5}, }, data: docToBytes(fooBytes{ Foo: []byte{0, 1, 2, 3, 4, 5}, }), }, // GODRIVER-2427 // Test that a struct of non-pointer types with UnmarshalBSON functions defined for the pointer of the field // will marshal and unmarshal to the same Go values when the non-pointer values are the respctive zero values. { name: `zero-value non-pointer fields with pointer UnmarshalBSON function should marshal and unmarshal to the same values`, sType: reflect.TypeOf(unmarshalerNonPtrStruct{}), want: &zeroNonPtrStruct, data: docToBytes(zeroNonPtrStruct), }, // GODRIVER-2427 // Test that a struct of non-pointer types with UnmarshalBSON functions defined for the pointer of the field // unmarshal to the same Go values when the non-pointer values are non-zero values. { name: `non-zero-value non-pointer fields with pointer UnmarshalBSON function should marshal and unmarshal to the same values`, sType: reflect.TypeOf(unmarshalerNonPtrStruct{}), want: &valNonPtrStruct, data: docToBytes(valNonPtrStruct), }, } } // unmarshalerPtrStruct contains a collection of fields that are all pointers to custom types that // implement the bson.Unmarshaler interface. It is used to test the BSON unmarshal behavior for // pointer types with custom UnmarshalBSON functions. type unmarshalerPtrStruct struct { I myInt64 M myMap B myBytes S myString } // unmarshalerNonPtrStruct contains a collection of non-pointer fields that are all to custom types that implement the // bson.Unmarshaler interface. It is used to test the BSON unmarshal behavior for types with custom UnmarshalBSON // functions. type unmarshalerNonPtrStruct struct { I myInt64 M myMap B myBytes S myString } type myInt64 int64 func (mi myInt64) UnmarshalBSON(bytes []byte) error { if len(bytes) == 0 { return nil } i, err := bsonrw.NewBSONValueReader(bsontype.Int64, bytes).ReadInt64() if err != nil { return err } mi = myInt64(i) return nil } type myMap map[string]string func (mm myMap) UnmarshalBSON(bytes []byte) error { if len(bytes) == 0 { return nil } var m map[string]string err := Unmarshal(bytes, &m) mm = myMap(m) return err } type myBytes []byte func (mb myBytes) UnmarshalBSON(bytes []byte) error { if len(bytes) == 0 { return nil } b, _, err := bsonrw.NewBSONValueReader(bsontype.Binary, bytes).ReadBinary() if err != nil { return err } mb = b return nil } type myString string func (ms myString) UnmarshalBSON(bytes []byte) error { if len(bytes) == 0 { return nil } s, err := bsonrw.NewBSONValueReader(bsontype.String, bytes).ReadString() if err != nil { return err } ms = myString(s) return nil }	6.44 KB	2025-05-25 12:27

Edit File:

Terminal