8ee802d · typeable/oauth2-proxy

git.iko.soy/typeable/oauth2-proxy

Lint for non-comment linter errors

commit8ee802d4e5e99c79e2140201cf85eb2a8238dfd4 authorJoel Speed <Joel.speed@hotmail.co.uk> dateThu 29 Nov 2018, 14:26 (8 years ago) parent990873e

30 files changed+337−334

compare with master

unifiedsplit

Gopkg.toml−4

@@ -3,10 +3,6 @@

33# for detailed Gopkg.toml documentation.

44#

6−[[constraint]]

7− name = "github.com/18F/hmacauth"

8− version = "~1.0.1"

9−

106[[constraint]]

117 name = "github.com/BurntSushi/toml"

128 version = "~0.3.0"

api/api.go+1−1

@@ -32,7 +32,7 @@ func Request(req *http.Request) (*simplejson.Json, error) {

3232 return data, nil

3333}

3434

35−func RequestJson(req *http.Request, v interface{}) error {

35+func RequestJSON(req *http.Request, v interface{}) error {

3636 resp, err := http.DefaultClient.Do(req)

3737 if err != nil {

3838 log.Printf("%s %s %s", req.Method, req.URL, err)

api/api_test.go+4−3

@@ -1,20 +1,21 @@

11package api

33import (

4− "github.com/bitly/go-simplejson"

54 "io/ioutil"

65 "net/http"

76 "net/http/httptest"

87 "strings"

98 "testing"

109

10+ "github.com/bitly/go-simplejson"

11+

1112 "github.com/stretchr/testify/assert"

1213)

1314

14−func testBackend(response_code int, payload string) *httptest.Server {

15+func testBackend(responseCode int, payload string) *httptest.Server {

1516 return httptest.NewServer(http.HandlerFunc(

1617 func(w http.ResponseWriter, r *http.Request) {

17− w.WriteHeader(response_code)

18+ w.WriteHeader(responseCode)

1819 w.Write([]byte(payload))

1920 }))

2021}

cookie/cookies_test.go+3−2

@@ -24,10 +24,11 @@ func TestEncodeAndDecodeAccessToken(t *testing.T) {

2424}

2525

2626func TestEncodeAndDecodeAccessTokenB64(t *testing.T) {

27− const secret_b64 = "A3Xbr6fu6Al0HkgrP1ztjb-mYiwmxgNPP-XbNsz1WBk="

27+ const secretBase64 = "A3Xbr6fu6Al0HkgrP1ztjb-mYiwmxgNPP-XbNsz1WBk="

2828 const token = "my access token"

2929

30− secret, err := base64.URLEncoding.DecodeString(secret_b64)

30+ secret, err := base64.URLEncoding.DecodeString(secretBase64)

31+ assert.Equal(t, nil, err)

3132 c, err := NewCipher([]byte(secret))

3233 assert.Equal(t, nil, err)

3334

cookie/nonce.go+1

@@ -5,6 +5,7 @@ import (

55 "fmt"

66)

8+// Nonce generates a random 16 byte string to be used as a nonce

89func Nonce() (nonce string, err error) {

910 b := make([]byte, 16)

1011 _, err = rand.Read(b)

htpasswd.go+5−5

@@ -28,12 +28,12 @@ func NewHtpasswdFromFile(path string) (*HtpasswdFile, error) {

2828}

2929

3030func NewHtpasswd(file io.Reader) (*HtpasswdFile, error) {

31− csv_reader := csv.NewReader(file)

32− csv_reader.Comma = ':'

33− csv_reader.Comment = '#'

34− csv_reader.TrimLeadingSpace = true

31+ csvReader := csv.NewReader(file)

32+ csvReader.Comma = ':'

33+ csvReader.Comment = '#'

34+ csvReader.TrimLeadingSpace = true

3535

36− records, err := csv_reader.ReadAll()

36+ records, err := csvReader.ReadAll()

3737 if err != nil {

3838 return nil, err

3939 }

htpasswd_test.go+1

@@ -20,6 +20,7 @@ func TestSHA(t *testing.T) {

2020

2121func TestBcrypt(t *testing.T) {

2222 hash1, err := bcrypt.GenerateFromPassword([]byte("password"), 1)

23+ assert.Equal(t, err, nil)

2324 hash2, err := bcrypt.GenerateFromPassword([]byte("top-secret"), 2)

2425 assert.Equal(t, err, nil)

2526

http.go+5−5

@@ -23,12 +23,12 @@ func (s *Server) ListenAndServe() {

2323}

2424

2525func (s *Server) ServeHTTP() {

26− httpAddress := s.Opts.HttpAddress

26+ HTTPAddress := s.Opts.HTTPAddress

2727 scheme := ""

2828

29− i := strings.Index(httpAddress, "://")

29+ i := strings.Index(HTTPAddress, "://")

3030 if i > -1 {

31− scheme = httpAddress[0:i]

31+ scheme = HTTPAddress[0:i]

3232 }

3333

3434 var networkType string

@@ -39,7 +39,7 @@ func (s *Server) ServeHTTP() {

3939 networkType = scheme

4040 }

4141

42− slice := strings.SplitN(httpAddress, "//", 2)

42+ slice := strings.SplitN(HTTPAddress, "//", 2)

4343 listenAddr := slice[len(slice)-1]

4444

4545 listener, err := net.Listen(networkType, listenAddr)

@@ -58,7 +58,7 @@ func (s *Server) ServeHTTP() {

5858}

5959

6060func (s *Server) ServeHTTPS() {

61− addr := s.Opts.HttpsAddress

61+ addr := s.Opts.HTTPSAddress

6262 config := &tls.Config{

6363 MinVersion: tls.VersionTLS12,

6464 MaxVersion: tls.VersionTLS12,

oauthproxy.go+21−16

@@ -14,14 +14,19 @@ import (

1414 "strings"

1515 "time"

1616

17+ "github.com/mbland/hmacauth"

1718 "github.com/pusher/oauth2_proxy/cookie"

1819 "github.com/pusher/oauth2_proxy/providers"

19− "github.com/mbland/hmacauth"

2020)

2121

22−const SignatureHeader = "GAP-Signature"

22+const (

23+ SignatureHeader = "GAP-Signature"

2324

24−var SignatureHeaders []string = []string{

25+ httpScheme = "http"

26+ httpsScheme = "https"

27+)

28+

29+var SignatureHeaders = []string{

2530 "Content-Length",

2631 "Content-Md5",

2732 "Content-Type",

@@ -40,7 +45,7 @@ type OAuthProxy struct {

4045 CSRFCookieName string

4146 CookieDomain string

4247 CookieSecure bool

43− CookieHttpOnly bool

48+ CookieHTTPOnly bool

4449 CookieExpire time.Duration

4550 CookieRefresh time.Duration

4651 Validator func(string) bool

@@ -125,7 +130,7 @@ func NewOAuthProxy(opts *Options, validator func(string) bool) *OAuthProxy {

125130 for _, u := range opts.proxyURLs {

126131 path := u.Path

127132 switch u.Scheme {

128− case "http", "https":

133+ case httpScheme, httpsScheme:

129134 u.Path = ""

130135 log.Printf("mapping path %q => upstream %q", path, u)

131136 proxy := NewReverseProxy(u)

@@ -160,7 +165,7 @@ func NewOAuthProxy(opts *Options, validator func(string) bool) *OAuthProxy {

160165 refresh = fmt.Sprintf("after %s", opts.CookieRefresh)

161166 }

162167

163− log.Printf("Cookie settings: name:%s secure(https):%v httponly:%v expiry:%s domain:%s refresh:%s", opts.CookieName, opts.CookieSecure, opts.CookieHttpOnly, opts.CookieExpire, opts.CookieDomain, refresh)

168+ log.Printf("Cookie settings: name:%s secure(https):%v httponly:%v expiry:%s domain:%s refresh:%s", opts.CookieName, opts.CookieSecure, opts.CookieHTTPOnly, opts.CookieExpire, opts.CookieDomain, refresh)

164169

165170 var cipher *cookie.Cipher

166171 if opts.PassAccessToken || (opts.CookieRefresh != time.Duration(0)) {

@@ -177,7 +182,7 @@ func NewOAuthProxy(opts *Options, validator func(string) bool) *OAuthProxy {

177182 CookieSeed: opts.CookieSecret,

178183 CookieDomain: opts.CookieDomain,

179184 CookieSecure: opts.CookieSecure,

180− CookieHttpOnly: opts.CookieHttpOnly,

185+ CookieHTTPOnly: opts.CookieHTTPOnly,

181186 CookieExpire: opts.CookieExpire,

182187 CookieRefresh: opts.CookieRefresh,

183188 Validator: validator,

@@ -218,9 +223,9 @@ func (p *OAuthProxy) GetRedirectURI(host string) string {

218223 u = *p.redirectURL

219224 if u.Scheme == "" {

220225 if p.CookieSecure {

221− u.Scheme = "https"

226+ u.Scheme = httpsScheme

222227 } else {

223− u.Scheme = "http"

228+ u.Scheme = httpScheme

224229 }

225230 }

226231 u.Host = host

@@ -285,7 +290,7 @@ func (p *OAuthProxy) makeCookie(req *http.Request, name string, value string, ex

285290 Value: value,

286291 Path: "/",

287292 Domain: p.CookieDomain,

288− HttpOnly: p.CookieHttpOnly,

293+ HttpOnly: p.CookieHTTPOnly,

289294 Secure: p.CookieSecure,

290295 Expires: now.Add(expiration),

291296 }

@@ -374,12 +379,12 @@ func (p *OAuthProxy) SignInPage(rw http.ResponseWriter, req *http.Request, code

374379 p.ClearSessionCookie(rw, req)

375380 rw.WriteHeader(code)

376381

377− redirect_url := req.URL.RequestURI()

382+ redirecURL := req.URL.RequestURI()

378383 if req.Header.Get("X-Auth-Request-Redirect") != "" {

379− redirect_url = req.Header.Get("X-Auth-Request-Redirect")

384+ redirecURL = req.Header.Get("X-Auth-Request-Redirect")

380385 }

381− if redirect_url == p.SignInPath {

382− redirect_url = "/"

386+ if redirecURL == p.SignInPath {

387+ redirecURL = "/"

383388 }

384389

385390 t := struct {

@@ -394,7 +399,7 @@ func (p *OAuthProxy) SignInPage(rw http.ResponseWriter, req *http.Request, code

394399 ProviderName: p.provider.Data().ProviderName,

395400 SignInMessage: p.SignInMessage,

396401 CustomLogin: p.displayCustomLoginForm(),

397− Redirect: redirect_url,

402+ Redirect: redirecURL,

398403 Version: VERSION,

399404 ProxyPrefix: p.ProxyPrefix,

400405 Footer: template.HTML(p.Footer),

@@ -653,7 +658,7 @@ func (p *OAuthProxy) Authenticate(rw http.ResponseWriter, req *http.Request) int

653658 }

654659

655660 if saveSession && session != nil {

656− err := p.SaveSession(rw, req, session)

661+ err = p.SaveSession(rw, req, session)

657662 if err != nil {

658663 log.Printf("%s %s", remoteAddr, err)

659664 return http.StatusInternalServerError

oauthproxy_test.go+148−150

@@ -15,8 +15,8 @@ import (

1515 "testing"

1616 "time"

1717

18− "github.com/pusher/oauth2_proxy/providers"

1918 "github.com/mbland/hmacauth"

19+ "github.com/pusher/oauth2_proxy/providers"

2020 "github.com/stretchr/testify/assert"

2121)

2222

@@ -98,28 +98,28 @@ type TestProvider struct {

9898 ValidToken bool

9999}

100100

101−func NewTestProvider(provider_url *url.URL, email_address string) *TestProvider {

101+func NewTestProvider(providerURL *url.URL, emailAddress string) *TestProvider {

102102 return &TestProvider{

103103 ProviderData: &providers.ProviderData{

104104 ProviderName: "Test Provider",

105105 LoginURL: &url.URL{

106106 Scheme: "http",

107− Host: provider_url.Host,

107+ Host: providerURL.Host,

108108 Path: "/oauth/authorize",

109109 },

110110 RedeemURL: &url.URL{

111111 Scheme: "http",

112− Host: provider_url.Host,

112+ Host: providerURL.Host,

113113 Path: "/oauth/token",

114114 },

115115 ProfileURL: &url.URL{

116116 Scheme: "http",

117− Host: provider_url.Host,

117+ Host: providerURL.Host,

118118 Path: "/api/v1/profile",

119119 },

120120 Scope: "profile.email",

121121 },

122− EmailAddress: email_address,

122+ EmailAddress: emailAddress,

123123 }

124124}

125125

@@ -132,11 +132,10 @@ func (tp *TestProvider) ValidateSessionState(session *providers.SessionState) bo

132132}

133133

134134func TestBasicAuthPassword(t *testing.T) {

135− provider_server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

135+ providerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

136136 log.Printf("%#v", r)

137− url := r.URL

138− payload := ""

139− switch url.Path {

137+ var payload string

138+ switch r.URL.Path {

140139 case "/oauth/token":

141140 payload = `{"access_token": "my_auth_token"}`

142141 default:

@@ -149,7 +148,7 @@ func TestBasicAuthPassword(t *testing.T) {

149148 w.Write([]byte(payload))

150149 }))

151150 opts := NewOptions()

152− opts.Upstreams = append(opts.Upstreams, provider_server.URL)

151+ opts.Upstreams = append(opts.Upstreams, providerServer.URL)

153152 // The CookieSecret must be 32 bytes in order to create the AES

154153 // cipher.

155154 opts.CookieSecret = "xyzzyplughxyzzyplughxyzzyplughxp"

@@ -161,13 +160,13 @@ func TestBasicAuthPassword(t *testing.T) {

161160 opts.BasicAuthPassword = "This is a secure password"

162161 opts.Validate()

163162

164− provider_url, _ := url.Parse(provider_server.URL)

165− const email_address = "michael.bland@gsa.gov"

166− const user_name = "michael.bland"

163+ providerURL, _ := url.Parse(providerServer.URL)

164+ const emailAddress = "michael.bland@gsa.gov"

165+ const username = "michael.bland"

167166

168− opts.provider = NewTestProvider(provider_url, email_address)

167+ opts.provider = NewTestProvider(providerURL, emailAddress)

169168 proxy := NewOAuthProxy(opts, func(email string) bool {

170− return email == email_address

169+ return email == emailAddress

171170 })

172171

173172 rw := httptest.NewRecorder()

@@ -182,10 +181,10 @@ func TestBasicAuthPassword(t *testing.T) {

182181

183182 cookieName := proxy.CookieName

184183 var value string

185− key_prefix := cookieName + "="

184+ keyPrefix := cookieName + "="

186185

187186 for _, field := range strings.Split(cookie, "; ") {

188− value = strings.TrimPrefix(field, key_prefix)

187+ value = strings.TrimPrefix(field, keyPrefix)

189188 if value != field {

190189 break

191190 } else {

@@ -206,15 +205,15 @@ func TestBasicAuthPassword(t *testing.T) {

206205 rw = httptest.NewRecorder()

207206 proxy.ServeHTTP(rw, req)

208207

209− expectedHeader := "Basic " + base64.StdEncoding.EncodeToString([]byte(user_name+":"+opts.BasicAuthPassword))

208+ expectedHeader := "Basic " + base64.StdEncoding.EncodeToString([]byte(username+":"+opts.BasicAuthPassword))

210209 assert.Equal(t, expectedHeader, rw.Body.String())

211− provider_server.Close()

210+ providerServer.Close()

212211}

213212

214213type PassAccessTokenTest struct {

215− provider_server *httptest.Server

216− proxy *OAuthProxy

217− opts *Options

214+ providerServer *httptest.Server

215+ proxy *OAuthProxy

216+ opts *Options

218217}

219218

220219type PassAccessTokenTestOptions struct {

@@ -224,12 +223,11 @@ type PassAccessTokenTestOptions struct {

224223func NewPassAccessTokenTest(opts PassAccessTokenTestOptions) *PassAccessTokenTest {

225224 t := &PassAccessTokenTest{}

226225

227− t.provider_server = httptest.NewServer(

226+ t.providerServer = httptest.NewServer(

228227 http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

229228 log.Printf("%#v", r)

230− url := r.URL

231− payload := ""

232− switch url.Path {

229+ var payload string

230+ switch r.URL.Path {

233231 case "/oauth/token":

234232 payload = `{"access_token": "my_auth_token"}`

235233 default:

@@ -243,7 +241,7 @@ func NewPassAccessTokenTest(opts PassAccessTokenTestOptions) *PassAccessTokenTes

243241 }))

244242

245243 t.opts = NewOptions()

246− t.opts.Upstreams = append(t.opts.Upstreams, t.provider_server.URL)

244+ t.opts.Upstreams = append(t.opts.Upstreams, t.providerServer.URL)

247245 // The CookieSecret must be 32 bytes in order to create the AES

248246 // cipher.

249247 t.opts.CookieSecret = "xyzzyplughxyzzyplughxyzzyplughxp"

@@ -253,21 +251,21 @@ func NewPassAccessTokenTest(opts PassAccessTokenTestOptions) *PassAccessTokenTes

253251 t.opts.PassAccessToken = opts.PassAccessToken

254252 t.opts.Validate()

255253

256− provider_url, _ := url.Parse(t.provider_server.URL)

257− const email_address = "michael.bland@gsa.gov"

254+ providerURL, _ := url.Parse(t.providerServer.URL)

255+ const emailAddress = "michael.bland@gsa.gov"

258256

259− t.opts.provider = NewTestProvider(provider_url, email_address)

257+ t.opts.provider = NewTestProvider(providerURL, emailAddress)

260258 t.proxy = NewOAuthProxy(t.opts, func(email string) bool {

261− return email == email_address

259+ return email == emailAddress

262260 })

263261 return t

264262}

265263

266−func (pat_test *PassAccessTokenTest) Close() {

267− pat_test.provider_server.Close()

264+func (patTest *PassAccessTokenTest) Close() {

265+ patTest.providerServer.Close()

268266}

269267

270−func (pat_test *PassAccessTokenTest) getCallbackEndpoint() (http_code int,

268+func (patTest *PassAccessTokenTest) getCallbackEndpoint() (httpCode int,

271269 cookie string) {

272270 rw := httptest.NewRecorder()

273271 req, err := http.NewRequest("GET", "/oauth2/callback?code=callback_code&state=nonce:",

@@ -275,18 +273,18 @@ func (pat_test *PassAccessTokenTest) getCallbackEndpoint() (http_code int,

275273 if err != nil {

276274 return 0, ""

277275 }

278− req.AddCookie(pat_test.proxy.MakeCSRFCookie(req, "nonce", time.Hour, time.Now()))

279− pat_test.proxy.ServeHTTP(rw, req)

276+ req.AddCookie(patTest.proxy.MakeCSRFCookie(req, "nonce", time.Hour, time.Now()))

277+ patTest.proxy.ServeHTTP(rw, req)

280278 return rw.Code, rw.HeaderMap["Set-Cookie"][1]

281279}

282280

283−func (pat_test *PassAccessTokenTest) getRootEndpoint(cookie string) (http_code int, access_token string) {

284− cookieName := pat_test.proxy.CookieName

281+func (patTest *PassAccessTokenTest) getRootEndpoint(cookie string) (httpCode int, accessToken string) {

282+ cookieName := patTest.proxy.CookieName

285283 var value string

286− key_prefix := cookieName + "="

284+ keyPrefix := cookieName + "="

287285

288286 for _, field := range strings.Split(cookie, "; ") {

289− value = strings.TrimPrefix(field, key_prefix)

287+ value = strings.TrimPrefix(field, keyPrefix)

290288 if value != field {

291289 break

292290 } else {

@@ -310,18 +308,18 @@ func (pat_test *PassAccessTokenTest) getRootEndpoint(cookie string) (http_code i

310308 })

311309

312310 rw := httptest.NewRecorder()

313− pat_test.proxy.ServeHTTP(rw, req)

311+ patTest.proxy.ServeHTTP(rw, req)

314312 return rw.Code, rw.Body.String()

315313}

316314

317315func TestForwardAccessTokenUpstream(t *testing.T) {

318− pat_test := NewPassAccessTokenTest(PassAccessTokenTestOptions{

316+ patTest := NewPassAccessTokenTest(PassAccessTokenTestOptions{

319317 PassAccessToken: true,

320318 })

321− defer pat_test.Close()

319+ defer patTest.Close()

322320

323321 // A successful validation will redirect and set the auth cookie.

324− code, cookie := pat_test.getCallbackEndpoint()

322+ code, cookie := patTest.getCallbackEndpoint()

325323 if code != 302 {

326324 t.Fatalf("expected 302; got %d", code)

327325 }

@@ -330,7 +328,7 @@ func TestForwardAccessTokenUpstream(t *testing.T) {

330328 // Now we make a regular request; the access_token from the cookie is

331329 // forwarded as the "X-Forwarded-Access-Token" header. The token is

332330 // read by the test provider server and written in the response body.

333− code, payload := pat_test.getRootEndpoint(cookie)

331+ code, payload := patTest.getRootEndpoint(cookie)

334332 if code != 200 {

335333 t.Fatalf("expected 200; got %d", code)

336334 }

@@ -338,13 +336,13 @@ func TestForwardAccessTokenUpstream(t *testing.T) {

338336}

339337

340338func TestDoNotForwardAccessTokenUpstream(t *testing.T) {

341− pat_test := NewPassAccessTokenTest(PassAccessTokenTestOptions{

339+ patTest := NewPassAccessTokenTest(PassAccessTokenTestOptions{

342340 PassAccessToken: false,

343341 })

344− defer pat_test.Close()

342+ defer patTest.Close()

345343

346344 // A successful validation will redirect and set the auth cookie.

347− code, cookie := pat_test.getCallbackEndpoint()

345+ code, cookie := patTest.getCallbackEndpoint()

348346 if code != 302 {

349347 t.Fatalf("expected 302; got %d", code)

350348 }

@@ -352,7 +350,7 @@ func TestDoNotForwardAccessTokenUpstream(t *testing.T) {

352350

353351 // Now we make a regular request, but the access token header should

354352 // not be present.

355− code, payload := pat_test.getRootEndpoint(cookie)

353+ code, payload := patTest.getRootEndpoint(cookie)

356354 if code != 200 {

357355 t.Fatalf("expected 200; got %d", code)

358356 }

@@ -360,49 +358,49 @@ func TestDoNotForwardAccessTokenUpstream(t *testing.T) {

360358}

361359

362360type SignInPageTest struct {

363− opts *Options

364− proxy *OAuthProxy

365− sign_in_regexp *regexp.Regexp

366− sign_in_provider_regexp *regexp.Regexp

361+ opts *Options

362+ proxy *OAuthProxy

363+ signInRegexp *regexp.Regexp

364+ signInProviderRegexp *regexp.Regexp

367365}

368366

369367const signInRedirectPattern = `<input type="hidden" name="rd" value="(.*)">`

370368const signInSkipProvider = `>Found<`

371369

372370func NewSignInPageTest(skipProvider bool) *SignInPageTest {

373− var sip_test SignInPageTest

371+ var sipTest SignInPageTest

374372

375− sip_test.opts = NewOptions()

376− sip_test.opts.CookieSecret = "foobar"

377− sip_test.opts.ClientID = "bazquux"

378− sip_test.opts.ClientSecret = "xyzzyplugh"

379− sip_test.opts.SkipProviderButton = skipProvider

380− sip_test.opts.Validate()

373+ sipTest.opts = NewOptions()

374+ sipTest.opts.CookieSecret = "foobar"

375+ sipTest.opts.ClientID = "bazquux"

376+ sipTest.opts.ClientSecret = "xyzzyplugh"

377+ sipTest.opts.SkipProviderButton = skipProvider

378+ sipTest.opts.Validate()

381379

382− sip_test.proxy = NewOAuthProxy(sip_test.opts, func(email string) bool {

380+ sipTest.proxy = NewOAuthProxy(sipTest.opts, func(email string) bool {

383381 return true

384382 })

385− sip_test.sign_in_regexp = regexp.MustCompile(signInRedirectPattern)

386− sip_test.sign_in_provider_regexp = regexp.MustCompile(signInSkipProvider)

383+ sipTest.signInRegexp = regexp.MustCompile(signInRedirectPattern)

384+ sipTest.signInProviderRegexp = regexp.MustCompile(signInSkipProvider)

387385

388− return &sip_test

386+ return &sipTest

389387}

390388

391−func (sip_test *SignInPageTest) GetEndpoint(endpoint string) (int, string) {

389+func (sipTest *SignInPageTest) GetEndpoint(endpoint string) (int, string) {

392390 rw := httptest.NewRecorder()

393391 req, _ := http.NewRequest("GET", endpoint, strings.NewReader(""))

394− sip_test.proxy.ServeHTTP(rw, req)

392+ sipTest.proxy.ServeHTTP(rw, req)

395393 return rw.Code, rw.Body.String()

396394}

397395

398396func TestSignInPageIncludesTargetRedirect(t *testing.T) {

399− sip_test := NewSignInPageTest(false)

397+ sipTest := NewSignInPageTest(false)

400398 const endpoint = "/some/random/endpoint"

401399

402− code, body := sip_test.GetEndpoint(endpoint)

400+ code, body := sipTest.GetEndpoint(endpoint)

403401 assert.Equal(t, 403, code)

404402

405− match := sip_test.sign_in_regexp.FindStringSubmatch(body)

403+ match := sipTest.signInRegexp.FindStringSubmatch(body)

406404 if match == nil {

407405 t.Fatal("Did not find pattern in body: " +

408406 signInRedirectPattern + "\nBody:\n" + body)

@@ -414,11 +412,11 @@ func TestSignInPageIncludesTargetRedirect(t *testing.T) {

414412}

415413

416414func TestSignInPageDirectAccessRedirectsToRoot(t *testing.T) {

417− sip_test := NewSignInPageTest(false)

418− code, body := sip_test.GetEndpoint("/oauth2/sign_in")

415+ sipTest := NewSignInPageTest(false)

416+ code, body := sipTest.GetEndpoint("/oauth2/sign_in")

419417 assert.Equal(t, 200, code)

420418

421− match := sip_test.sign_in_regexp.FindStringSubmatch(body)

419+ match := sipTest.signInRegexp.FindStringSubmatch(body)

422420 if match == nil {

423421 t.Fatal("Did not find pattern in body: " +

424422 signInRedirectPattern + "\nBody:\n" + body)

@@ -429,13 +427,13 @@ func TestSignInPageDirectAccessRedirectsToRoot(t *testing.T) {

429427}

430428

431429func TestSignInPageSkipProvider(t *testing.T) {

432− sip_test := NewSignInPageTest(true)

430+ sipTest := NewSignInPageTest(true)

433431 const endpoint = "/some/random/endpoint"

434432

435− code, body := sip_test.GetEndpoint(endpoint)

433+ code, body := sipTest.GetEndpoint(endpoint)

436434 assert.Equal(t, 302, code)

437435

438− match := sip_test.sign_in_provider_regexp.FindStringSubmatch(body)

436+ match := sipTest.signInProviderRegexp.FindStringSubmatch(body)

439437 if match == nil {

440438 t.Fatal("Did not find pattern in body: " +

441439 signInSkipProvider + "\nBody:\n" + body)

@@ -443,13 +441,13 @@ func TestSignInPageSkipProvider(t *testing.T) {

443441}

444442

445443func TestSignInPageSkipProviderDirect(t *testing.T) {

446− sip_test := NewSignInPageTest(true)

444+ sipTest := NewSignInPageTest(true)

447445 const endpoint = "/sign_in"

448446

449− code, body := sip_test.GetEndpoint(endpoint)

447+ code, body := sipTest.GetEndpoint(endpoint)

450448 assert.Equal(t, 302, code)

451449

452− match := sip_test.sign_in_provider_regexp.FindStringSubmatch(body)

450+ match := sipTest.signInProviderRegexp.FindStringSubmatch(body)

453451 if match == nil {

454452 t.Fatal("Did not find pattern in body: " +

455453 signInSkipProvider + "\nBody:\n" + body)

@@ -457,50 +455,50 @@ func TestSignInPageSkipProviderDirect(t *testing.T) {

457455}

458456

459457type ProcessCookieTest struct {

460− opts *Options

461− proxy *OAuthProxy

462− rw *httptest.ResponseRecorder

463− req *http.Request

464− provider TestProvider

465− response_code int

466− validate_user bool

458+ opts *Options

459+ proxy *OAuthProxy

460+ rw *httptest.ResponseRecorder

461+ req *http.Request

462+ provider TestProvider

463+ responseCode int

464+ validateUser bool

467465}

468466

469467type ProcessCookieTestOpts struct {

470− provider_validate_cookie_response bool

468+ providerValidateCookieResponse bool

471469}

472470

473471func NewProcessCookieTest(opts ProcessCookieTestOpts) *ProcessCookieTest {

474− var pc_test ProcessCookieTest

472+ var pcTest ProcessCookieTest

475473

476− pc_test.opts = NewOptions()

477− pc_test.opts.ClientID = "bazquux"

478− pc_test.opts.ClientSecret = "xyzzyplugh"

479− pc_test.opts.CookieSecret = "0123456789abcdefabcd"

474+ pcTest.opts = NewOptions()

475+ pcTest.opts.ClientID = "bazquux"

476+ pcTest.opts.ClientSecret = "xyzzyplugh"

477+ pcTest.opts.CookieSecret = "0123456789abcdefabcd"

480478 // First, set the CookieRefresh option so proxy.AesCipher is created,

481479 // needed to encrypt the access_token.

482− pc_test.opts.CookieRefresh = time.Hour

483− pc_test.opts.Validate()

480+ pcTest.opts.CookieRefresh = time.Hour

481+ pcTest.opts.Validate()

484482

485− pc_test.proxy = NewOAuthProxy(pc_test.opts, func(email string) bool {

486− return pc_test.validate_user

483+ pcTest.proxy = NewOAuthProxy(pcTest.opts, func(email string) bool {

484+ return pcTest.validateUser

487485 })

488− pc_test.proxy.provider = &TestProvider{

489− ValidToken: opts.provider_validate_cookie_response,

486+ pcTest.proxy.provider = &TestProvider{

487+ ValidToken: opts.providerValidateCookieResponse,

490488 }

491489

492490 // Now, zero-out proxy.CookieRefresh for the cases that don't involve

493491 // access_token validation.

494− pc_test.proxy.CookieRefresh = time.Duration(0)

495− pc_test.rw = httptest.NewRecorder()

496− pc_test.req, _ = http.NewRequest("GET", "/", strings.NewReader(""))

497− pc_test.validate_user = true

498− return &pc_test

492+ pcTest.proxy.CookieRefresh = time.Duration(0)

493+ pcTest.rw = httptest.NewRecorder()

494+ pcTest.req, _ = http.NewRequest("GET", "/", strings.NewReader(""))

495+ pcTest.validateUser = true

496+ return &pcTest

499497}

500498

501499func NewProcessCookieTestWithDefaults() *ProcessCookieTest {

502500 return NewProcessCookieTest(ProcessCookieTestOpts{

503− provider_validate_cookie_response: true,

501+ providerValidateCookieResponse: true,

504502 })

505503}

506504

@@ -522,12 +520,12 @@ func (p *ProcessCookieTest) LoadCookiedSession() (*providers.SessionState, time.

522520}

523521

524522func TestLoadCookiedSession(t *testing.T) {

525− pc_test := NewProcessCookieTestWithDefaults()

523+ pcTest := NewProcessCookieTestWithDefaults()

526524

527525 startSession := &providers.SessionState{Email: "michael.bland@gsa.gov", AccessToken: "my_access_token"}

528− pc_test.SaveSession(startSession, time.Now())

526+ pcTest.SaveSession(startSession, time.Now())

529527

530− session, _, err := pc_test.LoadCookiedSession()

528+ session, _, err := pcTest.LoadCookiedSession()

531529 assert.Equal(t, nil, err)

532530 assert.Equal(t, startSession.Email, session.Email)

533531 assert.Equal(t, "michael.bland", session.User)

@@ -535,9 +533,9 @@ func TestLoadCookiedSession(t *testing.T) {

535533}

536534

537535func TestProcessCookieNoCookieError(t *testing.T) {

538− pc_test := NewProcessCookieTestWithDefaults()

536+ pcTest := NewProcessCookieTestWithDefaults()

539537

540− session, _, err := pc_test.LoadCookiedSession()

538+ session, _, err := pcTest.LoadCookiedSession()

541539 assert.Equal(t, "Cookie \"_oauth2_proxy\" not present", err.Error())

542540 if session != nil {

543541 t.Errorf("expected nil session. got %#v", session)

@@ -545,14 +543,14 @@ func TestProcessCookieNoCookieError(t *testing.T) {

545543}

546544

547545func TestProcessCookieRefreshNotSet(t *testing.T) {

548− pc_test := NewProcessCookieTestWithDefaults()

549− pc_test.proxy.CookieExpire = time.Duration(23) * time.Hour

546+ pcTest := NewProcessCookieTestWithDefaults()

547+ pcTest.proxy.CookieExpire = time.Duration(23) * time.Hour

550548 reference := time.Now().Add(time.Duration(-2) * time.Hour)

551549

552550 startSession := &providers.SessionState{Email: "michael.bland@gsa.gov", AccessToken: "my_access_token"}

553− pc_test.SaveSession(startSession, reference)

551+ pcTest.SaveSession(startSession, reference)

554552

555− session, age, err := pc_test.LoadCookiedSession()

553+ session, age, err := pcTest.LoadCookiedSession()

556554 assert.Equal(t, nil, err)

557555 if age < time.Duration(-2)*time.Hour {

558556 t.Errorf("cookie too young %v", age)

@@ -561,13 +559,13 @@ func TestProcessCookieRefreshNotSet(t *testing.T) {

561559}

562560

563561func TestProcessCookieFailIfCookieExpired(t *testing.T) {

564− pc_test := NewProcessCookieTestWithDefaults()

565− pc_test.proxy.CookieExpire = time.Duration(24) * time.Hour

562+ pcTest := NewProcessCookieTestWithDefaults()

563+ pcTest.proxy.CookieExpire = time.Duration(24) * time.Hour

566564 reference := time.Now().Add(time.Duration(25) * time.Hour * -1)

567565 startSession := &providers.SessionState{Email: "michael.bland@gsa.gov", AccessToken: "my_access_token"}

568− pc_test.SaveSession(startSession, reference)

566+ pcTest.SaveSession(startSession, reference)

569567

570− session, _, err := pc_test.LoadCookiedSession()

568+ session, _, err := pcTest.LoadCookiedSession()

571569 assert.NotEqual(t, nil, err)

572570 if session != nil {

573571 t.Errorf("expected nil session %#v", session)

@@ -575,14 +573,14 @@ func TestProcessCookieFailIfCookieExpired(t *testing.T) {

575573}

576574

577575func TestProcessCookieFailIfRefreshSetAndCookieExpired(t *testing.T) {

578− pc_test := NewProcessCookieTestWithDefaults()

579− pc_test.proxy.CookieExpire = time.Duration(24) * time.Hour

576+ pcTest := NewProcessCookieTestWithDefaults()

577+ pcTest.proxy.CookieExpire = time.Duration(24) * time.Hour

580578 reference := time.Now().Add(time.Duration(25) * time.Hour * -1)

581579 startSession := &providers.SessionState{Email: "michael.bland@gsa.gov", AccessToken: "my_access_token"}

582− pc_test.SaveSession(startSession, reference)

580+ pcTest.SaveSession(startSession, reference)

583581

584− pc_test.proxy.CookieRefresh = time.Hour

585− session, _, err := pc_test.LoadCookiedSession()

582+ pcTest.proxy.CookieRefresh = time.Hour

583+ session, _, err := pcTest.LoadCookiedSession()

586584 assert.NotEqual(t, nil, err)

587585 if session != nil {

588586 t.Errorf("expected nil session %#v", session)

@@ -590,10 +588,10 @@ func TestProcessCookieFailIfRefreshSetAndCookieExpired(t *testing.T) {

590588}

591589

592590func NewAuthOnlyEndpointTest() *ProcessCookieTest {

593− pc_test := NewProcessCookieTestWithDefaults()

594− pc_test.req, _ = http.NewRequest("GET",

595− pc_test.opts.ProxyPrefix+"/auth", nil)

596− return pc_test

591+ pcTest := NewProcessCookieTestWithDefaults()

592+ pcTest.req, _ = http.NewRequest("GET",

593+ pcTest.opts.ProxyPrefix+"/auth", nil)

594+ return pcTest

597595}

598596

599597func TestAuthOnlyEndpointAccepted(t *testing.T) {

@@ -636,7 +634,7 @@ func TestAuthOnlyEndpointUnauthorizedOnEmailValidationFailure(t *testing.T) {

636634 startSession := &providers.SessionState{

637635 Email: "michael.bland@gsa.gov", AccessToken: "my_access_token"}

638636 test.SaveSession(startSession, time.Now())

639− test.validate_user = false

637+ test.validateUser = false

640638

641639 test.proxy.ServeHTTP(test.rw, test.req)

642640 assert.Equal(t, http.StatusUnauthorized, test.rw.Code)

@@ -645,33 +643,33 @@ func TestAuthOnlyEndpointUnauthorizedOnEmailValidationFailure(t *testing.T) {

645643}

646644

647645func TestAuthOnlyEndpointSetXAuthRequestHeaders(t *testing.T) {

648− var pc_test ProcessCookieTest

646+ var pcTest ProcessCookieTest

649647

650− pc_test.opts = NewOptions()

651− pc_test.opts.SetXAuthRequest = true

652− pc_test.opts.Validate()

648+ pcTest.opts = NewOptions()

649+ pcTest.opts.SetXAuthRequest = true

650+ pcTest.opts.Validate()

653651

654− pc_test.proxy = NewOAuthProxy(pc_test.opts, func(email string) bool {

655− return pc_test.validate_user

652+ pcTest.proxy = NewOAuthProxy(pcTest.opts, func(email string) bool {

653+ return pcTest.validateUser

656654 })

657− pc_test.proxy.provider = &TestProvider{

655+ pcTest.proxy.provider = &TestProvider{

658656 ValidToken: true,

659657 }

660658

661− pc_test.validate_user = true

659+ pcTest.validateUser = true

662660

663− pc_test.rw = httptest.NewRecorder()

664− pc_test.req, _ = http.NewRequest("GET",

665− pc_test.opts.ProxyPrefix+"/auth", nil)

661+ pcTest.rw = httptest.NewRecorder()

662+ pcTest.req, _ = http.NewRequest("GET",

663+ pcTest.opts.ProxyPrefix+"/auth", nil)

666664

667665 startSession := &providers.SessionState{

668666 User: "oauth_user", Email: "oauth_user@example.com", AccessToken: "oauth_token"}

669− pc_test.SaveSession(startSession, time.Now())

667+ pcTest.SaveSession(startSession, time.Now())

670668

671− pc_test.proxy.ServeHTTP(pc_test.rw, pc_test.req)

672− assert.Equal(t, http.StatusAccepted, pc_test.rw.Code)

673− assert.Equal(t, "oauth_user", pc_test.rw.HeaderMap["X-Auth-Request-User"][0])

674− assert.Equal(t, "oauth_user@example.com", pc_test.rw.HeaderMap["X-Auth-Request-Email"][0])

669+ pcTest.proxy.ServeHTTP(pcTest.rw, pcTest.req)

670+ assert.Equal(t, http.StatusAccepted, pcTest.rw.Code)

671+ assert.Equal(t, "oauth_user", pcTest.rw.HeaderMap["X-Auth-Request-User"][0])

672+ assert.Equal(t, "oauth_user@example.com", pcTest.rw.HeaderMap["X-Auth-Request-Email"][0])

675673}

676674

677675func TestAuthSkippedForPreflightRequests(t *testing.T) {

@@ -689,8 +687,8 @@ func TestAuthSkippedForPreflightRequests(t *testing.T) {

689687 opts.SkipAuthPreflight = true

690688 opts.Validate()

691689

692− upstream_url, _ := url.Parse(upstream.URL)

693− opts.provider = NewTestProvider(upstream_url, "")

690+ upstreamURL, _ := url.Parse(upstream.URL)

691+ opts.provider = NewTestProvider(upstreamURL, "")

694692

695693 proxy := NewOAuthProxy(opts, func(string) bool { return false })

696694 rw := httptest.NewRecorder()

@@ -723,7 +721,7 @@ func (v *SignatureAuthenticator) Authenticate(w http.ResponseWriter, r *http.Req

723721type SignatureTest struct {

724722 opts *Options

725723 upstream *httptest.Server

726− upstream_host string

724+ upstreamHost string

727725 provider *httptest.Server

728726 header http.Header

729727 rw *httptest.ResponseRecorder

@@ -740,20 +738,20 @@ func NewSignatureTest() *SignatureTest {

740738 authenticator := &SignatureAuthenticator{}

741739 upstream := httptest.NewServer(

742740 http.HandlerFunc(authenticator.Authenticate))

743− upstream_url, _ := url.Parse(upstream.URL)

741+ upstreamURL, _ := url.Parse(upstream.URL)

744742 opts.Upstreams = append(opts.Upstreams, upstream.URL)

745743

746744 providerHandler := func(w http.ResponseWriter, r *http.Request) {

747745 w.Write([]byte(`{"access_token": "my_auth_token"}`))

748746 }

749747 provider := httptest.NewServer(http.HandlerFunc(providerHandler))

750− provider_url, _ := url.Parse(provider.URL)

751− opts.provider = NewTestProvider(provider_url, "mbland@acm.org")

748+ providerURL, _ := url.Parse(provider.URL)

749+ opts.provider = NewTestProvider(providerURL, "mbland@acm.org")

752750

753751 return &SignatureTest{

754752 opts,

755753 upstream,

756− upstream_url.Host,

754+ upstreamURL.Host,

757755 provider,

758756 make(http.Header),

759757 httptest.NewRecorder(),

options.go+19−17

@@ -13,16 +13,17 @@ import (

1313 "strings"

1414 "time"

1515

16− "github.com/pusher/oauth2_proxy/providers"

1716 oidc "github.com/coreos/go-oidc"

1817 "github.com/mbland/hmacauth"

18+ "github.com/pusher/oauth2_proxy/providers"

1919)

2020

21−// Configuration Options that can be set by Command Line Flag, or Config File

21+// Options holds Configuration Options that can be set by Command Line Flag,

22+// or Config File

2223type Options struct {

2324 ProxyPrefix string `flag:"proxy-prefix" cfg:"proxy-prefix"`

24− HttpAddress string `flag:"http-address" cfg:"http_address"`

25− HttpsAddress string `flag:"https-address" cfg:"https_address"`

25+ HTTPAddress string `flag:"http-address" cfg:"http_address"`

26+ HTTPSAddress string `flag:"https-address" cfg:"https_address"`

2627 RedirectURL string `flag:"redirect-url" cfg:"redirect_url"`

2728 ClientID string `flag:"client-id" cfg:"client_id" env:"OAUTH2_PROXY_CLIENT_ID"`

2829 ClientSecret string `flag:"client-secret" cfg:"client_secret" env:"OAUTH2_PROXY_CLIENT_SECRET"`

@@ -48,7 +49,7 @@ type Options struct {

4849 CookieExpire time.Duration `flag:"cookie-expire" cfg:"cookie_expire" env:"OAUTH2_PROXY_COOKIE_EXPIRE"`

4950 CookieRefresh time.Duration `flag:"cookie-refresh" cfg:"cookie_refresh" env:"OAUTH2_PROXY_COOKIE_REFRESH"`

5051 CookieSecure bool `flag:"cookie-secure" cfg:"cookie_secure"`

51− CookieHttpOnly bool `flag:"cookie-httponly" cfg:"cookie_httponly"`

52+ CookieHTTPOnly bool `flag:"cookie-httponly" cfg:"cookie_httponly"`

5253

5354 Upstreams []string `flag:"upstream" cfg:"upstreams"`

5455 SkipAuthRegex []string `flag:"skip-auth-regex" cfg:"skip_auth_regex"`

@@ -96,12 +97,12 @@ type SignatureData struct {

9697func NewOptions() *Options {

9798 return &Options{

9899 ProxyPrefix: "/oauth2",

99− HttpAddress: "127.0.0.1:4180",

100− HttpsAddress: ":443",

100+ HTTPAddress: "127.0.0.1:4180",

101+ HTTPSAddress: ":443",

101102 DisplayHtpasswdForm: true,

102103 CookieName: "_oauth2_proxy",

103104 CookieSecure: true,

104− CookieHttpOnly: true,

105+ CookieHTTPOnly: true,

105106 CookieExpire: time.Duration(168) * time.Hour,

106107 CookieRefresh: time.Duration(0),

107108 SetXAuthRequest: false,

@@ -116,11 +117,11 @@ func NewOptions() *Options {

116117 }

117118}

118119

119−func parseURL(to_parse string, urltype string, msgs []string) (*url.URL, []string) {

120− parsed, err := url.Parse(to_parse)

120+func parseURL(toParse string, urltype string, msgs []string) (*url.URL, []string) {

121+ parsed, err := url.Parse(toParse)

121122 if err != nil {

122123 return nil, append(msgs, fmt.Sprintf(

123− "error parsing %s-url=%q %s", urltype, to_parse, err))

124+ "error parsing %s-url=%q %s", urltype, toParse, err))

124125 }

125126 return parsed, msgs

126127}

@@ -190,17 +191,17 @@ func (o *Options) Validate() error {

190191 msgs = parseProviderInfo(o, msgs)

191192

192193 if o.PassAccessToken || (o.CookieRefresh != time.Duration(0)) {

193− valid_cookie_secret_size := false

194+ validCookieSecretSize := false

194195 for _, i := range []int{16, 24, 32} {

195196 if len(secretBytes(o.CookieSecret)) == i {

196− valid_cookie_secret_size = true

197+ validCookieSecretSize = true

197198 }

198199 }

199200 var decoded bool

200201 if string(secretBytes(o.CookieSecret)) != o.CookieSecret {

201202 decoded = true

202203 }

203− if valid_cookie_secret_size == false {

204+ if validCookieSecretSize == false {

204205 var suffix string

205206 if decoded {

206207 suffix = fmt.Sprintf(" note: cookie secret was base64 decoded from %q", o.CookieSecret)

@@ -294,12 +295,13 @@ func parseSignatureKey(o *Options, msgs []string) []string {

294295 }

295296

296297 algorithm, secretKey := components[0], components[1]

297− if hash, err := hmacauth.DigestNameToCryptoHash(algorithm); err != nil {

298+ var hash crypto.Hash

299+ var err error

300+ if hash, err = hmacauth.DigestNameToCryptoHash(algorithm); err != nil {

298301 return append(msgs, "unsupported signature hash algorithm: "+

299302 o.SignatureKey)

300− } else {

301− o.signatureData = &SignatureData{hash, secretKey}

302303 }

304+ o.signatureData = &SignatureData{hash, secretKey}

303305 return msgs

304306}

305307

options_test.go+2−2

@@ -88,9 +88,9 @@ func TestProxyURLs(t *testing.T) {

8888 o.Upstreams = append(o.Upstreams, "http://127.0.0.1:8081")

8989 assert.Equal(t, nil, o.Validate())

9090 expected := []*url.URL{

91− &url.URL{Scheme: "http", Host: "127.0.0.1:8080", Path: "/"},

91+ {Scheme: "http", Host: "127.0.0.1:8080", Path: "/"},

9292 // note the '/' was added

93− &url.URL{Scheme: "http", Host: "127.0.0.1:8081", Path: "/"},

93+ {Scheme: "http", Host: "127.0.0.1:8081", Path: "/"},

9494 }

9595 assert.Equal(t, expected, o.proxyURLs)

9696}

providers/azure.go+5−4

@@ -3,11 +3,12 @@ package providers

33import (

44 "errors"

55 "fmt"

6− "github.com/bitly/go-simplejson"

7− "github.com/pusher/oauth2_proxy/api"

86 "log"

97 "net/http"

108 "net/url"

10+ "github.com/bitly/go-simplejson"

11+ "github.com/pusher/oauth2_proxy/api"

1112)

1213

1314type AzureProvider struct {

@@ -60,9 +61,9 @@ func (p *AzureProvider) Configure(tenant string) {

6061 }

6162}

6263

63−func getAzureHeader(access_token string) http.Header {

64+func getAzureHeader(accessToken string) http.Header {

6465 header := make(http.Header)

65− header.Set("Authorization", fmt.Sprintf("Bearer %s", access_token))

66+ header.Set("Authorization", fmt.Sprintf("Bearer %s", accessToken))

6667 return header

6768}

6869

providers/azure_test.go+1−2

@@ -110,8 +110,7 @@ func testAzureBackend(payload string) *httptest.Server {

110110

111111 return httptest.NewServer(http.HandlerFunc(

112112 func(w http.ResponseWriter, r *http.Request) {

113− url := r.URL

114− if url.Path != path || url.RawQuery != query {

113+ if r.URL.Path != path || r.URL.RawQuery != query {

115114 w.WriteHeader(404)

116115 } else if r.Header.Get("Authorization") != "Bearer imaginary_access_token" {

117116 w.WriteHeader(403)

providers/facebook.go+3−3

@@ -43,11 +43,11 @@ func NewFacebookProvider(p *ProviderData) *FacebookProvider {

4343 return &FacebookProvider{ProviderData: p}

4444}

4545

46−func getFacebookHeader(access_token string) http.Header {

46+func getFacebookHeader(accessToken string) http.Header {

4747 header := make(http.Header)

4848 header.Set("Accept", "application/json")

4949 header.Set("x-li-format", "json")

50− header.Set("Authorization", fmt.Sprintf("Bearer %s", access_token))

50+ header.Set("Authorization", fmt.Sprintf("Bearer %s", accessToken))

5151 return header

5252}

5353

@@ -65,7 +65,7 @@ func (p *FacebookProvider) GetEmailAddress(s *SessionState) (string, error) {

6565 Email string

6666 }

6767 var r result

68− err = api.RequestJson(req, &r)

68+ err = api.RequestJSON(req, &r)

6969 if err != nil {

7070 return "", err

7171 }

providers/github.go+2−2

@@ -106,7 +106,7 @@ func (p *GitHubProvider) hasOrg(accessToken string) (bool, error) {

106106 }

107107

108108 orgs = append(orgs, op...)

109− pn += 1

109+ pn++

110110 }

111111

112112 var presentOrgs []string

@@ -186,7 +186,7 @@ func (p *GitHubProvider) hasOrgAndTeam(accessToken string) (bool, error) {

186186 log.Printf("Missing Team:%q from Org:%q in teams: %v", p.Team, p.Org, presentTeams)

187187 } else {

188188 var allOrgs []string

189− for org, _ := range presentOrgs {

189+ for org := range presentOrgs {

190190 allOrgs = append(allOrgs, org)

191191 }

192192 log.Printf("Missing Organization:%q in %#v", p.Org, allOrgs)

providers/github_test.go+5−6

@@ -29,19 +29,18 @@ func testGitHubProvider(hostname string) *GitHubProvider {

2929

3030func testGitHubBackend(payload []string) *httptest.Server {

3131 pathToQueryMap := map[string][]string{

32− "/user": []string{""},

33− "/user/emails": []string{""},

34− "/user/orgs": []string{"limit=200&page=1", "limit=200&page=2", "limit=200&page=3"},

32+ "/user": {""},

33+ "/user/emails": {""},

34+ "/user/orgs": {"limit=200&page=1", "limit=200&page=2", "limit=200&page=3"},

3535 }

3636

3737 return httptest.NewServer(http.HandlerFunc(

3838 func(w http.ResponseWriter, r *http.Request) {

39− url := r.URL

40− query, ok := pathToQueryMap[url.Path]

39+ query, ok := pathToQueryMap[r.URL.Path]

4140 validQuery := false

4241 index := 0

4342 for i, q := range query {

44− if q == url.RawQuery {

43+ if q == r.URL.RawQuery {

4544 validQuery = true

4645 index = i

4746 }

providers/gitlab_test.go+7−8

@@ -33,8 +33,7 @@ func testGitLabBackend(payload string) *httptest.Server {

3333

3434 return httptest.NewServer(http.HandlerFunc(

3535 func(w http.ResponseWriter, r *http.Request) {

36− url := r.URL

37− if url.Path != path || url.RawQuery != query {

36+ if r.URL.Path != path || r.URL.RawQuery != query {

3837 w.WriteHeader(404)

3938 } else {

4039 w.WriteHeader(200)

@@ -87,8 +86,8 @@ func TestGitLabProviderGetEmailAddress(t *testing.T) {

8786 b := testGitLabBackend("{\"email\": \"michael.bland@gsa.gov\"}")

8887 defer b.Close()

8988

90− b_url, _ := url.Parse(b.URL)

91− p := testGitLabProvider(b_url.Host)

89+ bURL, _ := url.Parse(b.URL)

90+ p := testGitLabProvider(bURL.Host)

9291

9392 session := &SessionState{AccessToken: "imaginary_access_token"}

9493 email, err := p.GetEmailAddress(session)

@@ -102,8 +101,8 @@ func TestGitLabProviderGetEmailAddressFailedRequest(t *testing.T) {

102101 b := testGitLabBackend("unused payload")

103102 defer b.Close()

104103

105− b_url, _ := url.Parse(b.URL)

106− p := testGitLabProvider(b_url.Host)

104+ bURL, _ := url.Parse(b.URL)

105+ p := testGitLabProvider(bURL.Host)

107106

108107 // We'll trigger a request failure by using an unexpected access

109108 // token. Alternatively, we could allow the parsing of the payload as

@@ -118,8 +117,8 @@ func TestGitLabProviderGetEmailAddressEmailNotPresentInPayload(t *testing.T) {

118117 b := testGitLabBackend("{\"foo\": \"bar\"}")

119118 defer b.Close()

120119

121− b_url, _ := url.Parse(b.URL)

122− p := testGitLabProvider(b_url.Host)

120+ bURL, _ := url.Parse(b.URL)

121+ p := testGitLabProvider(bURL.Host)

123122

124123 session := &SessionState{AccessToken: "imaginary_access_token"}

125124 email, err := p.GetEmailAddress(session)

providers/google.go+3−3

@@ -62,7 +62,7 @@ func NewGoogleProvider(p *ProviderData) *GoogleProvider {

6262 }

6363}

6464

65−func emailFromIdToken(idToken string) (string, error) {

65+func emailFromIDToken(idToken string) (string, error) {

6666

6767 // id_token is a base64 encode ID token payload

6868 // https://developers.google.com/accounts/docs/OAuth2Login#obtainuserinfo

@@ -129,14 +129,14 @@ func (p *GoogleProvider) Redeem(redirectURL, code string) (s *SessionState, err

129129 AccessToken string `json:"access_token"`

130130 RefreshToken string `json:"refresh_token"`

131131 ExpiresIn int64 `json:"expires_in"`

132− IdToken string `json:"id_token"`

132+ IDToken string `json:"id_token"`

133133 }

134134 err = json.Unmarshal(body, &jsonResponse)

135135 if err != nil {

136136 return

137137 }

138138 var email string

139− email, err = emailFromIdToken(jsonResponse.IdToken)

139+ email, err = emailFromIDToken(jsonResponse.IDToken)

140140 if err != nil {

141141 return

142142 }

providers/google_test.go+5−5

@@ -81,7 +81,7 @@ type redeemResponse struct {

8181 AccessToken string `json:"access_token"`

8282 RefreshToken string `json:"refresh_token"`

8383 ExpiresIn int64 `json:"expires_in"`

84− IdToken string `json:"id_token"`

84+ IDToken string `json:"id_token"`

8585}

8686

8787func TestGoogleProviderGetEmailAddress(t *testing.T) {

@@ -90,7 +90,7 @@ func TestGoogleProviderGetEmailAddress(t *testing.T) {

9090 AccessToken: "a1234",

9191 ExpiresIn: 10,

9292 RefreshToken: "refresh12345",

93− IdToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"email": "michael.bland@gsa.gov", "email_verified":true}`)),

93+ IDToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"email": "michael.bland@gsa.gov", "email_verified":true}`)),

9494 })

9595 assert.Equal(t, nil, err)

9696 var server *httptest.Server

@@ -127,7 +127,7 @@ func TestGoogleProviderGetEmailAddressInvalidEncoding(t *testing.T) {

127127 p := newGoogleProvider()

128128 body, err := json.Marshal(redeemResponse{

129129 AccessToken: "a1234",

130− IdToken: "ignored prefix." + `{"email": "michael.bland@gsa.gov"}`,

130+ IDToken: "ignored prefix." + `{"email": "michael.bland@gsa.gov"}`,

131131 })

132132 assert.Equal(t, nil, err)

133133 var server *httptest.Server

@@ -146,7 +146,7 @@ func TestGoogleProviderGetEmailAddressInvalidJson(t *testing.T) {

146146

147147 body, err := json.Marshal(redeemResponse{

148148 AccessToken: "a1234",

149− IdToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"email": michael.bland@gsa.gov}`)),

149+ IDToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"email": michael.bland@gsa.gov}`)),

150150 })

151151 assert.Equal(t, nil, err)

152152 var server *httptest.Server

@@ -165,7 +165,7 @@ func TestGoogleProviderGetEmailAddressEmailMissing(t *testing.T) {

165165 p := newGoogleProvider()

166166 body, err := json.Marshal(redeemResponse{

167167 AccessToken: "a1234",

168− IdToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"not_email": "missing"}`)),

168+ IDToken: "ignored prefix." + base64.URLEncoding.EncodeToString([]byte(`{"not_email": "missing"}`)),

169169 })

170170 assert.Equal(t, nil, err)

171171 var server *httptest.Server

providers/internal_util.go+3−8

@@ -46,13 +46,13 @@ func stripParam(param, endpoint string) string {

4646}

4747

4848// validateToken returns true if token is valid

49−func validateToken(p Provider, access_token string, header http.Header) bool {

50− if access_token == "" || p.Data().ValidateURL == nil {

49+func validateToken(p Provider, accessToken string, header http.Header) bool {

50+ if accessToken == "" || p.Data().ValidateURL == nil {

5151 return false

5252 }

5353 endpoint := p.Data().ValidateURL.String()

5454 if len(header) == 0 {

55− params := url.Values{"access_token": {access_token}}

55+ params := url.Values{"access_token": {accessToken}}

5656 endpoint = endpoint + "?" + params.Encode()

5757 }

5858 resp, err := api.RequestUnparsedResponse(endpoint, header)

@@ -72,8 +72,3 @@ func validateToken(p Provider, access_token string, header http.Header) bool {

7272 log.Printf("token validation request failed: status %d - %s", resp.StatusCode, body)

7373 return false

7474}

75−

76−func updateURL(url *url.URL, hostname string) {

77− url.Scheme = "http"

78− url.Host = hostname

79−}

providers/internal_util_test.go+47−42

@@ -10,6 +10,11 @@ import (

1010 "github.com/stretchr/testify/assert"

1111)

1212

13+func updateURL(url *url.URL, hostname string) {

14+ url.Scheme = "http"

15+ url.Host = hostname

16+}

17+

1318type ValidateSessionStateTestProvider struct {

1419 *ProviderData

1520}

@@ -25,28 +30,28 @@ func (tp *ValidateSessionStateTestProvider) ValidateSessionState(s *SessionState

2530}

2631

2732type ValidateSessionStateTest struct {

28− backend *httptest.Server

29− response_code int

30− provider *ValidateSessionStateTestProvider

31− header http.Header

33+ backend *httptest.Server

34+ responseCode int

35+ provider *ValidateSessionStateTestProvider

36+ header http.Header

3237}

3338

3439func NewValidateSessionStateTest() *ValidateSessionStateTest {

35− var vt_test ValidateSessionStateTest

40+ var vtTest ValidateSessionStateTest

3641

37− vt_test.backend = httptest.NewServer(

42+ vtTest.backend = httptest.NewServer(

3843 http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

3944 if r.URL.Path != "/oauth/tokeninfo" {

4045 w.WriteHeader(500)

4146 w.Write([]byte("unknown URL"))

4247 }

43− token_param := r.FormValue("access_token")

44− if token_param == "" {

48+ tokenParam := r.FormValue("access_token")

49+ if tokenParam == "" {

4550 missing := false

46− received_headers := r.Header

47− for k, _ := range vt_test.header {

48− received := received_headers.Get(k)

49− expected := vt_test.header.Get(k)

51+ receivedHeaders := r.Header

52+ for k := range vtTest.header {

53+ received := receivedHeaders.Get(k)

54+ expected := vtTest.header.Get(k)

5055 if received == "" || received != expected {

5156 missing = true

5257 }

@@ -56,68 +61,68 @@ func NewValidateSessionStateTest() *ValidateSessionStateTest {

5661 w.Write([]byte("no token param and missing or incorrect headers"))

5762 }

5863 }

59− w.WriteHeader(vt_test.response_code)

64+ w.WriteHeader(vtTest.responseCode)

6065 w.Write([]byte("only code matters; contents disregarded"))

6166

6267 }))

63− backend_url, _ := url.Parse(vt_test.backend.URL)

64− vt_test.provider = &ValidateSessionStateTestProvider{

68+ backendURL, _ := url.Parse(vtTest.backend.URL)

69+ vtTest.provider = &ValidateSessionStateTestProvider{

6570 ProviderData: &ProviderData{

6671 ValidateURL: &url.URL{

6772 Scheme: "http",

68− Host: backend_url.Host,

73+ Host: backendURL.Host,

6974 Path: "/oauth/tokeninfo",

7075 },

7176 },

7277 }

73− vt_test.response_code = 200

74− return &vt_test

78+ vtTest.responseCode = 200

79+ return &vtTest

7580}

7681

77−func (vt_test *ValidateSessionStateTest) Close() {

78− vt_test.backend.Close()

82+func (vtTest *ValidateSessionStateTest) Close() {

83+ vtTest.backend.Close()

7984}

8085

8186func TestValidateSessionStateValidToken(t *testing.T) {

82− vt_test := NewValidateSessionStateTest()

83− defer vt_test.Close()

84− assert.Equal(t, true, validateToken(vt_test.provider, "foobar", nil))

87+ vtTest := NewValidateSessionStateTest()

88+ defer vtTest.Close()

89+ assert.Equal(t, true, validateToken(vtTest.provider, "foobar", nil))

8590}

8691

8792func TestValidateSessionStateValidTokenWithHeaders(t *testing.T) {

88− vt_test := NewValidateSessionStateTest()

89− defer vt_test.Close()

90− vt_test.header = make(http.Header)

91− vt_test.header.Set("Authorization", "Bearer foobar")

93+ vtTest := NewValidateSessionStateTest()

94+ defer vtTest.Close()

95+ vtTest.header = make(http.Header)

96+ vtTest.header.Set("Authorization", "Bearer foobar")

9297 assert.Equal(t, true,

93− validateToken(vt_test.provider, "foobar", vt_test.header))

98+ validateToken(vtTest.provider, "foobar", vtTest.header))

9499}

95100

96101func TestValidateSessionStateEmptyToken(t *testing.T) {

97− vt_test := NewValidateSessionStateTest()

98− defer vt_test.Close()

99− assert.Equal(t, false, validateToken(vt_test.provider, "", nil))

102+ vtTest := NewValidateSessionStateTest()

103+ defer vtTest.Close()

104+ assert.Equal(t, false, validateToken(vtTest.provider, "", nil))

100105}

101106

102107func TestValidateSessionStateEmptyValidateURL(t *testing.T) {

103− vt_test := NewValidateSessionStateTest()

104− defer vt_test.Close()

105− vt_test.provider.Data().ValidateURL = nil

106− assert.Equal(t, false, validateToken(vt_test.provider, "foobar", nil))

108+ vtTest := NewValidateSessionStateTest()

109+ defer vtTest.Close()

110+ vtTest.provider.Data().ValidateURL = nil

111+ assert.Equal(t, false, validateToken(vtTest.provider, "foobar", nil))

107112}

108113

109114func TestValidateSessionStateRequestNetworkFailure(t *testing.T) {

110− vt_test := NewValidateSessionStateTest()

115+ vtTest := NewValidateSessionStateTest()

111116 // Close immediately to simulate a network failure

112− vt_test.Close()

113− assert.Equal(t, false, validateToken(vt_test.provider, "foobar", nil))

117+ vtTest.Close()

118+ assert.Equal(t, false, validateToken(vtTest.provider, "foobar", nil))

114119}

115120

116121func TestValidateSessionStateExpiredToken(t *testing.T) {

117− vt_test := NewValidateSessionStateTest()

118− defer vt_test.Close()

119− vt_test.response_code = 401

120− assert.Equal(t, false, validateToken(vt_test.provider, "foobar", nil))

122+ vtTest := NewValidateSessionStateTest()

123+ defer vtTest.Close()

124+ vtTest.responseCode = 401

125+ assert.Equal(t, false, validateToken(vtTest.provider, "foobar", nil))

121126}

122127

123128func TestStripTokenNotPresent(t *testing.T) {

providers/linkedin.go+2−2

@@ -39,11 +39,11 @@ func NewLinkedInProvider(p *ProviderData) *LinkedInProvider {

3939 return &LinkedInProvider{ProviderData: p}

4040}

4141

42−func getLinkedInHeader(access_token string) http.Header {

42+func getLinkedInHeader(accessToken string) http.Header {

4343 header := make(http.Header)

4444 header.Set("Accept", "application/json")

4545 header.Set("x-li-format", "json")

46− header.Set("Authorization", fmt.Sprintf("Bearer %s", access_token))

46+ header.Set("Authorization", fmt.Sprintf("Bearer %s", accessToken))

4747 return header

4848}

4949

providers/linkedin_test.go+7−8

@@ -31,8 +31,7 @@ func testLinkedInBackend(payload string) *httptest.Server {

3131

3232 return httptest.NewServer(http.HandlerFunc(

3333 func(w http.ResponseWriter, r *http.Request) {

34− url := r.URL

35− if url.Path != path {

34+ if r.URL.Path != path {

3635 w.WriteHeader(404)

3736 } else if r.Header.Get("Authorization") != "Bearer imaginary_access_token" {

3837 w.WriteHeader(403)

@@ -95,8 +94,8 @@ func TestLinkedInProviderGetEmailAddress(t *testing.T) {

9594 b := testLinkedInBackend(`"user@linkedin.com"`)

9695 defer b.Close()

9796

98− b_url, _ := url.Parse(b.URL)

99− p := testLinkedInProvider(b_url.Host)

97+ bURL, _ := url.Parse(b.URL)

98+ p := testLinkedInProvider(bURL.Host)

10099

101100 session := &SessionState{AccessToken: "imaginary_access_token"}

102101 email, err := p.GetEmailAddress(session)

@@ -108,8 +107,8 @@ func TestLinkedInProviderGetEmailAddressFailedRequest(t *testing.T) {

108107 b := testLinkedInBackend("unused payload")

109108 defer b.Close()

110109

111− b_url, _ := url.Parse(b.URL)

112− p := testLinkedInProvider(b_url.Host)

110+ bURL, _ := url.Parse(b.URL)

111+ p := testLinkedInProvider(bURL.Host)

113112

114113 // We'll trigger a request failure by using an unexpected access

115114 // token. Alternatively, we could allow the parsing of the payload as

@@ -124,8 +123,8 @@ func TestLinkedInProviderGetEmailAddressEmailNotPresentInPayload(t *testing.T) {

124123 b := testLinkedInBackend("{\"foo\": \"bar\"}")

125124 defer b.Close()

126125

127− b_url, _ := url.Parse(b.URL)

128− p := testLinkedInProvider(b_url.Host)

126+ bURL, _ := url.Parse(b.URL)

127+ p := testLinkedInProvider(bURL.Host)

129128

130129 session := &SessionState{AccessToken: "imaginary_access_token"}

131130 email, err := p.GetEmailAddress(session)

providers/provider_default.go+2−1

@@ -121,7 +121,8 @@ func (p *ProviderData) ValidateSessionState(s *SessionState) bool {

121121 return validateToken(p, s.AccessToken, nil)

122122}

123123

124−// RefreshSessionIfNeeded

124+// RefreshSessionIfNeeded should refresh the user's session if required and

125+// do nothing if a refresh is not required

125126func (p *ProviderData) RefreshSessionIfNeeded(s *SessionState) (bool, error) {

126127 return false, nil

127128}

validator.go+5−5

@@ -42,11 +42,11 @@ func (um *UserMap) LoadAuthenticatedEmailsFile() {

4242 log.Fatalf("failed opening authenticated-emails-file=%q, %s", um.usersFile, err)

4343 }

4444 defer r.Close()

45− csv_reader := csv.NewReader(r)

46− csv_reader.Comma = ','

47− csv_reader.Comment = '#'

48− csv_reader.TrimLeadingSpace = true

49− records, err := csv_reader.ReadAll()

45+ csvReader := csv.NewReader(r)

46+ csvReader.Comma = ','

47+ csvReader.Comment = '#'

48+ csvReader.TrimLeadingSpace = true

49+ records, err := csvReader.ReadAll()

5050 if err != nil {

5151 log.Printf("error reading authenticated-emails-file=%q, %s", um.usersFile, err)

5252 return

validator_test.go+13−13

@@ -8,15 +8,15 @@ import (

88)

1010type ValidatorTest struct {

11− auth_email_file *os.File

12− done chan bool

13− update_seen bool

11+ authEmailFile *os.File

12+ done chan bool

13+ updateSeen bool

1414}

1515

1616func NewValidatorTest(t *testing.T) *ValidatorTest {

1717 vt := &ValidatorTest{}

1818 var err error

19− vt.auth_email_file, err = ioutil.TempFile("", "test_auth_emails_")

19+ vt.authEmailFile, err = ioutil.TempFile("", "test_auth_emails_")

2020 if err != nil {

2121 t.Fatal("failed to create temp file: " + err.Error())

2222 }

@@ -26,27 +26,27 @@ func NewValidatorTest(t *testing.T) *ValidatorTest {

2626

2727func (vt *ValidatorTest) TearDown() {

2828 vt.done <- true

29− os.Remove(vt.auth_email_file.Name())

29+ os.Remove(vt.authEmailFile.Name())

3030}

3131

3232func (vt *ValidatorTest) NewValidator(domains []string,

3333 updated chan<- bool) func(string) bool {

34− return newValidatorImpl(domains, vt.auth_email_file.Name(),

34+ return newValidatorImpl(domains, vt.authEmailFile.Name(),

3535 vt.done, func() {

36− if vt.update_seen == false {

36+ if vt.updateSeen == false {

3737 updated <- true

38− vt.update_seen = true

38+ vt.updateSeen = true

3939 }

4040 })

4141}

4242

43−// This will close vt.auth_email_file.

43+// This will close vt.authEmailFile.

4444func (vt *ValidatorTest) WriteEmails(t *testing.T, emails []string) {

45− defer vt.auth_email_file.Close()

46− vt.auth_email_file.WriteString(strings.Join(emails, "\n"))

47− if err := vt.auth_email_file.Close(); err != nil {

45+ defer vt.authEmailFile.Close()

46+ vt.authEmailFile.WriteString(strings.Join(emails, "\n"))

47+ if err := vt.authEmailFile.Close(); err != nil {

4848 t.Fatal("failed to close temp file " +

49− vt.auth_email_file.Name() + ": " + err.Error())

49+ vt.authEmailFile.Name() + ": " + err.Error())

5050 }

5151}

5252

validator_watcher_copy_test.go+4−4

@@ -12,18 +12,18 @@ import (

1212

1313func (vt *ValidatorTest) UpdateEmailFileViaCopyingOver(

1414 t *testing.T, emails []string) {

15− orig_file := vt.auth_email_file

15+ origFile := vt.authEmailFile

1616 var err error

17− vt.auth_email_file, err = ioutil.TempFile("", "test_auth_emails_")

17+ vt.authEmailFile, err = ioutil.TempFile("", "test_auth_emails_")

1818 if err != nil {

1919 t.Fatal("failed to create temp file for copy: " + err.Error())

2020 }

2121 vt.WriteEmails(t, emails)

22− err = os.Rename(vt.auth_email_file.Name(), orig_file.Name())

22+ err = os.Rename(vt.authEmailFile.Name(), origFile.Name())

2323 if err != nil {

2424 t.Fatal("failed to copy over temp file: " + err.Error())

2525 }

26− vt.auth_email_file = orig_file

26+ vt.authEmailFile = origFile

2727}

2828

2929func TestValidatorOverwriteEmailListViaCopyingOver(t *testing.T) {

validator_watcher_test.go+9−9

@@ -10,8 +10,8 @@ import (

1010

1111func (vt *ValidatorTest) UpdateEmailFile(t *testing.T, emails []string) {

1212 var err error

13− vt.auth_email_file, err = os.OpenFile(

14− vt.auth_email_file.Name(), os.O_WRONLY|os.O_CREATE, 0600)

13+ vt.authEmailFile, err = os.OpenFile(

14+ vt.authEmailFile.Name(), os.O_WRONLY|os.O_CREATE, 0600)

1515 if err != nil {

1616 t.Fatal("failed to re-open temp file for updates")

1717 }

@@ -20,24 +20,24 @@ func (vt *ValidatorTest) UpdateEmailFile(t *testing.T, emails []string) {

2020

2121func (vt *ValidatorTest) UpdateEmailFileViaRenameAndReplace(

2222 t *testing.T, emails []string) {

23− orig_file := vt.auth_email_file

23+ origFile := vt.authEmailFile

2424 var err error

25− vt.auth_email_file, err = ioutil.TempFile("", "test_auth_emails_")

25+ vt.authEmailFile, err = ioutil.TempFile("", "test_auth_emails_")

2626 if err != nil {

2727 t.Fatal("failed to create temp file for rename and replace: " +

2828 err.Error())

2929 }

3030 vt.WriteEmails(t, emails)

3131

32− moved_name := orig_file.Name() + "-moved"

33− err = os.Rename(orig_file.Name(), moved_name)

34− err = os.Rename(vt.auth_email_file.Name(), orig_file.Name())

32+ movedName := origFile.Name() + "-moved"

33+ err = os.Rename(origFile.Name(), movedName)

34+ err = os.Rename(vt.authEmailFile.Name(), origFile.Name())

3535 if err != nil {

3636 t.Fatal("failed to rename and replace temp file: " +

3737 err.Error())

3838 }

39− vt.auth_email_file = orig_file

40− os.Remove(moved_name)

39+ vt.authEmailFile = origFile

40+ os.Remove(movedName)

4141}

4242

4343func TestValidatorOverwriteEmailListDirectly(t *testing.T) {

watcher.go+4−4

@@ -13,11 +13,11 @@ import (

1313

1414func WaitForReplacement(filename string, op fsnotify.Op,

1515 watcher *fsnotify.Watcher) {

16− const sleep_interval = 50 * time.Millisecond

16+ const sleepInterval = 50 * time.Millisecond

1717

1818 // Avoid a race when fsnofity.Remove is preceded by fsnotify.Chmod.

1919 if op&fsnotify.Chmod != 0 {

20− time.Sleep(sleep_interval)

20+ time.Sleep(sleepInterval)

2121 }

2222 for {

2323 if _, err := os.Stat(filename); err == nil {

@@ -26,7 +26,7 @@ func WaitForReplacement(filename string, op fsnotify.Op,

2626 return

2727 }

2828 }

29− time.Sleep(sleep_interval)

29+ time.Sleep(sleepInterval)

3030 }

3131}

3232

@@ -56,7 +56,7 @@ func WatchForUpdates(filename string, done <-chan bool, action func()) {

5656 }

5757 log.Printf("reloading after event: %s", event)

5858 action()

59− case err := <-watcher.Errors:

59+ case err = <-watcher.Errors:

6060 log.Printf("error watching %s: %s", filename, err)

6161 }

6262 }