GODRIVER-406: roundtrip zero values of time.Time

Change-Id: Ifb94fb1013489a888a10a188cc877779d90b09fd

Author: Sam Kleinman

bson/bson_test.go

@@ -10,6 +10,9 @@ import (
 	"encoding/binary"
 	"math"
 	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestValue(t *testing.T) {
@@ -102,3 +105,27 @@ func TestValue(t *testing.T) {
 	})
 	t.Run("document", func(t *testing.T) {})
 }
+
+func TestTimeRoundTrip(t *testing.T) {
+	val := struct {
+		Value time.Time
+		ID    string
+	}{
+		ID: "time-rt-test",
+	}
+
+	assert.True(t, val.Value.IsZero())
+
+	bsonOut, err := Marshal(val)
+	assert.NoError(t, err)
+	rtval := struct {
+		Value time.Time
+		ID    string
+	}{}
+
+	err = Unmarshal(bsonOut, &rtval)
+	assert.NoError(t, err)
+	assert.Equal(t, val, rtval)
+	assert.True(t, rtval.Value.IsZero())
+
+}

bson/decode.go

@@ -54,6 +54,12 @@ var tEmptySlice = reflect.TypeOf([]interface{}(nil))
 
 var zeroVal reflect.Value
 
+// this references the quantity of milliseconds between zero time and
+// the unix epoch. useful for making sure that we convert time.Time
+// objects correctly to match the legacy bson library's handling of
+// time.Time values.
+const zeroEpochMs = int64(62135596800000)
+
 // Unmarshaler describes a type that can unmarshal itself from BSON bytes.
 type Unmarshaler interface {
 	UnmarshalBSON([]byte) error
@@ -474,7 +480,11 @@ func (d *Decoder) getReflectValue(v *Value, containerType reflect.Type, outer re
 			return val, nil
 		}
 
-		val = reflect.ValueOf(v.DateTime())
+		if int64(v.getUint64()) == -zeroEpochMs {
+			val = reflect.ValueOf(time.Time{})
+		} else {
+			val = reflect.ValueOf(v.DateTime())
+		}
 	case 0xA:
 		if containerType != tEmpty {
 			return val, nil

bson/encode.go

@@ -437,6 +437,9 @@ func (e *encoder) encodeSliceAsArray(rval reflect.Value, minsize bool) ([]*Value
 		case decimal.Decimal128:
 			vals = append(vals, VC.Decimal128(t))
 			continue
+		case time.Time:
+			vals = append(vals, VC.DateTime(t.Unix()*1000+int64(t.Nanosecond()/1e6)))
+			continue
 		}
 
 		sval = e.underlyingVal(sval)
@@ -513,6 +516,9 @@ func (e *encoder) encodeStruct(val reflect.Value) ([]*Element, error) {
 		case decimal.Decimal128:
 			elems = append(elems, EC.Decimal128(key, t))
 			continue
+		case time.Time:
+			elems = append(elems, EC.DateTime(key, t.Unix()*1000+int64(t.Nanosecond()/1e6)))
+			continue
 		}
 		field = e.underlyingVal(field)
 
@@ -659,18 +665,11 @@ func (e *encoder) elemFromValue(key string, val reflect.Value, minsize bool) (*E
 			elem = EC.ArrayFromElements(key, arrayElems...)
 		}
 	case reflect.Struct:
-		switch val.Interface().(type) {
-		case time.Time:
-			t := val.Interface().(time.Time)
-
-			elem = EC.DateTime(key, t.UnixNano()/int64(time.Millisecond))
-		default:
-			structElems, err := e.encodeStruct(val)
-			if err != nil {
-				return nil, err
-			}
-			elem = EC.SubDocumentFromElements(key, structElems...)
+		structElems, err := e.encodeStruct(val)
+		if err != nil {
+			return nil, err
 		}
+		elem = EC.SubDocumentFromElements(key, structElems...)
 	default:
 		return nil, fmt.Errorf("Unsupported value type %s", val.Kind())
 	}
@@ -763,18 +762,11 @@ func (e *encoder) valueFromValue(val reflect.Value, minsize bool) (*Value, error
 			elem = VC.ArrayFromValues(arrayElems...)
 		}
 	case reflect.Struct:
-		switch val.Interface().(type) {
-		case time.Time:
-			t := val.Interface().(time.Time)
-
-			elem = VC.DateTime(t.UnixNano() / int64(time.Millisecond))
-		default:
-			structElems, err := e.encodeStruct(val)
-			if err != nil {
-				return nil, err
-			}
-			elem = VC.DocumentFromElements(structElems...)
+		structElems, err := e.encodeStruct(val)
+		if err != nil {
+			return nil, err
 		}
+		elem = VC.DocumentFromElements(structElems...)
 	default:
 		return nil, fmt.Errorf("Unsupported value type %s", val.Kind())
 	}

bson/value.go

@@ -373,8 +373,7 @@ func (v *Value) Double() float64 {
 	if v.data[v.start] != '\x01' {
 		panic(ElementTypeError{"compact.Element.double", Type(v.data[v.start])})
 	}
-	bits := binary.LittleEndian.Uint64(v.data[v.offset : v.offset+8])
-	return math.Float64frombits(bits)
+	return math.Float64frombits(v.getUint64())
 }
 
 // DoubleOK is the same as Double, but returns a boolean instead of panicking.
@@ -608,7 +607,7 @@ func (v *Value) DateTime() time.Time {
 	if v.data[v.start] != '\x09' {
 		panic(ElementTypeError{"compact.Element.dateTime", Type(v.data[v.start])})
 	}
-	i := binary.LittleEndian.Uint64(v.data[v.offset : v.offset+8])
+	i := v.getUint64()
 	return time.Unix(int64(i)/1000, int64(i)%1000*1000000)
 }
 
@@ -840,7 +839,11 @@ func (v *Value) Int64() int64 {
 	if v.data[v.start] != '\x12' {
 		panic(ElementTypeError{"compact.Element.int64Type", Type(v.data[v.start])})
 	}
-	return int64(binary.LittleEndian.Uint64(v.data[v.offset : v.offset+8]))
+	return int64(v.getUint64())
+}
+
+func (v *Value) getUint64() uint64 {
+	return binary.LittleEndian.Uint64(v.data[v.offset : v.offset+8])
 }
 
 // Int64OK is the same as Int64, except that it returns a boolean instead of