Refactor keys and queries in datastore service and implementation.

impl/memory/datastore_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"
         "testing"
         "time"
 
         dsS "github.com/luci/gae/service/datastore"
-        "github.com/luci/gae/service/datastore/dskey"
         "github.com/luci/gae/service/datastore/serialize"
         infoS "github.com/luci/gae/service/info"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
-func TestDatastoreKinder(t *testing.T) {
-        t.Parallel()
-
-        Convey("Datastore keys", t, func() {
-                c := Use(context.Background())
-                ds := dsS.Get(c)
-                So(ds, ShouldNotBeNil)
-
-                Convey("implements DSNewKeyer", func() {
-                        Convey("NewKey", func() {
-                                key := ds.NewKey("nerd", "stringID", 0, nil)
-                                So(key, ShouldNotBeNil)
-                                So(key.Kind(), ShouldEqual, "nerd")
-                                So(key.StringID(), ShouldEqual, "stringID")
-                                So(key.IntID(), ShouldEqual, 0)
-                                So(key.Parent(), ShouldBeNil)
-                                So(key.AppID(), ShouldEqual, "dev~app")
-                                So(key.Namespace(), ShouldEqual, "")
-                                So(key.String(), ShouldEqual, "/nerd,stringID")
-                                So(key.Incomplete(), ShouldBeFalse)
-                                So(key.Valid(false, "dev~app", ""), ShouldBeTrue)
-                        })
-                })
-
-        })
-}
-
 type MetaGroup struct {
-        _id    int64   `gae:"$id,1"`
-        _kind  string  `gae:"$kind,__entity_group__"`
-        Parent dsS.Key `gae:"$parent"`
+        _id    int64    `gae:"$id,1"`
+        _kind  string   `gae:"$kind,__entity_group__"`
+        Parent *dsS.Key `gae:"$parent"`
 
         Version int64 `gae:"__version__"`
 }
 
-func testGetMeta(c context.Context, k dsS.Key) int64 {
+func testGetMeta(c context.Context, k *dsS.Key) int64 {
         ds := dsS.Get(c)
-        mg := &MetaGroup{Parent: dskey.Root(k)}
+        mg := &MetaGroup{Parent: k.Root()}
         if err := ds.Get(mg); err != nil {
                 panic(err)
         }
         return mg.Version
 }
 
 var pls = dsS.GetPLS
 
 type Foo struct {
-        Id     int64   `gae:"$id"`
-        Parent dsS.Key `gae:"$parent"`
+        Id     int64    `gae:"$id"`
+        Parent *dsS.Key `gae:"$parent"`
 
         Val int
 }
 
 func TestDatastoreSingleReadWriter(t *testing.T) {
         t.Parallel()
 
         Convey("Datastore single reads and writes", t, func() {
                 c := Use(context.Background())
                 ds := dsS.Get(c)
                 So(ds, ShouldNotBeNil)
 
                 Convey("getting objects that DNE is an error", func() {
                         So(ds.Get(&Foo{Id: 1}), ShouldEqual, dsS.ErrNoSuchEntity)
                 })
 
                 Convey("bad namespaces fail", func() {
                         _, err := infoS.Get(c).Namespace("$$blzyall")
                         So(err.Error(), ShouldContainSubstring, "namespace \"$$blzyall\" does not match")
                 })
 
                 Convey("Can Put stuff", func() {
                         // with an incomplete key!
                         f := &Foo{Val: 10}
                         So(ds.Put(f), ShouldBeNil)
                         k := ds.KeyForObj(f)
-                        So(k.String(), ShouldEqual, "/Foo,1")
+                        So(k.String(), ShouldEqual, "dev~app::/Foo,1")
 
                         Convey("and Get it back", func() {
                                 newFoo := &Foo{Id: 1}
                                 So(ds.Get(newFoo), ShouldBeNil)
                                 So(newFoo, ShouldResemble, f)
 
                                 Convey("but it's hidden from a different namespace", func() {
                                         c, err := infoS.Get(c).Namespace("whombat")
                                         So(err, ShouldBeNil)
                                         ds = dsS.Get(c)
@@ skipping 17 matching lines @@
                                 So(testGetMeta(c, k), ShouldEqual, 1)
 
                                 foos := make([]Foo, 10)
                                 for i := range foos {
                                         foos[i].Val = 10
                                         foos[i].Parent = k
                                 }
                                 So(ds.PutMulti(foos), ShouldBeNil)
                                 So(testGetMeta(c, k), ShouldEqual, 11)
 
-                                keys := make([]dsS.Key, len(foos))
+                                keys := make([]*dsS.Key, len(foos))
                                 for i, f := range foos {
                                         keys[i] = ds.KeyForObj(&f)
                                 }
 
                                 Convey("ensure that group versions persist across deletes", func() {
                                         So(ds.DeleteMulti(append(keys, k)), ShouldBeNil)
 
                                         // TODO(riannucci): replace with a Count query instead of this cast
                                         /*
                                                 ents := ds.(*dsImpl).data.head.GetCollection("ents:")
@@ skipping 27 matching lines @@
                                 })
 
                         })
                 })
 
                 Convey("implements DSTransactioner", func() {
                         Convey("Put", func() {
                                 f := &Foo{Val: 10}
                                 So(ds.Put(f), ShouldBeNil)
                                 k := ds.KeyForObj(f)
-                                So(k.String(), ShouldEqual, "/Foo,1")
+                                So(k.String(), ShouldEqual, "dev~app::/Foo,1")
 
                                 Convey("can Put new entity groups", func() {
                                         err := ds.RunInTransaction(func(c context.Context) error {
                                                 ds := dsS.Get(c)
 
                                                 f := &Foo{Val: 100}
                                                 So(ds.Put(f), ShouldBeNil)
                                                 So(f.Id, ShouldEqual, 2)
 
                                                 f.Id = 0
@@ skipping 13 matching lines @@
                                         So(ds.Get(f), ShouldBeNil)
                                         So(f.Val, ShouldEqual, 200)
                                 })
 
                                 Convey("can Put new entities in a current group", func() {
                                         err := ds.RunInTransaction(func(c context.Context) error {
                                                 ds := dsS.Get(c)
 
                                                 f := &Foo{Val: 100, Parent: k}
                                                 So(ds.Put(f), ShouldBeNil)
-                                                So(ds.KeyForObj(f).String(), ShouldEqual, "/Foo,1/Foo,1")
+                                                So(ds.KeyForObj(f).String(), ShouldEqual, "dev~app::/Foo,1/Foo,1")
 
                                                 f.Id = 0
                                                 f.Val = 200
                                                 So(ds.Put(f), ShouldBeNil)
-                                                So(ds.KeyForObj(f).String(), ShouldEqual, "/Foo,1/Foo,2")
+                                                So(ds.KeyForObj(f).String(), ShouldEqual, "dev~app::/Foo,1/Foo,2")
 
                                                 return nil
                                         }, nil)
                                         So(err, ShouldBeNil)
 
                                         f := &Foo{Id: 1, Parent: k}
                                         So(ds.Get(f), ShouldBeNil)
                                         So(f.Val, ShouldEqual, 100)
 
                                         f.Id = 2
@@ skipping 314 matching lines @@
                 ds := dsS.Get(Use(context.Background()))
                 m := Model{ID: 1}
                 So(ds.Put(&m), ShouldBeNil)
 
                 // Reset to something non zero to ensure zero is fetched.
                 m.Time = time.Now().UTC()
                 So(ds.Get(&m), ShouldBeNil)
                 So(m.Time.IsZero(), ShouldBeTrue)
         })
 }