Interface update, per-method Contexts.

impl/memory/memcache_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 (
         "testing"
         "time"
 
-        infoS "github.com/luci/gae/service/info"
-        mcS "github.com/luci/gae/service/memcache"
+        "github.com/luci/gae/service/info"
+        mc "github.com/luci/gae/service/memcache"
+
         "github.com/luci/luci-go/common/clock/testclock"
         . "github.com/luci/luci-go/common/testing/assertions"
+
+        "golang.org/x/net/context"
+
         . "github.com/smartystreets/goconvey/convey"
-        "golang.org/x/net/context"
 )
 
 func TestMemcache(t *testing.T) {
         t.Parallel()
 
         Convey("memcache", t, func() {
                 now := time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)
                 c, tc := testclock.UseTime(context.Background(), now)
                 c = Use(c)
-                mc := mcS.Get(c)
 
                 Convey("implements MCSingleReadWriter", func() {
                         Convey("Add", func() {
-                                itm := (mc.NewItem("sup").
+                                itm := (mc.NewItem(c, "sup").
                                         SetValue([]byte("cool")).
                                         SetExpiration(time.Second))
-                                So(mc.Add(itm), ShouldBeNil)
+                                So(mc.Add(c, itm), ShouldBeNil)
                                 Convey("which rejects objects already there", func() {
-                                        So(mc.Add(itm), ShouldEqual, mcS.ErrNotStored)
+                                        So(mc.Add(c, itm), ShouldEqual, mc.ErrNotStored)
                                 })
                         })
 
                         Convey("Get", func() {
                                 itm := &mcItem{
                                         key:        "sup",
                                         value:      []byte("cool"),
                                         expiration: time.Second,
                                 }
-                                So(mc.Add(itm), ShouldBeNil)
+                                So(mc.Add(c, itm), ShouldBeNil)
 
                                 testItem := &mcItem{
                                         key:   "sup",
                                         value: []byte("cool"),
                                         CasID: 1,
                                 }
-                                getItm, err := mc.Get("sup")
+                                getItm, err := mc.GetKey(c, "sup")
                                 So(err, ShouldBeNil)
                                 So(getItm, ShouldResemble, testItem)
 
                                 Convey("which can expire", func() {
                                         tc.Add(time.Second * 4)
-                                        getItm, err := mc.Get("sup")
-                                        So(err, ShouldEqual, mcS.ErrCacheMiss)
+                                        getItm, err := mc.GetKey(c, "sup")
+                                        So(err, ShouldEqual, mc.ErrCacheMiss)
                                         So(getItm, ShouldResemble, &mcItem{key: "sup"})
                                 })
                         })
 
                         Convey("Delete", func() {
                                 Convey("works if it's there", func() {
                                         itm := &mcItem{
                                                 key:        "sup",
                                                 value:      []byte("cool"),
                                                 expiration: time.Second,
                                         }
-                                        So(mc.Add(itm), ShouldBeNil)
+                                        So(mc.Add(c, itm), ShouldBeNil)
 
-                                        So(mc.Delete("sup"), ShouldBeNil)
+                                        So(mc.Delete(c, "sup"), ShouldBeNil)
 
-                                        _, err := mc.Get("sup")
-                                        So(err, ShouldEqual, mcS.ErrCacheMiss)
+                                        _, err := mc.GetKey(c, "sup")
+                                        So(err, ShouldEqual, mc.ErrCacheMiss)
                                 })
 
                                 Convey("but not if it's not there", func() {
-                                        So(mc.Delete("sup"), ShouldEqual, mcS.ErrCacheMiss)
+                                        So(mc.Delete(c, "sup"), ShouldEqual, mc.ErrCacheMiss)
                                 })
                         })
 
                         Convey("Set", func() {
                                 itm := &mcItem{
                                         key:        "sup",
                                         value:      []byte("cool"),
                                         expiration: time.Second,
                                 }
-                                So(mc.Add(itm), ShouldBeNil)
+                                So(mc.Add(c, itm), ShouldBeNil)
 
                                 itm.SetValue([]byte("newp"))
-                                So(mc.Set(itm), ShouldBeNil)
+                                So(mc.Set(c, itm), ShouldBeNil)
 
                                 testItem := &mcItem{
                                         key:   "sup",
                                         value: []byte("newp"),
                                         CasID: 2,
                                 }
-                                getItm, err := mc.Get("sup")
+                                getItm, err := mc.GetKey(c, "sup")
                                 So(err, ShouldBeNil)
                                 So(getItm, ShouldResemble, testItem)
 
                                 Convey("Flush works too", func() {
-                                        So(mc.Flush(), ShouldBeNil)
-                                        _, err := mc.Get("sup")
-                                        So(err, ShouldEqual, mcS.ErrCacheMiss)
+                                        So(mc.Flush(c), ShouldBeNil)
+                                        _, err := mc.GetKey(c, "sup")
+                                        So(err, ShouldEqual, mc.ErrCacheMiss)
                                 })
                         })
 
                         Convey("Set (nil) is equivalent to Set([]byte{})", func() {
-                                So(mc.Set(mc.NewItem("bob")), ShouldBeNil)
+                                So(mc.Set(c, mc.NewItem(c, "bob")), ShouldBeNil)
 
-                                bob, err := mc.Get("bob")
+                                bob, err := mc.GetKey(c, "bob")
                                 So(err, ShouldBeNil)
                                 So(bob.Value(), ShouldResemble, []byte{})
                         })
 
                         Convey("Increment", func() {
-                                val, err := mc.Increment("num", 7, 2)
+                                val, err := mc.Increment(c, "num", 7, 2)
                                 So(err, ShouldBeNil)
                                 So(val, ShouldEqual, 9)
 
                                 Convey("IncrementExisting", func() {
-                                        val, err := mc.IncrementExisting("num", -2)
+                                        val, err := mc.IncrementExisting(c, "num", -2)
                                         So(err, ShouldBeNil)
                                         So(val, ShouldEqual, 7)
 
-                                        val, err = mc.IncrementExisting("num", -100)
+                                        val, err = mc.IncrementExisting(c, "num", -100)
                                         So(err, ShouldBeNil)
                                         So(val, ShouldEqual, 0)
 
-                                        _, err = mc.IncrementExisting("noexist", 2)
-                                        So(err, ShouldEqual, mcS.ErrCacheMiss)
+                                        _, err = mc.IncrementExisting(c, "noexist", 2)
+                                        So(err, ShouldEqual, mc.ErrCacheMiss)
 
-                                        So(mc.Set(mc.NewItem("text").SetValue([]byte("hello world, hooman!"))), ShouldBeNil)
+                                        So(mc.Set(c, mc.NewItem(c, "text").SetValue([]byte("hello world, hooman!"))), ShouldBeNil)
 
-                                        _, err = mc.IncrementExisting("text", 2)
+                                        _, err = mc.IncrementExisting(c, "text", 2)
                                         So(err.Error(), ShouldContainSubstring, "got invalid current value")
                                 })
                         })
 
                         Convey("CompareAndSwap", func() {
-                                itm := mcS.Item(&mcItem{
+                                itm := mc.Item(&mcItem{
                                         key:        "sup",
                                         value:      []byte("cool"),
                                         expiration: time.Second * 2,
                                 })
-                                So(mc.Add(itm), ShouldBeNil)
+                                So(mc.Add(c, itm), ShouldBeNil)
 
                                 Convey("works after a Get", func() {
-                                        itm, err := mc.Get("sup")
+                                        itm, err := mc.GetKey(c, "sup")
                                         So(err, ShouldBeNil)
                                         So(itm.(*mcItem).CasID, ShouldEqual, 1)
 
                                         itm.SetValue([]byte("newp"))
-                                        So(mc.CompareAndSwap(itm), ShouldBeNil)
+                                        So(mc.CompareAndSwap(c, itm), ShouldBeNil)
                                 })
 
                                 Convey("but fails if you don't", func() {
                                         itm.SetValue([]byte("newp"))
-                                        So(mc.CompareAndSwap(itm), ShouldEqual, mcS.ErrCASConflict)
+                                        So(mc.CompareAndSwap(c, itm), ShouldEqual, mc.ErrCASConflict)
                                 })
 
                                 Convey("and fails if the item is expired/gone", func() {
                                         tc.Add(3 * time.Second)
                                         itm.SetValue([]byte("newp"))
-                                        So(mc.CompareAndSwap(itm), ShouldEqual, mcS.ErrNotStored)
+                                        So(mc.CompareAndSwap(c, itm), ShouldEqual, mc.ErrNotStored)
                                 })
                         })
                 })
 
                 Convey("check that the internal implementation is sane", func() {
                         curTime := now
-                        err := mc.Add(&mcItem{
+                        err := mc.Add(c, &mcItem{
                                 key:        "sup",
                                 value:      []byte("cool"),
                                 expiration: time.Second * 2,
                         })
 
                         for i := 0; i < 4; i++ {
-                                _, err := mc.Get("sup")
+                                _, err := mc.GetKey(c, "sup")
                                 So(err, ShouldBeNil)
                         }
-                        _, err = mc.Get("wot")
-                        So(err, ShouldErrLike, mcS.ErrCacheMiss)
+                        _, err = mc.GetKey(c, "wot")
+                        So(err, ShouldErrLike, mc.ErrCacheMiss)
 
-                        mci := mc.Raw().(*memcacheImpl)
+                        mci := mc.Raw(c).(*memcacheImpl)
 
-                        stats, err := mc.Stats()
+                        stats, err := mc.Stats(c)
                         So(err, ShouldBeNil)
                         So(stats.Items, ShouldEqual, 1)
                         So(stats.Bytes, ShouldEqual, 4)
                         So(stats.Hits, ShouldEqual, 4)
                         So(stats.Misses, ShouldEqual, 1)
                         So(stats.ByteHits, ShouldEqual, 4*4)
                         So(mci.data.casID, ShouldEqual, 1)
                         So(mci.data.items["sup"], ShouldResemble, &mcDataItem{
                                 value:      []byte("cool"),
                                 expiration: curTime.Add(time.Second * 2).Truncate(time.Second),
                                 casID:      1,
                         })
 
-                        getItm, err := mc.Get("sup")
+                        getItm, err := mc.GetKey(c, "sup")
                         So(err, ShouldBeNil)
                         So(len(mci.data.items), ShouldEqual, 1)
                         So(mci.data.casID, ShouldEqual, 1)
 
                         testItem := &mcItem{
                                 key:   "sup",
                                 value: []byte("cool"),
                                 CasID: 1,
                         }
                         So(getItm, ShouldResemble, testItem)
                 })
 
                 Convey("When adding an item to an unset namespace", func() {
-                        _, has := infoS.Get(c).GetNamespace()
-                        So(has, ShouldBeFalse)
+                        So(info.GetNamespace(c), ShouldEqual, "")
 
-                        item := mc.NewItem("foo").SetValue([]byte("heya"))
-                        So(mc.Set(item), ShouldBeNil)
+                        item := mc.NewItem(c, "foo").SetValue([]byte("heya"))
+                        So(mc.Set(c, item), ShouldBeNil)
 
                         Convey("The item can be retrieved from the unset namespace.", func() {
-                                got, err := mc.Get("foo")
+                                got, err := mc.GetKey(c, "foo")
                                 So(err, ShouldBeNil)
                                 So(got.Value(), ShouldResemble, []byte("heya"))
                         })
 
                         Convey("The item can be retrieved from a set, empty namespace.", func() {
                                 // Now test with empty namespace.
-                                c = infoS.Get(c).MustNamespace("")
+                                c = info.MustNamespace(c, "")
 
-                                got, err := mc.Get("foo")
+                                got, err := mc.GetKey(c, "foo")
                                 So(err, ShouldBeNil)
                                 So(got.Value(), ShouldResemble, []byte("heya"))
                         })
                 })
         })
 }