Add context-aware "time" library wrapper.

go/src/infra/gae/libs/wrapper/memory/taskqueue_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 (
         "fmt"
         "infra/gae/libs/wrapper"
+        "infra/libs/clock"
+        "infra/libs/clock/testclock"
         "math/rand"
         "net/http"
         "testing"
         "time"
 
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 
         "appengine/taskqueue"
 )
 
 func TestTaskQueue(t *testing.T) {
         t.Parallel()
 
         Convey("TaskQueue", t, func() {
                 now := time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC)
-                timeNow := func(context.Context) time.Time {
-                        ret := now
-                        now = now.Add(time.Second)
-                        return ret
-                }
-                c := wrapper.SetTimeNowFactory(context.Background(), timeNow)
-                c = wrapper.SetMathRand(c, rand.New(rand.NewSource(wrapper.GetTimeNow(c).UnixNano())))
+                tc := testclock.New(now)
+                c := clock.SetClock(context.Background(), tc)
+                c = wrapper.SetMathRand(c, rand.New(rand.NewSource(clock.Now(c).UnixNano())))
                 c = Use(c)
 
                 tq := wrapper.GetTQ(c).(interface {
                         wrapper.TQMultiReadWriter
                         wrapper.TQTestable
                 })
 
                 So(tq, ShouldNotBeNil)
 
                 Convey("implements TQMultiReadWriter", func() {
                         Convey("Add", func() {
                                 t := &taskqueue.Task{Path: "/hello/world"}
 
                                 Convey("works", func() {
-                                        curTime := now
                                         t.Delay = 4 * time.Second
                                         t.Header = http.Header{}
                                         t.Header.Add("Cat", "tabby")
                                         t.Payload = []byte("watwatwat")
                                         t.RetryOptions = &taskqueue.RetryOptions{AgeLimit: 7 * time.Second}
                                         _, err := tq.Add(t, "")
                                         So(err, ShouldBeNil)
                                         name := "Z_UjshxM9ecyMQfGbZmUGOEcgxWU0_5CGLl_-RntudwAw2DqQ5-58bzJiWQN4OKzeuUb9O4JrPkUw2rOvk2Ax46THojnQ6avBQgZdrKcJmrwQ6o4qKfJdiyUbGXvy691yRfzLeQhs6cBhWrgf3wH-VPMcA4SC-zlbJ2U8An7I0zJQA5nBFnMNoMgT-2peGoay3rCSbj4z9VFFm9kS_i6JCaQH518ujLDSNCYdjTq6B6lcWrZAh0U_q3a1S2nXEwrKiw_t9MTNQFgAQZWyGBbvZQPmeRYtu8SPaWzTfd25v_YWgBuVL2rRSPSMvlDwE04nNdtvVzE8vNNiA1zRimmdzKeqATQF9_ReUvj4D7U8dcS703DZWfKMBLgBffY9jqCassOOOw77V72Oq5EVauUw3Qw0L6bBsfM9FtahTKUdabzRZjXUoze3EK4KXPt3-wdidau-8JrVf2XFocjjZbwHoxcGvbtT3b4nGLDlgwdC00bwaFBZWff"
                                         So(*tq.GetScheduledTasks()["default"][name], ShouldResemble, taskqueue.Task{
-                                                ETA:          curTime.Add(4 * time.Second),
+                                                ETA:          now.Add(4 * time.Second),
                                                 Header:       http.Header{"Cat": []string{"tabby"}},
                                                 Method:       "POST",
                                                 Name:         name,
                                                 Path:         "/hello/world",
                                                 Payload:      []byte("watwatwat"),
                                                 RetryOptions: &taskqueue.RetryOptions{AgeLimit: 7 * time.Second},
                                         })
                                 })
 
                                 Convey("cannot add to bad queues", func() {
@@ skipping 35 matching lines @@
 
                                         err = tq.Delete(t, "")
                                         So(err, ShouldBeNil)
 
                                         // can't add a deleted task!
                                         _, err = tq.Add(t, "")
                                         So(err, ShouldEqual, taskqueue.ErrTaskAlreadyAdded)
                                 })
 
                                 Convey("cannot set ETA+Delay", func() {
-                                        t.ETA = wrapper.GetTimeNow(c).Add(time.Hour)
+                                        t.ETA = clock.Now(c).Add(time.Hour)
+                                        tc.Add(time.Second)
                                         t.Delay = time.Hour
                                         So(func() { tq.Add(t, "") }, ShouldPanic)
                                 })
 
                                 Convey("must use a reasonable method", func() {
                                         t.Method = "Crystal"
                                         _, err := tq.Add(t, "")
                                         So(err.Error(), ShouldContainSubstring, "bad method")
                                 })
 
@@ skipping 14 matching lines @@
                                         So(err.Error(), ShouldContainSubstring, "INVALID_TASK_NAME")
                                 })
 
                                 Convey("can be broken", func() {
                                         tq.BreakFeatures(nil, "Add")
                                         _, err := tq.Add(t, "")
                                         So(err.Error(), ShouldContainSubstring, "TRANSIENT_ERROR")
                                 })
 
                                 Convey("AddMulti also works", func() {
-                                        curTime := now
-
                                         t2 := dupTask(t)
                                         t2.Path = "/hi/city"
 
                                         expect := []*taskqueue.Task{t, t2}
 
                                         tasks, err := tq.AddMulti(expect, "default")
                                         So(err, ShouldBeNil)
                                         So(len(tasks), ShouldEqual, 2)
                                         So(len(tq.GetScheduledTasks()["default"]), ShouldEqual, 2)
 
                                         for i := range expect {
                                                 Convey(fmt.Sprintf("task %d: %s", i, expect[i].Path), func() {
                                                         expect[i].Method = "POST"
-                                                        expect[i].ETA = curTime.Add(time.Duration(i) * time.Second)
+                                                        expect[i].ETA = now
                                                         So(expect[i].Name, ShouldEqual, "")
                                                         So(len(tasks[i].Name), ShouldEqual, 500)
                                                         tasks[i].Name = ""
                                                         So(tasks[i], ShouldResemble, expect[i])
                                                 })
                                         }
 
                                         Convey("can be broken", func() {
                                                 tq.BreakFeatures(nil, "AddMulti")
                                                 _, err := tq.AddMulti([]*taskqueue.Task{t}, "")
@@ skipping 289 matching lines @@
                                 }()
 
                                 So(tq.GetScheduledTasks()["default"][tEnQ.Name], ShouldResemble, tEnQ)
                                 So(tq.GetTombstonedTasks()["default"][tEnQ2.Name], ShouldResemble, tEnQ2)
                                 So(tq.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                 })
         })
 }