LogDog: Fix archival Get/Tail implementations.

logdog/common/storage/memory/memory_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 memory
 
 import (
         "bytes"
         "encoding/binary"
         "errors"
@@ skipping 19 matching lines @@
 
 // index builds an index of stream message number to array offset.
 func index(recs []*rec) map[types.MessageIndex]int {
         index := map[types.MessageIndex]int{}
         for i, r := range recs {
                 index[r.index] = i
         }
         return index
 }
 
+func mustGetIndex(e *storage.Entry) types.MessageIndex {
+        idx, err := e.GetStreamIndex()
+        if err != nil {
+                panic(err)
+        }
+        return idx
+}
+
 func TestBigTable(t *testing.T) {
         t.Parallel()
 
         Convey(`A memory Storage instance.`, t, func() {
                 st := Storage{}
                 defer st.Close()
 
                 project := config.ProjectName("test-project")
                 path := types.StreamPath("testing/+/foo/bar")
 
@@ skipping 18 matching lines @@
                         So(putRange(7, 2), ShouldBeNil)
                         So(putRange(10, 1), ShouldBeNil)
 
                         // Forward-indexed records.
                         recs := make([]*rec, len(indices))
                         for i, idx := range indices {
                                 recs[i] = numRec(idx)
                         }
 
                         var getRecs []*rec
-                        getAllCB := func(idx types.MessageIndex, data []byte) bool {
+                        getAllCB := func(e *storage.Entry) bool {
                                 getRecs = append(getRecs, &rec{
-                                        index: idx,
-                                        data:  data,
+                                        index: mustGetIndex(e),
+                                        data:  e.D,
                                 })
                                 return true
                         }
 
                         Convey(`Put()`, func() {
                                 req := storage.PutRequest{
                                         Project: project,
                                         Path:    path,
                                 }
 
@@ skipping 32 matching lines @@
                                 Convey(`Will adhere to hard limit.`, func() {
                                         st.MaxGetCount = 3
                                         req.Limit = 4
 
                                         So(st.Get(req, getAllCB), ShouldBeNil)
                                         So(getRecs, ShouldResemble, recs[:3])
                                 })
 
                                 Convey(`Will stop iterating if callback returns false.`, func() {
                                         count := 0
-                                        err := st.Get(req, func(types.MessageIndex, []byte) bool {
+                                        err := st.Get(req, func(*storage.Entry) bool {
                                                 count++
                                                 return false
                                         })
                                         So(err, ShouldBeNil)
                                         So(count, ShouldEqual, 1)
                                 })
 
                                 Convey(`Will fail to retrieve records if the project doesn't exist.`, func() {
                                         req.Project = "project-does-not-exist"
 
                                         So(st.Get(req, getAllCB), ShouldEqual, storage.ErrDoesNotExist)
                                 })
 
                                 Convey(`Will fail to retrieve records if the path doesn't exist.`, func() {
                                         req.Path = "testing/+/does/not/exist"
 
                                         So(st.Get(req, getAllCB), ShouldEqual, storage.ErrDoesNotExist)
                                 })
 
                                 Convey(`Will return an error if one is set.`, func() {
                                         st.SetErr(errors.New("test error"))
 
                                         So(st.Get(req, nil), ShouldErrLike, "test error")
                                 })
                         })
 
                         Convey(`Tail()`, func() {
                                 Convey(`Can retrieve the tail record, 10.`, func() {
-                                        d, idx, err := st.Tail(project, path)
+                                        e, err := st.Tail(project, path)
                                         So(err, ShouldBeNil)
-                                        So(d, ShouldResemble, numRec(10).data)
-                                        So(idx, ShouldEqual, 10)
+                                        So(e.D, ShouldResemble, numRec(10).data)
+                                        So(mustGetIndex(e), ShouldEqual, 10)
                                 })
 
                                 Convey(`Will fail to retrieve records if the project doesn't exist.`, func() {
-                                        _, _, err := st.Tail("project-does-not-exist", path)
+                                        _, err := st.Tail("project-does-not-exist", path)
                                         So(err, ShouldEqual, storage.ErrDoesNotExist)
                                 })
 
                                 Convey(`Will fail to retrieve records if the path doesn't exist.`, func() {
-                                        _, _, err := st.Tail(project, "testing/+/does/not/exist")
+                                        _, err := st.Tail(project, "testing/+/does/not/exist")
                                         So(err, ShouldEqual, storage.ErrDoesNotExist)
                                 })
 
                                 Convey(`Will return an error if one is set.`, func() {
                                         st.SetErr(errors.New("test error"))
-                                        _, _, err := st.Tail("", "")
+                                        _, err := st.Tail("", "")
                                         So(err, ShouldErrLike, "test error")
                                 })
                         })
 
                         Convey(`Config()`, func() {
                                 cfg := storage.Config{
                                         MaxLogAge: time.Hour,
                                 }
 
                                 Convey(`Can update the configuration.`, func() {
@@ skipping 15 matching lines @@
 
                                 st.SetErr(nil)
                                 So(st.Config(storage.Config{}), ShouldBeNil)
 
                                 st.SetErr(errors.New("test error"))
                                 So(st.Config(storage.Config{}), ShouldErrLike, "test error")
                         })
                 })
         })
 }