LogDog: BigTable batching schema.

server/internal/logdog/collector/utils_test.go

 // Copyright 2016 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 collector
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 106 matching lines @@
         }
         return int(sp.TerminalIndex), true
 }
 
 // testStorage is a testing storage instance that returns errors.
 type testStorage struct {
         storage.Storage
         err func() error
 }
 
-func (s *testStorage) Put(r *storage.PutRequest) error {
+func (s *testStorage) Put(r storage.PutRequest) error {
         if s.err != nil {
                 if err := s.err(); err != nil {
                         return err
                 }
         }
         return s.Storage.Put(r)
 }
 
 // bundleBuilder is a set of utility functions to help test cases construct
 // specific logpb.ButlerLogBundle layouts.
@@ skipping 64 matching lines @@
                                         },
                                 },
                         },
                 },
         }
 }
 
 func (b *bundleBuilder) bundle() []byte {
         bytes := b.bundleWithEntries(b.entries...)
         b.entries = nil
+
         return bytes
 }
 
 func (b *bundleBuilder) bundleWithEntries(e ...*logpb.ButlerLogBundle_Entry) []byte {
         bundle := logpb.ButlerLogBundle{
                 Source:    "test stream",
                 Timestamp: google.NewTimestamp(clock.Now(b)),
                 Entries:   e,
         }
 
@@ skipping 54 matching lines @@
         st := actual.(storage.Storage)
         name := expected[0].(string)
 
         // Load all entries for this stream.
         req := storage.GetRequest{
                 Path: types.StreamPath(name),
         }
 
         entries := make(map[int]*logpb.LogEntry)
         var ierr error
-        err := st.Get(&req, func(idx types.MessageIndex, d []byte) bool {
+        err := st.Get(req, func(idx types.MessageIndex, d []byte) bool {
                 le := logpb.LogEntry{}
                 if ierr = proto.Unmarshal(d, &le); ierr != nil {
                         return false
                 }
                 entries[int(idx)] = &le
                 return true
         })
         if ierr != nil {
                 err = ierr
         }
@@ skipping 12 matching lines @@
                         return fmt.Sprintf("*%d", i)
                 }
                 return ""
         }
 
         var failed []string
         for _, exp := range expected[1:] {
                 switch e := exp.(type) {
                 case int:
                         if err := assertLogEntry(e); err != "" {
-                                failed = append(failed, err)
+                                failed = append(failed, fmt.Sprintf("missing{%s}", err))
                         }
 
                 case indexRange:
                         var errs []string
                         for i := e.start; i <= e.end; i++ {
                                 if err := assertLogEntry(i); err != "" {
                                         errs = append(errs, err)
                                 }
                         }
                         if len(errs) > 0 {
@@ skipping 18 matching lines @@
                         extra[i] = fmt.Sprintf("%d", idx)
                 }
                 failed = append(failed, fmt.Sprintf("extra{%s}", strings.Join(extra, ",")))
         }
 
         if len(failed) > 0 {
                 return strings.Join(failed, ", ")
         }
         return ""
 }