Add context-aware "time" library wrapper.

go/src/infra/gae/libs/wrapper/memory/memcache_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 memory
 
 import (
         "infra/gae/libs/wrapper"
         "infra/gae/libs/wrapper/unsafe"
+        "infra/libs/clock/testclock"
         "testing"
         "time"
 
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 
         "appengine/memcache"
 )
 
 func TestMemcache(t *testing.T) {
         t.Parallel()
 
         Convey("memcache", t, func() {
-                now := time.Now()
-                timeNow := func(context.Context) time.Time {
-                        ret := now
-                        now = now.Add(time.Second)
-                        return ret
-                }
-                c := Use(wrapper.SetTimeNowFactory(context.Background(), timeNow))
+                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)
                 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,
@@ skipping 24 matching lines @@
                                 testItem := &memcache.Item{
                                         Key:   "sup",
                                         Value: []byte("cool"),
                                 }
                                 unsafe.MCSetCasID(testItem, 1)
                                 i, err := mc.Get("sup")
                                 So(err, ShouldBeNil)
                                 So(i, ShouldResemble, testItem)
 
                                 Convey("which can expire", func() {
-                                        now = now.Add(time.Second * 4)
+                                        tc.Add(time.Second * 4)
                                         i, err := mc.Get("sup")
                                         So(err, ShouldEqual, memcache.ErrCacheMiss)
                                         So(i, ShouldBeNil)
                                 })
 
                                 Convey("which can be broken intentionally", func() {
                                         mci.BreakFeatures(nil, "Get")
                                         _, err := mc.Get("sup")
                                         So(err, ShouldEqual, memcache.ErrServerError)
                                 })
@@ skipping 77 matching lines @@
                                         So(err, ShouldBeNil)
                                 })
 
                                 Convey("but fails if you don't", func() {
                                         itm.Value = []byte("newp")
                                         err = mc.CompareAndSwap(itm)
                                         So(err, ShouldEqual, memcache.ErrCASConflict)
                                 })
 
                                 Convey("and fails if the item is expired/gone", func() {
-                                        // run the clock forward
-                                        wrapper.GetTimeNow(c)
-                                        wrapper.GetTimeNow(c)
+                                        tc.Add(3 * time.Second)
                                         itm.Value = []byte("newp")
                                         err = mc.CompareAndSwap(itm)
                                         So(err, ShouldEqual, memcache.ErrNotStored)
                                 })
 
                                 Convey("and can be broken", func() {
                                         mci.BreakFeatures(nil, "CompareAndSwap")
                                         err = mc.CompareAndSwap(itm)
                                         So(err, ShouldEqual, memcache.ErrServerError)
                                 })
@@ skipping 26 matching lines @@
                         testItem := &memcache.Item{
                                 Key:   "sup",
                                 Value: []byte("cool"),
                         }
                         unsafe.MCSetCasID(testItem, 1)
                         So(el, ShouldResemble, testItem)
                 })
 
         })
 }