Interface update, per-method Contexts.

impl/memory/datastore_query_execution_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.
 
 package memory
 
 import (
         "fmt"
         "strings"
         "testing"
         "time"
 
         "github.com/luci/gae/service/blobstore"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
+func mkKey(appID, namespace string, elems ...interface{}) *ds.Key {
+        return ds.KeyContext{appID, namespace}.MakeKey(elems...)
+}
+
 type qExpect struct {
         q     *ds.Query
         inTxn bool
 
         get   []ds.PropertyMap
         keys  []*ds.Key
         count int
 }
 
 type qExStage struct {
@@ skipping 46 matching lines @@
                 "Extra", "hello", "waffle",
         ),
         pmap("$key", key("Kind", 3, "Kind", 2), Next,
                 "Val", 3, 4, Next,
                 "Extra", "hello", "waffle",
         ),
         pmap("$key", key("Kind", 3, "Kind", 3), Next,
                 "Val", 3, 4, 2, 1, Next,
                 "Extra", "nuts",
         ),
-        pmap("$key", ds.MakeKey("dev~app", "", "Kind", "id")),
-        pmap("$key", ds.MakeKey("dev~app", "bob", "Kind", "id")),
+        pmap("$key", mkKey("dev~app", "", "Kind", "id")),
+        pmap("$key", mkKey("dev~app", "bob", "Kind", "id")),
 }
 
 var collapsedData = []ds.PropertyMap{
         // PTTime
         pmap("$key", key("Kind", 1), Next,
                 "Date", time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC), Next,
         ),
         pmap("$key", key("Kind", 2), Next,
                 "Date", time.Date(2000, time.March, 1, 1, 1, 1, 1, time.UTC), Next,
         ),
@@ skipping 42 matching lines @@
                                         key("Kind", 3, "Child", "seven"),
                                 }},
                                 {q: nq("Child").Ancestor(key("Kind", 3)).EventualConsistency(true), keys: []*ds.Key{}},
                                 {q: nq("Child").Ancestor(key("Kind", 3)).EventualConsistency(true), keys: []*ds.Key{
                                         key("Kind", 3, "Child", "seven"),
                                 }, inTxn: true},
                                 {q: nq("Child").Ancestor(key("Kind", 3)), keys: []*ds.Key{
                                         key("Kind", 3, "Child", "seven"),
                                 }, inTxn: true},
                                 {q: nq("__namespace__"), get: []ds.PropertyMap{
-                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "ns")),
+                                        pmap("$key", mkKey("dev~app", "", "__namespace__", "ns")),
                                 }},
                                 {q: nq("__namespace__").Offset(1), get: []ds.PropertyMap{}},
                                 {q: nq("__namespace__").Offset(1).Limit(1), get: []ds.PropertyMap{}},
                         },
                 },
 
                 {
                         putEnts: stage2Data,
                         delEnts: []*ds.Key{key("Unique", 1)},
                         addIdxs: []*ds.IndexDefinition{
@@ skipping 181 matching lines @@
                                                 "When", 996688461000000),
                                 }},
 
                                 // Original (complex) types are retained when getting the full value.
                                 {q: nq("Kind").Order("When"), get: []ds.PropertyMap{
                                         stage1Data[1],
                                         stage1Data[3],
                                         stage1Data[2],
                                 }},
                                 {q: nq("__namespace__"), get: []ds.PropertyMap{
-                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", 1)),
-                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "bob")),
-                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "ns")),
+                                        pmap("$key", mkKey("dev~app", "", "__namespace__", 1)),
+                                        pmap("$key", mkKey("dev~app", "", "__namespace__", "bob")),
+                                        pmap("$key", mkKey("dev~app", "", "__namespace__", "ns")),
                                 }},
                                 {q: nq("__namespace__").Offset(1), get: []ds.PropertyMap{
-                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "bob")),
-                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "ns")),
+                                        pmap("$key", mkKey("dev~app", "", "__namespace__", "bob")),
+                                        pmap("$key", mkKey("dev~app", "", "__namespace__", "ns")),
                                 }},
                                 {q: nq("__namespace__").Offset(1).Limit(1), get: []ds.PropertyMap{
-                                        pmap("$key", ds.MakeKey("dev~app", "", "__namespace__", "bob")),
+                                        pmap("$key", mkKey("dev~app", "", "__namespace__", "bob")),
                                 }},
                         },
 
                         extraFns: []func(context.Context){
                                 func(c context.Context) {
-                                        data := ds.Get(c)
                                         curs := ds.Cursor(nil)
 
                                         q := nq("").Gt("__key__", key("Kind", 2))
 
-                                        err := data.Run(q, func(pm ds.PropertyMap, gc ds.CursorCB) error {
+                                        err := ds.Run(c, q, func(pm ds.PropertyMap, gc ds.CursorCB) error {
                                                 So(pm, ShouldResemble, pmap(
                                                         "$key", key("Kind", 2, "__entity_group__", 1), Next,
                                                         "__version__", 1))
 
                                                 err := error(nil)
                                                 curs, err = gc()
                                                 So(err, ShouldBeNil)
                                                 return ds.Stop
                                         })
                                         So(err, shouldBeSuccessful)
 
-                                        err = data.Run(q.Start(curs), func(pm ds.PropertyMap) error {
+                                        err = ds.Run(c, q.Start(curs), func(pm ds.PropertyMap) error {
                                                 So(pm, ShouldResemble, stage1Data[2])
                                                 return ds.Stop
                                         })
                                         So(err, shouldBeSuccessful)
                                 },
 
                                 func(c context.Context) {
-                                        data := ds.Get(c)
                                         q := nq("Something").Eq("Does", 2).Order("Not", "-Work")
-                                        So(data.Run(q, func(ds.Key) {}), ShouldErrLike, strings.Join([]string{
+                                        So(ds.Run(c, q, func(ds.Key) {}), ShouldErrLike, strings.Join([]string{
                                                 "Consider adding:",
                                                 "- kind: Something",
                                                 "  properties:",
                                                 "  - name: Does",
                                                 "  - name: Not",
                                                 "  - name: Work",
                                                 "    direction: desc",
                                         }, "\n"))
                                 },
 
                                 func(c context.Context) {
-                                        data := ds.Get(c)
                                         q := nq("Something").Ancestor(key("Kind", 3)).Order("Val")
-                                        So(data.Run(q, func(ds.Key) {}), ShouldErrLike, strings.Join([]string{
+                                        So(ds.Run(c, q, func(ds.Key) {}), ShouldErrLike, strings.Join([]string{
                                                 "Consider adding:",
                                                 "- kind: Something",
                                                 "  ancestor: yes",
                                                 "  properties:",
                                                 "  - name: Val",
                                         }, "\n"))
                                 },
                         },
                 },
 
@@ skipping 60 matching lines @@
                                 },
                         },
                 },
         }},
 }
 
 func TestQueryExecution(t *testing.T) {
         t.Parallel()
 
         Convey("Test query execution", t, func() {
-                c, err := info.Get(Use(context.Background())).Namespace("ns")
+                c, err := info.Namespace(Use(context.Background()), "ns")
                 if err != nil {
                         panic(err)
                 }
 
-                So(info.Get(c).FullyQualifiedAppID(), ShouldEqual, "dev~app")
-                ns, has := info.Get(c).GetNamespace()
-                So(ns, ShouldEqual, "ns")
-                So(has, ShouldBeTrue)
+                So(info.FullyQualifiedAppID(c), ShouldEqual, "dev~app")
+                So(info.GetNamespace(c), ShouldEqual, "ns")
 
-                data := ds.Get(c)
-                testing := data.Testable()
+                testing := ds.GetTestable(c)
 
                 for _, tc := range queryExecutionTests {
                         Convey(tc.name, func() {
                                 for i, stage := range tc.test {
                                         // outside of Convey, since these must always happen
                                         testing.CatchupIndexes()
 
                                         testing.AddIndexes(stage.addIdxs...)
                                         byNs := map[string][]ds.PropertyMap{}
                                         for _, ent := range stage.putEnts {
                                                 k := ds.GetMetaDefault(ent, "key", nil).(*ds.Key)
                                                 byNs[k.Namespace()] = append(byNs[k.Namespace()], ent)
                                         }
                                         for ns, ents := range byNs {
-                                                c := info.Get(c).MustNamespace(ns)
-                                                data := ds.Get(c)
-                                                if err := data.PutMulti(ents); err != nil {
+                                                c := info.MustNamespace(c, ns)
+                                                if err := ds.Put(c, ents); err != nil {
                                                         // prevent Convey from thinking this assertion should show up in
                                                         // every test loop.
                                                         panic(err)
                                                 }
                                         }
 
-                                        if err := data.DeleteMulti(stage.delEnts); err != nil {
+                                        if err := ds.Delete(c, stage.delEnts); err != nil {
                                                 panic(err)
                                         }
 
                                         Convey(fmt.Sprintf("stage %d", i), func() {
                                                 for j, expect := range stage.expect {
-                                                        runner := func(f func(ic context.Context) error, _ *ds.TransactionOptions) error {
+                                                        runner := func(c context.Context, f func(ic context.Context) error, _ *ds.TransactionOptions) error {
                                                                 return f(c)
                                                         }
                                                         if expect.inTxn {
-                                                                runner = data.RunInTransaction
+                                                                runner = ds.RunInTransaction
                                                         }
 
                                                         if expect.count == 0 {
                                                                 if len(expect.keys) > 0 {
                                                                         expect.count = len(expect.keys)
                                                                 } else {
                                                                         expect.count = len(expect.get)
                                                                 }
                                                         }
 
                                                         if expect.keys != nil {
                                                                 Convey(fmt.Sprintf("expect %d (keys)", j), func() {
-                                                                        err := runner(func(c context.Context) error {
-                                                                                data := ds.Get(c)
-                                                                                count, err := data.Count(expect.q)
+                                                                        err := runner(c, func(c context.Context) error {
+                                                                                count, err := ds.Count(c, expect.q)
                                                                                 So(err, shouldBeSuccessful)
                                                                                 So(count, ShouldEqual, expect.count)
 
                                                                                 rslt := []*ds.Key(nil)
-                                                                                So(data.GetAll(expect.q, &rslt), shouldBeSuccessful)
+                                                                                So(ds.GetAll(c, expect.q, &rslt), shouldBeSuccessful)
                                                                                 So(len(rslt), ShouldEqual, len(expect.keys))
                                                                                 for i, r := range rslt {
                                                                                         So(r, ShouldResemble, expect.keys[i])
                                                                                 }
                                                                                 return nil
                                                                         }, &ds.TransactionOptions{XG: true})
                                                                         So(err, shouldBeSuccessful)
                                                                 })
                                                         }
 
                                                         if expect.get != nil {
                                                                 Convey(fmt.Sprintf("expect %d (data)", j), func() {
-                                                                        err := runner(func(c context.Context) error {
-                                                                                data := ds.Get(c)
-                                                                                count, err := data.Count(expect.q)
+                                                                        err := runner(c, func(c context.Context) error {
+                                                                                count, err := ds.Count(c, expect.q)
                                                                                 So(err, shouldBeSuccessful)
                                                                                 So(count, ShouldEqual, expect.count)
 
                                                                                 rslt := []ds.PropertyMap(nil)
-                                                                                So(data.GetAll(expect.q, &rslt), shouldBeSuccessful)
+                                                                                So(ds.GetAll(c, expect.q, &rslt), shouldBeSuccessful)
                                                                                 So(len(rslt), ShouldEqual, len(expect.get))
                                                                                 for i, r := range rslt {
                                                                                         So(r, ShouldResemble, expect.get[i])
                                                                                 }
                                                                                 return nil
                                                                         }, &ds.TransactionOptions{XG: true})
                                                                         So(err, shouldBeSuccessful)
                                                                 })
                                                         }
                                                 }
 
                                                 for j, fn := range stage.extraFns {
                                                         Convey(fmt.Sprintf("extraFn %d", j), func() {
                                                                 fn(c)
                                                         })
                                                 }
                                         })
                                 }
                         })
                 }
         })
 
         Convey("Test AutoIndex", t, func() {
-                c, err := info.Get(Use(context.Background())).Namespace("ns")
+                c, err := info.Namespace(Use(context.Background()), "ns")
                 if err != nil {
                         panic(err)
                 }
 
-                data := ds.Get(c)
-                testing := data.Testable()
+                testing := ds.GetTestable(c)
                 testing.Consistent(true)
 
-                So(data.Put(pmap("$key", key("Kind", 1), Next,
+                So(ds.Put(c, pmap("$key", key("Kind", 1), Next,
                         "Val", 1, 2, 3, Next,
                         "Extra", "hello",
                 )), shouldBeSuccessful)
 
-                So(data.Put(pmap("$key", key("Kind", 2), Next,
+                So(ds.Put(c, pmap("$key", key("Kind", 2), Next,
                         "Val", 2, 3, 9, Next,
                         "Extra", "ace", "hello", "there",
                 )), shouldBeSuccessful)
 
                 q := nq("Kind").Gt("Val", 2).Order("Val", "Extra")
 
-                count, err := data.Count(q)
+                count, err := ds.Count(c, q)
                 So(err, ShouldErrLike, "Insufficient indexes")
 
                 testing.AutoIndex(true)
 
-                count, err = data.Count(q)
+                count, err = ds.Count(c, q)
                 So(err, shouldBeSuccessful)
                 So(count, ShouldEqual, 2)
         })
 }
 
 func shouldBeSuccessful(actual interface{}, expected ...interface{}) string {
         if len(expected) != 0 {
                 return "no expected values permitted"
         }
         if actual == nil {
                 return ""
         }
 
         v, ok := actual.(error)
         if !ok {
                 return fmt.Sprintf("type of 'actual' must be error, not %T", actual)
         }
         if v == nil || v == ds.Stop {
                 return ""
         }
         return fmt.Sprintf("expected success value, not %v", v)
 }