File: //opt/go/pkg/mod/go.mongodb.org/
[email protected]/bson/bsoncodec/default_value_encoders_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 bsoncodec
import (
"encoding/json"
"errors"
"fmt"
"math"
"net/url"
"reflect"
"strings"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"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"
)
type myInterface interface {
Foo() int
}
type myStruct struct {
Val int
}
func (ms myStruct) Foo() int {
return ms.Val
}
func TestDefaultValueEncoders(t *testing.T) {
var dve DefaultValueEncoders
var wrong = func(string, string) string { return "wrong" }
type mybool bool
type myint8 int8
type myint16 int16
type myint32 int32
type myint64 int64
type myint int
type myuint8 uint8
type myuint16 uint16
type myuint32 uint32
type myuint64 uint64
type myuint uint
type myfloat32 float32
type myfloat64 float64
now := time.Now().Truncate(time.Millisecond)
pjsnum := new(json.Number)
*pjsnum = json.Number("3.14159")
d128 := primitive.NewDecimal128(12345, 67890)
var nilValueMarshaler *testValueMarshaler
var nilMarshaler *testMarshaler
var nilProxy *testProxy
vmStruct := struct{ V testValueMarshalPtr }{testValueMarshalPtr{t: bsontype.String, buf: []byte{0x04, 0x00, 0x00, 0x00, 'f', 'o', 'o', 0x00}}}
mStruct := struct{ V testMarshalPtr }{testMarshalPtr{buf: bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159))}}
pStruct := struct{ V testProxyPtr }{testProxyPtr{ret: int64(1234567890)}}
type subtest struct {
name string
val interface{}
ectx *EncodeContext
llvrw *bsonrwtest.ValueReaderWriter
invoke bsonrwtest.Invoked
err error
}
testCases := []struct {
name string
ve ValueEncoder
subtests []subtest
}{
{
"BooleanEncodeValue",
ValueEncoderFunc(dve.BooleanEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "BooleanEncodeValue", Kinds: []reflect.Kind{reflect.Bool}, Received: reflect.ValueOf(wrong)},
},
{"fast path", bool(true), nil, nil, bsonrwtest.WriteBoolean, nil},
{"reflection path", mybool(true), nil, nil, bsonrwtest.WriteBoolean, nil},
},
},
{
"IntEncodeValue",
ValueEncoderFunc(dve.IntEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "IntEncodeValue",
Kinds: []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
Received: reflect.ValueOf(wrong),
},
},
{"int8/fast path", int8(127), nil, nil, bsonrwtest.WriteInt32, nil},
{"int16/fast path", int16(32767), nil, nil, bsonrwtest.WriteInt32, nil},
{"int32/fast path", int32(2147483647), nil, nil, bsonrwtest.WriteInt32, nil},
{"int64/fast path", int64(1234567890987), nil, nil, bsonrwtest.WriteInt64, nil},
{"int64/fast path - minsize", int64(math.MaxInt32), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"int64/fast path - minsize too large", int64(math.MaxInt32 + 1), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"int64/fast path - minsize too small", int64(math.MinInt32 - 1), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"int/fast path - positive int32", int(math.MaxInt32 - 1), nil, nil, bsonrwtest.WriteInt32, nil},
{"int/fast path - negative int32", int(math.MinInt32 + 1), nil, nil, bsonrwtest.WriteInt32, nil},
{"int/fast path - MaxInt32", int(math.MaxInt32), nil, nil, bsonrwtest.WriteInt32, nil},
{"int/fast path - MinInt32", int(math.MinInt32), nil, nil, bsonrwtest.WriteInt32, nil},
{"int8/reflection path", myint8(127), nil, nil, bsonrwtest.WriteInt32, nil},
{"int16/reflection path", myint16(32767), nil, nil, bsonrwtest.WriteInt32, nil},
{"int32/reflection path", myint32(2147483647), nil, nil, bsonrwtest.WriteInt32, nil},
{"int64/reflection path", myint64(1234567890987), nil, nil, bsonrwtest.WriteInt64, nil},
{"int64/reflection path - minsize", myint64(math.MaxInt32), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"int64/reflection path - minsize too large", myint64(math.MaxInt32 + 1), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"int64/reflection path - minsize too small", myint64(math.MinInt32 - 1), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"int/reflection path - positive int32", myint(math.MaxInt32 - 1), nil, nil, bsonrwtest.WriteInt32, nil},
{"int/reflection path - negative int32", myint(math.MinInt32 + 1), nil, nil, bsonrwtest.WriteInt32, nil},
{"int/reflection path - MaxInt32", myint(math.MaxInt32), nil, nil, bsonrwtest.WriteInt32, nil},
{"int/reflection path - MinInt32", myint(math.MinInt32), nil, nil, bsonrwtest.WriteInt32, nil},
},
},
{
"UintEncodeValue",
defaultUIntCodec,
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "UintEncodeValue",
Kinds: []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
Received: reflect.ValueOf(wrong),
},
},
{"uint8/fast path", uint8(127), nil, nil, bsonrwtest.WriteInt32, nil},
{"uint16/fast path", uint16(32767), nil, nil, bsonrwtest.WriteInt32, nil},
{"uint32/fast path", uint32(2147483647), nil, nil, bsonrwtest.WriteInt64, nil},
{"uint64/fast path", uint64(1234567890987), nil, nil, bsonrwtest.WriteInt64, nil},
{"uint/fast path", uint(1234567), nil, nil, bsonrwtest.WriteInt64, nil},
{"uint32/fast path - minsize", uint32(2147483647), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"uint64/fast path - minsize", uint64(2147483647), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"uint/fast path - minsize", uint(2147483647), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"uint32/fast path - minsize too large", uint32(2147483648), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"uint64/fast path - minsize too large", uint64(2147483648), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"uint/fast path - minsize too large", uint(2147483648), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"uint64/fast path - overflow", uint64(1 << 63), nil, nil, bsonrwtest.Nothing, fmt.Errorf("%d overflows int64", uint64(1<<63))},
{"uint8/reflection path", myuint8(127), nil, nil, bsonrwtest.WriteInt32, nil},
{"uint16/reflection path", myuint16(32767), nil, nil, bsonrwtest.WriteInt32, nil},
{"uint32/reflection path", myuint32(2147483647), nil, nil, bsonrwtest.WriteInt64, nil},
{"uint64/reflection path", myuint64(1234567890987), nil, nil, bsonrwtest.WriteInt64, nil},
{"uint32/reflection path - minsize", myuint32(2147483647), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"uint64/reflection path - minsize", myuint64(2147483647), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"uint/reflection path - minsize", myuint(2147483647), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt32, nil},
{"uint32/reflection path - minsize too large", myuint(1 << 31), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"uint64/reflection path - minsize too large", myuint64(1 << 31), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"uint/reflection path - minsize too large", myuint(2147483648), &EncodeContext{MinSize: true}, nil, bsonrwtest.WriteInt64, nil},
{"uint64/reflection path - overflow", myuint64(1 << 63), nil, nil, bsonrwtest.Nothing, fmt.Errorf("%d overflows int64", uint64(1<<63))},
},
},
{
"FloatEncodeValue",
ValueEncoderFunc(dve.FloatEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "FloatEncodeValue",
Kinds: []reflect.Kind{reflect.Float32, reflect.Float64},
Received: reflect.ValueOf(wrong),
},
},
{"float32/fast path", float32(3.14159), nil, nil, bsonrwtest.WriteDouble, nil},
{"float64/fast path", float64(3.14159), nil, nil, bsonrwtest.WriteDouble, nil},
{"float32/reflection path", myfloat32(3.14159), nil, nil, bsonrwtest.WriteDouble, nil},
{"float64/reflection path", myfloat64(3.14159), nil, nil, bsonrwtest.WriteDouble, nil},
},
},
{
"TimeEncodeValue",
defaultTimeCodec,
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "TimeEncodeValue", Types: []reflect.Type{tTime}, Received: reflect.ValueOf(wrong)},
},
{"time.Time", now, nil, nil, bsonrwtest.WriteDateTime, nil},
},
},
{
"MapEncodeValue",
defaultMapCodec,
[]subtest{
{
"wrong kind",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "MapEncodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: reflect.ValueOf(wrong)},
},
{
"WriteDocument Error",
map[string]interface{}{},
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wd error"), ErrAfter: bsonrwtest.WriteDocument},
bsonrwtest.WriteDocument,
errors.New("wd error"),
},
{
"Lookup Error",
map[string]int{"foo": 1},
&EncodeContext{Registry: NewRegistryBuilder().Build()},
&bsonrwtest.ValueReaderWriter{},
bsonrwtest.WriteDocument,
fmt.Errorf("no encoder found for int"),
},
{
"WriteDocumentElement Error",
map[string]interface{}{"foo": "bar"},
&EncodeContext{Registry: buildDefaultRegistry()},
&bsonrwtest.ValueReaderWriter{Err: errors.New("wde error"), ErrAfter: bsonrwtest.WriteDocumentElement},
bsonrwtest.WriteDocumentElement,
errors.New("wde error"),
},
{
"EncodeValue Error",
map[string]interface{}{"foo": "bar"},
&EncodeContext{Registry: buildDefaultRegistry()},
&bsonrwtest.ValueReaderWriter{Err: errors.New("ev error"), ErrAfter: bsonrwtest.WriteString},
bsonrwtest.WriteString,
errors.New("ev error"),
},
{
"empty map/success",
map[string]interface{}{},
&EncodeContext{Registry: NewRegistryBuilder().Build()},
&bsonrwtest.ValueReaderWriter{},
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"with interface/success",
map[string]myInterface{"foo": myStruct{1}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"with interface/nil/success",
map[string]myInterface{"foo": nil},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"non-string key success",
map[int]interface{}{
1: "foobar",
},
&EncodeContext{Registry: buildDefaultRegistry()},
&bsonrwtest.ValueReaderWriter{},
bsonrwtest.WriteDocumentEnd,
nil,
},
},
},
{
"ArrayEncodeValue",
ValueEncoderFunc(dve.ArrayEncodeValue),
[]subtest{
{
"wrong kind",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "ArrayEncodeValue", Kinds: []reflect.Kind{reflect.Array}, Received: reflect.ValueOf(wrong)},
},
{
"WriteArray Error",
[1]string{},
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wa error"), ErrAfter: bsonrwtest.WriteArray},
bsonrwtest.WriteArray,
errors.New("wa error"),
},
{
"Lookup Error",
[1]int{1},
&EncodeContext{Registry: NewRegistryBuilder().Build()},
&bsonrwtest.ValueReaderWriter{},
bsonrwtest.WriteArray,
fmt.Errorf("no encoder found for int"),
},
{
"WriteArrayElement Error",
[1]string{"foo"},
&EncodeContext{Registry: buildDefaultRegistry()},
&bsonrwtest.ValueReaderWriter{Err: errors.New("wae error"), ErrAfter: bsonrwtest.WriteArrayElement},
bsonrwtest.WriteArrayElement,
errors.New("wae error"),
},
{
"EncodeValue Error",
[1]string{"foo"},
&EncodeContext{Registry: buildDefaultRegistry()},
&bsonrwtest.ValueReaderWriter{Err: errors.New("ev error"), ErrAfter: bsonrwtest.WriteString},
bsonrwtest.WriteString,
errors.New("ev error"),
},
{
"[1]primitive.E/success",
[1]primitive.E{{"hello", "world"}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"[1]primitive.E/success",
[1]primitive.E{{"hello", nil}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"[1]interface/success",
[1]myInterface{myStruct{1}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteArrayEnd,
nil,
},
{
"[1]interface/nil/success",
[1]myInterface{nil},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteArrayEnd,
nil,
},
},
},
{
"SliceEncodeValue",
defaultSliceCodec,
[]subtest{
{
"wrong kind",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "SliceEncodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: reflect.ValueOf(wrong)},
},
{
"WriteArray Error",
[]string{},
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wa error"), ErrAfter: bsonrwtest.WriteArray},
bsonrwtest.WriteArray,
errors.New("wa error"),
},
{
"Lookup Error",
[]int{1},
&EncodeContext{Registry: NewRegistryBuilder().Build()},
&bsonrwtest.ValueReaderWriter{},
bsonrwtest.WriteArray,
fmt.Errorf("no encoder found for int"),
},
{
"WriteArrayElement Error",
[]string{"foo"},
&EncodeContext{Registry: buildDefaultRegistry()},
&bsonrwtest.ValueReaderWriter{Err: errors.New("wae error"), ErrAfter: bsonrwtest.WriteArrayElement},
bsonrwtest.WriteArrayElement,
errors.New("wae error"),
},
{
"EncodeValue Error",
[]string{"foo"},
&EncodeContext{Registry: buildDefaultRegistry()},
&bsonrwtest.ValueReaderWriter{Err: errors.New("ev error"), ErrAfter: bsonrwtest.WriteString},
bsonrwtest.WriteString,
errors.New("ev error"),
},
{
"D/success",
primitive.D{{"hello", "world"}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"D/success",
primitive.D{{"hello", nil}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"empty slice/success",
[]interface{}{},
&EncodeContext{Registry: NewRegistryBuilder().Build()},
&bsonrwtest.ValueReaderWriter{},
bsonrwtest.WriteArrayEnd,
nil,
},
{
"interface/success",
[]myInterface{myStruct{1}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteArrayEnd,
nil,
},
{
"interface/success",
[]myInterface{nil},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteArrayEnd,
nil,
},
},
},
{
"ObjectIDEncodeValue",
ValueEncoderFunc(dve.ObjectIDEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "ObjectIDEncodeValue", Types: []reflect.Type{tOID}, Received: reflect.ValueOf(wrong)},
},
{
"primitive.ObjectID/success",
primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C},
nil, nil, bsonrwtest.WriteObjectID, nil,
},
},
},
{
"Decimal128EncodeValue",
ValueEncoderFunc(dve.Decimal128EncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "Decimal128EncodeValue", Types: []reflect.Type{tDecimal}, Received: reflect.ValueOf(wrong)},
},
{"Decimal128/success", d128, nil, nil, bsonrwtest.WriteDecimal128, nil},
},
},
{
"JSONNumberEncodeValue",
ValueEncoderFunc(dve.JSONNumberEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "JSONNumberEncodeValue", Types: []reflect.Type{tJSONNumber}, Received: reflect.ValueOf(wrong)},
},
{
"json.Number/invalid",
json.Number("hello world"),
nil, nil, bsonrwtest.Nothing, errors.New(`strconv.ParseFloat: parsing "hello world": invalid syntax`),
},
{
"json.Number/int64/success",
json.Number("1234567890"),
nil, nil, bsonrwtest.WriteInt64, nil,
},
{
"json.Number/float64/success",
json.Number("3.14159"),
nil, nil, bsonrwtest.WriteDouble, nil,
},
},
},
{
"URLEncodeValue",
ValueEncoderFunc(dve.URLEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "URLEncodeValue", Types: []reflect.Type{tURL}, Received: reflect.ValueOf(wrong)},
},
{"url.URL", url.URL{Scheme: "http", Host: "example.com"}, nil, nil, bsonrwtest.WriteString, nil},
},
},
{
"ByteSliceEncodeValue",
defaultByteSliceCodec,
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "ByteSliceEncodeValue", Types: []reflect.Type{tByteSlice}, Received: reflect.ValueOf(wrong)},
},
{"[]byte", []byte{0x01, 0x02, 0x03}, nil, nil, bsonrwtest.WriteBinary, nil},
{"[]byte/nil", []byte(nil), nil, nil, bsonrwtest.WriteNull, nil},
},
},
{
"EmptyInterfaceEncodeValue",
defaultEmptyInterfaceCodec,
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "EmptyInterfaceEncodeValue", Types: []reflect.Type{tEmpty}, Received: reflect.ValueOf(wrong)},
},
},
},
{
"ValueMarshalerEncodeValue",
ValueEncoderFunc(dve.ValueMarshalerEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "ValueMarshalerEncodeValue",
Types: []reflect.Type{tValueMarshaler},
Received: reflect.ValueOf(wrong),
},
},
{
"MarshalBSONValue error",
testValueMarshaler{err: errors.New("mbsonv error")},
nil,
nil,
bsonrwtest.Nothing,
errors.New("mbsonv error"),
},
{
"Copy error",
testValueMarshaler{},
nil,
nil,
bsonrwtest.Nothing,
fmt.Errorf("Cannot copy unknown BSON type %s", bsontype.Type(0)),
},
{
"success struct implementation",
testValueMarshaler{t: bsontype.String, buf: []byte{0x04, 0x00, 0x00, 0x00, 'f', 'o', 'o', 0x00}},
nil,
nil,
bsonrwtest.WriteString,
nil,
},
{
"success ptr to struct implementation",
&testValueMarshaler{t: bsontype.String, buf: []byte{0x04, 0x00, 0x00, 0x00, 'f', 'o', 'o', 0x00}},
nil,
nil,
bsonrwtest.WriteString,
nil,
},
{
"success nil ptr to struct implementation",
nilValueMarshaler,
nil,
nil,
bsonrwtest.WriteNull,
nil,
},
{
"success ptr to ptr implementation",
&testValueMarshalPtr{t: bsontype.String, buf: []byte{0x04, 0x00, 0x00, 0x00, 'f', 'o', 'o', 0x00}},
nil,
nil,
bsonrwtest.WriteString,
nil,
},
{
"unaddressable ptr implementation",
testValueMarshalPtr{t: bsontype.String, buf: []byte{0x04, 0x00, 0x00, 0x00, 'f', 'o', 'o', 0x00}},
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "ValueMarshalerEncodeValue",
Types: []reflect.Type{tValueMarshaler},
Received: reflect.ValueOf(testValueMarshalPtr{}),
},
},
},
},
{
"MarshalerEncodeValue",
ValueEncoderFunc(dve.MarshalerEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "MarshalerEncodeValue", Types: []reflect.Type{tMarshaler}, Received: reflect.ValueOf(wrong)},
},
{
"MarshalBSON error",
testMarshaler{err: errors.New("mbson error")},
nil,
nil,
bsonrwtest.Nothing,
errors.New("mbson error"),
},
{
"success struct implementation",
testMarshaler{buf: bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159))},
nil,
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"success ptr to struct implementation",
&testMarshaler{buf: bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159))},
nil,
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"success nil ptr to struct implementation",
nilMarshaler,
nil,
nil,
bsonrwtest.WriteNull,
nil,
},
{
"success ptr to ptr implementation",
&testMarshalPtr{buf: bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159))},
nil,
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"unaddressable ptr implementation",
testMarshalPtr{buf: bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159))},
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "MarshalerEncodeValue", Types: []reflect.Type{tMarshaler}, Received: reflect.ValueOf(testMarshalPtr{})},
},
},
},
{
"ProxyEncodeValue",
ValueEncoderFunc(dve.ProxyEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "ProxyEncodeValue", Types: []reflect.Type{tProxy}, Received: reflect.ValueOf(wrong)},
},
{
"Proxy error",
testProxy{err: errors.New("proxy error")},
nil,
nil,
bsonrwtest.Nothing,
errors.New("proxy error"),
},
{
"Lookup error",
testProxy{ret: nil},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.Nothing,
ErrNoEncoder{Type: nil},
},
{
"success struct implementation",
testProxy{ret: int64(1234567890)},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteInt64,
nil,
},
{
"success ptr to struct implementation",
&testProxy{ret: int64(1234567890)},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteInt64,
nil,
},
{
"success nil ptr to struct implementation",
nilProxy,
nil,
nil,
bsonrwtest.WriteNull,
nil,
},
{
"success ptr to ptr implementation",
&testProxyPtr{ret: int64(1234567890)},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteInt64,
nil,
},
{
"unaddressable ptr implementation",
testProxyPtr{ret: int64(1234567890)},
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "ProxyEncodeValue", Types: []reflect.Type{tProxy}, Received: reflect.ValueOf(testProxyPtr{})},
},
},
},
{
"PointerCodec.EncodeValue",
NewPointerCodec(),
[]subtest{
{
"nil",
nil,
nil,
nil,
bsonrwtest.WriteNull,
nil,
},
{
"not pointer",
int32(123456),
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "PointerCodec.EncodeValue", Kinds: []reflect.Kind{reflect.Ptr}, Received: reflect.ValueOf(int32(123456))},
},
{
"typed nil",
(*int32)(nil),
nil,
nil,
bsonrwtest.WriteNull,
nil,
},
{
"no encoder",
&wrong,
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.Nothing,
ErrNoEncoder{Type: reflect.TypeOf(wrong)},
},
},
},
{
"pointer implementation addressable interface",
NewPointerCodec(),
[]subtest{
{
"ValueMarshaler",
&vmStruct,
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"Marshaler",
&mStruct,
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"Proxy",
&pStruct,
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
},
},
{
"JavaScriptEncodeValue",
ValueEncoderFunc(dve.JavaScriptEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "JavaScriptEncodeValue", Types: []reflect.Type{tJavaScript}, Received: reflect.ValueOf(wrong)},
},
{"JavaScript", primitive.JavaScript("foobar"), nil, nil, bsonrwtest.WriteJavascript, nil},
},
},
{
"SymbolEncodeValue",
ValueEncoderFunc(dve.SymbolEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "SymbolEncodeValue", Types: []reflect.Type{tSymbol}, Received: reflect.ValueOf(wrong)},
},
{"Symbol", primitive.Symbol("foobar"), nil, nil, bsonrwtest.WriteSymbol, nil},
},
},
{
"BinaryEncodeValue",
ValueEncoderFunc(dve.BinaryEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "BinaryEncodeValue", Types: []reflect.Type{tBinary}, Received: reflect.ValueOf(wrong)},
},
{"Binary/success", primitive.Binary{Data: []byte{0x01, 0x02}, Subtype: 0xFF}, nil, nil, bsonrwtest.WriteBinaryWithSubtype, nil},
},
},
{
"UndefinedEncodeValue",
ValueEncoderFunc(dve.UndefinedEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "UndefinedEncodeValue", Types: []reflect.Type{tUndefined}, Received: reflect.ValueOf(wrong)},
},
{"Undefined/success", primitive.Undefined{}, nil, nil, bsonrwtest.WriteUndefined, nil},
},
},
{
"DateTimeEncodeValue",
ValueEncoderFunc(dve.DateTimeEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "DateTimeEncodeValue", Types: []reflect.Type{tDateTime}, Received: reflect.ValueOf(wrong)},
},
{"DateTime/success", primitive.DateTime(1234567890), nil, nil, bsonrwtest.WriteDateTime, nil},
},
},
{
"NullEncodeValue",
ValueEncoderFunc(dve.NullEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "NullEncodeValue", Types: []reflect.Type{tNull}, Received: reflect.ValueOf(wrong)},
},
{"Null/success", primitive.Null{}, nil, nil, bsonrwtest.WriteNull, nil},
},
},
{
"RegexEncodeValue",
ValueEncoderFunc(dve.RegexEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "RegexEncodeValue", Types: []reflect.Type{tRegex}, Received: reflect.ValueOf(wrong)},
},
{"Regex/success", primitive.Regex{Pattern: "foo", Options: "bar"}, nil, nil, bsonrwtest.WriteRegex, nil},
},
},
{
"DBPointerEncodeValue",
ValueEncoderFunc(dve.DBPointerEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "DBPointerEncodeValue", Types: []reflect.Type{tDBPointer}, Received: reflect.ValueOf(wrong)},
},
{
"DBPointer/success",
primitive.DBPointer{
DB: "foobar",
Pointer: primitive.ObjectID{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C},
},
nil, nil, bsonrwtest.WriteDBPointer, nil,
},
},
},
{
"TimestampEncodeValue",
ValueEncoderFunc(dve.TimestampEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "TimestampEncodeValue", Types: []reflect.Type{tTimestamp}, Received: reflect.ValueOf(wrong)},
},
{"Timestamp/success", primitive.Timestamp{T: 12345, I: 67890}, nil, nil, bsonrwtest.WriteTimestamp, nil},
},
},
{
"MinKeyEncodeValue",
ValueEncoderFunc(dve.MinKeyEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "MinKeyEncodeValue", Types: []reflect.Type{tMinKey}, Received: reflect.ValueOf(wrong)},
},
{"MinKey/success", primitive.MinKey{}, nil, nil, bsonrwtest.WriteMinKey, nil},
},
},
{
"MaxKeyEncodeValue",
ValueEncoderFunc(dve.MaxKeyEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{Name: "MaxKeyEncodeValue", Types: []reflect.Type{tMaxKey}, Received: reflect.ValueOf(wrong)},
},
{"MaxKey/success", primitive.MaxKey{}, nil, nil, bsonrwtest.WriteMaxKey, nil},
},
},
{
"CoreDocumentEncodeValue",
ValueEncoderFunc(dve.CoreDocumentEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "CoreDocumentEncodeValue",
Types: []reflect.Type{tCoreDocument},
Received: reflect.ValueOf(wrong),
},
},
{
"WriteDocument Error",
bsoncore.Document{},
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wd error"), ErrAfter: bsonrwtest.WriteDocument},
bsonrwtest.WriteDocument,
errors.New("wd error"),
},
{
"bsoncore.Document.Elements Error",
bsoncore.Document{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",
bsoncore.Document(buildDocument(bsoncore.AppendNullElement(nil, "foo"))),
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wde error"), ErrAfter: bsonrwtest.WriteDocumentElement},
bsonrwtest.WriteDocumentElement,
errors.New("wde error"),
},
{
"encodeValue error",
bsoncore.Document(buildDocument(bsoncore.AppendNullElement(nil, "foo"))),
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("ev error"), ErrAfter: bsonrwtest.WriteNull},
bsonrwtest.WriteNull,
errors.New("ev error"),
},
{
"iterator error",
bsoncore.Document{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"),
},
},
},
{
"StructEncodeValue",
defaultTestStructCodec,
[]subtest{
{
"interface value",
struct{ Foo myInterface }{Foo: myStruct{1}},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
{
"nil interface value",
struct{ Foo myInterface }{Foo: nil},
&EncodeContext{Registry: buildDefaultRegistry()},
nil,
bsonrwtest.WriteDocumentEnd,
nil,
},
},
},
{
"CodeWithScopeEncodeValue",
ValueEncoderFunc(dve.CodeWithScopeEncodeValue),
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "CodeWithScopeEncodeValue",
Types: []reflect.Type{tCodeWithScope},
Received: reflect.ValueOf(wrong),
},
},
{
"WriteCodeWithScope error",
primitive.CodeWithScope{},
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wcws error"), ErrAfter: bsonrwtest.WriteCodeWithScope},
bsonrwtest.WriteCodeWithScope,
errors.New("wcws error"),
},
{
"CodeWithScope/success",
primitive.CodeWithScope{
Code: "var hello = 'world';",
Scope: primitive.D{},
},
&EncodeContext{Registry: buildDefaultRegistry()},
nil, bsonrwtest.WriteDocumentEnd, nil,
},
},
},
{
"CoreArrayEncodeValue",
defaultArrayCodec,
[]subtest{
{
"wrong type",
wrong,
nil,
nil,
bsonrwtest.Nothing,
ValueEncoderError{
Name: "CoreArrayEncodeValue",
Types: []reflect.Type{tCoreArray},
Received: reflect.ValueOf(wrong),
},
},
{
"WriteArray Error",
bsoncore.Array{},
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wa error"), ErrAfter: bsonrwtest.WriteArray},
bsonrwtest.WriteArray,
errors.New("wa error"),
},
{
"WriteArrayElement Error",
bsoncore.Array(buildDocumentArray(func(doc []byte) []byte {
return bsoncore.AppendNullElement(nil, "foo")
})),
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("wae error"), ErrAfter: bsonrwtest.WriteArrayElement},
bsonrwtest.WriteArrayElement,
errors.New("wae error"),
},
{
"encodeValue error",
bsoncore.Array(buildDocumentArray(func(doc []byte) []byte {
return bsoncore.AppendNullElement(nil, "foo")
})),
nil,
&bsonrwtest.ValueReaderWriter{Err: errors.New("ev error"), ErrAfter: bsonrwtest.WriteNull},
bsonrwtest.WriteNull,
errors.New("ev error"),
},
},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
for _, subtest := range tc.subtests {
t.Run(subtest.name, func(t *testing.T) {
var ec 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) {
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},
buildDocument(bsoncore.AppendObjectIDElement(nil, "foo", oid)),
nil,
},
{
"map[string][]int32",
map[string][]int32{"Z": {1, 2, 3}},
buildDocumentArray(func(doc []byte) []byte {
doc = bsoncore.AppendInt32Element(doc, "0", 1)
doc = bsoncore.AppendInt32Element(doc, "1", 2)
return bsoncore.AppendInt32Element(doc, "2", 3)
}),
nil,
},
{
"map[string][]primitive.ObjectID",
map[string][]primitive.ObjectID{"Z": oids},
buildDocumentArray(func(doc []byte) []byte {
doc = bsoncore.AppendObjectIDElement(doc, "0", oids[0])
doc = bsoncore.AppendObjectIDElement(doc, "1", oids[1])
return bsoncore.AppendObjectIDElement(doc, "2", oids[2])
}),
nil,
},
{
"map[string][]json.Number(int64)",
map[string][]json.Number{"Z": {json.Number("5"), json.Number("10")}},
buildDocumentArray(func(doc []byte) []byte {
doc = bsoncore.AppendInt64Element(doc, "0", 5)
return bsoncore.AppendInt64Element(doc, "1", 10)
}),
nil,
},
{
"map[string][]json.Number(float64)",
map[string][]json.Number{"Z": {json.Number("5"), json.Number("10.1")}},
buildDocumentArray(func(doc []byte) []byte {
doc = bsoncore.AppendInt64Element(doc, "0", 5)
return bsoncore.AppendDoubleElement(doc, "1", 10.1)
}),
nil,
},
{
"map[string][]*url.URL",
map[string][]*url.URL{"Z": {murl}},
buildDocumentArray(func(doc []byte) []byte {
return bsoncore.AppendStringElement(doc, "0", murl.String())
}),
nil,
},
{
"map[string][]primitive.Decimal128",
map[string][]primitive.Decimal128{"Z": {decimal128}},
buildDocumentArray(func(doc []byte) []byte {
return bsoncore.AppendDecimal128Element(doc, "0", decimal128)
}),
nil,
},
{
"-",
struct {
A string `bson:"-"`
}{
A: "",
},
[]byte{0x05, 0x00, 0x00, 0x00, 0x00},
nil,
},
{
"omitempty",
struct {
A string `bson:",omitempty"`
}{
A: "",
},
[]byte{0x05, 0x00, 0x00, 0x00, 0x00},
nil,
},
{
"omitempty, empty time",
struct {
A time.Time `bson:",omitempty"`
}{
A: time.Time{},
},
[]byte{0x05, 0x00, 0x00, 0x00, 0x00},
nil,
},
{
"no private fields",
noPrivateFields{a: "should be empty"},
[]byte{0x05, 0x00, 0x00, 0x00, 0x00},
nil,
},
{
"minsize",
struct {
A int64 `bson:",minsize"`
}{
A: 12345,
},
buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)),
nil,
},
{
"inline",
struct {
Foo struct {
A int64 `bson:",minsize"`
} `bson:",inline"`
}{
Foo: struct {
A int64 `bson:",minsize"`
}{
A: 12345,
},
},
buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)),
nil,
},
{
"inline struct pointer",
struct {
Foo *struct {
A int64 `bson:",minsize"`
} `bson:",inline"`
Bar *struct {
B int64
} `bson:",inline"`
}{
Foo: &struct {
A int64 `bson:",minsize"`
}{
A: 12345,
},
Bar: nil,
},
buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)),
nil,
},
{
"nested inline struct pointer",
struct {
Foo *struct {
Bar *struct {
A int64 `bson:",minsize"`
} `bson:",inline"`
} `bson:",inline"`
}{
Foo: &struct {
Bar *struct {
A int64 `bson:",minsize"`
} `bson:",inline"`
}{
Bar: &struct {
A int64 `bson:",minsize"`
}{
A: 12345,
},
},
},
buildDocument(bsoncore.AppendInt32Element(nil, "a", 12345)),
nil,
},
{
"inline nil struct pointer",
struct {
Foo *struct {
A int64 `bson:",minsize"`
} `bson:",inline"`
}{
Foo: nil,
},
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 {
Foo map[string]string `bson:",inline"`
}{
Foo: map[string]string{"foo": "bar"},
},
buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar")),
nil,
},
{
"alternate name bson:name",
struct {
A string `bson:"foo"`
}{
A: "bar",
},
buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar")),
nil,
},
{
"alternate name",
struct {
A string `bson:"foo"`
}{
A: "bar",
},
buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar")),
nil,
},
{
"inline, omitempty",
struct {
A string
Foo zeroTest `bson:"omitempty,inline"`
}{
A: "bar",
Foo: zeroTest{true},
},
buildDocument(bsoncore.AppendStringElement(nil, "a", "bar")),
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
}
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 Proxy
AG testProxy
AH map[string]interface{}
AI primitive.CodeWithScope
}{
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",
},
Q: oid,
T: nil,
Y: json.Number("5"),
Z: now,
AA: json.Number("10.1"),
AB: murl,
AC: decimal128,
AD: &now,
AE: testValueMarshaler{t: bsontype.String, buf: bsoncore.AppendString(nil, "hello, world")},
AF: testProxy{ret: struct{ Hello string }{Hello: "world!"}},
AG: testProxy{ret: struct{ Pi float64 }{Pi: 3.14159}},
AH: nil,
AI: primitive.CodeWithScope{Code: "var hello = 'world';", Scope: primitive.D{{"pi", 3.14159}}},
},
buildDocument(func(doc []byte) []byte {
doc = bsoncore.AppendBooleanElement(doc, "a", true)
doc = bsoncore.AppendInt32Element(doc, "b", 123)
doc = bsoncore.AppendInt64Element(doc, "c", 456)
doc = bsoncore.AppendInt32Element(doc, "d", 789)
doc = bsoncore.AppendInt64Element(doc, "e", 101112)
doc = bsoncore.AppendDoubleElement(doc, "f", 3.14159)
doc = bsoncore.AppendStringElement(doc, "g", "Hello, world")
doc = bsoncore.AppendDocumentElement(doc, "h", buildDocument(bsoncore.AppendStringElement(nil, "foo", "bar")))
doc = bsoncore.AppendBinaryElement(doc, "i", 0x00, []byte{0x01, 0x02, 0x03})
doc = bsoncore.AppendArrayElement(doc, "k",
buildArray(bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "baz"), "1", "qux")),
)
doc = bsoncore.AppendDocumentElement(doc, "l", buildDocument(bsoncore.AppendStringElement(nil, "m", "foobar")))
doc = bsoncore.AppendObjectIDElement(doc, "q", oid)
doc = bsoncore.AppendNullElement(doc, "t")
doc = bsoncore.AppendInt64Element(doc, "y", 5)
doc = bsoncore.AppendDateTimeElement(doc, "z", now.UnixNano()/int64(time.Millisecond))
doc = bsoncore.AppendDoubleElement(doc, "aa", 10.1)
doc = bsoncore.AppendStringElement(doc, "ab", murl.String())
doc = bsoncore.AppendDecimal128Element(doc, "ac", decimal128)
doc = bsoncore.AppendDateTimeElement(doc, "ad", now.UnixNano()/int64(time.Millisecond))
doc = bsoncore.AppendStringElement(doc, "ae", "hello, world")
doc = bsoncore.AppendDocumentElement(doc, "af", buildDocument(bsoncore.AppendStringElement(nil, "hello", "world!")))
doc = bsoncore.AppendDocumentElement(doc, "ag", buildDocument(bsoncore.AppendDoubleElement(nil, "pi", 3.14159)))
doc = bsoncore.AppendNullElement(doc, "ah")
doc = bsoncore.AppendCodeWithScopeElement(doc, "ai",
"var hello = 'world';", buildDocument(bsoncore.AppendDoubleElement(nil, "pi", 3.14159)),
)
return doc
}(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
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 []Proxy
AG []testProxy
}{
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"}},
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: bsontype.String, buf: bsoncore.AppendString(nil, "hello")},
{t: bsontype.String, buf: bsoncore.AppendString(nil, "world")},
},
AF: []Proxy{
testProxy{ret: struct{ Hello string }{Hello: "world!"}},
testProxy{ret: struct{ Foo string }{Foo: "bar"}},
},
AG: []testProxy{
{ret: struct{ One int64 }{One: 1234567890}},
{ret: struct{ Pi float64 }{Pi: 3.14159}},
},
},
buildDocument(func(doc []byte) []byte {
doc = appendArrayElement(doc, "a", bsoncore.AppendBooleanElement(nil, "0", true))
doc = appendArrayElement(doc, "b", bsoncore.AppendInt32Element(nil, "0", 123))
doc = appendArrayElement(doc, "c", bsoncore.AppendInt64Element(nil, "0", 456))
doc = appendArrayElement(doc, "d", bsoncore.AppendInt32Element(nil, "0", 789))
doc = appendArrayElement(doc, "e", bsoncore.AppendInt64Element(nil, "0", 101112))
doc = appendArrayElement(doc, "f", bsoncore.AppendDoubleElement(nil, "0", 3.14159))
doc = appendArrayElement(doc, "g", bsoncore.AppendStringElement(nil, "0", "Hello, world"))
doc = appendArrayElement(doc, "h", bsoncore.BuildDocumentElement(nil, "0", bsoncore.AppendStringElement(nil, "foo", "bar")))
doc = appendArrayElement(doc, "i", bsoncore.AppendBinaryElement(nil, "0", 0x00, []byte{0x01, 0x02, 0x03}))
doc = appendArrayElement(doc, "k",
appendArrayElement(nil, "0",
bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "baz"), "1", "qux")),
)
doc = appendArrayElement(doc, "l", bsoncore.BuildDocumentElement(nil, "0", bsoncore.AppendStringElement(nil, "m", "foobar")))
doc = appendArrayElement(doc, "n",
appendArrayElement(nil, "0",
bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "foo"), "1", "bar")),
)
doc = appendArrayElement(doc, "r",
bsoncore.AppendObjectIDElement(
bsoncore.AppendObjectIDElement(
bsoncore.AppendObjectIDElement(nil,
"0", oids[0]),
"1", oids[1]),
"2", oids[2]),
)
doc = bsoncore.AppendNullElement(doc, "t")
doc = bsoncore.AppendNullElement(doc, "w")
doc = appendArrayElement(doc, "x", nil)
doc = appendArrayElement(doc, "y", bsoncore.BuildDocumentElement(nil, "0", nil))
doc = appendArrayElement(doc, "z",
bsoncore.AppendDateTimeElement(
bsoncore.AppendDateTimeElement(
nil, "0", now.UnixNano()/int64(time.Millisecond)),
"1", now.UnixNano()/int64(time.Millisecond)),
)
doc = appendArrayElement(doc, "aa", bsoncore.AppendDoubleElement(bsoncore.AppendInt64Element(nil, "0", 5), "1", 10.10))
doc = appendArrayElement(doc, "ab", bsoncore.AppendStringElement(nil, "0", murl.String()))
doc = appendArrayElement(doc, "ac", bsoncore.AppendDecimal128Element(nil, "0", decimal128))
doc = appendArrayElement(doc, "ad",
bsoncore.AppendDateTimeElement(
bsoncore.AppendDateTimeElement(nil, "0", now.UnixNano()/int64(time.Millisecond)),
"1", now.UnixNano()/int64(time.Millisecond)),
)
doc = appendArrayElement(doc, "ae",
bsoncore.AppendStringElement(bsoncore.AppendStringElement(nil, "0", "hello"), "1", "world"),
)
doc = appendArrayElement(doc, "af",
bsoncore.AppendDocumentElement(
bsoncore.AppendDocumentElement(nil, "0",
bsoncore.BuildDocument(nil, bsoncore.AppendStringElement(nil, "hello", "world!")),
), "1",
bsoncore.BuildDocument(nil, bsoncore.AppendStringElement(nil, "foo", "bar")),
),
)
doc = appendArrayElement(doc, "ag",
bsoncore.AppendDocumentElement(
bsoncore.AppendDocumentElement(nil, "0",
bsoncore.BuildDocument(nil, bsoncore.AppendInt64Element(nil, "one", 1234567890)),
), "1",
bsoncore.BuildDocument(nil, bsoncore.AppendDoubleElement(nil, "pi", 3.14159)),
),
)
return doc
}(nil)),
nil,
},
}
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 !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", bsoncore.Document(b), bsoncore.Document(tc.b))
}
})
}
})
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)
err := dve.EmptyInterfaceEncodeValue(EncodeContext{Registry: NewRegistryBuilder().Build()}, llvrw, val)
noerr(t, err)
if llvrw.Invoked != bsonrwtest.WriteNull {
t.Errorf("Incorrect method called. got %v; want %v", llvrw.Invoked, bsonrwtest.WriteNull)
}
})
t.Run("EmptyInterfaceEncodeValue/LookupEncoder error", func(t *testing.T) {
val := reflect.New(tEmpty).Elem()
val.Set(reflect.ValueOf(int64(1234567890)))
llvrw := new(bsonrwtest.ValueReaderWriter)
got := dve.EmptyInterfaceEncodeValue(EncodeContext{Registry: NewRegistryBuilder().Build()}, llvrw, val)
want := ErrNoEncoder{Type: tInt64}
if !compareErrors(got, want) {
t.Errorf("Did not receive expected error. got %v; want %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 testValueMarshalPtr struct {
t bsontype.Type
buf []byte
err error
}
func (tvm *testValueMarshalPtr) MarshalBSONValue() (bsontype.Type, []byte, error) {
return tvm.t, tvm.buf, tvm.err
}
type testMarshaler struct {
buf []byte
err error
}
func (tvm testMarshaler) MarshalBSON() ([]byte, error) {
return tvm.buf, tvm.err
}
type testMarshalPtr struct {
buf []byte
err error
}
func (tvm *testMarshalPtr) MarshalBSON() ([]byte, error) {
return tvm.buf, tvm.err
}
type testProxy struct {
ret interface{}
err error
}
func (tp testProxy) ProxyBSON() (interface{}, error) { return tp.ret, tp.err }
type testProxyPtr struct {
ret interface{}
err error
}
func (tp *testProxyPtr) ProxyBSON() (interface{}, error) { return tp.ret, tp.err }