LogDog: Add Storage-layer data caching.

logdog/common/storage/archive/storage_test.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package archive
 
 import (
         "bytes"
         "fmt"
         "io"
         "io/ioutil"
         "testing"
 
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/gs"
         "github.com/luci/luci-go/logdog/api/logpb"
         "github.com/luci/luci-go/logdog/common/archive"
         "github.com/luci/luci-go/logdog/common/renderer"
         "github.com/luci/luci-go/logdog/common/storage"
+        "github.com/luci/luci-go/logdog/common/storage/memory"
 
         cloudStorage "cloud.google.com/go/storage"
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 const (
@@ skipping 276 matching lines @@
                                         }
                                 })
                         }
                 })
 
                 // Individual error test cases.
                 for _, tc := range []struct {
                         title string
                         fn    func() error
                 }{
-                        {"Get", func() error { return st.Get(storage.GetRequest{}, nil) }},
+                        {"Get", func() error { return st.Get(storage.GetRequest{}, func(*storage.Entry) bool { return true }) }},
                         {"Tail", func() (err error) {
                                 _, err = st.Tail("", "")
                                 return
                         }},
                 } {
-                        Convey(fmt.Sprintf("Error case: %q", tc.title), func() {
+                        Convey(fmt.Sprintf("Testing retrieval: %q", tc.title), func() {
                                 Convey(`With missing log stream returns ErrDoesNotExist.`, func() {
                                         stImpl.streamPath = "does-not-exist"
 
                                         So(st.Get(storage.GetRequest{}, nil), ShouldEqual, storage.ErrDoesNotExist)
                                 })
 
                                 Convey(`With a client error returns that error.`, func() {
                                         client.err = errors.New("test error")
 
                                         So(errors.Unwrap(tc.fn()), ShouldEqual, client.err)
@@ skipping 15 matching lines @@
                                         client.index = []byte{0x00}
 
                                         So(tc.fn(), ShouldErrLike, "failed to unmarshal index")
                                 })
 
                                 Convey(`With junk stream data returns an error.`, func() {
                                         client.stream = []byte{0x00, 0x01, 0xff}
 
                                         So(tc.fn(), ShouldErrLike, "failed to unmarshal")
                                 })
+
+                                Convey(`With data entries and a cache, only loads the index once.`, func() {
+                                        var cache memory.Cache
+                                        stImpl.Cache = &cache
+
+                                        gen.generate("foo", "bar", "baz", "qux", "quux")
+                                        client.load(&gen)
+
+                                        // Assert that an attempted load will fail with an error. This is so
+                                        // we don't accidentally test something that doesn't follow the path
+                                        // we're intending to follow.
+                                        client.indexErr = errors.New("not using a cache")
+                                        So(errors.Unwrap(tc.fn()), ShouldEqual, client.indexErr)
+
+                                        for i := 0; i < 10; i++ {
+                                                if i == 0 {
+                                                        // First time successfully reads the index.
+                                                        client.indexErr = nil
+                                                } else {
+                                                        // Subsequent attempts to load the index will result in an error.
+                                                        // This ensures that if they are successful, it's because we're
+                                                        // hitting the cache.
+                                                        client.indexErr = errors.New("not using a cache")
+                                                }
+
+                                                So(tc.fn(), ShouldBeNil)
+                                        }
+                                })
                         })
                 }
 
                 Convey(`Tail with no log entries returns ErrDoesNotExist.`, func() {
                         client.load(&gen)
 
                         _, err := st.Tail("", "")
                         So(err, ShouldEqual, storage.ErrDoesNotExist)
                 })
         })
 }