[errors] de-specialize Transient in favor of Tags.

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"
         "testing"
         "time"
 
         "github.com/luci/luci-go/common/clock/testclock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/gs"
         "github.com/luci/luci-go/common/proto/google"
+        "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/logdog/api/endpoints/coordinator/services/v1"
         "github.com/luci/luci-go/logdog/api/logpb"
         "github.com/luci/luci-go/logdog/common/storage"
         "github.com/luci/luci-go/logdog/common/storage/memory"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
 
         "github.com/golang/protobuf/proto"
         "github.com/golang/protobuf/ptypes/empty"
         "golang.org/x/net/context"
@@ skipping 435 matching lines @@
                                         TerminalIndex: 3,
 
                                         StreamUrl: gsURL(project, "logstream.entries"),
                                         IndexUrl:  gsURL(project, "logstream.index"),
                                         DataUrl:   gsURL(project, "data.bin"),
                                 })
                         })
 
                         Convey(`When a transient archival error occurs, will not consume the task.`, func() {
                                 addTestEntry(project, 0, 1, 2, 3, 4)
-                                gsc.newWriterErr = func(*testGSWriter) error { return errors.WrapTransient(errors.New("test error")) }
+                                gsc.newWriterErr = func(*testGSWriter) error { return errors.New("test error", retry.Tag) }
 
                                 So(ar.archiveTaskImpl(c, task), ShouldErrLike, "test error")
                                 So(task.consumed, ShouldBeFalse)
                         })
 
                         Convey(`When a non-transient archival error occurs`, func() {
                                 addTestEntry(project, 0, 1, 2, 3, 4)
                                 archiveErr := errors.New("archive failure error")
                                 gsc.newWriterErr = func(*testGSWriter) error { return archiveErr }
 
@@ skipping 179 matching lines @@
                         addTestEntry(project, 0, 1, 2, 3)
 
                         for _, failName := range []string{"/logstream.entries", "/logstream.index", "/data.bin"} {
                                 for _, testCase := range []struct {
                                         name  string
                                         setup func()
                                 }{
                                         {"writer create failure", func() {
                                                 gsc.newWriterErr = func(w *testGSWriter) error {
                                                         if strings.HasSuffix(string(w.path), failName) {
-                                                                return errors.WrapTransient(errors.New("test error"))
+                                                                return errors.New("test error", retry.Tag)
                                                         }
                                                         return nil
                                                 }
                                         }},
 
                                         {"write failure", func() {
                                                 gsc.newWriterErr = func(w *testGSWriter) error {
                                                         if strings.HasSuffix(string(w.path), failName) {
-                                                                w.writeErr = errors.WrapTransient(errors.New("test error"))
+                                                                w.writeErr = errors.New("test error", retry.Tag)
                                                         }
                                                         return nil
                                                 }
                                         }},
 
                                         {"rename failure", func() {
                                                 gsc.renameErr = func(src, dst gs.Path) error {
                                                         if strings.HasSuffix(string(src), failName) {
-                                                                return errors.WrapTransient(errors.New("test error"))
+                                                                return errors.New("test error", retry.Tag)
                                                         }
                                                         return nil
                                                 }
                                         }},
 
                                         {"close failure", func() {
                                                 gsc.newWriterErr = func(w *testGSWriter) error {
                                                         if strings.HasSuffix(string(w.path), failName) {
-                                                                w.closeErr = errors.WrapTransient(errors.New("test error"))
+                                                                w.closeErr = errors.New("test error", retry.Tag)
                                                         }
                                                         return nil
                                                 }
                                         }},
 
                                         {"delete failure after other failure", func() {
                                                 // Simulate a write failure. This is the error that will actually
                                                 // be returned.
                                                 gsc.newWriterErr = func(w *testGSWriter) error {
                                                         if strings.HasSuffix(string(w.path), failName) {
-                                                                w.writeErr = errors.WrapTransient(errors.New("test error"))
+                                                                w.writeErr = errors.New("test error", retry.Tag)
                                                         }
                                                         return nil
                                                 }
 
                                                 // This will trigger whe NewWriter fails from the above
                                                 // instrumentation.
                                                 gsc.deleteErr = func(p gs.Path) error {
                                                         if strings.HasSuffix(string(p), failName) {
                                                                 return errors.New("other error")
                                                         }
                                                         return nil
                                                 }
                                         }},
                                 } {
                                         Convey(fmt.Sprintf(`Can handle %s for %s, and will not archive.`, testCase.name, failName), func() {
                                                 testCase.setup()
 
                                                 So(ar.archiveTaskImpl(c, task), ShouldErrLike, "test error")
                                                 So(task.consumed, ShouldBeFalse)
                                                 So(archiveRequest, ShouldBeNil)
                                         })
                                 }
                         }
                 })
         })
 }