Refactor keys and queries in datastore service and implementation.

service/datastore/properties_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 datastore
 
 import (
         "math"
         "testing"
         "time"
@@ skipping 18 matching lines @@
                                 So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTNull")
                         })
                         Convey("set", func() {
                                 pv := MkPropertyNI(100)
                                 So(pv.Value(), ShouldHaveSameTypeAs, int64(100))
                                 So(pv.Value(), ShouldEqual, 100)
                                 So(pv.IndexSetting(), ShouldEqual, NoIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTInt")
 
-                                pv.SetValue(nil, ShouldIndex)
+                                So(pv.SetValue(nil, ShouldIndex), ShouldBeNil)
                                 So(pv.Value(), ShouldBeNil)
                                 So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTNull")
                         })
                         Convey("derived types", func() {
                                 Convey("int", func() {
                                         pv := MkProperty(19)
                                         So(pv.Value(), ShouldHaveSameTypeAs, int64(19))
                                         So(pv.Value(), ShouldEqual, 19)
                                         So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
@@ skipping 12 matching lines @@
                                         So(pv.Type().String(), ShouldEqual, "PTString")
                                 })
                                 Convey("blobstore.Key is distinquished", func() {
                                         pv := MkProperty(blobstore.Key("sup"))
                                         So(pv.Value(), ShouldEqual, blobstore.Key("sup"))
                                         So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                         So(pv.Type().String(), ShouldEqual, "PTBlobKey")
                                 })
                                 Convey("float", func() {
                                         pv := Property{}
-                                        pv.SetValue(myfloat(19.7), ShouldIndex)
+                                        So(pv.SetValue(myfloat(19.7), ShouldIndex), ShouldBeNil)
                                         So(pv.Value(), ShouldHaveSameTypeAs, float64(19.7))
                                         So(pv.Value(), ShouldEqual, float32(19.7))
                                         So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                         So(pv.Type().String(), ShouldEqual, "PTFloat")
                                 })
                         })
                         Convey("bad type", func() {
                                 pv := Property{}
                                 err := pv.SetValue(complex(100, 29), ShouldIndex)
                                 So(err.Error(), ShouldContainSubstring, "has bad type complex")
@@ skipping 21 matching lines @@
                                 err = pv.SetValue(time.Unix(math.MaxInt64, 0).UTC(), ShouldIndex)
                                 So(err.Error(), ShouldContainSubstring, "time value out of range")
                                 So(pv.Value(), ShouldBeNil)
                                 So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTNull")
                         })
                         Convey("time gets rounded", func() {
                                 pv := Property{}
                                 now := time.Now().In(time.UTC)
                                 now = now.Round(time.Microsecond).Add(time.Nanosecond * 313)
-                                pv.SetValue(now, ShouldIndex)
+                                So(pv.SetValue(now, ShouldIndex), ShouldBeNil)
                                 So(pv.Value(), ShouldHappenBefore, now)
                                 So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTTime")
                         })
                         Convey("[]byte allows IndexSetting", func() {
                                 pv := Property{}
-                                pv.SetValue([]byte("hello"), ShouldIndex)
+                                So(pv.SetValue([]byte("hello"), ShouldIndex), ShouldBeNil)
                                 So(pv.Value(), ShouldResemble, []byte("hello"))
                                 So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
                                 So(pv.Type().String(), ShouldEqual, "PTBytes")
                         })
                 })
         })
 }
 
 func TestDSPropertyMapImpl(t *testing.T) {
         t.Parallel()
@@ skipping 39 matching lines @@
 
                                 Convey("weird value", func() {
                                         pm := PropertyMap{}
                                         err := pm.SetMeta("sup", complex(100, 20))
                                         So(err.Error(), ShouldContainSubstring, "bad type")
                                 })
                         })
                 })
         })
 }