go: Replace Logrus with go-logging.

go/src/infra/libs/auth/auth_test.go

 // Copyright 2014 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 auth
 
 import (
         "io/ioutil"
         "net/http"
         "os"
         "path/filepath"
         "testing"
 
         "infra/libs/auth/internal"
         "infra/libs/logging"
 
         "golang.org/x/net/context"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
+var (
+        log = logging.DefaultLogger
+)
+
 func ExampleDefaultAuthenticatedClient() {
         client, err := DefaultAuthenticatedClient(SilentLogin)
         if err == ErrLoginRequired {
-                logging.Errorf("Run 'auth login' to login")
+                log.Errorf("Run 'auth login' to login")
                 return
         }
         if err != nil {
-                logging.Errorf("Failed to login: %s", err)
+                log.Errorf("Failed to login: %s", err)
                 return
         }
         client.Get("https://some-server.appspot.com")
 }
 
 func mockSecretsDir() string {
         tempDir, err := ioutil.TempDir("", "auth_test")
         So(err, ShouldBeNil)
 
         prev := secretsDir
@@ skipping 10 matching lines @@
 func mockTokenProvider(factory func() internal.TokenProvider) {
         prev := makeTokenProvider
         makeTokenProvider = func(*Options) (internal.TokenProvider, error) {
                 return factory(), nil
         }
         Reset(func() {
                 makeTokenProvider = prev
         })
 }
 
-func mockTerminal() {
-        prev := logging.IsTerminal
-        logging.IsTerminal = true
-        Reset(func() {
-                logging.IsTerminal = prev
-        })
-}
-
 func TestAuthenticator(t *testing.T) {
         Convey("Given mocked secrets dir", t, func() {
                 tempDir := mockSecretsDir()
 
                 Convey("Check NewAuthenticator defaults", func() {
                         clientID, clientSecret := DefaultClient()
                         a := NewAuthenticator(Options{}).(*authenticatorImpl)
                         So(a.opts, ShouldResemble, &Options{
                                 Method:                 AutoSelectMethod,
                                 Scopes:                 []string{OAuthScopeEmail},
@@ skipping 29 matching lines @@
                         So(len(left), ShouldEqual, 1)
                         So(left[0].Name(), ShouldEqual, "not-secret.txt")
                 })
         })
 }
 
 func TestAuthenticatedClient(t *testing.T) {
         Convey("Given mocked secrets dir", t, func() {
                 var tokenProvider internal.TokenProvider
 
-                mockTerminal()
                 mockSecretsDir()
                 mockTokenProvider(func() internal.TokenProvider { return tokenProvider })
 
                 Convey("Test login required", func() {
                         tokenProvider = &fakeTokenProvider{interactive: true}
                         c, err := AuthenticatedClient(InteractiveLogin, NewAuthenticator(Options{}))
                         So(err, ShouldBeNil)
                         So(c, ShouldNotEqual, http.DefaultClient)
                 })
 
                 Convey("Test login not required", func() {
                         tokenProvider = &fakeTokenProvider{interactive: true}
                         c, err := AuthenticatedClient(OptionalLogin, NewAuthenticator(Options{}))
                         So(err, ShouldBeNil)
                         So(c, ShouldEqual, http.DefaultClient)
                 })
         })
 }
 
 func TestRefreshToken(t *testing.T) {
         Convey("Given mocked secrets dir", t, func() {
                 var tokenProvider *fakeTokenProvider
 
-                mockTerminal()
                 mockSecretsDir()
                 mockTokenProvider(func() internal.TokenProvider { return tokenProvider })
 
                 Convey("Test non interactive auth", func() {
                         tokenProvider = &fakeTokenProvider{
                                 interactive: false,
                                 tokenToMint: &fakeToken{},
                         }
                         auth, ok := NewAuthenticator(Options{}).(*authenticatorImpl)
                         So(ok, ShouldBeTrue)
@@ skipping 97 matching lines @@
         expired bool
 }
 
 func (t *fakeToken) Equals(another internal.Token) bool {
         casted, ok := another.(*fakeToken)
         return ok && casted == t
 }
 
 func (t *fakeToken) RequestHeaders() map[string]string { return make(map[string]string) }
 func (t *fakeToken) Expired() bool                     { return t.expired }