aecontext-handlers

aecontext-handlers are a bunch of AppEngine context handlers that wrap the
standard net/http HandlerFunc, enabling you to easily switch out how the
AppEngine Context is created, depending on what environment (production / test)
the code is running in.

Example usage

Note that this is an AppEngine main application, hence there is no func main() {}.

main.go

package main
import (
    "github.com/gorilla/mux"
    "golang.org/x/net/context"
    "net/http"
    "github.com/tintinnabulate/aecontext-handlers/handlers"
)
// createHTTPRouter : creates our URL router. As an argument it takes in a
// ToHandlerHOF, whose job is to make the conversion to a standard HandlerFunc()
// format. This means we can change how the AppEngine Context gets created, by
// passing in different ToHandlerHOF implementations. In this case, we use the one
// we want for production (see `init()` function)
func createHTTPRouter(f handlers.ToHandlerHOF) *mux.Router {
    appRouter := mux.NewRouter()
    appRouter.HandleFunc("/foo", f(fooHandler)).Methods("GET")
    return appRouter
}
// fooHandler : handle /foo
func fooHandler(ctx context.Context, w http.ResponseWriter, req *http.Request) {
}
func init() {
    // create our URL router, passing in a HOF that converts to a standard HandlerFunc()
    router := createHTTPRouter(handlers.ToHTTPHandler)
    http.Handle("/", router)
}

main_test.go

package main
import (
    "net/http"
    "net/http/httptest"
    "testing"
    c "github.com/smartystreets/goconvey/convey"
    "github.com/tintinnabulate/aecontext-handlers/handlers"
)
// TestFooHandler : does just that
func TestFooHandler(t *testing.T) {
    // Get our testing context and aetest instance
    ctx, inst := handlers.GetTestingContext()
    // Remember to close it at the end of every test!
    defer inst.Close()
    c.Convey("When user visits the foo page", t, func() {
        // create our router, using this testing context
        r := createHTTPRouter(handlers.ToHTTPHandlerConverter(ctx))
        record := httptest.NewRecorder()
        req, err := http.NewRequest("GET", "/foo", nil)
        c.So(err, c.ShouldBeNil)
        c.Convey("The status should equal http.StatusOK", func() {
            // use the router to serve the request, recording the response
            r.ServeHTTP(record, req)
            // Assert that the return code matches what we expect
            c.So(record.Code, c.ShouldEqual, http.StatusOK)
        })
    })
}

Used by

• https://github.com/tintinnabulate/registration-webapp (See register.go and register_test.go)
• https://github.com/tintinnabulate/vmail (See signup.go and signup_test.go)

Inspired by

This idea was taken, almost completely unmodified, from the excellent Compound Theory blog:

https://www.compoundtheory.com/testing-go-http-handlers-in-google-app-engine-with-mux-and-higher-order-functions

All credit goes to that :-)