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"
@@ skipping 52 matching lines @@
         ),
         pmap("$key", key("Kind", 3, "Child", "seven"), Next,
                 "Interesting", 28, Next,
                 "Extra", "hello",
         ),
         pmap("$key", key("Unique", 1), Next,
                 "Derp", 39,
         ),
 }
 
+var stage1Data3Enc = pmap("$key", key("Kind", 6), Next,
+        "Val", 5, 3, 2, Next,
+        "When", 946688461000000, Next,
+        "Extra", "waffle",
+)
+
 var stage2Data = []ds.PropertyMap{
         pmap("$key", key("Kind", 3, "Kind", 1), Next,
                 "Val", 2, 4, 28, Next,
                 "Extra", "hello", "waffle",
         ),
         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 timeData = []ds.PropertyMap{
+        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,
+        ),
+}
+
 var queryExecutionTests = []qExTest{
         {"basic", []qExStage{
                 {
                         addIdxs: []*ds.IndexDefinition{
                                 indx("Unrelated", "-thing", "bob", "-__key__"),
                                 indx("Wat", "deep", "opt", "other"),
                                 indx("Wat", "meep", "opt", "other"),
                         },
                 },
 
@@ skipping 25 matching lines @@
 
                 {
                         putEnts: stage2Data,
                         delEnts: []*ds.Key{key("Unique", 1)},
                         addIdxs: []*ds.IndexDefinition{
                                 indx("Kind!", "-Extra", "-Val"),
                                 indx("Kind!", "-Extra", "-Val", "-__key__"),
                                 indx("Kind!", "Bogus", "Extra", "-Val"),
                         },
                         expect: []qExpect{
-                                {q: nq("Kind"), get: stage1Data[:4]},
+                                {q: nq("Kind"), get: []ds.PropertyMap{
+                                        stage1Data[0], stage1Data[1], stage1Data[2], stage1Data3Enc,
+                                }},
 
                                 {q: nq("Kind").Offset(2).Limit(1), get: []ds.PropertyMap{
                                         stage1Data[2],
                                 }},
 
                                 {q: nq("Missing"), get: []ds.PropertyMap{}},
 
                                 {q: nq("Missing").Eq("Bogus", 3), get: []ds.PropertyMap{}},
 
                                 {q: nq("Kind").Eq("Extra", "waffle"), get: []ds.PropertyMap{
-                                        stage1Data[2], stage1Data[3],
+                                        stage1Data[2], stage1Data3Enc,
                                 }},
 
                                 // get ziggy with it
                                 {q: nq("Kind").Eq("Extra", "waffle").Eq("Val", 100), get: []ds.PropertyMap{
                                         stage1Data[2],
                                 }},
 
                                 {q: nq("Child").Eq("Interesting", 28).Eq("Extra", "hello"), get: []ds.PropertyMap{
                                         stage1Data[4],
                                 }},
 
                                 {q: nq("Kind").Eq("Val", 2, 3), get: []ds.PropertyMap{
                                         stage1Data[0],
-                                        stage1Data[3],
+                                        stage1Data3Enc,
                                 }},
 
                                 // note the kind :)
                                 {q: (nq("Kind").Ancestor(key("Kind", 3)).
                                         Start(curs("__key__", key("Kind", 3))).
                                         End(curs("__key__", key("Kind", 3, "Zeta", "woot")))),
                                         keys: []*ds.Key{
                                                 key("Kind", 3),
                                                 key("Kind", 3, "Kind", 1),
                                                 key("Kind", 3, "Kind", 2),
@@ skipping 29 matching lines @@
                                                 key("Kind", 3, "Kind", 2),
                                                 key("Kind", 3, "Kind", 3),
                                         },
                                         get: []ds.PropertyMap{
                                                 stage2Data[1],
                                                 stage2Data[2],
                                         },
                                 },
 
                                 {q: nq("Kind").Gt("Val", 2).Lte("Val", 5), get: []ds.PropertyMap{
-                                        stage1Data[0], stage1Data[3],
+                                        stage1Data[0], stage1Data3Enc,
                                 }},
 
                                 {q: nq("Kind").Gt("Val", 2).Lte("Val", 5).Order("-Val"), get: []ds.PropertyMap{
-                                        stage1Data[3], stage1Data[0],
+                                        stage1Data3Enc, stage1Data[0],
                                 }},
 
                                 {q: nq("").Gt("__key__", key("Kind", 2)),
                                         // count counts from the index with KeysOnly and so counts the deleted
                                         // entity Unique/1.
                                         count: 8,
                                         get: []ds.PropertyMap{
                                                 // TODO(riannucci): determine if the real datastore shows metadata
                                                 // during kindless queries. The documentation seems to imply so, but
                                                 // I'd like to be sure.
                                                 pmap("$key", key("Kind", 2, "__entity_group__", 1), Next,
                                                         "__version__", 1),
                                                 stage1Data[2],
                                                 stage1Data[4],
                                                 // this is 5 because the value is retrieved from HEAD and not from
                                                 // the index snapshot!
                                                 pmap("$key", key("Kind", 3, "__entity_group__", 1), Next,
                                                         "__version__", 5),
-                                                stage1Data[3],
+                                                stage1Data3Enc,
                                                 pmap("$key", key("Kind", 6, "__entity_group__", 1), Next,
                                                         "__version__", 1),
                                                 pmap("$key", key("Unique", 1, "__entity_group__", 1), Next,
                                                         "__version__", 2),
                                         }},
 
                                 {q: (nq("Kind").
                                         Gt("Val", 2).Eq("Extra", "waffle").
                                         Order("-Val").
                                         Ancestor(key("Kind", 3))),
@@ skipping 63 matching lines @@
                                                 "When", 27),
                                         pmap("$key", key("Kind", 6), Next,
                                                 "When", 946688461000000),
                                         pmap("$key", key("Kind", 3), Next,
                                                 "When", 996688461000000),
                                 }},
 
                                 // Original (complex) types are retained when getting the full value.
                                 {q: nq("Kind").Order("When"), get: []ds.PropertyMap{
                                         stage1Data[1],
-                                        stage1Data[3],
+                                        stage1Data3Enc,
                                         stage1Data[2],
                                 }},
                         },
 
                         extraFns: []func(context.Context){
                                 func(c context.Context) {
                                         data := ds.Get(c)
                                         curs := ds.Cursor(nil)
 
                                         q := nq("").Gt("__key__", key("Kind", 2))
@@ skipping 52 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],
                                 }},
                         },
                 },
         }},
+        {"time range", []qExStage{
+                {
+                        addIdxs: []*ds.IndexDefinition{
+                                indx("Kind!", "Date"),

[iannucci, 2015/12/29 18:29:20]

I think ! is shorthand for ancestor here, which you don't need?

+                        },
+                },
+                {
+                        putEnts: timeData,
+                },
+                {
+                        expect: []qExpect{
+                                {
+                                        q: nq("Kind").Lte("Date", time.Date(2000, time.February, 1, 1, 1, 1, 1, time.UTC)),
+                                        get: []ds.PropertyMap{
+                                                pmap("$key", key("Kind", 1), Next,
+                                                        "Date", 946688461000000, Next,
+                                                ),
+                                        },
+                                },
+                        },
+                },
+        }},
 }
 
 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)
         })
 }