Auto-project on distinct inequality fields.

impl/prod/everything_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.
 
 // +build appengine
 
 package prod
 
 import (
         "testing"
@@ skipping 164 matching lines @@
                                         },
                                         {
                                                 "$key":    {mpNI(ds.KeyForObj(&orig))},
                                                 "ValueBS": {mp("zurple")},
                                         },
                                 })
 
                                 count, err := ds.Count(q)
                                 So(err, ShouldBeNil)
                                 So(count, ShouldEqual, 4)
+
+                                q = datastore.NewQuery("TestStruct").Lte("ValueI", 7).Project("ValueS").Distinct(true)
+                                rslts = []datastore.PropertyMap{}
+                                So(ds.GetAll(q, &rslts), ShouldBeNil)
+                                So(rslts, ShouldResemble, []datastore.PropertyMap{
+                                        {
+                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
+                                                "ValueI": {mp(1)},
+                                                "ValueS": {mp("hello")},
+                                        },
+                                        {
+                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
+                                                "ValueI": {mp(1)},
+                                                "ValueS": {mp("world")},
+                                        },
+                                        {
+                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
+                                                "ValueI": {mp(7)},
+                                                "ValueS": {mp("hello")},
+                                        },
+                                        {
+                                                "$key":   {mpNI(ds.KeyForObj(&orig))},
+                                                "ValueI": {mp(7)},
+                                                "ValueS": {mp("world")},
+                                        },
+                                })
+
+                                count, err = ds.Count(q)
+                                So(err, ShouldBeNil)
+                                So(count, ShouldEqual, 4)

[iannucci, 2016/02/27 01:02:02]

We should have a test like this one for impl/memory too

                         })
                 })
 
                 Convey("Can Put/Get (time)", func() {
                         // time comparisons in Go are wonky, so this is pulled out
                         pm := datastore.PropertyMap{
                                 "$key": {mpNI(ds.NewKey("Something", "value", 0, nil))},
                                 "Time": {
                                         mp(time.Date(1938, time.January, 1, 1, 1, 1, 1, time.UTC)),
                                         mp(time.Time{}),
                                 },
                         }
                         So(ds.Put(&pm), ShouldBeNil)
 
                         rslt := datastore.PropertyMap{}
                         rslt.SetMeta("key", ds.KeyForObj(pm))
                         So(ds.Get(&rslt), ShouldBeNil)
 
                         So(pm["Time"][0].Value(), ShouldResemble, rslt["Time"][0].Value())
 
                         q := datastore.NewQuery("Something").Project("Time")
                         all := []datastore.PropertyMap{}
                         So(ds.GetAll(q, &all), ShouldBeNil)
                         So(len(all), ShouldEqual, 2)
                         prop := all[0]["Time"][0]
                         So(prop.Type(), ShouldEqual, datastore.PTInt)
 
                         tval, err := prop.Project(datastore.PTTime)
                         So(err, ShouldBeNil)
-                        So(tval, ShouldResemble, time.Time{})
+                        So(tval, ShouldResemble, time.Time{}.UTC())
 
                         tval, err = all[1]["Time"][0].Project(datastore.PTTime)
                         So(err, ShouldBeNil)
                         So(tval, ShouldResemble, pm["Time"][0].Value())
 
                         ent := datastore.PropertyMap{
                                 "$key": {mpNI(ds.MakeKey("Something", "value"))},
                         }
                         So(ds.Get(&ent), ShouldBeNil)
                         So(ent["Time"], ShouldResemble, pm["Time"])
                 })
 
                 Convey("memcache: Set (nil) is the same as Set ([]byte{})", func() {
                         So(mc.Set(mc.NewItem("bob")), ShouldBeNil) // normally would panic because Value is nil
 
                         bob, err := mc.Get("bob")
                         So(err, ShouldBeNil)
                         So(bob.Value(), ShouldResemble, []byte{})
                 })
         })
 }