Make HTTP middleware easier to use

appengine/tumble/tumbletest.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 tumble
 
 import (
         "fmt"
         "net/http"
         "net/http/httptest"
         "os"
         "strings"
         "time"
 
         "github.com/julienschmidt/httprouter"
         "github.com/luci/gae/impl/memory"
         "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/taskqueue"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/clock/testclock"
         "github.com/luci/luci-go/common/cryptorand"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/memlogger"
+        "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/settings"
         "golang.org/x/net/context"
 )
 
 // Testing is a high-level testing object for testing applications that use
 // tumble.
 type Testing struct {
         Service
 }
 
@@ skipping 76 matching lines @@
         for _, tsk := range tsks {
                 logging.Debugf(c, "found task: %v", tsk)
                 if tsk.ETA.After(clk.Now().UTC()) {
                         logging.Infof(c, "skipping task: ETA(%s): %s", tsk.ETA, tsk.Path)
                         continue
                 }
                 toks := strings.Split(tsk.Path, "/")
 
                 // Process the shard until a success or hard failure.
                 retryHTTP(c, func(rec *httptest.ResponseRecorder) {
-                        t.ProcessShardHandler(c, rec, &http.Request{
-                                Header: http.Header{"X-AppEngine-QueueName": []string{baseName}},
-                        }, httprouter.Params{
-                                {Key: "shard_id", Value: toks[4]},
-                                {Key: "timestamp", Value: toks[6]},
+                        t.ProcessShardHandler(&router.Context{
+                                Context: c,
+                                Writer:  rec,
+                                Request: &http.Request{
+                                        Header: http.Header{"X-AppEngine-QueueName": []string{baseName}},
+                                },
+                                Params: httprouter.Params{
+                                        {Key: "shard_id", Value: toks[4]},
+                                        {Key: "timestamp", Value: toks[6]},
+                                },
                         })
                 })
 
                 if err := tq.Delete(tsk, baseName); err != nil {
                         panic(fmt.Errorf("Deleting task failed: %s", err))
                 }
                 ret++
         }
         return ret
 }
 
 // FireAllTasks will force all tumble shards to run in the future.
 func (t *Testing) FireAllTasks(c context.Context) {
         retryHTTP(c, func(rec *httptest.ResponseRecorder) {
                 // Fire all tasks until a success or hard failure.
-                t.FireAllTasksHandler(c, rec, &http.Request{
-                        Header: http.Header{"X-Appengine-Cron": []string{"true"}},
-                }, nil)
+                t.FireAllTasksHandler(&router.Context{
+                        Context: c,
+                        Writer:  rec,
+                        Request: &http.Request{
+                                Header: http.Header{"X-Appengine-Cron": []string{"true"}},
+                        },
+                        Params: nil,

[iannucci, 2016/06/13 19:23:29]

can omit nil-initializers for structs.

+                })
         })
 }
 
 // AdvanceTime advances the test clock enough so that Iterate will be able to
 // pick up tasks in the task queue.
 func (t *Testing) AdvanceTime(c context.Context) {
         clk := clock.Get(c).(testclock.TestClock)
         cfg := t.GetConfig(c)
         toAdd := time.Duration(cfg.TemporalMinDelay) + time.Duration(cfg.TemporalRoundFactor) + time.Second
         logging.Infof(c, "adding %s to %s", toAdd, clk.Now().UTC())
@@ skipping 47 matching lines @@
                                 lmsg := logging.Get(c).(*memlogger.MemLogger).Messages()
                                 panic(fmt.Errorf("HTTP non-transient error: %s: %#v", err, lmsg))
                         }
                         logging.WithError(err).Warningf(c, "Transient error encountered, retrying.")
 
                 default:
                         panic(fmt.Errorf("HTTP error %d (%s): %s", rec.Code, http.StatusText(rec.Code), rec.Body.String()))
                 }
         }
 }