GODRIVER-1777 allow inline struct fields to be overwritten by higher … (#535)

Author: iwysiu

bson/bsoncodec/default_value_decoders_test.go

@@ -2677,6 +2677,53 @@ func TestDefaultValueDecoders(t *testing.T) {
 				buildDocument([]byte{}),
 				nil,
 			},
+			{
+				"inline overwrite",
+				struct {
+					Foo struct {
+						A int32
+						B string
+					} `bson:",inline"`
+					A int64
+				}{
+					Foo: struct {
+						A int32
+						B string
+					}{
+						A: 0,
+						B: "foo",
+					},
+					A: 54321,
+				},
+				buildDocument(func(doc []byte) []byte {
+					doc = bsoncore.AppendStringElement(doc, "b", "foo")
+					doc = bsoncore.AppendInt64Element(doc, "a", 54321)
+					return doc
+				}(nil)),
+				nil,
+			},
+			{
+				"inline overwrite with nested structs",
+				struct {
+					Foo struct {
+						A int32
+					} `bson:",inline"`
+					Bar struct {
+						A int32
+					} `bson:",inline"`
+					A int64
+				}{
+					Foo: struct {
+						A int32
+					}{},
+					Bar: struct {
+						A int32
+					}{},
+					A: 54321,
+				},
+				buildDocument(bsoncore.AppendInt64Element(nil, "a", 54321)),
+				nil,
+			},
 			{
 				"inline map",
 				struct {
@@ -3062,6 +3109,43 @@ func TestDefaultValueDecoders(t *testing.T) {
 			}
 		})
 	})
+	t.Run("error path", func(t *testing.T) {
+		testCases := []struct {
+			name  string
+			value interface{}
+			b     []byte
+			err   error
+		}{
+			{
+				"duplicate name struct",
+				struct {
+					A int64
+					B int64 `bson:"a"`
+				}{
+					A: 0,
+					B: 54321,
+				},
+				buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)),
+				fmt.Errorf("duplicated key a"),
+			},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				vr := bsonrw.NewBSONDocumentReader(tc.b)
+				reg := buildDefaultRegistry()
+				vtype := reflect.TypeOf(tc.value)
+				dec, err := reg.LookupDecoder(vtype)
+				noerr(t, err)
+
+				gotVal := reflect.New(reflect.TypeOf(tc.value)).Elem()
+				err = dec.DecodeValue(DecodeContext{Registry: reg}, vr, gotVal)
+				if err == nil || !strings.Contains(err.Error(), tc.err.Error()) {
+					t.Errorf("Did not receive expected error. got %v; want %v", err, tc.err)
+				}
+			})
+		}
+	})
 
 	t.Run("defaultEmptyInterfaceCodec.DecodeValue", func(t *testing.T) {
 		t.Run("DecodeValue", func(t *testing.T) {

bson/bsoncodec/default_value_encoders_test.go

@@ -13,6 +13,7 @@ import (
 	"math"
 	"net/url"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -1379,6 +1380,78 @@ func TestDefaultValueEncoders(t *testing.T) {
 				buildDocument([]byte{}),
 				nil,
 			},
+			{
+				"inline overwrite",
+				struct {
+					Foo struct {
+						A int32
+						B string
+					} `bson:",inline"`
+					A int64
+				}{
+					Foo: struct {
+						A int32
+						B string
+					}{
+						A: 0,
+						B: "foo",
+					},
+					A: 54321,
+				},
+				buildDocument(func(doc []byte) []byte {
+					doc = bsoncore.AppendStringElement(doc, "b", "foo")
+					doc = bsoncore.AppendInt64Element(doc, "a", 54321)
+					return doc
+				}(nil)),
+				nil,
+			},
+			{
+				"inline overwrite respects ordering",
+				struct {
+					A   int64
+					Foo struct {
+						A int32
+						B string
+					} `bson:",inline"`
+				}{
+					A: 54321,
+					Foo: struct {
+						A int32
+						B string
+					}{
+						A: 0,
+						B: "foo",
+					},
+				},
+				buildDocument(func(doc []byte) []byte {
+					doc = bsoncore.AppendInt64Element(doc, "a", 54321)
+					doc = bsoncore.AppendStringElement(doc, "b", "foo")
+					return doc
+				}(nil)),
+				nil,
+			},
+			{
+				"inline overwrite with nested structs",
+				struct {
+					Foo struct {
+						A int32
+					} `bson:",inline"`
+					Bar struct {
+						A int32
+					} `bson:",inline"`
+					A int64
+				}{
+					Foo: struct {
+						A int32
+					}{},
+					Bar: struct {
+						A int32
+					}{},
+					A: 54321,
+				},
+				buildDocument(bsoncore.AppendInt64Element(nil, "a", 54321)),
+				nil,
+			},
 			{
 				"inline map",
 				struct {
@@ -1676,6 +1749,52 @@ func TestDefaultValueEncoders(t *testing.T) {
 		}
 	})
 
+	t.Run("error path", func(t *testing.T) {
+		testCases := []struct {
+			name  string
+			value interface{}
+			err   error
+		}{
+			{
+				"duplicate name struct",
+				struct {
+					A int64
+					B int64 `bson:"a"`
+				}{
+					A: 0,
+					B: 54321,
+				},
+				fmt.Errorf("duplicated key a"),
+			},
+			{
+				"inline map",
+				struct {
+					Foo map[string]string `bson:",inline"`
+					Baz string
+				}{
+					Foo: map[string]string{"baz": "bar"},
+					Baz: "hi",
+				},
+				fmt.Errorf("Key baz of inlined map conflicts with a struct field name"),
+			},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				b := make(bsonrw.SliceWriter, 0, 512)
+				vw, err := bsonrw.NewBSONValueWriter(&b)
+				noerr(t, err)
+				reg := buildDefaultRegistry()
+				enc, err := reg.LookupEncoder(reflect.TypeOf(tc.value))
+				noerr(t, err)
+				err = enc.EncodeValue(EncodeContext{Registry: reg}, vw, reflect.ValueOf(tc.value))
+				if err == nil || !strings.Contains(err.Error(), tc.err.Error()) {
+					t.Errorf("Did not receive expected error. got %v; want %v", err, tc.err)
+				}
+			})
+		}
+	})
+
 	t.Run("EmptyInterfaceEncodeValue/nil", func(t *testing.T) {
 		val := reflect.New(tEmpty).Elem()
 		llvrw := new(bsonrwtest.ValueReaderWriter)