LogDog/Archivist: Conditionally render data.

logdog/server/archivist/archivist_test.go

 // Copyright 2016 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 archivist
 
 import (
         "fmt"
         "strings"
         "sync"
@@ skipping 192 matching lines @@
 
         Convey(`A testing archive setup`, t, func() {
                 c, tc := testclock.UseTime(context.Background(), testclock.TestTimeUTC)
 
                 st := memory.Storage{}
                 gsc := testGSClient{}
 
                 // Set up our test log stream.
                 project := "test-project"
                 desc := logpb.LogStreamDescriptor{
-                        Prefix:        "testing",
-                        Name:          "foo",
-                        BinaryFileExt: "bin",
-                }
-                descBytes, err := proto.Marshal(&desc)
-                if err != nil {
-                        panic(err)
+                        Prefix: "testing",
+                        Name:   "foo",
                 }
 
                 // Utility function to add a log entry for "ls".
                 addTestEntry := func(p string, idxs ...int) {
                         for _, v := range idxs {
                                 le := logpb.LogEntry{
                                         PrefixIndex: uint64(v),
                                         StreamIndex: uint64(v),
                                         Content: &logpb.LogEntry_Text{&logpb.Text{
                                                 Lines: []*logpb.Text_Line{
@@ skipping 43 matching lines @@
                 }
 
                 // Set up our test Coordinator client stubs.
                 stream := logdog.LoadStreamResponse{
                         State: &logdog.LogStreamState{
                                 ProtoVersion:  logpb.Version,
                                 TerminalIndex: -1,
                                 Archived:      false,
                                 Purged:        false,
                         },
-                        Desc: descBytes,
 
                         // Age is ON the expiration threshold, so not expired.
                         Age:         archiveTask.CompletePeriod,
                         ArchivalKey: archiveTask.Key,
                 }
 
+                // Allow tests to modify the log stream descriptor.
+                reloadDesc := func() {
+                        descBytes, err := proto.Marshal(&desc)
+                        if err != nil {
+                                panic(err)
+                        }
+                        stream.Desc = descBytes
+                }
+                reloadDesc()
+
                 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 archiveStreamErr
                         },
                 }
 
-                stBase := Settings{}
+                stBase := Settings{
+                        AlwaysRender: true,
+                }
 
                 ar := Archivist{
                         Service: &sc,
                         SettingsLoader: func(c context.Context, proj config.ProjectName) (*Settings, error) {
                                 // Extra slashes to test concatenation,.
                                 st := stBase
                                 st.GSBase = gs.Path(fmt.Sprintf("gs://archival/%s/path/to/archive/", proj))
                                 st.GSStagingBase = gs.Path(fmt.Sprintf("gs://archival-staging/%s/path/to/archive/", proj))
                                 return &st, nil
                         },
@@ skipping 272 matching lines @@
                                                 TerminalIndex: 2,
 
                                                 StreamUrl: gsURL(project, "logstream.entries"),
                                                 IndexUrl:  gsURL(project, "logstream.index"),
                                                 DataUrl:   gsURL(project, "data.bin"),
                                         })
                                 })
                         })
                 })
 
+                Convey(`When not configured to always render`, func() {
+                        stBase.AlwaysRender = false
+
+                        addTestEntry(project, 0, 1, 2, 3, 4)
+                        stream.State.TerminalIndex = 4
+
+                        Convey(`Will not emit a data stream if no binary file extension is specified.`, func() {
+                                So(ar.archiveTaskImpl(c, task), ShouldBeNil)
+                                So(task.consumed, ShouldBeTrue)
+
+                                So(hasStreams(true, true, false), ShouldBeTrue)
+                                So(archiveRequest, ShouldResemble, &logdog.ArchiveStreamRequest{
+                                        Project:       project,
+                                        Id:            archiveTask.Id,
+                                        LogEntryCount: 5,
+                                        TerminalIndex: 4,
+
+                                        StreamUrl: gsURL(project, "logstream.entries"),
+                                        IndexUrl:  gsURL(project, "logstream.index"),
+                                })
+                        })
+
+                        Convey(`Will emit a data stream if a binary file extension is specified.`, func() {
+                                desc.BinaryFileExt = "foobar"
+                                reloadDesc()
+
+                                So(ar.archiveTaskImpl(c, task), ShouldBeNil)
+                                So(task.consumed, ShouldBeTrue)
+
+                                So(hasStreams(true, true, true), ShouldBeTrue)
+                                So(archiveRequest, ShouldResemble, &logdog.ArchiveStreamRequest{
+                                        Project:       project,
+                                        Id:            archiveTask.Id,
+                                        LogEntryCount: 5,
+                                        TerminalIndex: 4,
+
+                                        StreamUrl: gsURL(project, "logstream.entries"),
+                                        IndexUrl:  gsURL(project, "logstream.index"),
+                                        DataUrl:   gsURL(project, "data.foobar"),
+                                })
+                        })
+                })
+
                 Convey(`With an empty project name, will fail and consume the task.`, func() {
                         archiveTask.Project = ""
 
                         So(ar.archiveTaskImpl(c, task), ShouldErrLike, "invalid project name")
                         So(task.consumed, ShouldBeTrue)
                 })
 
                 Convey(`With an invalid project name, will fail and consume the task.`, func() {
                         archiveTask.Project = "!!! invalid project name !!!"
 
@@ skipping 72 matching lines @@
 
                                                 So(ar.archiveTaskImpl(c, task), ShouldErrLike, "test error")
                                                 So(task.consumed, ShouldBeFalse)
                                                 So(archiveRequest, ShouldBeNil)
                                         })
                                 }
                         }
                 })
         })
 }