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

logdog/server/collector/coordinator/cache_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 coordinator
 
 import (
         "fmt"
         "sync"
         "sync/atomic"
         "testing"
         "time"
 
         "github.com/luci/luci-go/common/clock/testclock"
         "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
 
         "golang.org/x/net/context"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 // testCoordinator is an implementation of Coordinator that can be used for
 // testing.
@@ skipping 212 matching lines @@
                                 r2 := <-resultC
 
                                 So(r1.ProtoVersion, ShouldEqual, "remote")
                                 So(r2.ProtoVersion, ShouldEqual, "remote")
                                 So(tcc.calls, ShouldEqual, 2)
                         })
 
                         Convey(`RegisterStream`, func() {
                                 Convey(`A transient registration error will result in a RegisterStream error.`, func() {
                                         tcc.errC = make(chan error, 1)
-                                        tcc.errC <- errors.WrapTransient(errors.New("test error"))
+                                        tcc.errC <- errors.New("test error", retry.Tag)
 
                                         _, err := ssc.RegisterStream(c, &st, nil)
                                         So(err, ShouldNotBeNil)
                                         So(tcc.calls, ShouldEqual, 1)
 
                                         Convey(`A second request will call through, try again, and succeed.`, func() {
                                                 tcc.errC = nil
 
                                                 _, err := ssc.RegisterStream(c, &st, nil)
                                                 So(err, ShouldBeNil)
@@ skipping 21 matching lines @@
 
                         Convey(`TerminateStream`, func() {
                                 tr := TerminateRequest{
                                         Project:       st.Project,
                                         ID:            st.ID,
                                         TerminalIndex: 1337,
                                 }
 
                                 Convey(`The termination endpoint returns a transient error, it will propagate.`, func() {
                                         tcc.errC = make(chan error, 1)
-                                        tcc.errC <- errors.WrapTransient(errors.New("test error"))
+                                        tcc.errC <- errors.New("test error", retry.Tag)
 
                                         err := ssc.TerminateStream(c, &tr)
-                                        So(errors.IsTransient(err), ShouldBeTrue)
+                                        So(retry.Tag.In(err), ShouldBeTrue)
                                         So(tcc.calls, ShouldEqual, 1)
 
                                         Convey(`A second attempt will call through, try again, and succeed.`, func() {
                                                 tcc.errC = nil
 
                                                 err := ssc.TerminateStream(c, &tr)
                                                 So(err, ShouldBeNil)
                                                 So(tcc.calls, ShouldEqual, 2)
                                         })
                                 })
@@ skipping 84 matching lines @@
                         remotes := 0
                         for i := 0; i < count; i++ {
                                 if state[i].ProtoVersion == "remote" {
                                         remotes++
                                 }
                         }
                         So(remotes, ShouldEqual, count)
                 })
         })
 }