Reland: Refactor current GAE abstraction library to be free of the SDK*

go/src/infra/gae/libs/gae/memory/memcache_test.go

Index: go/src/infra/gae/libs/gae/memory/memcache_test.go
diff --git a/go/src/infra/gae/libs/wrapper/memory/memcache_test.go b/go/src/infra/gae/libs/gae/memory/memcache_test.go
similarity index 59%
rename from go/src/infra/gae/libs/wrapper/memory/memcache_test.go
rename to go/src/infra/gae/libs/gae/memory/memcache_test.go
index ab1934c7aea78b8a39f47e86d67d223e6ab8764c..0829aa40185f6da07d4d7b1ec71ddfdcaaa19da0 100644
--- a/go/src/infra/gae/libs/wrapper/memory/memcache_test.go
+++ b/go/src/infra/gae/libs/gae/memory/memcache_test.go
@@ -5,16 +5,14 @@
 package memory
 
 import (
-	"infra/gae/libs/wrapper"
-	"infra/gae/libs/wrapper/unsafe"
-	"infra/libs/clock/testclock"
+	"golang.org/x/net/context"
+	"infra/gae/libs/gae"
 	"testing"
 	"time"
 
-	. "github.com/smartystreets/goconvey/convey"
-	"golang.org/x/net/context"
+	"github.com/luci/luci-go/common/clock/testclock"
 
-	"appengine/memcache"
+	. "github.com/smartystreets/goconvey/convey"
 )
 
 func TestMemcache(t *testing.T) {
@@ -24,45 +22,45 @@ func TestMemcache(t *testing.T) {
 		now := time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)
 		c, tc := testclock.UseTime(context.Background(), now)
 		c = Use(c)
-		mc := wrapper.GetMC(c)
-		mci := wrapper.GetMC(c).(*memcacheImpl)
+		mc := gae.GetMC(c)
+		mci := gae.GetMC(c).(*memcacheImpl)
 		So(mc, ShouldNotEqual, mci) // two impls with the same memcacheData
 
 		Convey("implements MCSingleReadWriter", func() {
 			Convey("Add", func() {
-				itm := &memcache.Item{
-					Key:        "sup",
-					Value:      []byte("cool"),
-					Expiration: time.Second,
+				itm := &mcItem{
+					key:        "sup",
+					value:      []byte("cool"),
+					expiration: time.Second,
 				}
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 				Convey("which rejects objects already there", func() {
 					err := mc.Add(itm)
-					So(err, ShouldEqual, memcache.ErrNotStored)
+					So(err, ShouldEqual, gae.ErrMCNotStored)
 				})
 
 				Convey("which can be broken intentionally", func() {
 					mci.BreakFeatures(nil, "Add")
 					err := mc.Add(itm)
-					So(err, ShouldEqual, memcache.ErrServerError)
+					So(err, ShouldEqual, gae.ErrMCServerError)
 				})
 			})
 
 			Convey("Get", func() {
-				itm := &memcache.Item{
-					Key:        "sup",
-					Value:      []byte("cool"),
-					Expiration: time.Second,
+				itm := &mcItem{
+					key:        "sup",
+					value:      []byte("cool"),
+					expiration: time.Second,
 				}
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 
-				testItem := &memcache.Item{
-					Key:   "sup",
-					Value: []byte("cool"),
+				testItem := &mcItem{
+					key:   "sup",
+					value: []byte("cool"),
+					CasID: 1,
 				}
-				unsafe.MCSetCasID(testItem, 1)
 				i, err := mc.Get("sup")
 				So(err, ShouldBeNil)
 				So(i, ShouldResemble, testItem)
@@ -70,23 +68,23 @@ func TestMemcache(t *testing.T) {
 				Convey("which can expire", func() {
 					tc.Add(time.Second * 4)
 					i, err := mc.Get("sup")
-					So(err, ShouldEqual, memcache.ErrCacheMiss)
+					So(err, ShouldEqual, gae.ErrMCCacheMiss)
 					So(i, ShouldBeNil)
 				})
 
 				Convey("which can be broken intentionally", func() {
 					mci.BreakFeatures(nil, "Get")
 					_, err := mc.Get("sup")
-					So(err, ShouldEqual, memcache.ErrServerError)
+					So(err, ShouldEqual, gae.ErrMCServerError)
 				})
 			})
 
 			Convey("Delete", func() {
 				Convey("works if it's there", func() {
-					itm := &memcache.Item{
-						Key:        "sup",
-						Value:      []byte("cool"),
-						Expiration: time.Second,
+					itm := &mcItem{
+						key:        "sup",
+						value:      []byte("cool"),
+						expiration: time.Second,
 					}
 					err := mc.Add(itm)
 					So(err, ShouldBeNil)
@@ -95,40 +93,40 @@ func TestMemcache(t *testing.T) {
 					So(err, ShouldBeNil)
 
 					i, err := mc.Get("sup")
-					So(err, ShouldEqual, memcache.ErrCacheMiss)
+					So(err, ShouldEqual, gae.ErrMCCacheMiss)
 					So(i, ShouldBeNil)
 				})
 
 				Convey("but not if it's not there", func() {
 					err := mc.Delete("sup")
-					So(err, ShouldEqual, memcache.ErrCacheMiss)
+					So(err, ShouldEqual, gae.ErrMCCacheMiss)
 				})
 
 				Convey("and can be broken", func() {
 					mci.BreakFeatures(nil, "Delete")
 					err := mc.Delete("sup")
-					So(err, ShouldEqual, memcache.ErrServerError)
+					So(err, ShouldEqual, gae.ErrMCServerError)
 				})
 			})
 
 			Convey("Set", func() {
-				itm := &memcache.Item{
-					Key:        "sup",
-					Value:      []byte("cool"),
-					Expiration: time.Second,
+				itm := &mcItem{
+					key:        "sup",
+					value:      []byte("cool"),
+					expiration: time.Second,
 				}
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 
-				itm.Value = []byte("newp")
+				itm.SetValue([]byte("newp"))
 				err = mc.Set(itm)
 				So(err, ShouldBeNil)
 
-				testItem := &memcache.Item{
-					Key:   "sup",
-					Value: []byte("newp"),
+				testItem := &mcItem{
+					key:   "sup",
+					value: []byte("newp"),
+					CasID: 2,
 				}
-				unsafe.MCSetCasID(testItem, 2)
 				i, err := mc.Get("sup")
 				So(err, ShouldBeNil)
 				So(i, ShouldResemble, testItem)
@@ -136,66 +134,66 @@ func TestMemcache(t *testing.T) {
 				Convey("and can be broken", func() {
 					mci.BreakFeatures(nil, "Set")
 					err := mc.Set(itm)
-					So(err, ShouldEqual, memcache.ErrServerError)
+					So(err, ShouldEqual, gae.ErrMCServerError)
 				})
 			})
 
 			Convey("CompareAndSwap", func() {
-				itm := &memcache.Item{
-					Key:        "sup",
-					Value:      []byte("cool"),
-					Expiration: time.Second * 2,
-				}
+				itm := gae.MCItem(&mcItem{
+					key:        "sup",
+					value:      []byte("cool"),
+					expiration: time.Second * 2,
+				})
 				err := mc.Add(itm)
 				So(err, ShouldBeNil)
 
 				Convey("works after a Get", func() {
 					itm, err = mc.Get("sup")
 					So(err, ShouldBeNil)
-					So(unsafe.MCGetCasID(itm), ShouldEqual, 1)
+					So(itm.(*mcItem).CasID, ShouldEqual, 1)
 
-					itm.Value = []byte("newp")
+					itm.SetValue([]byte("newp"))
 					err = mc.CompareAndSwap(itm)
 					So(err, ShouldBeNil)
 				})
 
 				Convey("but fails if you don't", func() {
-					itm.Value = []byte("newp")
+					itm.SetValue([]byte("newp"))
 					err = mc.CompareAndSwap(itm)
-					So(err, ShouldEqual, memcache.ErrCASConflict)
+					So(err, ShouldEqual, gae.ErrMCCASConflict)
 				})
 
 				Convey("and fails if the item is expired/gone", func() {
 					tc.Add(3 * time.Second)
-					itm.Value = []byte("newp")
+					itm.SetValue([]byte("newp"))
 					err = mc.CompareAndSwap(itm)
-					So(err, ShouldEqual, memcache.ErrNotStored)
+					So(err, ShouldEqual, gae.ErrMCNotStored)
 				})
 
 				Convey("and can be broken", func() {
 					mci.BreakFeatures(nil, "CompareAndSwap")
 					err = mc.CompareAndSwap(itm)
-					So(err, ShouldEqual, memcache.ErrServerError)
+					So(err, ShouldEqual, gae.ErrMCServerError)
 				})
 			})
 		})
 
 		Convey("check that the internal implementation is sane", func() {
 			curTime := now
-			err := mc.Add(&memcache.Item{
-				Key:        "sup",
-				Value:      []byte("cool"),
-				Expiration: time.Second * 2,
+			err := mc.Add(&mcItem{
+				key:        "sup",
+				value:      []byte("cool"),
+				expiration: time.Second * 2,
 			})
 
 			So(err, ShouldBeNil)
 			So(len(mci.data.items), ShouldEqual, 1)
 			So(mci.data.casID, ShouldEqual, 1)
-			So(mci.data.items["sup"], ShouldResemble, &unsafe.Item{
-				Key:        "sup",
-				Value:      []byte("cool"),
+			So(mci.data.items["sup"], ShouldResemble, &mcItem{
+				key:        "sup",
+				value:      []byte("cool"),
+				expiration: time.Duration(curTime.Add(time.Second * 2).UnixNano()),
 				CasID:      1,
-				Expiration: time.Duration(curTime.Add(time.Second * 2).UnixNano()),
 			})
 
 			el, err := mc.Get("sup")
@@ -203,11 +201,11 @@ func TestMemcache(t *testing.T) {
 			So(len(mci.data.items), ShouldEqual, 1)
 			So(mci.data.casID, ShouldEqual, 1)
 
-			testItem := &memcache.Item{
-				Key:   "sup",
-				Value: []byte("cool"),
+			testItem := &mcItem{
+				key:   "sup",
+				value: []byte("cool"),
+				CasID: 1,
 			}
-			unsafe.MCSetCasID(testItem, 1)
 			So(el, ShouldResemble, testItem)
 		})