impl/memory: Fix time serialization encoding.

impl/memory/datastore_query_execution_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memory
 
 import (
         "fmt"
         "strings"
         "testing"
         "time"
 
+        "github.com/luci/gae/service/blobstore"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
+        "golang.org/x/net/context"
+
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
-        "golang.org/x/net/context"
 )
 
 type qExpect struct {
         q     *ds.Query
         inTxn bool
 
         get   []ds.PropertyMap
         keys  []*ds.Key
         count int
 }
@@ skipping 50 matching lines @@
         pmap("$key", key("Kind", 3, "Kind", 2), Next,
                 "Val", 3, 4, Next,
                 "Extra", "hello", "waffle",
         ),
         pmap("$key", key("Kind", 3, "Kind", 3), Next,
                 "Val", 3, 4, 2, 1, Next,
                 "Extra", "nuts",
         ),
 }
 
+var collapsedData = []ds.PropertyMap{
+        // PTTime
+        pmap("$key", key("Kind", 1), Next,
+                "Date", time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC), Next,
+        ),
+        pmap("$key", key("Kind", 2), Next,
+                "Date", time.Date(2000, time.March, 1, 1, 1, 1, 1, time.UTC), Next,
+        ),
+
+        // PTBlobKey
+        pmap("$key", key("Kind", 3), Next,
+                "Key", blobstore.Key("foo"), Next,
+        ),
+        pmap("$key", key("Kind", 4), Next,
+                "Key", blobstore.Key("qux"), Next,
+        ),
+
+        // PTBytes
+        pmap("$key", key("Kind", 5), Next,
+                "Val", []byte("ohai"), Next,
+        ),
+        pmap("$key", key("Kind", 6), Next,
+                "Val", []byte("uwutm8"), Next,
+        ),
+}
+
 var queryExecutionTests = []qExTest{
         {"basic", []qExStage{
                 {
                         addIdxs: []*ds.IndexDefinition{
                                 indx("Unrelated", "-thing", "bob", "-__key__"),
                                 indx("Wat", "deep", "opt", "other"),
                                 indx("Wat", "meep", "opt", "other"),
                         },
                 },
 
@@ skipping 280 matching lines @@
                                 {q: nq("Unique").Gt("__key__", key("AKind", 5)).Lte("__key__", key("Zeta", "prime")),
                                         keys: []*ds.Key{key("Unique", 1)},
                                         get:  []ds.PropertyMap{}},
 
                                 {q: nq("Kind").Eq("Val", 1, 3), get: []ds.PropertyMap{
                                         stage1Data[0], stage2Data[2],
                                 }},
                         },
                 },
         }},
+        {"collapsed types", []qExStage{
+                {
+                        putEnts: collapsedData,
+                },
+                {
+                        expect: []qExpect{
+                                // PTTime
+                                {
+                                        q: nq("Kind").Lte("Date", time.Date(2000, time.February, 1, 1, 1, 1, 1, time.UTC)),
+                                        get: []ds.PropertyMap{
+                                                collapsedData[0],
+                                        },
+                                },
+                                {
+                                        q: nq("Kind").Eq("Date", time.Date(2000, time.March, 1, 1, 1, 1, 1, time.UTC)),
+                                        get: []ds.PropertyMap{
+                                                collapsedData[1],
+                                        },
+                                },
+
+                                // PTBlobKey
+                                {
+                                        q: nq("Kind").Lte("Key", blobstore.Key("foo")),
+                                        get: []ds.PropertyMap{
+                                                collapsedData[2],
+                                        },
+                                },
+                                {
+                                        q: nq("Kind").Eq("Key", blobstore.Key("qux")),
+                                        get: []ds.PropertyMap{
+                                                collapsedData[3],
+                                        },
+                                },
+
+                                // PTBytes
+                                {
+                                        q: nq("Kind").Lte("Val", []byte("ohai")),
+                                        get: []ds.PropertyMap{
+                                                collapsedData[4],
+                                        },
+                                },
+                                {
+                                        q: nq("Kind").Eq("Val", []byte("uwutm8")),
+                                        get: []ds.PropertyMap{
+                                                collapsedData[5],
+                                        },
+                                },
+                        },
+                },
+        }},
 }
 
 func TestQueryExecution(t *testing.T) {
         t.Parallel()
 
         Convey("Test query execution", t, func() {
                 c, err := info.Get(Use(context.Background())).Namespace("ns")
                 if err != nil {
                         panic(err)
                 }
@@ skipping 63 matching lines @@
                                                                         err := runner(func(c context.Context) error {
                                                                                 data := ds.Get(c)
                                                                                 count, err := data.Count(expect.q)
                                                                                 So(err, ShouldBeNil)
                                                                                 So(count, ShouldEqual, expect.count)
 
                                                                                 rslt := []ds.PropertyMap(nil)
                                                                                 So(data.GetAll(expect.q, &rslt), ShouldBeNil)
                                                                                 So(len(rslt), ShouldEqual, len(expect.get))
                                                                                 for i, r := range rslt {
-                                                                                        So(r, ShouldResemble, expect.get[i])
+                                                                                        So(r, ShouldResembleV, expect.get[i])
                                                                                 }
                                                                                 return nil
                                                                         }, &ds.TransactionOptions{XG: true})
                                                                         So(err, ShouldBeNil)
                                                                 })
                                                         }
                                                 }
 
                                                 for j, fn := range stage.extraFns {
                                                         Convey(fmt.Sprintf("extraFn %d", j), func() {
@@ skipping 31 matching lines @@
                 count, err := data.Count(q)
                 So(err, ShouldErrLike, "Insufficient indexes")
 
                 testing.AutoIndex(true)
 
                 count, err = data.Count(q)
                 So(err, ShouldBeNil)
                 So(count, ShouldEqual, 2)
         })
 }