Fix memcache.Interface.Get to return a memcache.Item

filter/dscache/dscache_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package dscache
 
 import (
         "bytes"
         "encoding/binary"
         "errors"
@@ skipping 48 matching lines @@
 
         Convey("Test dscache", t, func() {
                 c := mathrand.Set(context.Background(), rand.New(rand.NewSource(1)))
                 clk := testclock.New(zeroTime)
                 c = clock.Set(c, clk)
                 c = memory.Use(c)
 
                 dsUnder := datastore.Get(c)
                 mc := memcache.Get(c)
 
-                itmFor := func(i int, k *datastore.Key) memcache.Item {
-                        return mc.NewItem(MakeMemcacheKey(i, k))
-                }
-
                 shardsForKey := func(k *datastore.Key) int {
                         last := k.Last()
                         if last.Kind == "shardObj" {
                                 return int(last.IntID)
                         }
                         if last.Kind == "noCacheObj" {
                                 return 0
                         }
                         return DefaultShards
                 }
@@ skipping 18 matching lines @@
                                 }
                                 encoded := append([]byte{0}, serialize.ToBytes(pm)...)
 
                                 o := object{ID: 1, Value: "hi"}
                                 So(ds.Put(&o), ShouldBeNil)
 
                                 o = object{ID: 1}
                                 So(dsUnder.Get(&o), ShouldBeNil)
                                 So(o.Value, ShouldEqual, "hi")
 
-                                itm := itmFor(0, ds.KeyForObj(&o))
-                                So(mc.Get(itm), ShouldEqual, memcache.ErrCacheMiss)
+                                itm, err := mc.Get(MakeMemcacheKey(0, ds.KeyForObj(&o)))
+                                So(err, ShouldEqual, memcache.ErrCacheMiss)
 
                                 o = object{ID: 1}
                                 So(ds.Get(&o), ShouldBeNil)
                                 So(o.Value, ShouldEqual, "hi")
-                                So(mc.Get(itm), ShouldBeNil)
+
+                                itm, err = mc.Get(itm.Key())
+                                So(err, ShouldBeNil)
                                 So(itm.Value(), ShouldResemble, encoded)
 
                                 Convey("now we don't need the datastore!", func() {
                                         o := object{ID: 1}
 
                                         // delete it, bypassing the cache filter. Don't do this in production
                                         // unless you want a crappy cache.
                                         So(dsUnder.Delete(ds.KeyForObj(&o)), ShouldBeNil)
 
-                                        itm := itmFor(0, ds.KeyForObj(&o))
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err := mc.Get(MakeMemcacheKey(0, ds.KeyForObj(&o)))
+                                        So(err, ShouldBeNil)
                                         So(itm.Value(), ShouldResemble, encoded)
 
                                         So(ds.Get(&o), ShouldBeNil)
                                         So(o.Value, ShouldEqual, "hi")
                                 })
 
                                 Convey("deleting it properly records that fact, however", func() {
                                         o := object{ID: 1}
                                         So(ds.Delete(ds.KeyForObj(&o)), ShouldBeNil)
 
-                                        itm := itmFor(0, ds.KeyForObj(&o))
-                                        So(mc.Get(itm), ShouldEqual, memcache.ErrCacheMiss)
+                                        itm, err := mc.Get(MakeMemcacheKey(0, ds.KeyForObj(&o)))
+                                        So(err, ShouldEqual, memcache.ErrCacheMiss)
                                         So(ds.Get(&o), ShouldEqual, datastore.ErrNoSuchEntity)
 
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err = mc.Get(itm.Key())
+                                        So(err, ShouldBeNil)
                                         So(itm.Value(), ShouldResemble, []byte{})
 
                                         // this one hits memcache
                                         So(ds.Get(&o), ShouldEqual, datastore.ErrNoSuchEntity)
                                 })
                         })
 
                         Convey("compression works", func() {
                                 o := object{ID: 2, Value: `¯\_(ツ)_/¯`}
                                 data := make([]byte, 4000)
                                 for i := range data {
                                         const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
                                         data[i] = alpha[i%len(alpha)]
                                 }
                                 o.BigData = data
 
                                 So(ds.Put(&o), ShouldBeNil)
                                 So(ds.Get(&o), ShouldBeNil)
 
-                                itm := itmFor(0, ds.KeyForObj(&o))
-                                So(mc.Get(itm), ShouldBeNil)
+                                itm, err := mc.Get(MakeMemcacheKey(0, ds.KeyForObj(&o)))
+                                So(err, ShouldBeNil)
 
                                 So(itm.Value()[0], ShouldEqual, ZlibCompression)
                                 So(len(itm.Value()), ShouldEqual, 653) // a bit smaller than 4k
 
                                 // ensure the next Get comes from the cache
                                 So(dsUnder.Delete(ds.KeyForObj(&o)), ShouldBeNil)
 
                                 o = object{ID: 2}
                                 So(ds.Get(&o), ShouldBeNil)
                                 So(o.Value, ShouldEqual, `¯\_(ツ)_/¯`)
@@ skipping 16 matching lines @@
                                                 o := &object{ID: 1}
                                                 So(ds.Get(o), ShouldBeNil)
                                                 So(o.Value, ShouldEqual, "else")
                                                 o.Value = "txn"
                                                 So(ds.Put(o), ShouldBeNil)
 
                                                 So(ds.Delete(ds.KeyForObj(&object{ID: 2})), ShouldBeNil)
                                                 return nil
                                         }, &datastore.TransactionOptions{XG: true}), ShouldBeNil)
 
-                                        So(mc.Get(itmFor(0, ds.KeyForObj(&object{ID: 1}))),
-                                                ShouldEqual, memcache.ErrCacheMiss)
-                                        So(mc.Get(itmFor(0, ds.KeyForObj(&object{ID: 2}))),
-                                                ShouldEqual, memcache.ErrCacheMiss)
+                                        _, err := mc.Get(MakeMemcacheKey(0, ds.KeyForObj(&object{ID: 1})))
+                                        So(err, ShouldEqual, memcache.ErrCacheMiss)
+                                        _, err = mc.Get(MakeMemcacheKey(0, ds.KeyForObj(&object{ID: 2})))
+                                        So(err, ShouldEqual, memcache.ErrCacheMiss)
                                         o := &object{ID: 1}
                                         So(ds.Get(o), ShouldBeNil)
                                         So(o.Value, ShouldEqual, "txn")
                                 })
 
                                 Convey("errors don't invalidate", func() {
                                         // populate an object @ ID1
                                         So(ds.Put(&object{ID: 1, Value: "something"}), ShouldBeNil)
                                         So(ds.Get(&object{ID: 1}), ShouldBeNil)
                                         So(numMemcacheItems(), ShouldEqual, 1)
@@ skipping 60 matching lines @@
                                         type model struct {
                                                 ID         int64 `gae:"$id"`
                                                 DSCacheExp int64 `gae:"$dscache.expiration,7"`
 
                                                 Value string
                                         }
 
                                         So(ds.Put(&model{ID: 1, Value: "mooo"}), ShouldBeNil)
                                         So(ds.Get(&model{ID: 1}), ShouldBeNil)
 
-                                        itm := itmFor(0, ds.KeyForObj(&model{ID: 1}))
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err := mc.Get(MakeMemcacheKey(0, ds.KeyForObj(&model{ID: 1})))
+                                        So(err, ShouldBeNil)
 
                                         clk.Add(10 * time.Second)
-                                        So(mc.Get(itm), ShouldEqual, memcache.ErrCacheMiss)
+                                        _, err = mc.Get(itm.Key())
+                                        So(err, ShouldEqual, memcache.ErrCacheMiss)
                                 })
                         })
 
                         Convey("screw cases", func() {
                                 Convey("memcache contains bogus value (simulated failed AddMulti)", func() {
                                         o := &object{ID: 1, Value: "spleen"}
                                         So(ds.Put(o), ShouldBeNil)
 
                                         sekret := []byte("I am a banana")
-                                        itm := itmFor(0, ds.KeyForObj(o)).SetValue(sekret)
+                                        itm := mc.NewItem(MakeMemcacheKey(0, ds.KeyForObj(o))).SetValue(sekret)
                                         So(mc.Set(itm), ShouldBeNil)
 
                                         o = &object{ID: 1}
                                         So(ds.Get(o), ShouldBeNil)
                                         So(o.Value, ShouldEqual, "spleen")
 
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err := mc.Get(itm.Key())
+                                        So(err, ShouldBeNil)
                                         So(itm.Flags(), ShouldEqual, ItemUKNONWN)
                                         So(itm.Value(), ShouldResemble, sekret)
                                 })
 
                                 Convey("memcache contains bogus value (corrupt entry)", func() {
                                         o := &object{ID: 1, Value: "spleen"}
                                         So(ds.Put(o), ShouldBeNil)
 
                                         sekret := []byte("I am a banana")
-                                        itm := (itmFor(0, ds.KeyForObj(o)).
+                                        itm := (mc.NewItem(MakeMemcacheKey(0, ds.KeyForObj(o))).
                                                 SetValue(sekret).
                                                 SetFlags(uint32(ItemHasData)))
                                         So(mc.Set(itm), ShouldBeNil)
 
                                         o = &object{ID: 1}
                                         So(ds.Get(o), ShouldBeNil)
                                         So(o.Value, ShouldEqual, "spleen")
 
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err := mc.Get(itm.Key())
+                                        So(err, ShouldBeNil)
                                         So(itm.Flags(), ShouldEqual, ItemHasData)
                                         So(itm.Value(), ShouldResemble, sekret)
                                 })
 
                                 Convey("other entity has the lock", func() {
                                         o := &object{ID: 1, Value: "spleen"}
                                         So(ds.Put(o), ShouldBeNil)
 
                                         sekret := []byte("r@vmarod!#)%9T")
-                                        itm := (itmFor(0, ds.KeyForObj(o)).
+                                        itm := (mc.NewItem(MakeMemcacheKey(0, ds.KeyForObj(o))).
                                                 SetValue(sekret).
                                                 SetFlags(uint32(ItemHasLock)))
                                         So(mc.Set(itm), ShouldBeNil)
 
                                         o = &object{ID: 1}
                                         So(ds.Get(o), ShouldBeNil)
                                         So(o.Value, ShouldEqual, "spleen")
 
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err := mc.Get(itm.Key())
+                                        So(err, ShouldBeNil)
                                         So(itm.Flags(), ShouldEqual, ItemHasLock)
                                         So(itm.Value(), ShouldResemble, sekret)
                                 })
 
                                 Convey("massive entities can't be cached", func() {
                                         o := &object{ID: 1, Value: "spleen"}
                                         mr := mathrand.Get(c)
                                         numRounds := (internalValueSizeLimit / 8) * 2
                                         buf := bytes.Buffer{}
                                         for i := 0; i < numRounds; i++ {
                                                 So(binary.Write(&buf, binary.LittleEndian, mr.Int63()), ShouldBeNil)
                                         }
                                         o.BigData = buf.Bytes()
                                         So(ds.Put(o), ShouldBeNil)
 
                                         o.BigData = nil
                                         So(ds.Get(o), ShouldBeNil)
 
-                                        itm := itmFor(0, ds.KeyForObj(o))
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err := mc.Get(MakeMemcacheKey(0, ds.KeyForObj(o)))
+                                        So(err, ShouldBeNil)
 
                                         // Is locked until the next put, forcing all access to the datastore.
                                         So(itm.Value(), ShouldResemble, []byte{})
                                         So(itm.Flags(), ShouldEqual, ItemHasLock)
 
                                         o.BigData = []byte("hi :)")
                                         So(ds.Put(o), ShouldBeNil)
                                         So(ds.Get(o), ShouldBeNil)
 
-                                        So(mc.Get(itm), ShouldBeNil)
+                                        itm, err = mc.Get(itm.Key())
+                                        So(err, ShouldBeNil)
                                         So(itm.Flags(), ShouldEqual, ItemHasData)
                                 })
 
                                 Convey("failure on Setting memcache locks is a hard stop", func() {
                                         c, fb := featureBreaker.FilterMC(c, nil)
                                         fb.BreakFeatures(nil, "SetMulti")
                                         ds := datastore.Get(c)
                                         So(ds.Put(&object{ID: 1}).Error(), ShouldContainSubstring, "SetMulti")
                                 })
 
@@ skipping 63 matching lines @@
                 InstanceEnabledStatic = false
                 defer func() {
                         InstanceEnabledStatic = true
                 }()
 
                 c := context.Background()
                 newC := FilterRDS(c, nil)
                 So(newC, ShouldEqual, c)
         })
 }