Retry RPC deadlines when fetching GAE settings.

common/lazyslot/lazyslot_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 lazyslot
 
 import (
+        "fmt"
         "sync"
         "testing"
         "time"
 
         "golang.org/x/net/context"
 
+        "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/clock/testclock"
+        "github.com/luci/luci-go/common/retry"
 
+        . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestLazySlot(t *testing.T) {
         Convey("Blocking mode works", t, func() {
                 c, clk := newContext()
 
                 lock := sync.Mutex{}
                 counter := 0
 
@@ skipping 104 matching lines @@
 
         Convey("Checks for nil", t, func(conv C) {
                 c, clk := newContext()
                 s := Slot{
                         Fetcher: func(c context.Context, prev Value) (Value, error) {
                                 return Value{nil, clk.Now().Add(time.Second)}, nil
                         },
                 }
                 So(func() { s.Get(c) }, ShouldPanicWith, "lazyslot.Slot Fetcher returned nil value")
         })
+
+        Convey("Does retries", t, func(conv C) {
+                c, clk := newContext()
+
+                clk.SetTimerCallback(func(d time.Duration, t clock.Timer) {
+                        if testclock.HasTags(t, "retry") {
+                                clk.Add(d)
+                        }
+                })
+
+                lock := sync.Mutex{}
+                calls := 0
+
+                s := Slot{
+                        RetryFactory: retry.Default,
+                        Fetcher: func(c context.Context, prev Value) (Value, error) {
+                                lock.Lock()
+                                defer lock.Unlock()
+                                calls++
+                                return Value{}, fmt.Errorf("omg, error")
+                        },
+                }
+                _, err := s.Get(c)
+                So(err, ShouldErrLike, "context deadline exceeded")
+                So(calls, ShouldEqual, 8) // depends on retry config and deadline
+        })
+
+        Convey("Panics in retries", t, func(conv C) {
+                c, clk := newContext()
+
+                clk.SetTimerCallback(func(d time.Duration, t clock.Timer) {
+                        if testclock.HasTags(t, "retry") {
+                                clk.Add(d)
+                        }
+                })
+
+                lock := sync.Mutex{}
+                calls := 0
+
+                s := Slot{
+                        RetryFactory: retry.Default,
+                        Fetcher: func(c context.Context, prev Value) (Value, error) {
+                                lock.Lock()
+                                defer lock.Unlock()
+                                calls++
+                                if calls == 4 {
+                                        panic("omg, panic")
+                                }
+                                return Value{}, fmt.Errorf("omg, error")
+                        },
+                }
+                So(func() { s.Get(c) }, ShouldPanicWith, "omg, panic")
+                So(calls, ShouldEqual, 4)
+        })
 }
 
 func newContext() (context.Context, testclock.TestClock) {
         return testclock.UseTime(context.Background(), time.Unix(1442270520, 0))
 }