common/lazyslot: Simplify code a little bit.

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 (
         "sync"
         "testing"
         "time"
 
+        "golang.org/x/net/context"
+
         "github.com/luci/luci-go/common/clock/testclock"
 
+        . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
-        "golang.org/x/net/context"
 )
 
 func TestLazySlot(t *testing.T) {
         Convey("Blocking mode works", t, func() {
                 c, clk := newContext()
 
+                lock := sync.Mutex{}
                 counter := 0
+
                 s := Slot{
                         Fetcher: func(c context.Context, prev Value) (Value, error) {
+                                lock.Lock()
+                                defer lock.Unlock()
                                 counter++
                                 return Value{counter, clk.Now().Add(time.Second)}, nil
                         },
                 }
 
                 // Initial fetch.
-                So(s.Peek(), ShouldResemble, Value{})
+                So(s.current, ShouldBeNil)
                 v, err := s.Get(c)
                 So(err, ShouldBeNil)
                 So(v.Value.(int), ShouldEqual, 1)
-                So(s.Peek().Value.(int), ShouldEqual, 1)
 
                 // Still fresh.
                 v, err = s.Get(c)
                 So(err, ShouldBeNil)
                 So(v.Value.(int), ShouldEqual, 1)
 
                 // Expires and refreshed.
                 clk.Add(5 * time.Second)
                 v, err = s.Get(c)
                 So(err, ShouldBeNil)
@@ skipping 60 matching lines @@
                 }
                 v, err := s.Get(c)
                 So(err, ShouldBeNil)
                 So(v.Value.(int), ShouldEqual, 1)
 
                 // Make it expire. Start panicing fetch.
                 clk.Add(5 * time.Second)
                 s.Fetcher = func(c context.Context, prev Value) (Value, error) {
                         panic("omg")
                 }
-                So(func() { s.Get(c) }, ShouldPanicWith, "omg")
+                _, err = s.Get(c)
+                So(err, ShouldErrLike, "panic caught in lazyslot.Slot Fetcher - omg")
 
                 // Doesn't deadlock.
                 s.Fetcher = func(c context.Context, prev Value) (Value, error) {
                         return Value{2, clk.Now().Add(time.Second)}, nil
                 }
                 v, err = s.Get(c)
                 So(err, ShouldBeNil)
                 So(v.Value.(int), ShouldEqual, 2)
         })
+
+        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
+                        },
+                }
+                _, err := s.Get(c)
+                So(err, ShouldErrLike, "lazyslot.Slot Fetcher returned nil value")
+        })
 }
 
 func newContext() (context.Context, testclock.TestClock) {
         return testclock.UseTime(context.Background(), time.Unix(1442270520, 0))
 }