LogDog: Handle archive failures.

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 (
         "errors"
         "fmt"
         "strings"
@@ skipping 207 matching lines @@
                                 Path:          string(desc.Path()),
                                 ProtoVersion:  logpb.Version,
                                 TerminalIndex: -1,
                                 Archived:      false,
                                 Purged:        false,
                         },
                         Desc: descBytes,
                 }
 
                 var archiveRequest *logdog.ArchiveStreamRequest
+                var archiveStreamErr error
                 sc := testServicesClient{
                         lsCallback: func(req *logdog.LoadStreamRequest) (*logdog.LoadStreamResponse, error) {
                                 return &stream, nil
                         },
                         asCallback: func(req *logdog.ArchiveStreamRequest) error {
                                 archiveRequest = req
-                                return nil
+                                return archiveStreamErr
                         },
                 }
 
                 ar := Archivist{
                         Service:  &sc,
                         Storage:  &st,
                         GSClient: &gsc,
                         GSBase:   gs.Path("gs://archive-test/path/to/archive/"), // Extra slashes to test concatenation.
                 }
 
@@ skipping 119 matching lines @@
                                         So(archiveRequest, ShouldResemble, &logdog.ArchiveStreamRequest{
                                                 Path:          task.Path,
                                                 Complete:      false,
                                                 TerminalIndex: 4,
 
                                                 StreamUrl: gsURL("logstream.entries"),
                                                 IndexUrl:  gsURL("logstream.index"),
                                                 DataUrl:   gsURL("data.bin"),
                                         })
                                 })
+
+                                Convey(`When an archival error occurs, will submit an ArchiveStreamRequest with Error set.`, func() {
+                                        gsc.newWriterErr = func(*testGSWriter) error { return errors.New("test error") }
+                                        archiveStreamErr = errors.New("test error")
+
+                                        So(ar.Archive(c, &task), ShouldEqual, archiveStreamErr)
+                                        So(archiveRequest, ShouldResemble, &logdog.ArchiveStreamRequest{
+                                                Path:          task.Path,
+                                                Complete:      false,
+                                                TerminalIndex: -1,
+                                                Error:         true,
+                                        })
+                                })
                         })
 
                         Convey(`With terminal index 3`, func() {
                                 stream.State.TerminalIndex = 3
 
                                 Convey(`Will successfully archive if there are no entries.`, func() {
                                         So(ar.Archive(c, &task), ShouldBeNil)
 
                                         So(hasStreams(true, true, false), ShouldBeTrue)
                                         So(archiveRequest, ShouldResemble, &logdog.ArchiveStreamRequest{
@@ skipping 92 matching lines @@
                                                                         return errors.New("other error")
                                                                 }
 
                                                                 // First delete (on create).
                                                                 failed = true
                                                         }
                                                         return nil
                                                 }
                                         }},
                                 } {
-                                        Convey(fmt.Sprintf(`Can handle %s for %s`, testCase.name, failName), func() {
+                                        Convey(fmt.Sprintf(`Can handle %s for %s, and will not archive.`, testCase.name, failName), func() {
                                                 testCase.setup()
                                                 So(ar.Archive(c, &task), ShouldErrLike, "test error")
+                                                So(archiveRequest, ShouldBeNil)
                                         })
                                 }
                         }
                 })
         })
 }