Interface update, per-method Contexts.

filter/count/count_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 count
 
 import (
         "fmt"
         "testing"
 
         "github.com/luci/gae/filter/featureBreaker"
         "github.com/luci/gae/impl/memory"
-        "github.com/luci/gae/service/datastore"
+        ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         "github.com/luci/gae/service/mail"
         "github.com/luci/gae/service/memcache"
         "github.com/luci/gae/service/taskqueue"
         "github.com/luci/gae/service/user"
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
@@ skipping 22 matching lines @@
 func TestCount(t *testing.T) {
         t.Parallel()
 
         Convey("Test Count filter", t, func() {
                 c, fb := featureBreaker.FilterRDS(memory.Use(context.Background()), nil)
                 c, ctr := FilterRDS(c)
 
                 So(c, ShouldNotBeNil)
                 So(ctr, ShouldNotBeNil)
 
-                ds := datastore.Get(c)
-                vals := []datastore.PropertyMap{{
-                        "Val":  datastore.MkProperty(100),
-                        "$key": datastore.MkPropertyNI(ds.NewKey("Kind", "", 1, nil)),
+                vals := []ds.PropertyMap{{
+                        "Val":  ds.MkProperty(100),
+                        "$key": ds.MkPropertyNI(ds.NewKey(c, "Kind", "", 1, nil)),
                 }}
 
                 Convey("Calling a ds function should reflect in counter", func() {
-                        So(ds.PutMulti(vals), ShouldBeNil)
+                        So(ds.Put(c, vals), ShouldBeNil)
                         So(ctr.PutMulti.Successes(), ShouldEqual, 1)
 
                         Convey("effects are cumulative", func() {
-                                So(ds.PutMulti(vals), ShouldBeNil)
+                                So(ds.Put(c, vals), ShouldBeNil)
                                 So(ctr.PutMulti.Successes(), ShouldEqual, 2)
 
                                 Convey("even within transactions", func() {
-                                        die(ds.RunInTransaction(func(c context.Context) error {
-                                                ds := datastore.Get(c)
-                                                So(ds.PutMulti(append(vals, vals[0])), ShouldBeNil)
+                                        die(ds.RunInTransaction(c, func(c context.Context) error {
+                                                So(ds.Put(c, append(vals, vals[0])), ShouldBeNil)
                                                 return nil
                                         }, nil))
                                 })
                         })
                 })
 
                 Convey("errors count against errors", func() {
                         fb.BreakFeatures(nil, "GetMulti")
 
-                        So(ds.GetMulti(vals), ShouldErrLike, `"GetMulti" is broken`)
+                        So(ds.Get(c, vals), ShouldErrLike, `"GetMulti" is broken`)
                         So(ctr.GetMulti.Errors(), ShouldEqual, 1)
 
                         fb.UnbreakFeatures("GetMulti")
 
-                        So(ds.PutMulti(vals), ShouldBeNil)
+                        So(ds.Put(c, vals), ShouldBeNil)
 
-                        die(ds.GetMulti(vals))
+                        die(ds.Get(c, vals))
                         So(ctr.GetMulti.Errors(), ShouldEqual, 1)
                         So(ctr.GetMulti.Successes(), ShouldEqual, 1)
                         So(ctr.GetMulti.Total(), ShouldEqual, 2)
                 })
 
                 Convey(`datastore.Stop does not count as an error`, func() {
-                        fb.BreakFeatures(datastore.Stop, "GetMulti")
+                        fb.BreakFeatures(ds.Stop, "GetMulti")
 
-                        So(ds.GetMulti(vals), ShouldBeNil)
+                        So(ds.Get(c, vals), ShouldBeNil)
                         So(ctr.GetMulti.Successes(), ShouldEqual, 1)
                         So(ctr.GetMulti.Errors(), ShouldEqual, 0)
                         So(ctr.GetMulti.Total(), ShouldEqual, 1)
                 })
         })
 
         Convey("works for memcache", t, func() {
                 c, ctr := FilterMC(memory.Use(context.Background()))
                 So(c, ShouldNotBeNil)
                 So(ctr, ShouldNotBeNil)
-                mc := memcache.Get(c)
 
-                die(mc.Set(mc.NewItem("hello").SetValue([]byte("sup"))))
+                die(memcache.Set(c, memcache.NewItem(c, "hello").SetValue([]byte("sup"))))
 
-                _, err := mc.Get("Wat")
+                _, err := memcache.GetKey(c, "Wat")
                 So(err, ShouldNotBeNil)
 
-                _, err = mc.Get("hello")
+                _, err = memcache.GetKey(c, "hello")
                 die(err)
 
                 So(ctr.SetMulti, shouldHaveSuccessesAndErrors, 1, 0)
                 So(ctr.GetMulti, shouldHaveSuccessesAndErrors, 2, 0)
                 So(ctr.NewItem, shouldHaveSuccessesAndErrors, 3, 0)
         })
 
         Convey("works for taskqueue", t, func() {
                 c, ctr := FilterTQ(memory.Use(context.Background()))
                 So(c, ShouldNotBeNil)
                 So(ctr, ShouldNotBeNil)
-                tq := taskqueue.Get(c)
 
-                die(tq.Add(&taskqueue.Task{Name: "wat"}, ""))
-                So(tq.Add(&taskqueue.Task{Name: "wat"}, "DNE_QUEUE"),
+                die(taskqueue.Add(c, "", &taskqueue.Task{Name: "wat"}))
+                So(taskqueue.Add(c, "DNE_QUEUE", &taskqueue.Task{Name: "wat"}),
                         ShouldErrLike, "UNKNOWN_QUEUE")
 
                 So(ctr.AddMulti, shouldHaveSuccessesAndErrors, 1, 1)
         })
 
         Convey("works for global info", t, func() {
                 c, fb := featureBreaker.FilterGI(memory.Use(context.Background()), nil)
                 c, ctr := FilterGI(c)
                 So(c, ShouldNotBeNil)
                 So(ctr, ShouldNotBeNil)
 
-                gi := info.Get(c)
-
-                _, err := gi.Namespace("foo")
+                _, err := info.Namespace(c, "foo")
                 die(err)
                 fb.BreakFeatures(nil, "Namespace")
-                _, err = gi.Namespace("boom")
+                _, err = info.Namespace(c, "boom")
                 So(err, ShouldErrLike, `"Namespace" is broken`)
 
                 So(ctr.Namespace, shouldHaveSuccessesAndErrors, 1, 1)
         })
 
         Convey("works for user", t, func() {
                 c, fb := featureBreaker.FilterUser(memory.Use(context.Background()), nil)
                 c, ctr := FilterUser(c)
                 So(c, ShouldNotBeNil)
                 So(ctr, ShouldNotBeNil)
 
-                u := user.Get(c)
-
-                _, err := u.CurrentOAuth("foo")
+                _, err := user.CurrentOAuth(c, "foo")
                 die(err)
                 fb.BreakFeatures(nil, "CurrentOAuth")
-                _, err = u.CurrentOAuth("foo")
+                _, err = user.CurrentOAuth(c, "foo")
                 So(err, ShouldErrLike, `"CurrentOAuth" is broken`)
 
                 So(ctr.CurrentOAuth, shouldHaveSuccessesAndErrors, 1, 1)
         })
 
         Convey("works for mail", t, func() {
                 c, fb := featureBreaker.FilterMail(memory.Use(context.Background()), nil)
                 c, ctr := FilterMail(c)
                 So(c, ShouldNotBeNil)
                 So(ctr, ShouldNotBeNil)
 
-                m := mail.Get(c)
-
-                err := m.Send(&mail.Message{
+                err := mail.Send(c, &mail.Message{
                         Sender: "admin@example.com",
                         To:     []string{"coolDood@example.com"},
                         Body:   "hi",
                 })
                 die(err)
 
                 fb.BreakFeatures(nil, "Send")
-                err = m.Send(&mail.Message{
+                err = mail.Send(c, &mail.Message{
                         Sender: "admin@example.com",
                         To:     []string{"coolDood@example.com"},
                         Body:   "hi",
                 })
                 So(err, ShouldErrLike, `"Send" is broken`)
 
                 So(ctr.Send, shouldHaveSuccessesAndErrors, 1, 1)
         })
 }
 
 func ExampleFilterRDS() {
         // Set up your context using a base service implementation (memory or prod)
         c := memory.Use(context.Background())
 
         // Apply the counter.FilterRDS
         c, counter := FilterRDS(c)
 
         // functions use ds from the context like normal... they don't need to know
         // that there are any filters at all.
         someCalledFunc := func(c context.Context) {
-                ds := datastore.Get(c)
-                vals := []datastore.PropertyMap{{
-                        "FieldName": datastore.MkProperty(100),
-                        "$key":      datastore.MkProperty(ds.NewKey("Kind", "", 1, nil))},
+                vals := []ds.PropertyMap{{
+                        "FieldName": ds.MkProperty(100),
+                        "$key":      ds.MkProperty(ds.NewKey(c, "Kind", "", 1, nil))},
                 }
-                if err := ds.PutMulti(vals); err != nil {
+                if err := ds.Put(c, vals); err != nil {
                         panic(err)
                 }
         }
 
         // Using the other function.
         someCalledFunc(c)
         someCalledFunc(c)
 
         // Then we can see what happened!
         fmt.Printf("%d\n", counter.PutMulti.Successes())
         // Output:
         // 2
 }