Clear LUCI_CONTEXT when running auth test.

common/auth/internal/luci_ctx_test.go

 // Copyright 2017 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 18 matching lines @@
         "github.com/luci/luci-go/common/retry/transient"
         "github.com/luci/luci-go/lucictx"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestLUCIContextProvider(t *testing.T) {
         t.Parallel()
 
+        // Clear any existing LUCI_CONTEXT["local_auth"], it may be present if the
+        // test runs on a LUCI bot.
+        baseCtx, err := lucictx.Set(context.Background(), "local_auth", nil)
+        if err != nil {
+                t.Fatal(err) // this should never happen
+        }
+
         Convey("Requires local_auth", t, func() {
-                _, err := NewLUCIContextTokenProvider(context.Background(), []string{"A"}, http.DefaultTransport)
+                _, err := NewLUCIContextTokenProvider(baseCtx, []string{"A"}, http.DefaultTransport)
                 So(err, ShouldErrLike, `no "local_auth" in LUCI_CONTEXT`)
         })
 
         Convey("Requires default_account_id", t, func() {
-                ctx := context.Background()
-                ctx = lucictx.SetLocalAuth(ctx, &lucictx.LocalAuth{
+                ctx := lucictx.SetLocalAuth(baseCtx, &lucictx.LocalAuth{
                         Accounts: []lucictx.LocalAuthAccount{{ID: "zzz"}},
                 })
                 _, err := NewLUCIContextTokenProvider(ctx, []string{"A"}, http.DefaultTransport)
                 So(err, ShouldErrLike, `no "default_account_id"`)
         })
 
         Convey("With mock server", t, func(c C) {
                 requests := make(chan rpcs.GetOAuthTokenRequest, 10000)
                 responses := make(chan interface{}, 1)
                 ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ skipping 18 matching lines @@
                                 w.WriteHeader(200)
                                 c.So(json.NewEncoder(w).Encode(resp), ShouldBeNil)
                         case int:
                                 http.Error(w, http.StatusText(resp), resp)
                         default:
                                 panic("unexpected response type")
                         }
                 }))
                 defer ts.Close()
 
-                ctx := context.Background()
-                ctx = lucictx.SetLocalAuth(ctx, &lucictx.LocalAuth{
+                ctx := lucictx.SetLocalAuth(baseCtx, &lucictx.LocalAuth{
                         RPCPort:          uint32(ts.Listener.Addr().(*net.TCPAddr).Port),
                         Secret:           []byte("zekret"),
                         DefaultAccountID: "acc_id",
                 })
 
                 p, err := NewLUCIContextTokenProvider(ctx, []string{"B", "A"}, http.DefaultTransport)
                 So(err, ShouldBeNil)
 
                 Convey("Happy path", func() {
                         responses <- rpcs.GetOAuthTokenResponse{
@@ skipping 39 matching lines @@
                                         ErrorMessage: "omg, error",
                                 },
                         }
                         tok, err := p.MintToken(ctx, nil)
                         So(tok, ShouldBeNil)
                         So(err, ShouldErrLike, `local auth - RPC code 123: omg, error`)
                         So(transient.Tag.In(err), ShouldBeFalse)
                 })
         })
 }