Make HTTP middleware easier to use

server/auth/openid/method_test.go

 // Copyright 2015 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 openid
 
 import (
         "fmt"
         "net/http"
         "net/http/httptest"
         "net/url"
         "testing"
         "time"
 
         "github.com/luci/luci-go/common/clock/testclock"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authtest"
+        "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/secrets/testsecrets"
         "github.com/luci/luci-go/server/settings"
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestFullFlow(t *testing.T) {
         Convey("with test context", t, func(c C) {
@@ skipping 57 matching lines @@
 
                         // Generate login URL.
                         loginURL, err := method.LoginURL(ctx, "/destination")
                         So(err, ShouldBeNil)
                         So(loginURL, ShouldEqual, "/auth/openid/login?r=%2Fdestination")
 
                         // "Visit" login URL.
                         req, err := http.NewRequest("GET", "http://fake"+loginURL, nil)
                         So(err, ShouldBeNil)
                         rec := httptest.NewRecorder()
-                        method.loginHandler(ctx, rec, req, nil)
+                        method.loginHandler(&router.Context{Context: ctx, Writer: rec, Request: req, Params: nil})
 
                         // It asks us to visit authorizarion endpoint.
                         So(rec.Code, ShouldEqual, http.StatusFound)
                         parsed, err := url.Parse(rec.Header().Get("Location"))
                         So(err, ShouldBeNil)
                         So(parsed.Host, ShouldEqual, ts.URL[len("http://"):])
                         So(parsed.Path, ShouldEqual, "/authorization")
                         So(parsed.Query(), ShouldResemble, url.Values{
                                 "client_id":     {"client_id"},
                                 "redirect_uri":  {"http://fake/redirect"},
                                 "response_type": {"code"},
                                 "scope":         {"openid email profile"},
                                 "prompt":        {"select_account"},
                                 "state": {
                                         "AXsiX2kiOiIxNDQyNTQwMDAwMDAwIiwiZGVzdF91cmwiOiIvZGVzdGluYXRpb24iLC" +
                                                 "Job3N0X3VybCI6ImZha2UifUFtzG6wPbuvHG2mY_Wf6eQ_Eiu7n3_Tf6GmRcse1g" +
                                                 "YE",
                                 },
                         })
 
                         // Pretend we've done it. OpenID redirects user's browser to callback URI.
                         // `callbackHandler` will call /token and /userinfo fake endpoints exposed
                         // by testserver.
                         callbackParams := url.Values{}
                         callbackParams.Set("code", "omg_auth_code")
                         callbackParams.Set("state", parsed.Query().Get("state"))
                         req, err = http.NewRequest("GET", "http://fake/redirect?"+callbackParams.Encode(), nil)
                         So(err, ShouldBeNil)
                         rec = httptest.NewRecorder()
-                        method.callbackHandler(ctx, rec, req, nil)
+                        method.callbackHandler(&router.Context{Context: ctx, Writer: rec, Request: req, Params: nil})
 
                         // We should be redirected to the login page, with session cookie set.
                         expectedCookie := "oid_session=AXsiX2kiOiIxNDQyNTQwMDAwMDAwIiwic2lkIjoi" +
                                 "dXNlcl9pZF9zdWIvMSJ9PmRzaOv-mS0PMHkve897iiELNmpiLi_j3ICG1VKuNCs"
                         So(rec.Code, ShouldEqual, http.StatusFound)
                         So(rec.Header().Get("Location"), ShouldEqual, "/destination")
                         So(rec.Header().Get("Set-Cookie"), ShouldEqual,
                                 expectedCookie+"; Path=/; Expires=Sun, 18 Oct 2015 01:18:20 GMT; Max-Age=2591100; HttpOnly")
 
                         // Use the cookie to authenticate some call.
@@ skipping 10 matching lines @@
                         })
 
                         // Now generate URL to and visit logout page.
                         logoutURL, err := method.LogoutURL(ctx, "/another_destination")
                         So(err, ShouldBeNil)
                         So(logoutURL, ShouldEqual, "/auth/openid/logout?r=%2Fanother_destination")
                         req, err = http.NewRequest("GET", "http://fake"+logoutURL, nil)
                         So(err, ShouldBeNil)
                         req.Header.Add("Cookie", expectedCookie)
                         rec = httptest.NewRecorder()
-                        method.logoutHandler(ctx, rec, req, nil)
+                        method.logoutHandler(&router.Context{Context: ctx, Writer: rec, Request: req, Params: nil})
 
                         // Should be redirected to destination with the cookie killed.
                         So(rec.Code, ShouldEqual, http.StatusFound)
                         So(rec.Header().Get("Location"), ShouldEqual, "/another_destination")
                         So(rec.Header().Get("Set-Cookie"), ShouldEqual,
                                 "oid_session=deleted; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT; Max-Age=0")
                 })
         })
 }
 
 func TestCallbackHandleEdgeCases(t *testing.T) {
         Convey("with test context", t, func(c C) {
                 ctx := context.Background()
                 ctx = settings.Use(ctx, settings.New(&settings.MemoryStorage{}))
                 ctx, _ = testclock.UseTime(ctx, time.Unix(1442540000, 0))
                 ctx = testsecrets.Use(ctx)
 
                 method := AuthMethod{SessionStore: &authtest.MemorySessionStore{}}
 
                 call := func(query map[string]string) *httptest.ResponseRecorder {
                         q := url.Values{}
                         for k, v := range query {
                                 q.Add(k, v)
                         }
                         req, err := http.NewRequest("GET", "/auth/openid/callback?"+q.Encode(), nil)
                         c.So(err, ShouldBeNil)
                         req.Host = "fake.com"
                         rec := httptest.NewRecorder()
-                        method.callbackHandler(ctx, rec, req, nil)
+                        method.callbackHandler(&router.Context{Context: ctx, Writer: rec, Request: req, Params: nil})
                         return rec
                 }
 
                 Convey("handles 'error'", func() {
                         rec := call(map[string]string{"error": "Omg, error"})
                         So(rec.Code, ShouldEqual, 400)
                         So(rec.Body.String(), ShouldEqual, "OpenID login error: Omg, error\n")
                 })
 
                 Convey("handles no 'code'", func() {
@@ skipping 54 matching lines @@
                 ctx := context.Background()
                 method := AuthMethod{SessionStore: &authtest.MemorySessionStore{}}
 
                 _, err := method.LoginURL(ctx, "http://somesite")
                 So(err, ShouldErrLike, "openid: dest URL in LoginURL or LogoutURL must be relative")
 
                 _, err = method.LogoutURL(ctx, "http://somesite")
                 So(err, ShouldErrLike, "openid: dest URL in LoginURL or LogoutURL must be relative")
         })
 }