Archivist asserts completeness through keys scan.

server/internal/logdog/archivist/archivist_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 archivist
 
 import (
         "fmt"
         "strings"
         "sync"
@@ skipping 375 matching lines @@
                         ack, err := ar.archiveTaskImpl(c, task)
                         So(err, ShouldErrLike, "completeness required, but stream has no terminal index")
                         So(ack, ShouldBeFalse)
                 })
 
                 Convey(`With terminal index "3"`, func() {
                         stream.State.TerminalIndex = 3
 
                         Convey(`Will fail not ACK a log stream with no entries.`, func() {
                                 ack, err := ar.archiveTaskImpl(c, task)
-                                So(err, ShouldErrLike, "stream has missing entries")
+                                So(err, ShouldEqual, storage.ErrDoesNotExist)
                                 So(ack, ShouldBeFalse)
                         })
 
                         Convey(`Will fail to archive {0, 1, 2, 4} (incomplete).`, func() {
                                 addTestEntry(0, 1, 2, 4)
 
                                 ack, err := ar.archiveTaskImpl(c, task)
-                                So(err, ShouldErrLike, "stream has missing entries")
+                                So(err, ShouldErrLike, "missing log entry")
                                 So(ack, ShouldBeFalse)
                         })
 
                         Convey(`Will successfully archive {0, 1, 2, 3, 4}, stopping at the terminal index.`, func() {
                                 addTestEntry(0, 1, 2, 3, 4)
 
                                 ack, err := ar.archiveTaskImpl(c, task)
                                 So(err, ShouldBeNil)
                                 So(ack, ShouldBeTrue)
 
                                 So(hasStreams(true, true, true), ShouldBeTrue)
                                 So(archiveRequest, ShouldResemble, &logdog.ArchiveStreamRequest{
                                         Path:          archiveTask.Path,
                                         LogEntryCount: 4,
                                         TerminalIndex: 3,
 
                                         StreamUrl: gsURL("logstream.entries"),
                                         IndexUrl:  gsURL("logstream.index"),
                                         DataUrl:   gsURL("data.bin"),
                                 })
                         })
 
-                        Convey(`When atransient archival error occurs, will not ACK it.`, func() {
+                        Convey(`When a transient archival error occurs, will not ACK it.`, func() {
+                                addTestEntry(0, 1, 2, 3, 4)
                                 gsc.newWriterErr = func(*testGSWriter) error { return errors.WrapTransient(errors.New("test error")) }
 
                                 ack, err := ar.archiveTaskImpl(c, task)
                                 So(err, ShouldErrLike, "test error")
                                 So(ack, ShouldBeFalse)
                         })
 
                         Convey(`When a non-transient archival error occurs`, func() {
+                                addTestEntry(0, 1, 2, 3, 4)
                                 archiveErr := errors.New("archive failure error")
                                 gsc.newWriterErr = func(*testGSWriter) error { return archiveErr }
 
                                 Convey(`If remote report returns an error, do not ACK.`, func() {
                                         archiveStreamErr = errors.New("test error")
 
                                         ack, err := ar.archiveTaskImpl(c, task)
                                         So(err, ShouldErrLike, "test error")
                                         So(ack, ShouldBeFalse)
 
@@ skipping 181 matching lines @@
                                                 ack, err := ar.archiveTaskImpl(c, task)
                                                 So(err, ShouldErrLike, "test error")
                                                 So(ack, ShouldBeFalse)
                                                 So(archiveRequest, ShouldBeNil)
                                         })
                                 }
                         }
                 })
         })
 }