Fix BigTable multi-entry row cached Tail.

logdog/common/storage/bigtable/storage_test.go

 // Copyright 2015 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 bigtable
 
 import (
         "bytes"
         "strconv"
         "testing"
 
         "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/data/recordio"
         "github.com/luci/luci-go/logdog/common/storage"
+        "github.com/luci/luci-go/logdog/common/storage/memory"
         "github.com/luci/luci-go/logdog/common/types"
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func mustGetIndex(e *storage.Entry) types.MessageIndex {
         idx, err := e.GetStreamIndex()
         if err != nil {
                 panic(err)
         }
         return idx
 }
 
 func TestStorage(t *testing.T) {
         t.Parallel()
 
         Convey(`A BigTable storage instance bound to a testing BigTable instance`, t, func() {
-                s := NewMemoryInstance(context.Background(), Options{})
+                var cache memory.Cache
+                s := NewMemoryInstance(context.Background(), Options{
+                        Cache: &cache,
+                })
                 defer s.Close()
 
                 project := config.ProjectName("test-project")
                 get := func(path string, index int, limit int, keysOnly bool) ([]string, error) {
                         req := storage.GetRequest{
                                 Project:  project,
                                 Path:     types.StreamPath(path),
                                 Index:    types.MessageIndex(index),
                                 Limit:    limit,
                                 KeysOnly: keysOnly,
@@ skipping 159 matching lines @@
                                         if err != nil {
                                                 return "", err
                                         }
                                         return string(e.D), nil
                                 }
 
                                 Convey(`A tail request for "A" returns A{4}.`, func() {
                                         got, err := tail("A")
                                         So(err, ShouldBeNil)
                                         So(got, ShouldEqual, "4")
+
+                                        Convey(`(Cache) A second request also returns A{4}.`, func() {
+                                                got, err := tail("A")
+                                                So(err, ShouldBeNil)
+                                                So(got, ShouldEqual, "4")
+                                        })
                                 })
 
                                 Convey(`A tail request for "B" returns nothing (no contiguous logs).`, func() {
                                         _, err := tail("B")
                                         So(err, ShouldEqual, storage.ErrDoesNotExist)
                                 })
 
                                 Convey(`A tail request for "C" returns 2.`, func() {
                                         got, err := tail("C")
                                         So(err, ShouldBeNil)
                                         So(got, ShouldEqual, "2")
+
+                                        Convey(`(Cache) A second request also returns 2.`, func() {
+                                                got, err := tail("C")
+                                                So(err, ShouldBeNil)
+                                                So(got, ShouldEqual, "2")
+                                        })
+
+                                        Convey(`(Cache) After "3" is added, a second request returns 4.`, func() {
+                                                So(put("C", 3, "3"), ShouldBeNil)
+
+                                                got, err := tail("C")
+                                                So(err, ShouldBeNil)
+                                                So(got, ShouldEqual, "4")
+                                        })
                                 })
 
                                 Convey(`A tail request for "INVALID" errors NOT FOUND.`, func() {
                                         _, err := tail("INVALID")
                                         So(err, ShouldEqual, storage.ErrDoesNotExist)
                                 })
                         })
                 })
         })
 }