Make HTTP middleware easier to use

appengine/cmd/milo/buildbot/pubsub_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 buildbot
 
 import (
         "bytes"
         "compress/zlib"
         "encoding/base64"
         "encoding/json"
         "io"
         "io/ioutil"
         "net/http"
         "net/http/httptest"
         "testing"
         "time"
 
         "github.com/julienschmidt/httprouter"
         "github.com/luci/gae/impl/memory"
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/clock/testclock"
+        "github.com/luci/luci-go/server/router"
         //log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
         "golang.org/x/net/context"
 )
 
 var (
         fakeTime = time.Date(2001, time.February, 3, 4, 5, 6, 7, time.UTC)
 )
@@ skipping 141 matching lines @@
                         }
                         ms := buildbotMaster{
                                 Name:    "fakename",
                                 Project: buildbotProject{Title: "some title"},
                                 Slaves:  slaves,
                         }
                         r := &http.Request{
                                 Body: newCombinedPsBody([]buildbotBuild{b}, &ms),
                         }
                         p := httprouter.Params{}
-                        PubSubHandler(c, h, r, p)
+                        PubSubHandler(&router.Context{
+                                Context: c,
+                                Writer:  h,
+                                Request: r,
+                                Params:  p,
+                        })
                         So(h.Code, ShouldEqual, 200)
                         Convey("And stores correctly", func() {
                                 loadB := &buildbotBuild{
                                         Master:      "Fake Master",
                                         Buildername: "Fake buildername",
                                         Number:      1234,
                                 }
                                 err := ds.Get(loadB)
                                 So(err, ShouldBeNil)
                                 So(loadB.Master, ShouldEqual, "Fake Master")
@@ skipping 11 matching lines @@
                                         ShouldEqual, 2222)
                         })
 
                         Convey("And a new master overwrites", func() {
                                 c, _ = testclock.UseTime(c, fakeTime.Add(time.Duration(1*time.Second)))
                                 ms.Project.Title = "some other title"
                                 h = httptest.NewRecorder()
                                 r := &http.Request{
                                         Body: newCombinedPsBody([]buildbotBuild{b}, &ms)}
                                 p = httprouter.Params{}
-                                PubSubHandler(c, h, r, p)
+                                PubSubHandler(&router.Context{
+                                        Context: c,
+                                        Writer:  h,
+                                        Request: r,
+                                        Params:  p,
+                                })
                                 So(h.Code, ShouldEqual, 200)
                                 m, internal, t, err := getMasterJSON(c, "fakename")
                                 So(err, ShouldBeNil)
                                 So(internal, ShouldEqual, false)
                                 So(m.Project.Title, ShouldEqual, "some other title")
                                 So(t.Unix(), ShouldEqual, 981173107)
                                 So(m.Name, ShouldEqual, "fakename")
                         })
                         Convey("And a new build overwrites", func() {
                                 b.Times = buildbotTimesFinished(123.0, 124.0)
                                 h = httptest.NewRecorder()
                                 r = &http.Request{
                                         Body: newCombinedPsBody([]buildbotBuild{b}, &ms),
                                 }
                                 p = httprouter.Params{}
-                                PubSubHandler(c, h, r, p)
+                                PubSubHandler(&router.Context{
+                                        Context: c,
+                                        Writer:  h,
+                                        Request: r,
+                                        Params:  p,
+                                })
                                 So(h.Code, ShouldEqual, 200)
                                 loadB := &buildbotBuild{
                                         Master:      "Fake Master",
                                         Buildername: "Fake buildername",
                                         Number:      1234,
                                 }
                                 err := ds.Get(loadB)
                                 So(err, ShouldBeNil)
                                 So(*loadB.Times[0], ShouldEqual, 123.0)
                                 So(*loadB.Times[1], ShouldEqual, 124.0)
                                 Convey("And another pending build is rejected", func() {
                                         b.Times = buildbotTimesPending(123.0)
                                         h = httptest.NewRecorder()
                                         r = &http.Request{
                                                 Body: newCombinedPsBody([]buildbotBuild{b}, &ms),
                                         }
                                         p = httprouter.Params{}
-                                        PubSubHandler(c, h, r, p)
+                                        PubSubHandler(&router.Context{
+                                                Context: c,
+                                                Writer:  h,
+                                                Request: r,
+                                                Params:  p,
+                                        })
                                         So(h.Code, ShouldEqual, 200)
                                         loadB := &buildbotBuild{
                                                 Master:      "Fake Master",
                                                 Buildername: "Fake buildername",
                                                 Number:      1234,
                                         }
                                         err := ds.Get(loadB)
                                         So(err, ShouldBeNil)
                                         So(*loadB.Times[0], ShouldEqual, 123.0)
                                         So(*loadB.Times[1], ShouldEqual, 124.0)
                                 })
                         })
                 })
 
                 Convey("Empty pubsub message", func() {
                         h := httptest.NewRecorder()
                         r := &http.Request{Body: ioutil.NopCloser(bytes.NewReader([]byte{}))}
                         p := httprouter.Params{}
-                        PubSubHandler(c, h, r, p)
+                        PubSubHandler(&router.Context{
+                                Context: c,
+                                Writer:  h,
+                                Request: r,
+                                Params:  p,
+                        })
                         So(h.Code, ShouldEqual, 200)
                 })
         })
 }