LogDog: Add signed GS URL fetching.

logdog/common/storage/archive/storage_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 archive
 
 import (
         "bytes"
         "fmt"
         "io"
@@ skipping 10 matching lines @@
 
         cloudStorage "cloud.google.com/go/storage"
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 const (
-        testIndexURL  = "gs://+/index"
-        testStreamURL = "gs://+/stream"
+        testIndexPath  = gs.Path("gs://+/index")
+        testStreamPath = gs.Path("gs://+/stream")
 )
 
 type logStreamGenerator struct {
         lines []string
 
         indexBuf  bytes.Buffer
         streamBuf bytes.Buffer
 }
 
 func (g *logStreamGenerator) lineFromEntry(e *storage.Entry) string {
@@ skipping 131 matching lines @@
 
         // If we have a client-level error, return it.
         if c.err != nil {
                 return nil, c.err
         }
 
         var (
                 data      []byte
                 readerErr error
         )
-        switch string(p) {
-        case testIndexURL:
+        switch p {
+        case testIndexPath:
                 data, readerErr = c.index, c.indexErr
-        case testStreamURL:
+        case testStreamPath:
                 data, readerErr = c.stream, c.streamErr
         default:
                 return nil, cloudStorage.ErrObjectNotExist
         }
 
         if offset >= 0 {
                 if offset >= int64(len(data)) {
                         offset = int64(len(data))
                 }
                 data = data[offset:]
@@ skipping 13 matching lines @@
 
         Convey(`A testing archive instance`, t, func() {
                 var (
                         c      = context.Background()
                         client fakeGSClient
                         gen    logStreamGenerator
                 )
                 defer client.Close()
 
                 opts := Options{
-                        IndexURL:  testIndexURL,
-                        StreamURL: testStreamURL,
-                        Client:    &client,
+                        Index:  testIndexPath,
+                        Stream: testStreamPath,
+                        Client: &client,
                 }
                 st, err := New(c, opts)
                 So(err, ShouldBeNil)
                 defer st.Close()
 
                 stImpl := st.(*storageImpl)
 
                 Convey(`Will fail to configure with ErrReadOnly`, func() {
                         So(st.Config(storage.Config{}), ShouldEqual, storage.ErrReadOnly)
                 })
 
                 Convey(`Will fail to Put with ErrReadOnly`, func() {
                         So(st.Put(storage.PutRequest{}), ShouldEqual, storage.ErrReadOnly)
                 })
 
                 Convey(`Given a stream with 5 log entries`, func() {
                         gen.generate("foo", "bar", "baz", "qux", "quux")
 
                         // Basic test cases.
                         for _, tc := range []struct {
                                 title string
                                 mod   func()
                         }{
                                 {`Complete index`, func() {}},
                                 {`Empty index protobuf`, func() { gen.sparseIndex() }},
-                                {`No index provided`, func() { stImpl.indexPath = "" }},
-                                {`Invalid index path`, func() { stImpl.indexPath = "does-not-exist" }},
+                                {`No index provided`, func() { stImpl.Index = "" }},
+                                {`Invalid index path`, func() { stImpl.Index = "does-not-exist" }},
                                 {`Sparse index with a start and terminal entry`, func() { gen.sparseIndex(0, 2, 4) }},
                                 {`Sparse index with a terminal entry`, func() { gen.sparseIndex(1, 3, 4) }},
                                 {`Sparse index missing a terminal entry`, func() { gen.sparseIndex(1, 3) }},
                         } {
                                 Convey(fmt.Sprintf(`Test Case: %q`, tc.title), func() {
                                         tc.mod()
 
                                         // Run through per-testcase variant set.
                                         for _, variant := range []struct {
                                                 title string
@@ skipping 54 matching lines @@
                         fn    func() error
                 }{
                         {"Get", func() error { return st.Get(storage.GetRequest{}, func(*storage.Entry) bool { return true }) }},
                         {"Tail", func() (err error) {
                                 _, err = st.Tail("", "")
                                 return
                         }},
                 } {
                         Convey(fmt.Sprintf("Testing retrieval: %q", tc.title), func() {
                                 Convey(`With missing log stream returns ErrDoesNotExist.`, func() {
-                                        stImpl.streamPath = "does-not-exist"
+                                        stImpl.Stream = "does-not-exist"
 
                                         So(st.Get(storage.GetRequest{}, nil), ShouldEqual, storage.ErrDoesNotExist)
                                 })
 
                                 Convey(`With a client error returns that error.`, func() {
                                         client.err = errors.New("test error")
 
                                         So(errors.Unwrap(tc.fn()), ShouldEqual, client.err)
                                 })
 
@@ skipping 52 matching lines @@
                 }
 
                 Convey(`Tail with no log entries returns ErrDoesNotExist.`, func() {
                         client.load(&gen)
 
                         _, err := st.Tail("", "")
                         So(err, ShouldEqual, storage.ErrDoesNotExist)
                 })
         })
 }