Make HTTP middleware easier to use

appengine/tsmon/handler_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 tsmon
 
 import (
         "fmt"
         "net/http"
         "net/http/httptest"
         "testing"
         "time"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/appengine/gaetesting"
         "github.com/luci/luci-go/common/clock/testclock"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/common/tsmon"
         "github.com/luci/luci-go/common/tsmon/monitor"
+        "github.com/luci/luci-go/server/router"
         "golang.org/x/net/context"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 type fakeInfo struct {
         info.RawInterface
 }
 
 func (i *fakeInfo) InstanceID() string { return "instance" }
@@ skipping 60 matching lines @@
 
 func TestHousekeepingHandler(t *testing.T) {
         Convey("Assigns task numbers to unassigned instances", t, func() {
                 c, _ := buildGAETestContext()
 
                 i, err := getOrCreateInstanceEntity(c)
                 So(err, ShouldBeNil)
                 So(i.TaskNum, ShouldEqual, -1)
 
                 rec := httptest.NewRecorder()
-                housekeepingHandler(c, rec, &http.Request{}, nil)
+                housekeepingHandler(&router.Context{
+                        Context: c,
+                        Writer:  rec,
+                        Request: &http.Request{},
+                })
                 So(rec.Code, ShouldEqual, http.StatusOK)
 
                 i, err = getOrCreateInstanceEntity(c)
                 So(err, ShouldBeNil)
                 So(i.TaskNum, ShouldEqual, 0)
         })
 
         Convey("Doesn't reassign the same task number", t, func() {
                 c, clock := buildGAETestContext()
 
                 otherInstance := instance{
                         ID:          "foobar",
                         TaskNum:     0,
                         LastUpdated: clock.Now(),
                 }
                 So(datastore.Get(c).Put(&otherInstance), ShouldBeNil)
 
                 getOrCreateInstanceEntity(c)
 
                 rec := httptest.NewRecorder()
-                housekeepingHandler(c, rec, &http.Request{}, nil)
+                housekeepingHandler(&router.Context{
+                        Context: c,
+                        Writer:  rec,
+                        Request: &http.Request{},
+                })
                 So(rec.Code, ShouldEqual, http.StatusOK)
 
                 i, err := getOrCreateInstanceEntity(c)
                 So(err, ShouldBeNil)
                 So(i.TaskNum, ShouldEqual, 1)
         })
 
         Convey("Expires old instances", t, func() {
                 c, clock := buildGAETestContext()
                 ds := datastore.Get(c)
 
                 oldInstance := instance{
                         ID:          "foobar",
                         TaskNum:     0,
                         LastUpdated: clock.Now(),
                 }
                 So(ds.Put(&oldInstance), ShouldBeNil)
                 exists, err := ds.Exists(ds.NewKey("Instance", "foobar", 0, nil))
                 So(err, ShouldBeNil)
                 So(exists.All(), ShouldBeTrue)
 
                 clock.Add(instanceExpirationTimeout + time.Second)
 
                 rec := httptest.NewRecorder()
-                housekeepingHandler(c, rec, &http.Request{}, nil)
+                housekeepingHandler(&router.Context{
+                        Context: c,
+                        Writer:  rec,
+                        Request: &http.Request{},
+                })
                 So(rec.Code, ShouldEqual, http.StatusOK)
 
                 exists, err = ds.Exists(ds.NewKey("Instance", "foobar", 0, nil))
                 So(err, ShouldBeNil)
                 So(exists.All(), ShouldBeFalse)
         })
 }