Interface update, per-method Contexts.

service/datastore/datastore_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "bytes"
         "fmt"
         "io/ioutil"
         "os"
         "path/filepath"
         "runtime"
         "testing"
 
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/common/errors"
+
+        "golang.org/x/net/context"
+
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
-        "golang.org/x/net/context"
 )
 
-func fakeDatastoreFactory(c context.Context, wantTxn bool) RawInterface {
-        i := info.Get(c)
-        fds := fakeDatastore{
-                aid: i.FullyQualifiedAppID(),
-        }
-        fds.ns, _ = i.GetNamespace()
-        return &fds
+func fakeDatastoreFactory(c context.Context) RawInterface {
+        return &fakeDatastore{Context: c}
 }
 
 var (
         errFail    = errors.New("Individual element fail")
         errFailAll = errors.New("Operation fail")
 )
 
 type fakeDatastore struct {
+        context.Context
         RawInterface
-        aid string
-        ns  string
-}
-
-func (f *fakeDatastore) mkKey(elems ...interface{}) *Key {
-        return MakeKey(f.aid, f.ns, elems...)
-}
-
-func (f *fakeDatastore) newKey(kind, stringID string, intID int64, parent *Key) *Key {
-        return NewKey(f.aid, f.ns, kind, stringID, intID, parent)
 }
 
 func (f *fakeDatastore) AllocateIDs(keys []*Key, cb NewKeyCB) error {
         if keys[0].Kind() == "FailAll" {
                 return errFailAll
         }
         for i, k := range keys {
                 if k.Kind() == "Fail" {
                         cb(nil, errFail)
                 } else {
-                        cb(f.newKey(k.Kind(), "", int64(i+1), k.Parent()), nil)
+                        cb(NewKey(f, k.Kind(), "", int64(i+1), k.Parent()), nil)
                 }
         }
         return nil
 }
 
 func (f *fakeDatastore) Run(fq *FinalizedQuery, cb RawRunCB) error {
         lim, _ := fq.Limit()
 
         cursCB := func() (Cursor, error) {
                 return fakeCursor("CURSOR"), nil
         }
 
         for i := int32(0); i < lim; i++ {
                 if v, ok := fq.eqFilts["$err_single"]; ok {
                         idx := fq.eqFilts["$err_single_idx"][0].Value().(int64)
                         if idx == int64(i) {
                                 return errors.New(v[0].Value().(string))
                         }
                 }
-                k := f.mkKey("Kind", i+1)
+                k := MakeKey(f, "Kind", i+1)
                 if i == 10 {
-                        k = f.mkKey("Kind", "eleven")
+                        k = MakeKey(f, "Kind", "eleven")
                 }
                 pm := PropertyMap{"Value": MkProperty(i)}
                 if err := cb(k, pm, cursCB); err != nil {
                         if err == Stop {
                                 err = nil
                         }
                         return err
                 }
         }
         return nil
 }
 
 func (f *fakeDatastore) PutMulti(keys []*Key, vals []PropertyMap, cb NewKeyCB) error {
         if keys[0].Kind() == "FailAll" {
                 return errFailAll
         }
         _, assertExtra := vals[0].GetMeta("assertExtra")
         for i, k := range keys {
                 err := error(nil)
                 if k.Kind() == "Fail" {
                         err = errFail
                 } else {
                         So(vals[i].Slice("Value"), ShouldResemble, PropertySlice{MkProperty(i)})
                         if assertExtra {
                                 So(vals[i].Slice("Extra"), ShouldResemble, PropertySlice{MkProperty("whoa")})
                         }
                         if k.IsIncomplete() {
-                                k = NewKey(k.AppID(), k.Namespace(), k.Kind(), "", int64(i+1), k.Parent())
+                                k = k.KeyContext().NewKey(k.Kind(), "", int64(i+1), k.Parent())
                         }
                 }
                 cb(k, err)
         }
         return nil
 }
 
 const noSuchEntityID = 0xdead
 
 func (f *fakeDatastore) GetMulti(keys []*Key, _meta MultiMetaGetter, cb GetMultiCB) error {
@@ skipping 201 matching lines @@
 }
 
 var _ MetaGetterSetter = (*MGSWithNoKind)(nil)
 
 func TestKeyForObj(t *testing.T) {
         t.Parallel()
 
         Convey("Test interface.KeyForObj", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
 
-                k := ds.MakeKey("Hello", "world")
+                k := MakeKey(c, "Hello", "world")
 
                 Convey("good", func() {
                         Convey("struct containing $key", func() {
                                 type keyStruct struct {
                                         Key *Key `gae:"$key"`
                                 }
 
                                 ks := &keyStruct{k}
-                                So(ds.KeyForObj(ks), ShouldEqual, k)
+                                So(KeyForObj(c, ks), ShouldEqual, k)
                         })
 
                         Convey("struct containing default $id and $kind", func() {
                                 type idStruct struct {
                                         id  string `gae:"$id,wut"`
                                         knd string `gae:"$kind,SuperKind"`
                                 }
 
-                                So(ds.KeyForObj(&idStruct{}).String(), ShouldEqual, `s~aid:ns:/SuperKind,"wut"`)
+                                So(KeyForObj(c, &idStruct{}).String(), ShouldEqual, `s~aid:ns:/SuperKind,"wut"`)
                         })
 
                         Convey("struct containing $id and $parent", func() {
-                                So(ds.KeyForObj(&CommonStruct{ID: 4}).String(), ShouldEqual, `s~aid:ns:/CommonStruct,4`)
+                                So(KeyForObj(c, &CommonStruct{ID: 4}).String(), ShouldEqual, `s~aid:ns:/CommonStruct,4`)
 
-                                So(ds.KeyForObj(&CommonStruct{ID: 4, Parent: k}).String(), ShouldEqual, `s~aid:ns:/Hello,"world"/CommonStruct,4`)
+                                So(KeyForObj(c, &CommonStruct{ID: 4, Parent: k}).String(), ShouldEqual, `s~aid:ns:/Hello,"world"/CommonStruct,4`)
                         })
 
                         Convey("a propmap with $key", func() {
                                 pm := PropertyMap{}
                                 So(pm.SetMeta("key", k), ShouldBeTrue)
-                                So(ds.KeyForObj(pm).String(), ShouldEqual, `s~aid:ns:/Hello,"world"`)
+                                So(KeyForObj(c, pm).String(), ShouldEqual, `s~aid:ns:/Hello,"world"`)
                         })
 
                         Convey("a propmap with $id, $kind, $parent", func() {
                                 pm := PropertyMap{}
                                 So(pm.SetMeta("id", 100), ShouldBeTrue)
                                 So(pm.SetMeta("kind", "Sup"), ShouldBeTrue)
-                                So(ds.KeyForObj(pm).String(), ShouldEqual, `s~aid:ns:/Sup,100`)
+                                So(KeyForObj(c, pm).String(), ShouldEqual, `s~aid:ns:/Sup,100`)
 
                                 So(pm.SetMeta("parent", k), ShouldBeTrue)
-                                So(ds.KeyForObj(pm).String(), ShouldEqual, `s~aid:ns:/Hello,"world"/Sup,100`)
+                                So(KeyForObj(c, pm).String(), ShouldEqual, `s~aid:ns:/Hello,"world"/Sup,100`)
                         })
 
                         Convey("a pls with $id, $parent", func() {
                                 pls := GetPLS(&CommonStruct{ID: 1})
-                                So(ds.KeyForObj(pls).String(), ShouldEqual, `s~aid:ns:/CommonStruct,1`)
+                                So(KeyForObj(c, pls).String(), ShouldEqual, `s~aid:ns:/CommonStruct,1`)
 
                                 So(pls.SetMeta("parent", k), ShouldBeTrue)
-                                So(ds.KeyForObj(pls).String(), ShouldEqual, `s~aid:ns:/Hello,"world"/CommonStruct,1`)
+                                So(KeyForObj(c, pls).String(), ShouldEqual, `s~aid:ns:/Hello,"world"/CommonStruct,1`)
                         })
                 })
 
                 Convey("bad", func() {
                         Convey("a propmap without $kind", func() {
                                 pm := PropertyMap{}
                                 So(pm.SetMeta("id", 100), ShouldBeTrue)
-                                So(func() { ds.KeyForObj(pm) }, ShouldPanic)
+                                So(func() { KeyForObj(c, pm) }, ShouldPanic)
                         })
 
                         Convey("a bad object", func() {
                                 type BadObj struct {
                                         ID int64 `gae:"$id"`
 
                                         NonSerializableField complex64
                                 }
 
-                                So(func() { ds.KeyForObjErr(&BadObj{ID: 1}) }, ShouldPanicLike,
+                                So(func() { KeyForObj(c, &BadObj{ID: 1}) }, ShouldPanicLike,
                                         `field "NonSerializableField" has invalid type: complex64`)
                         })
                 })
         })
 }
 
 func TestPopulateKey(t *testing.T) {
         t.Parallel()
 
         Convey("Test PopulateKey", t, func() {
-                k := NewKey("app", "namespace", "kind", "", 1337, nil)
+                k := KeyContext{"app", "namespace"}.NewKey("kind", "", 1337, nil)
 
                 Convey("Can set the key of a common struct.", func() {
                         var cs CommonStruct
 
                         So(PopulateKey(&cs, k), ShouldBeTrue)
                         So(cs.ID, ShouldEqual, 1337)
                 })
 
                 Convey("Will not set the value of a singleton struct.", func() {
                         var ss SingletonStruct
@@ skipping 15 matching lines @@
                 })
         })
 }
 
 func TestAllocateIDs(t *testing.T) {
         t.Parallel()
 
         Convey("A testing environment", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
 
                 Convey("Testing AllocateIDs", func() {
                         Convey("Will return nil if no entities are supplied.", func() {
-                                So(ds.AllocateIDs(), ShouldBeNil)
+                                So(AllocateIDs(c), ShouldBeNil)
                         })
 
                         Convey("single struct", func() {
                                 cs := CommonStruct{Value: 1}
-                                So(ds.AllocateIDs(&cs), ShouldBeNil)
+                                So(AllocateIDs(c, &cs), ShouldBeNil)
                                 So(cs.ID, ShouldEqual, 1)
                         })
 
                         Convey("struct slice", func() {
                                 csSlice := []*CommonStruct{{Value: 1}, {Value: 2}}
-                                So(ds.AllocateIDs(csSlice), ShouldBeNil)
+                                So(AllocateIDs(c, csSlice), ShouldBeNil)
                                 So(csSlice, ShouldResemble, []*CommonStruct{{ID: 1, Value: 1}, {ID: 2, Value: 2}})
                         })
 
                         Convey("single key will fail", func() {
-                                singleKey := ds.MakeKey("FooParent", "BarParent", "Foo", "Bar")
-                                So(func() { ds.AllocateIDs(singleKey) }, ShouldPanicLike,
+                                singleKey := MakeKey(c, "FooParent", "BarParent", "Foo", "Bar")
+                                So(func() { AllocateIDs(c, singleKey) }, ShouldPanicLike,
                                         "invalid input type (*datastore.Key): not a PLS, pointer-to-struct, or slice thereof")
                         })
 
                         Convey("key slice", func() {
-                                k0 := ds.MakeKey("Foo", "Bar")
-                                k1 := ds.MakeKey("Baz", "Qux")
+                                k0 := MakeKey(c, "Foo", "Bar")
+                                k1 := MakeKey(c, "Baz", "Qux")
                                 keySlice := []*Key{k0, k1}
-                                So(ds.AllocateIDs(keySlice), ShouldBeNil)
-                                So(keySlice[0].Equal(ds.MakeKey("Foo", 1)), ShouldBeTrue)
-                                So(keySlice[1].Equal(ds.MakeKey("Baz", 2)), ShouldBeTrue)
+                                So(AllocateIDs(c, keySlice), ShouldBeNil)
+                                So(keySlice[0].Equal(MakeKey(c, "Foo", 1)), ShouldBeTrue)
+                                So(keySlice[1].Equal(MakeKey(c, "Baz", 2)), ShouldBeTrue)
 
                                 // The original keys should not have changed.
-                                So(k0.Equal(ds.MakeKey("Foo", "Bar")), ShouldBeTrue)
-                                So(k1.Equal(ds.MakeKey("Baz", "Qux")), ShouldBeTrue)
+                                So(k0.Equal(MakeKey(c, "Foo", "Bar")), ShouldBeTrue)
+                                So(k1.Equal(MakeKey(c, "Baz", "Qux")), ShouldBeTrue)
                         })
 
                         Convey("fail all key slice", func() {
-                                keySlice := []*Key{ds.MakeKey("FailAll", "oops"), ds.MakeKey("Baz", "Qux")}
-                                So(ds.AllocateIDs(keySlice), ShouldEqual, errFailAll)
+                                keySlice := []*Key{MakeKey(c, "FailAll", "oops"), MakeKey(c, "Baz", "Qux")}
+                                So(AllocateIDs(c, keySlice), ShouldEqual, errFailAll)
                                 So(keySlice[0].StringID(), ShouldEqual, "oops")
                                 So(keySlice[1].StringID(), ShouldEqual, "Qux")
                         })
 
                         Convey("fail key slice", func() {
-                                keySlice := []*Key{ds.MakeKey("Fail", "oops"), ds.MakeKey("Baz", "Qux")}
-                                So(ds.AllocateIDs(keySlice), ShouldResemble, errors.MultiError{errFail, nil})
+                                keySlice := []*Key{MakeKey(c, "Fail", "oops"), MakeKey(c, "Baz", "Qux")}
+                                So(AllocateIDs(c, keySlice), ShouldResemble, errors.MultiError{errFail, nil})
                                 So(keySlice[0].StringID(), ShouldEqual, "oops")
                                 So(keySlice[1].IntID(), ShouldEqual, 2)
                         })
 
                         Convey("vararg with errors", func() {
                                 successSlice := []CommonStruct{{Value: 0}, {Value: 1}}
                                 failSlice := []FakePLS{{Kind: "Fail"}, {Value: 3}}
                                 emptySlice := []CommonStruct(nil)
                                 cs0 := CommonStruct{Value: 4}
                                 cs1 := FakePLS{Kind: "Fail", Value: 5}
-                                keySlice := []*Key{ds.MakeKey("Foo", "Bar"), ds.MakeKey("Baz", "Qux")}
+                                keySlice := []*Key{MakeKey(c, "Foo", "Bar"), MakeKey(c, "Baz", "Qux")}
                                 fpls := FakePLS{StringID: "ohai", Value: 6}
 
-                                err := ds.AllocateIDs(successSlice, failSlice, emptySlice, &cs0, &cs1, keySlice, &fpls)
+                                err := AllocateIDs(c, successSlice, failSlice, emptySlice, &cs0, &cs1, keySlice, &fpls)
                                 So(err, ShouldResemble, errors.MultiError{
                                         nil, errors.MultiError{errFail, nil}, nil, nil, errFail, nil, nil})
                                 So(successSlice[0].ID, ShouldEqual, 1)
                                 So(successSlice[1].ID, ShouldEqual, 2)
                                 So(failSlice[1].IntID, ShouldEqual, 4)
                                 So(cs0.ID, ShouldEqual, 5)
-                                So(keySlice[0].Equal(ds.MakeKey("Foo", 7)), ShouldBeTrue)
-                                So(keySlice[1].Equal(ds.MakeKey("Baz", 8)), ShouldBeTrue)
+                                So(keySlice[0].Equal(MakeKey(c, "Foo", 7)), ShouldBeTrue)
+                                So(keySlice[1].Equal(MakeKey(c, "Baz", 8)), ShouldBeTrue)
                                 So(fpls.IntID, ShouldEqual, 9)
                         })
                 })
         })
 }
 
 func TestPut(t *testing.T) {
         t.Parallel()
 
         Convey("A testing environment", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
 
                 Convey("Testing Put", func() {
                         Convey("bad", func() {
                                 Convey("static can't serialize", func() {
                                         bss := []badStruct{{}, {}}
-                                        So(func() { ds.Put(bss) }, ShouldPanicLike,
+                                        So(func() { Put(c, bss) }, ShouldPanicLike,
                                                 `field "Compy" has invalid type`)
                                 })
 
                                 Convey("static ptr can't serialize", func() {
                                         bss := []*badStruct{{}, {}}
-                                        So(func() { ds.Put(bss) }, ShouldPanicLike,
+                                        So(func() { Put(c, bss) }, ShouldPanicLike,
                                                 `field "Compy" has invalid type: complex64`)
                                 })
 
                                 Convey("static bad type", func() {
-                                        So(func() { ds.Put(100) }, ShouldPanicLike,
+                                        So(func() { Put(c, 100) }, ShouldPanicLike,
                                                 "invalid input type (int): not a PLS, pointer-to-struct, or slice thereof")
                                 })
 
                                 Convey("static bad type (slice of bad type)", func() {
-                                        So(func() { ds.Put([]int{}) }, ShouldPanicLike,
+                                        So(func() { Put(c, []int{}) }, ShouldPanicLike,
                                                 "invalid input type ([]int): not a PLS, pointer-to-struct, or slice thereof")
                                 })
 
                                 Convey("dynamic can't serialize", func() {
                                         fplss := []FakePLS{{failSave: true}, {}}
-                                        So(ds.Put(fplss), ShouldErrLike, "FakePLS.Save")
+                                        So(Put(c, fplss), ShouldErrLike, "FakePLS.Save")
                                 })
 
                                 Convey("can't get keys", func() {
                                         fplss := []FakePLS{{failGetMeta: true}, {}}
-                                        So(ds.Put(fplss), ShouldErrLike, "unable to extract $kind")
+                                        So(Put(c, fplss), ShouldErrLike, "unable to extract $kind")
                                 })
 
                                 Convey("get single error for RPC failure", func() {
                                         fplss := []FakePLS{{Kind: "FailAll"}, {}}
-                                        So(ds.Put(fplss), ShouldEqual, errFailAll)
+                                        So(Put(c, fplss), ShouldEqual, errFailAll)
                                 })
 
                                 Convey("get multi error for individual failures", func() {
                                         fplss := []FakePLS{{}, {Kind: "Fail"}}
-                                        So(ds.Put(fplss), ShouldResemble, errors.MultiError{nil, errFail})
+                                        So(Put(c, fplss), ShouldResemble, errors.MultiError{nil, errFail})
                                 })
 
                                 Convey("get with *Key is an error", func() {
-                                        So(func() { ds.Get(&Key{}) }, ShouldPanicLike,
+                                        So(func() { Get(c, &Key{}) }, ShouldPanicLike,
                                                 "invalid input type (*datastore.Key): not a PLS, pointer-to-struct, or slice thereof")
                                 })
 
                                 Convey("struct with no $kind is an error", func() {
                                         s := MGSWithNoKind{}
-                                        So(ds.Put(&s), ShouldErrLike, "unable to extract $kind")
+                                        So(Put(c, &s), ShouldErrLike, "unable to extract $kind")
                                 })
 
                                 Convey("struct with invalid but non-nil key is an error", func() {
                                         type BadParent struct {
                                                 ID     int64 `gae:"$id"`
                                                 Parent *Key  `gae:"$parent"`
                                         }
                                         // having an Incomplete parent makes an invalid key
-                                        bp := &BadParent{ID: 1, Parent: ds.MakeKey("Something", 0)}
-                                        So(ds.Put(bp), ShouldErrLike, ErrInvalidKey)
+                                        bp := &BadParent{ID: 1, Parent: MakeKey(c, "Something", 0)}
+                                        So(Put(c, bp), ShouldErrLike, ErrInvalidKey)
                                 })
 
                                 Convey("vararg with errors", func() {
                                         successSlice := []CommonStruct{{Value: 0}, {Value: 1}}
                                         failSlice := []FakePLS{{Kind: "Fail"}, {Value: 3}}
                                         emptySlice := []CommonStruct(nil)
                                         cs0 := CommonStruct{Value: 4}
                                         failPLS := FakePLS{Kind: "Fail", Value: 5}
                                         fpls := FakePLS{StringID: "ohai", Value: 6}
 
-                                        err := ds.Put(successSlice, failSlice, emptySlice, &cs0, &failPLS, &fpls)
+                                        err := Put(c, successSlice, failSlice, emptySlice, &cs0, &failPLS, &fpls)
                                         So(err, ShouldResemble, errors.MultiError{
                                                 nil, errors.MultiError{errFail, nil}, nil, nil, errFail, nil})
                                         So(successSlice[0].ID, ShouldEqual, 1)
                                         So(successSlice[1].ID, ShouldEqual, 2)
                                         So(cs0.ID, ShouldEqual, 5)
                                 })
                         })
 
                         Convey("ok", func() {
                                 Convey("[]S", func() {
                                         css := make([]CommonStruct, 7)
                                         for i := range css {
                                                 if i == 4 {
                                                         css[i].ID = 200
                                                 }
                                                 css[i].Value = int64(i)
                                         }
-                                        So(ds.Put(css), ShouldBeNil)
+                                        So(Put(c, css), ShouldBeNil)
                                         for i, cs := range css {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
                                                 So(cs.ID, ShouldEqual, expect)
                                         }
                                 })
 
                                 Convey("[]*S", func() {
                                         css := make([]*CommonStruct, 7)
                                         for i := range css {
                                                 css[i] = &CommonStruct{Value: int64(i)}
                                                 if i == 4 {
                                                         css[i].ID = 200
                                                 }
                                         }
-                                        So(ds.Put(css), ShouldBeNil)
+                                        So(Put(c, css), ShouldBeNil)
                                         for i, cs := range css {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
                                                 So(cs.ID, ShouldEqual, expect)
                                         }
 
                                         s := &CommonStruct{}
-                                        So(ds.Put(s), ShouldBeNil)
+                                        So(Put(c, s), ShouldBeNil)
                                         So(s.ID, ShouldEqual, 1)
                                 })
 
                                 Convey("[]P", func() {
                                         fplss := make([]FakePLS, 7)
                                         for i := range fplss {
                                                 fplss[i].Value = int64(i)
                                                 if i == 4 {
                                                         fplss[i].IntID = int64(200)
                                                 }
                                         }
-                                        So(ds.Put(fplss), ShouldBeNil)
+                                        So(Put(c, fplss), ShouldBeNil)
                                         for i, fpls := range fplss {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
                                                 So(fpls.IntID, ShouldEqual, expect)
                                         }
 
                                         pm := PropertyMap{"Value": MkProperty(0), "$kind": MkPropertyNI("Pmap")}
-                                        So(ds.Put(pm), ShouldBeNil)
-                                        So(ds.KeyForObj(pm).IntID(), ShouldEqual, 1)
+                                        So(Put(c, pm), ShouldBeNil)
+                                        So(KeyForObj(c, pm).IntID(), ShouldEqual, 1)
                                 })
 
                                 Convey("[]P (map)", func() {
                                         pms := make([]PropertyMap, 7)
                                         for i := range pms {
                                                 pms[i] = PropertyMap{
                                                         "$kind": MkProperty("Pmap"),
                                                         "Value": MkProperty(i),
                                                 }
                                                 if i == 4 {
                                                         So(pms[i].SetMeta("id", int64(200)), ShouldBeTrue)
                                                 }
                                         }
-                                        So(ds.Put(pms), ShouldBeNil)
+                                        So(Put(c, pms), ShouldBeNil)
                                         for i, pm := range pms {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
-                                                So(ds.KeyForObj(pm).String(), ShouldEqual, fmt.Sprintf("s~aid:ns:/Pmap,%d", expect))
+                                                So(KeyForObj(c, pm).String(), ShouldEqual, fmt.Sprintf("s~aid:ns:/Pmap,%d", expect))
                                         }
                                 })
 
                                 Convey("[]*P", func() {
                                         fplss := make([]*FakePLS, 7)
                                         for i := range fplss {
                                                 fplss[i] = &FakePLS{Value: int64(i)}
                                                 if i == 4 {
                                                         fplss[i].IntID = int64(200)
                                                 }
                                         }
-                                        So(ds.Put(fplss), ShouldBeNil)
+                                        So(Put(c, fplss), ShouldBeNil)
                                         for i, fpls := range fplss {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
                                                 So(fpls.IntID, ShouldEqual, expect)
                                         }
                                 })
 
                                 Convey("[]*P (map)", func() {
                                         pms := make([]*PropertyMap, 7)
                                         for i := range pms {
                                                 pms[i] = &PropertyMap{
                                                         "$kind": MkProperty("Pmap"),
                                                         "Value": MkProperty(i),
                                                 }
                                                 if i == 4 {
                                                         So(pms[i].SetMeta("id", int64(200)), ShouldBeTrue)
                                                 }
                                         }
-                                        So(ds.Put(pms), ShouldBeNil)
+                                        So(Put(c, pms), ShouldBeNil)
                                         for i, pm := range pms {
                                                 expect := int64(i + 1)
                                                 if i == 4 {
                                                         expect = 200
                                                 }
-                                                So(ds.KeyForObj(*pm).String(), ShouldEqual, fmt.Sprintf("s~aid:ns:/Pmap,%d", expect))
+                                                So(KeyForObj(c, *pm).String(), ShouldEqual, fmt.Sprintf("s~aid:ns:/Pmap,%d", expect))
                                         }
                                 })
 
                                 Convey("[]I", func() {
                                         ifs := []interface{}{
                                                 &CommonStruct{Value: 0},
                                                 &FakePLS{Value: 1},
                                                 PropertyMap{"Value": MkProperty(2), "$kind": MkPropertyNI("Pmap")},
                                                 &PropertyMap{"Value": MkProperty(3), "$kind": MkPropertyNI("Pmap")},
                                         }
-                                        So(ds.Put(ifs), ShouldBeNil)
+                                        So(Put(c, ifs), ShouldBeNil)
                                         for i := range ifs {
                                                 switch i {
                                                 case 0:
                                                         So(ifs[i].(*CommonStruct).ID, ShouldEqual, 1)
                                                 case 1:
                                                         fpls := ifs[i].(*FakePLS)
                                                         So(fpls.IntID, ShouldEqual, 2)
                                                 case 2:
-                                                        So(ds.KeyForObj(ifs[i].(PropertyMap)).String(), ShouldEqual, "s~aid:ns:/Pmap,3")
+                                                        So(KeyForObj(c, ifs[i].(PropertyMap)).String(), ShouldEqual, "s~aid:ns:/Pmap,3")
                                                 case 3:
-                                                        So(ds.KeyForObj(*ifs[i].(*PropertyMap)).String(), ShouldEqual, "s~aid:ns:/Pmap,4")
+                                                        So(KeyForObj(c, *ifs[i].(*PropertyMap)).String(), ShouldEqual, "s~aid:ns:/Pmap,4")
                                                 }
                                         }
                                 })
                         })
                 })
-
-                Convey("Testing PutMulti", func() {
-                        Convey("Fails for something other than a slice.", func() {
-                                cs := CommonStruct{}
-                                So(func() { ds.PutMulti(&cs) }, ShouldPanicLike,
-                                        "argument must be a slice, not *datastore.CommonStruct")
-                        })
-
-                        Convey("Succeeds for a slice.", func() {
-                                cs := []CommonStruct{{Value: 0}, {Value: 1}}
-                                So(ds.PutMulti(cs), ShouldBeNil)
-                                So(cs[0].ID, ShouldEqual, 1)
-                                So(cs[1].ID, ShouldEqual, 2)
-                        })
-
-                        Convey("Returns an item error in a MultiError.", func() {
-                                cs := []FakePLS{{Value: 0}, {Kind: "Fail"}}
-                                err := ds.PutMulti(cs)
-                                So(err, ShouldResemble, errors.MultiError{nil, errFail})
-                                So(cs[0].IntID, ShouldEqual, 1)
-                        })
-                })
         })
 }
 
 func TestExists(t *testing.T) {
         t.Parallel()
 
         Convey("A testing environment", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
 
-                k := ds.MakeKey("Hello", "world")
+                k := MakeKey(c, "Hello", "world")
 
                 Convey("Exists", func() {
                         // Single key.
-                        er, err := ds.Exists(k)
+                        er, err := Exists(c, k)
                         So(err, ShouldBeNil)
                         So(er.All(), ShouldBeTrue)
 
                         // Single key failure.
-                        _, err = ds.Exists(ds.MakeKey("Fail", "boom"))
+                        _, err = Exists(c, MakeKey(c, "Fail", "boom"))
                         So(err, ShouldEqual, errFail)
 
                         // Single slice of keys.
-                        er, err = ds.Exists([]*Key{k, ds.MakeKey("hello", "other")})
+                        er, err = Exists(c, []*Key{k, MakeKey(c, "hello", "other")})
                         So(err, ShouldBeNil)
                         So(er.All(), ShouldBeTrue)
 
                         // Single slice of keys failure.
-                        er, err = ds.Exists([]*Key{k, ds.MakeKey("Fail", "boom")})
+                        er, err = Exists(c, []*Key{k, MakeKey(c, "Fail", "boom")})
                         So(err, ShouldResemble, errors.MultiError{nil, errFail})
                         So(er.Get(0, 0), ShouldBeTrue)
 
                         // Single key missing.
-                        er, err = ds.Exists(ds.MakeKey("DNE", "nope"))
+                        er, err = Exists(c, MakeKey(c, "DNE", "nope"))
                         So(err, ShouldBeNil)
                         So(er.Any(), ShouldBeFalse)
 
                         // Multi-arg keys with one missing.
-                        er, err = ds.Exists(k, ds.MakeKey("DNE", "other"))
+                        er, err = Exists(c, k, MakeKey(c, "DNE", "other"))
                         So(err, ShouldBeNil)
                         So(er.Get(0), ShouldBeTrue)
                         So(er.Get(1), ShouldBeFalse)
 
                         // Multi-arg keys with two missing.
-                        er, err = ds.Exists(ds.MakeKey("DNE", "nope"), ds.MakeKey("DNE", "other"))
+                        er, err = Exists(c, MakeKey(c, "DNE", "nope"), MakeKey(c, "DNE", "other"))
                         So(err, ShouldBeNil)
                         So(er.Any(), ShouldBeFalse)
 
                         // Single struct pointer.
-                        er, err = ds.Exists(&CommonStruct{ID: 1})
+                        er, err = Exists(c, &CommonStruct{ID: 1})
                         So(err, ShouldBeNil)
                         So(er.All(), ShouldBeTrue)
 
                         // Multi-arg mixed key/struct/slices.
-                        er, err = ds.Exists(
+                        er, err = Exists(c,
                                 &CommonStruct{ID: 1},
                                 []*CommonStruct(nil),
-                                []*Key{ds.MakeKey("DNE", "nope"), ds.MakeKey("hello", "ohai")},
+                                []*Key{MakeKey(c, "DNE", "nope"), MakeKey(c, "hello", "ohai")},
                         )
                         So(err, ShouldBeNil)
                         So(er.Get(0), ShouldBeTrue)
                         So(er.Get(1), ShouldBeTrue)
                         So(er.Get(2), ShouldBeFalse)
                         So(er.Get(2, 0), ShouldBeFalse)
                         So(er.Get(2, 1), ShouldBeTrue)
                 })
-
-                Convey("ExistsMulti", func() {
-                        Convey("Returns no error if there are no failures.", func() {
-                                bl, err := ds.ExistsMulti([]*Key{k, ds.MakeKey("DNE", "nope"), ds.MakeKey("hello", "ohai")})
-                                So(err, ShouldBeNil)
-                                So(bl, ShouldResemble, BoolList{true, false, true})
-                        })
-
-                        Convey("Returns an item error in a MultiError.", func() {
-                                _, err := ds.ExistsMulti([]*Key{k, ds.MakeKey("Fail", "boom")})
-                                So(err, ShouldResemble, errors.MultiError{nil, errFail})
-                        })
-                })
         })
 }
 
 func TestDelete(t *testing.T) {
         t.Parallel()
 
         Convey("A testing environment", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
-                So(ds, ShouldNotBeNil)
 
                 Convey("Testing Delete", func() {
                         Convey("bad", func() {
                                 Convey("get single error for RPC failure", func() {
                                         keys := []*Key{
-                                                MakeKey("s~aid", "ns", "FailAll", 1),
-                                                MakeKey("s~aid", "ns", "Ok", 1),
+                                                MakeKey(c, "s~aid", "ns", "FailAll", 1),
+                                                MakeKey(c, "s~aid", "ns", "Ok", 1),
                                         }
-                                        So(ds.Delete(keys), ShouldEqual, errFailAll)
+                                        So(Delete(c, keys), ShouldEqual, errFailAll)
                                 })
 
                                 Convey("get multi error for individual failure", func() {
                                         keys := []*Key{
-                                                ds.MakeKey("Ok", 1),
-                                                ds.MakeKey("Fail", 2),
+                                                MakeKey(c, "Ok", 1),
+                                                MakeKey(c, "Fail", 2),
                                         }
-                                        So(ds.Delete(keys), ShouldResemble, errors.MultiError{nil, errFail})
+                                        So(Delete(c, keys), ShouldResemble, errors.MultiError{nil, errFail})
                                 })
 
                                 Convey("put with non-modifyable type is an error", func() {
                                         cs := CommonStruct{}
-                                        So(func() { ds.Put(cs) }, ShouldPanicLike,
+                                        So(func() { Put(c, cs) }, ShouldPanicLike,
                                                 "invalid input type (datastore.CommonStruct): not a pointer")
                                 })
 
                                 Convey("get single error when deleting a single", func() {
-                                        k := ds.MakeKey("Fail", 1)
-                                        So(ds.Delete(k), ShouldEqual, errFail)
+                                        k := MakeKey(c, "Fail", 1)
+                                        So(Delete(c, k), ShouldEqual, errFail)
                                 })
                         })
 
                         Convey("good", func() {
                                 // Single struct pointer.
-                                So(ds.Delete(&CommonStruct{ID: 1}), ShouldBeNil)
+                                So(Delete(c, &CommonStruct{ID: 1}), ShouldBeNil)
 
                                 // Single key.
-                                So(ds.Delete(ds.MakeKey("hello", "ohai")), ShouldBeNil)
+                                So(Delete(c, MakeKey(c, "hello", "ohai")), ShouldBeNil)
 
                                 // Single struct DNE.
-                                So(ds.Delete(&CommonStruct{ID: noSuchEntityID}), ShouldEqual, ErrNoSuchEntity)
+                                So(Delete(c, &CommonStruct{ID: noSuchEntityID}), ShouldEqual, ErrNoSuchEntity)
 
                                 // Single key DNE.
-                                So(ds.Delete(ds.MakeKey("DNE", "nope")), ShouldEqual, ErrNoSuchEntity)
+                                So(Delete(c, MakeKey(c, "DNE", "nope")), ShouldEqual, ErrNoSuchEntity)
 
                                 // Mixed key/struct/slices.
-                                err := ds.Delete(
+                                err := Delete(c,
                                         &CommonStruct{ID: 1},
-                                        []*Key{ds.MakeKey("hello", "ohai"), ds.MakeKey("DNE", "nope")},
+                                        []*Key{MakeKey(c, "hello", "ohai"), MakeKey(c, "DNE", "nope")},
                                 )
                                 So(err, ShouldResemble, errors.MultiError{nil, errors.MultiError{nil, ErrNoSuchEntity}})
                         })
                 })
-
-                Convey("Testing DeleteMulti", func() {
-                        Convey("Succeeds for valid keys.", func() {
-                                So(ds.DeleteMulti([]*Key{ds.MakeKey("hello", "ohai")}), ShouldBeNil)
-                                So(ds.DeleteMulti([]*Key{ds.MakeKey("hello", "ohai"), ds.MakeKey("hello", "sup")}), ShouldBeNil)
-                        })
-
-                        Convey("Returns an item error in a MultiError.", func() {
-                                So(ds.DeleteMulti([]*Key{ds.MakeKey("DNE", "oops")}), ShouldResemble, errors.MultiError{ErrNoSuchEntity})
-                        })
-                })
         })
 }
 
 func TestGet(t *testing.T) {
         t.Parallel()
 
         Convey("A testing environment", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
-                So(ds, ShouldNotBeNil)
 
                 Convey("Testing Get", func() {
                         Convey("bad", func() {
                                 Convey("static can't serialize", func() {
                                         toGet := []badStruct{{}, {}}
-                                        So(func() { ds.Get(toGet) }, ShouldPanicLike,
+                                        So(func() { Get(c, toGet) }, ShouldPanicLike,
                                                 `field "Compy" has invalid type: complex64`)
                                 })
 
                                 Convey("can't get keys", func() {
                                         fplss := []FakePLS{{failGetMeta: true}, {}}
-                                        So(ds.Get(fplss), ShouldErrLike, "unable to extract $kind")
+                                        So(Get(c, fplss), ShouldErrLike, "unable to extract $kind")
                                 })
 
                                 Convey("get single error for RPC failure", func() {
                                         fplss := []FakePLS{
                                                 {IntID: 1, Kind: "FailAll"},
                                                 {IntID: 2},
                                         }
-                                        So(ds.Get(fplss), ShouldEqual, errFailAll)
+                                        So(Get(c, fplss), ShouldEqual, errFailAll)
                                 })
 
                                 Convey("get multi error for individual failures", func() {
                                         fplss := []FakePLS{{IntID: 1}, {IntID: 2, Kind: "Fail"}}
-                                        So(ds.Get(fplss), ShouldResemble, errors.MultiError{nil, errFail})
+                                        So(Get(c, fplss), ShouldResemble, errors.MultiError{nil, errFail})
                                 })
 
                                 Convey("get with non-modifiable type is an error", func() {
                                         cs := CommonStruct{}
-                                        So(func() { ds.Get(cs) }, ShouldPanicLike,
+                                        So(func() { Get(c, cs) }, ShouldPanicLike,
                                                 "invalid input type (datastore.CommonStruct): not a pointer")
                                 })
 
                                 Convey("get with nil is an error", func() {
-                                        So(func() { ds.Get(nil) }, ShouldPanicLike,
+                                        So(func() { Get(c, nil) }, ShouldPanicLike,
                                                 "cannot use nil as single argument")
                                 })
 
                                 Convey("get with ptr-to-nonstruct is an error", func() {
                                         val := 100
-                                        So(func() { ds.Get(&val) }, ShouldPanicLike,
+                                        So(func() { Get(c, &val) }, ShouldPanicLike,
                                                 "invalid input type (*int): not a PLS, pointer-to-struct, or slice thereof")
                                 })
 
                                 Convey("failure to save metadata is no problem though", func() {
                                         // It just won't save the key
                                         cs := &FakePLS{IntID: 10, failSetMeta: true}
-                                        So(ds.Get(cs), ShouldBeNil)
+                                        So(Get(c, cs), ShouldBeNil)
                                 })
 
                                 Convey("vararg with errors", func() {
                                         successSlice := []CommonStruct{{ID: 1}, {ID: 2}}
                                         failSlice := []CommonStruct{{ID: noSuchEntityID}, {ID: 3}}
                                         emptySlice := []CommonStruct(nil)
                                         cs0 := CommonStruct{ID: 4}
                                         failPLS := CommonStruct{ID: noSuchEntityID}
                                         fpls := FakePLS{StringID: "ohai"}
 
-                                        err := ds.Get(successSlice, failSlice, emptySlice, &cs0, &failPLS, &fpls)
+                                        err := Get(c, successSlice, failSlice, emptySlice, &cs0, &failPLS, &fpls)
                                         So(err, ShouldResemble, errors.MultiError{
                                                 nil, errors.MultiError{ErrNoSuchEntity, nil}, nil, nil, ErrNoSuchEntity, nil})
                                         So(successSlice[0].Value, ShouldEqual, 1)
                                         So(successSlice[1].Value, ShouldEqual, 2)
                                         So(cs0.Value, ShouldEqual, 5)
                                         So(fpls.Value, ShouldEqual, 7)
                                 })
                         })
 
                         Convey("ok", func() {
                                 Convey("Get", func() {
                                         cs := &CommonStruct{ID: 1}
-                                        So(ds.Get(cs), ShouldBeNil)
+                                        So(Get(c, cs), ShouldBeNil)
                                         So(cs.Value, ShouldEqual, 1)
                                 })
 
                                 Convey("Raw access too", func() {
-                                        rds := ds.Raw()
-                                        keys := []*Key{ds.MakeKey("Kind", 1)}
+                                        rds := Raw(c)
+                                        keys := []*Key{MakeKey(c, "Kind", 1)}
                                         So(rds.GetMulti(keys, nil, func(pm PropertyMap, err error) error {
                                                 So(err, ShouldBeNil)
                                                 So(pm.Slice("Value")[0].Value(), ShouldEqual, 1)
                                                 return nil
                                         }), ShouldBeNil)
                                 })
 
                                 Convey("but general failure to save is fine on a Get", func() {
                                         cs := &FakePLS{failSave: true, IntID: 7}
-                                        So(ds.Get(cs), ShouldBeNil)
+                                        So(Get(c, cs), ShouldBeNil)
                                 })
 
                                 Convey("vararg", func() {
                                         successSlice := []CommonStruct{{ID: 1}, {ID: 2}}
                                         cs := CommonStruct{ID: 3}
 
-                                        err := ds.Get(successSlice, &cs)
+                                        err := Get(c, successSlice, &cs)
                                         So(err, ShouldBeNil)
                                         So(successSlice[0].Value, ShouldEqual, 1)
                                         So(successSlice[1].Value, ShouldEqual, 2)
                                         So(cs.Value, ShouldEqual, 3)
                                 })
                         })
                 })
-
-                Convey("Testing GetMulti", func() {
-                        Convey("Fails for something other than a slice.", func() {
-                                cs := CommonStruct{}
-                                So(func() { ds.GetMulti(&cs) }, ShouldPanicLike,
-                                        "argument must be a slice, not *datastore.CommonStruct")
-                        })
-
-                        Convey("Succeeds for a slice.", func() {
-                                cs := []CommonStruct{{ID: 1}}
-                                So(ds.GetMulti(cs), ShouldBeNil)
-                                So(cs[0].Value, ShouldEqual, 1)
-                        })
-
-                        Convey("Returns an item error in a MultiError.", func() {
-                                cs := []CommonStruct{{ID: 1}, {ID: noSuchEntityID}}
-                                err := ds.GetMulti(cs)
-                                So(err, ShouldResemble, errors.MultiError{nil, ErrNoSuchEntity})
-                                So(cs[0].Value, ShouldEqual, 1)
-                        })
-                })
         })
 }
 
 func TestGetAll(t *testing.T) {
         t.Parallel()
 
         Convey("Test GetAll", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
-                So(ds, ShouldNotBeNil)
 
                 q := NewQuery("").Limit(5)
 
                 Convey("bad", func() {
                         Convey("nil target", func() {
-                                So(func() { ds.GetAll(q, (*[]PropertyMap)(nil)) }, ShouldPanicLike,
+                                So(func() { GetAll(c, q, (*[]PropertyMap)(nil)) }, ShouldPanicLike,
                                         "invalid GetAll dst: <nil>")
                         })
 
                         Convey("bad type", func() {
                                 output := 100
-                                So(func() { ds.GetAll(q, &output) }, ShouldPanicLike,
+                                So(func() { GetAll(c, q, &output) }, ShouldPanicLike,
                                         "invalid argument type: expected slice, got int")
                         })
 
                         Convey("bad type (non pointer)", func() {
-                                So(func() { ds.GetAll(q, "moo") }, ShouldPanicLike,
+                                So(func() { GetAll(c, q, "moo") }, ShouldPanicLike,
                                         "invalid GetAll dst: must have a ptr-to-slice")
                         })
 
                         Convey("bad type (underspecified)", func() {
                                 output := []PropertyLoadSaver(nil)
-                                So(func() { ds.GetAll(q, &output) }, ShouldPanicLike,
+                                So(func() { GetAll(c, q, &output) }, ShouldPanicLike,
                                         "invalid GetAll dst (non-concrete element type): *[]datastore.PropertyLoadSaver")
                         })
                 })
 
                 Convey("ok", func() {
                         Convey("*[]S", func() {
                                 output := []CommonStruct(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         So(o.ID, ShouldEqual, i+1)
                                         So(o.Value, ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]*S", func() {
                                 output := []*CommonStruct(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         So(o.ID, ShouldEqual, i+1)
                                         So(o.Value, ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]P", func() {
                                 output := []FakePLS(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         So(o.gotLoaded, ShouldBeTrue)
                                         So(o.IntID, ShouldEqual, i+1)
                                         So(o.Value, ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]P (map)", func() {
                                 output := []PropertyMap(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         k, ok := o.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So(o.Slice("Value")[0].Value().(int64), ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]P (chan)", func() {
                                 output := []plsChan(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(output, ShouldHaveLength, 5)
                                 for _, o := range output {
-                                        So(ds.KeyForObj(o).StringID(), ShouldEqual, "whyDoIExist")
+                                        So(KeyForObj(c, o).StringID(), ShouldEqual, "whyDoIExist")
                                 }
                         })
 
                         Convey("*[]*P", func() {
                                 output := []*FakePLS(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, o := range output {
                                         So(o.gotLoaded, ShouldBeTrue)
                                         So(o.IntID, ShouldEqual, i+1)
                                         So(o.Value, ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]*P (map)", func() {
                                 output := []*PropertyMap(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, op := range output {
                                         o := *op
                                         k, ok := o.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So(o.Slice("Value")[0].Value().(int64), ShouldEqual, i)
                                 }
                         })
 
                         Convey("*[]*P (chan)", func() {
                                 output := []*plsChan(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(output, ShouldHaveLength, 5)
                                 for _, o := range output {
-                                        So(ds.KeyForObj(o).StringID(), ShouldEqual, "whyDoIExist")
+                                        So(KeyForObj(c, o).StringID(), ShouldEqual, "whyDoIExist")
                                 }
                         })
 
                         Convey("*[]*Key", func() {
                                 output := []*Key(nil)
-                                So(ds.GetAll(q, &output), ShouldBeNil)
+                                So(GetAll(c, q, &output), ShouldBeNil)
                                 So(len(output), ShouldEqual, 5)
                                 for i, k := range output {
                                         So(k.IntID(), ShouldEqual, i+1)
                                 }
                         })
 
                 })
         })
 }
 
 func TestRun(t *testing.T) {
         t.Parallel()
 
         Convey("Test Run", t, func() {
                 c := info.Set(context.Background(), fakeInfo{})
                 c = SetRawFactory(c, fakeDatastoreFactory)
-                ds := Get(c)
-                So(ds, ShouldNotBeNil)
 
                 q := NewQuery("kind").Limit(5)
 
                 Convey("bad", func() {
                         assertBadTypePanics := func(cb interface{}) {
-                                So(func() { ds.Run(q, cb) }, ShouldPanicLike,
+                                So(func() { Run(c, q, cb) }, ShouldPanicLike,
                                         "cb does not match the required callback signature")
                         }
 
                         Convey("not a function", func() {
                                 assertBadTypePanics("I am a potato")
                         })
 
                         Convey("nil", func() {
                                 assertBadTypePanics(nil)
                         })
 
                         Convey("interface", func() {
                                 assertBadTypePanics(func(pls PropertyLoadSaver) {})
                         })
 
                         Convey("bad proto type", func() {
                                 cb := func(v int) {
                                         panic("never here!")
                                 }
-                                So(func() { ds.Run(q, cb) }, ShouldPanicLike,
+                                So(func() { Run(c, q, cb) }, ShouldPanicLike,
                                         "invalid argument type: int is not a PLS or pointer-to-struct")
                         })
 
                         Convey("wrong # args", func() {
                                 assertBadTypePanics(func(v CommonStruct, _ CursorCB, _ int) {
                                         panic("never here!")
                                 })
                         })
 
                         Convey("wrong ret type", func() {
@@ skipping 10 matching lines @@
 
                         Convey("bad 2nd arg", func() {
                                 assertBadTypePanics(func(v CommonStruct, _ Cursor) error {
                                         panic("never here!")
                                 })
                         })
 
                         Convey("early abort on error", func() {
                                 q = q.Eq("$err_single", "Query fail").Eq("$err_single_idx", 3)
                                 i := 0
-                                So(ds.Run(q, func(c CommonStruct) {
+                                So(Run(c, q, func(c CommonStruct) {
                                         i++
                                 }), ShouldErrLike, "Query fail")
                                 So(i, ShouldEqual, 3)
                         })
 
                         Convey("return error on serialization failure", func() {
-                                So(ds.Run(q, func(_ permaBad) {
+                                So(Run(c, q, func(_ permaBad) {
                                         panic("never here")
                                 }).Error(), ShouldEqual, "permaBad")
                         })
                 })
 
                 Convey("ok", func() {
                         Convey("can return error to stop", func() {
                                 i := 0
-                                So(ds.Run(q, func(c CommonStruct) error {
+                                So(Run(c, q, func(c CommonStruct) error {
                                         i++
                                         return Stop
                                 }), ShouldBeNil)
                                 So(i, ShouldEqual, 1)
 
                                 i = 0
-                                So(ds.Run(q, func(c CommonStruct, _ CursorCB) error {
+                                So(Run(c, q, func(c CommonStruct, _ CursorCB) error {
                                         i++
                                         return fmt.Errorf("my error")
                                 }), ShouldErrLike, "my error")
                                 So(i, ShouldEqual, 1)
                         })
 
                         Convey("Can optionally get cursor function", func() {
                                 i := 0
-                                So(ds.Run(q, func(c CommonStruct, ccb CursorCB) {
+                                So(Run(c, q, func(c CommonStruct, ccb CursorCB) {
                                         i++
                                         curs, err := ccb()
                                         So(err, ShouldBeNil)
                                         So(curs.String(), ShouldEqual, "CURSOR")
                                 }), ShouldBeNil)
                                 So(i, ShouldEqual, 5)
                         })
 
                         Convey("*S", func() {
                                 i := 0
-                                So(ds.Run(q, func(cs *CommonStruct) {
+                                So(Run(c, q, func(cs *CommonStruct) {
                                         So(cs.ID, ShouldEqual, i+1)
                                         So(cs.Value, ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P", func() {
                                 i := 0
-                                So(ds.Run(q.Limit(12), func(fpls *FakePLS) {
+                                So(Run(c, q.Limit(12), func(fpls *FakePLS) {
                                         So(fpls.gotLoaded, ShouldBeTrue)
                                         if i == 10 {
                                                 So(fpls.StringID, ShouldEqual, "eleven")
                                         } else {
                                                 So(fpls.IntID, ShouldEqual, i+1)
                                         }
                                         So(fpls.Value, ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P (map)", func() {
                                 i := 0
-                                So(ds.Run(q, func(pm *PropertyMap) {
+                                So(Run(c, q, func(pm *PropertyMap) {
                                         k, ok := pm.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So((*pm).Slice("Value")[0].Value(), ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("*P (chan)", func() {
-                                So(ds.Run(q, func(c *plsChan) {
-                                        So(ds.KeyForObj(c).StringID(), ShouldEqual, "whyDoIExist")
+                                So(Run(c, q, func(ch *plsChan) {
+                                        So(KeyForObj(c, ch).StringID(), ShouldEqual, "whyDoIExist")
                                 }), ShouldBeNil)
                         })
 
                         Convey("S", func() {
                                 i := 0
-                                So(ds.Run(q, func(cs CommonStruct) {
+                                So(Run(c, q, func(cs CommonStruct) {
                                         So(cs.ID, ShouldEqual, i+1)
                                         So(cs.Value, ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("P", func() {
                                 i := 0
-                                So(ds.Run(q, func(fpls FakePLS) {
+                                So(Run(c, q, func(fpls FakePLS) {
                                         So(fpls.gotLoaded, ShouldBeTrue)
                                         So(fpls.IntID, ShouldEqual, i+1)
                                         So(fpls.Value, ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("P (map)", func() {
                                 i := 0
-                                So(ds.Run(q, func(pm PropertyMap) {
+                                So(Run(c, q, func(pm PropertyMap) {
                                         k, ok := pm.GetMeta("key")
                                         So(ok, ShouldBeTrue)
                                         So(k.(*Key).IntID(), ShouldEqual, i+1)
                                         So(pm.Slice("Value")[0].Value(), ShouldEqual, i)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                         Convey("P (chan)", func() {
-                                So(ds.Run(q, func(c plsChan) {
-                                        So(ds.KeyForObj(c).StringID(), ShouldEqual, "whyDoIExist")
+                                So(Run(c, q, func(ch plsChan) {
+                                        So(KeyForObj(c, ch).StringID(), ShouldEqual, "whyDoIExist")
                                 }), ShouldBeNil)
                         })
 
                         Convey("Key", func() {
                                 i := 0
-                                So(ds.Run(q, func(k *Key) {
+                                So(Run(c, q, func(k *Key) {
                                         So(k.IntID(), ShouldEqual, i+1)
                                         i++
                                 }), ShouldBeNil)
                         })
 
                 })
         })
 }
 
 type fixedDataDatastore struct {
@@ skipping 26 matching lines @@
                 cb(k, nil)
         }
         return nil
 }
 
 func TestSchemaChange(t *testing.T) {
         t.Parallel()
 
         Convey("Test changing schemas", t, func() {
                 fds := fixedDataDatastore{}
-                ds := &datastoreImpl{&fds, "", ""}
+                c := info.Set(context.Background(), fakeInfo{})
+                c = SetRaw(c, &fds)
 
                 Convey("Can add fields", func() {
                         initial := PropertyMap{
-                                "$key": mpNI(ds.MakeKey("Val", 10)),
+                                "$key": mpNI(MakeKey(c, "Val", 10)),
                                 "Val":  mp(100),
                         }
-                        So(ds.Put(initial), ShouldBeNil)
+                        So(Put(c, initial), ShouldBeNil)
 
                         type Val struct {
                                 ID int64 `gae:"$id"`
 
                                 Val    int64
                                 TwoVal int64 // whoa, TWO vals! amazing
                         }
                         tv := &Val{ID: 10, TwoVal: 2}
-                        So(ds.Get(tv), ShouldBeNil)
+                        So(Get(c, tv), ShouldBeNil)
                         So(tv, ShouldResemble, &Val{ID: 10, Val: 100, TwoVal: 2})
                 })
 
                 Convey("Removing fields", func() {
                         initial := PropertyMap{
-                                "$key":   mpNI(ds.MakeKey("Val", 10)),
+                                "$key":   mpNI(MakeKey(c, "Val", 10)),
                                 "Val":    mp(100),
                                 "TwoVal": mp(200),
                         }
-                        So(ds.Put(initial), ShouldBeNil)
+                        So(Put(c, initial), ShouldBeNil)
 
                         Convey("is normally an error", func() {
                                 type Val struct {
                                         ID int64 `gae:"$id"`
 
                                         Val int64
                                 }
                                 tv := &Val{ID: 10}
-                                So(ds.Get(tv), ShouldErrLike,
+                                So(Get(c, tv), ShouldErrLike,
                                         `gae: cannot load field "TwoVal" into a "datastore.Val`)
                                 So(tv, ShouldResemble, &Val{ID: 10, Val: 100})
                         })
 
                         Convey("Unless you have an ,extra field!", func() {
                                 type Val struct {
                                         ID int64 `gae:"$id"`
 
                                         Val   int64
                                         Extra PropertyMap `gae:",extra"`
                                 }
                                 tv := &Val{ID: 10}
-                                So(ds.Get(tv), ShouldBeNil)
+                                So(Get(c, tv), ShouldBeNil)
                                 So(tv, ShouldResemble, &Val{
                                         ID:  10,
                                         Val: 100,
                                         Extra: PropertyMap{
                                                 "TwoVal": PropertySlice{mp(200)},
                                         },
                                 })
                         })
                 })
 
                 Convey("Can round-trip extra fields", func() {
                         type Expando struct {
                                 ID int64 `gae:"$id"`
 
                                 Something int
                                 Extra     PropertyMap `gae:",extra"`
                         }
                         ex := &Expando{10, 17, PropertyMap{
                                 "Hello": mp("Hello"),
                                 "World": mp(true),
                         }}
-                        So(ds.Put(ex), ShouldBeNil)
+                        So(Put(c, ex), ShouldBeNil)
 
                         ex = &Expando{ID: 10}
-                        So(ds.Get(ex), ShouldBeNil)
+                        So(Get(c, ex), ShouldBeNil)
                         So(ex, ShouldResemble, &Expando{
                                 ID:        10,
                                 Something: 17,
                                 Extra: PropertyMap{
                                         "Hello": PropertySlice{mp("Hello")},
                                         "World": PropertySlice{mp(true)},
                                 },
                         })
                 })
 
                 Convey("Can read-but-not-write", func() {
                         initial := PropertyMap{
-                                "$key":   mpNI(ds.MakeKey("Convert", 10)),
+                                "$key":   mpNI(MakeKey(c, "Convert", 10)),
                                 "Val":    mp(100),
                                 "TwoVal": mp(200),
                         }
-                        So(ds.Put(initial), ShouldBeNil)
+                        So(Put(c, initial), ShouldBeNil)
                         type Convert struct {
                                 ID int64 `gae:"$id"`
 
                                 Val    int64
                                 NewVal int64
                                 Extra  PropertyMap `gae:"-,extra"`
                         }
-                        c := &Convert{ID: 10}
-                        So(ds.Get(c), ShouldBeNil)
-                        So(c, ShouldResemble, &Convert{
+                        cnv := &Convert{ID: 10}
+                        So(Get(c, cnv), ShouldBeNil)
+                        So(cnv, ShouldResemble, &Convert{
                                 ID: 10, Val: 100, NewVal: 0, Extra: PropertyMap{"TwoVal": PropertySlice{mp(200)}},
                         })
-                        c.NewVal = c.Extra.Slice("TwoVal")[0].Value().(int64)
-                        So(ds.Put(c), ShouldBeNil)
+                        cnv.NewVal = cnv.Extra.Slice("TwoVal")[0].Value().(int64)
+                        So(Put(c, cnv), ShouldBeNil)
 
-                        c = &Convert{ID: 10}
-                        So(ds.Get(c), ShouldBeNil)
-                        So(c, ShouldResemble, &Convert{
+                        cnv = &Convert{ID: 10}
+                        So(Get(c, cnv), ShouldBeNil)
+                        So(cnv, ShouldResemble, &Convert{
                                 ID: 10, Val: 100, NewVal: 200, Extra: nil,
                         })
                 })
 
                 Convey("Can black hole", func() {
                         initial := PropertyMap{
-                                "$key":   mpNI(ds.MakeKey("BlackHole", 10)),
+                                "$key":   mpNI(MakeKey(c, "BlackHole", 10)),
                                 "Val":    mp(100),
                                 "TwoVal": mp(200),
                         }
-                        So(ds.Put(initial), ShouldBeNil)
+                        So(Put(c, initial), ShouldBeNil)
                         type BlackHole struct {
                                 ID int64 `gae:"$id"`
 
                                 NewStuff  string
                                 blackHole PropertyMap `gae:"-,extra"`
                         }
                         b := &BlackHole{ID: 10, NewStuff: "(╯°□°)╯︵ ┻━┻"}
-                        So(ds.Get(b), ShouldBeNil)
+                        So(Get(c, b), ShouldBeNil)
                         So(b, ShouldResemble, &BlackHole{ID: 10, NewStuff: "(╯°□°)╯︵ ┻━┻"})
                 })
 
                 Convey("Can change field types", func() {
                         initial := PropertyMap{
-                                "$key": mpNI(ds.MakeKey("IntChange", 10)),
+                                "$key": mpNI(MakeKey(c, "IntChange", 10)),
                                 "Val":  mp(100),
                         }
-                        So(ds.Put(initial), ShouldBeNil)
+                        So(Put(c, initial), ShouldBeNil)
 
                         type IntChange struct {
                                 ID    int64 `gae:"$id"`
                                 Val   string
                                 Extra PropertyMap `gae:"-,extra"`
                         }
                         i := &IntChange{ID: 10}
-                        So(ds.Get(i), ShouldBeNil)
+                        So(Get(c, i), ShouldBeNil)
                         So(i, ShouldResemble, &IntChange{ID: 10, Extra: PropertyMap{"Val": PropertySlice{mp(100)}}})
                         i.Val = fmt.Sprint(i.Extra.Slice("Val")[0].Value())
-                        So(ds.Put(i), ShouldBeNil)
+                        So(Put(c, i), ShouldBeNil)
 
                         i = &IntChange{ID: 10}
-                        So(ds.Get(i), ShouldBeNil)
+                        So(Get(c, i), ShouldBeNil)
                         So(i, ShouldResemble, &IntChange{ID: 10, Val: "100"})
                 })
 
                 Convey("Native fields have priority over Extra fields", func() {
                         type Dup struct {
                                 ID    int64 `gae:"$id"`
                                 Val   int64
                                 Extra PropertyMap `gae:",extra"`
                         }
                         d := &Dup{ID: 10, Val: 100, Extra: PropertyMap{
                                 "Val":   PropertySlice{mp(200)},
                                 "Other": PropertySlice{mp("other")},
                         }}
-                        So(ds.Put(d), ShouldBeNil)
+                        So(Put(c, d), ShouldBeNil)
 
                         d = &Dup{ID: 10}
-                        So(ds.Get(d), ShouldBeNil)
+                        So(Get(c, d), ShouldBeNil)
                         So(d, ShouldResemble, &Dup{
                                 ID: 10, Val: 100, Extra: PropertyMap{"Other": PropertySlice{mp("other")}},
                         })
                 })
 
                 Convey("Can change repeated field to non-repeating field", func() {
                         initial := PropertyMap{
-                                "$key": mpNI(ds.MakeKey("NonRepeating", 10)),
+                                "$key": mpNI(MakeKey(c, "NonRepeating", 10)),
                                 "Val":  PropertySlice{mp(100), mp(200), mp(400)},
                         }
-                        So(ds.Put(initial), ShouldBeNil)
+                        So(Put(c, initial), ShouldBeNil)
 
                         type NonRepeating struct {
                                 ID    int64 `gae:"$id"`
                                 Val   int64
                                 Extra PropertyMap `gae:",extra"`
                         }
                         n := &NonRepeating{ID: 10}
-                        So(ds.Get(n), ShouldBeNil)
+                        So(Get(c, n), ShouldBeNil)
                         So(n, ShouldResemble, &NonRepeating{
                                 ID: 10, Val: 0, Extra: PropertyMap{
                                         "Val": PropertySlice{mp(100), mp(200), mp(400)},
                                 },
                         })
                 })
 
                 Convey("Deals correctly with recursive types", func() {
                         initial := PropertyMap{
-                                "$key": mpNI(ds.MakeKey("Outer", 10)),
+                                "$key": mpNI(MakeKey(c, "Outer", 10)),
                                 "I.A":  PropertySlice{mp(1), mp(2), mp(4)},
                                 "I.B":  PropertySlice{mp(10), mp(20), mp(40)},
                                 "I.C":  PropertySlice{mp(100), mp(200), mp(400)},
                         }
-                        So(ds.Put(initial), ShouldBeNil)
+                        So(Put(c, initial), ShouldBeNil)
                         type Inner struct {
                                 A int64
                                 B int64
                         }
                         type Outer struct {
                                 ID int64 `gae:"$id"`
 
                                 I     []Inner
                                 Extra PropertyMap `gae:",extra"`
                         }
                         o := &Outer{ID: 10}
-                        So(ds.Get(o), ShouldBeNil)
+                        So(Get(c, o), ShouldBeNil)
                         So(o, ShouldResemble, &Outer{
                                 ID: 10,
                                 I: []Inner{
                                         {1, 10},
                                         {2, 20},
                                         {4, 40},
                                 },
                                 Extra: PropertyMap{
                                         "I.C": PropertySlice{mp(100), mp(200), mp(400)},
                                 },
@@ skipping 253 matching lines @@
                         if err != nil {
                                 panic(fmt.Errorf("failed to find absolute path for `%s`", sameLevelDir))
                         }
 
                         ids, err := FindAndParseIndexYAML(abs)
                         So(err, ShouldBeNil)
                         So(ids[1].Kind, ShouldEqual, "Test Foo")
                 })
         })
 }