Modernise go-cachewrapper.

 * This changes the configuration mechanism in favour of functional
   options.
 * Updates table-tests not fail-fast.
 * Switches to using httptest.ResponseRecorder in favour of a custom
   version.

Author: bigkevmcd

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Kevin
+Copyright (c) 2014-2018 Kevin McDermott
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

README.md

@@ -3,6 +3,8 @@ go-cachewrapper
 
 Trivial wrapper for http.Handler that applies Cache-Control headers in the style of DropWizard.
 
+This uses a range of option functions to configure the cache header pragmas.
+
 Example
 -------
 
@@ -15,7 +17,7 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/bigkevmcd/go-cachewrapper"
+	cw "github.com/bigkevmcd/go-cachewrapper"
 )
 
 func helloWorld(w http.ResponseWriter, r *http.Request) {
@@ -25,7 +27,7 @@ func helloWorld(w http.ResponseWriter, r *http.Request) {
 const cacheTime = time.Minute * 60
 
 func main() {
-	http.Handle("/", cachewrapper.Cached(http.HandlerFunc(helloWorld), cachewrapper.CacheOptions{MaxAge: cacheTime, NoTransform: true}))
+	http.Handle("/", cw.Cached(http.HandlerFunc(helloWorld), cw.MaxAge(cacheTime), cw.NoTransform())
 	log.Fatal(http.ListenAndServe(":8000", nil))
 }
 ```

cache.go

@@ -17,10 +17,14 @@ type CacheControl struct {
 
 // Cached returns an http.Handler that sets appropriate Cache headers on
 // the outgoing response and passes requests to a wrapped http.Handler.
-func Cached(handler http.Handler, o CacheOptions) *CacheControl {
+func Cached(handler http.Handler, opts ...optionFunc) *CacheControl {
+	co := CacheOptions{}
+	for _, o := range opts {
+		o(&co)
+	}
 	return &CacheControl{
 		handler: handler,
-		options: o,
+		options: co,
 	}
 }
 
@@ -31,11 +35,74 @@ func (c *CacheControl) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	c.handler.ServeHTTP(w, r)
 }
 
-// These set the relevant headers in the response per
+// MaxAge configures the maximum-age cache option.
+func MaxAge(d time.Duration) optionFunc {
+	return func(o *CacheOptions) {
+		o.MaxAge = d
+	}
+}
+
+// NoTransform configures the the no-transform pragma.
+func NoTransform() optionFunc {
+	return func(o *CacheOptions) {
+		o.NoTransform = true
+	}
+}
+
+// Immutable configures the max-age pragma to be one year in the future.
+func Immutable() optionFunc {
+	return func(o *CacheOptions) {
+		o.Immutable = true
+	}
+}
+
+// Private configures the private cache option.
+func Private() optionFunc {
+	return func(o *CacheOptions) {
+		o.Private = true
+	}
+}
+
+// NoCache configures the no-cache pragma.
+func NoCache() optionFunc {
+	return func(o *CacheOptions) {
+		o.NoCache = true
+	}
+}
+
+// NoStore configures the no-store pragma.
+func NoStore() optionFunc {
+	return func(o *CacheOptions) {
+		o.NoStore = true
+	}
+}
+
+// MustRevalidate configures the must-revalidate pragma.
+func MustRevalidate() optionFunc {
+	return func(o *CacheOptions) {
+		o.MustRevalidate = true
+	}
+}
+
+// ProxyRevalidate configures the proxy-revalidate pragma.
+func ProxyRevalidate() optionFunc {
+	return func(o *CacheOptions) {
+		o.ProxyRevalidate = true
+	}
+}
+
+// SharedMaxAge configures the s-maxage pragma.
+func SharedMaxAge(d time.Duration) optionFunc {
+	return func(o *CacheOptions) {
+		o.SharedMaxAge = d
+	}
+}
+
+// These set the relevant pragmas in the response per
 // http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
 type CacheOptions struct {
 	Immutable       bool
-	IsPrivate       bool
+	Private         bool
 	NoCache         bool
 	NoStore         bool
 	NoTransform     bool
@@ -51,7 +118,7 @@ func (o CacheOptions) String() string {
 		o.MaxAge = ONE_YEAR_IN_HOURS
 	}
 
-	if o.IsPrivate {
+	if o.Private {
 		elements = append(elements, "private")
 	}
 
@@ -85,3 +152,5 @@ func (o CacheOptions) String() string {
 
 	return strings.Join(elements, ", ")
 }
+
+type optionFunc func(o *CacheOptions)

cache_test.go

@@ -1,50 +1,29 @@
 package cachewrapper
 
 import (
-	"bytes"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 	"time"
 )
 
-type testResponseWriter struct {
-	Body        bytes.Buffer
-	StatusCode  int
-	header      http.Header
-}
-
-func (w *testResponseWriter) Header() http.Header {
-	if nil == w.header {
-		w.header = make(map[string][]string)
-	}
-	return w.header
-}
-
-func (w *testResponseWriter) Write(p []byte) (int, error) {
-	return w.Body.Write(p)
-}
-
-func (w *testResponseWriter) WriteHeader(code int) {
-	w.StatusCode = code
-}
-
 func TestCacheControl(t *testing.T) {
-	w := &testResponseWriter{}
+	w := httptest.NewRecorder()
 	r, _ := http.NewRequest("POST", "http://example.com/foo", nil)
-	cached := Cached(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}), CacheOptions{MaxAge: time.Hour * 24 * 13, NoTransform: true})
+	cached := Cached(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}), MaxAge(time.Hour*24*13), NoTransform())
 	cached.ServeHTTP(w, r)
 
 	if "no-transform, max-age=1123200" != w.Header().Get("Cache-Control") {
-		t.Fatalf("Cache-Control headers were %s, expected 'no-transform, max-age=1123200'", w.Header().Get("Cache-Control"))
+		t.Fatalf("Cache-Control header: got %s, wanted 'no-transform, max-age=1123200'", w.Header().Get("Cache-Control"))
 	}
 }
 
-var cacheOptions = []struct {
+var cacheOptionTests = []struct {
 	o CacheOptions
 	h string
 }{
 	{CacheOptions{Immutable: true, NoTransform: true}, "no-transform, max-age=31536000"},
-	{CacheOptions{IsPrivate: true, NoTransform: true}, "private, no-transform"},
+	{CacheOptions{Private: true, NoTransform: true}, "private, no-transform"},
 	{CacheOptions{MaxAge: time.Hour * 24 * 13, NoTransform: true}, "no-transform, max-age=1123200"},
 	{CacheOptions{NoCache: true, NoTransform: true}, "no-cache, no-transform"},
 	{CacheOptions{NoStore: true, NoTransform: true}, "no-store, no-transform"},
@@ -55,9 +34,33 @@ var cacheOptions = []struct {
 }
 
 func TestCacheOptions(t *testing.T) {
-	for _, v := range cacheOptions {
-		if o := v.o.String(); v.h != o {
-			t.Fatalf("%#v got '%s', expected '%s'", v.o, o, v.h)
+	for _, tt := range cacheOptionTests {
+		if o := tt.o.String(); tt.h != o {
+			t.Errorf("%#v got '%s', wanted '%s'", tt.o, o, tt.h)
+		}
+	}
+}
+
+var cacheOptionFuncTests = []struct {
+	f optionFunc
+	h string
+}{
+	{Immutable(), "max-age=31536000"},
+	{Private(), "private"},
+	{MaxAge(time.Hour * 24 * 13), "max-age=1123200"},
+	{NoCache(), "no-cache"},
+	{NoStore(), "no-store"},
+	{MustRevalidate(), "must-revalidate"},
+	{ProxyRevalidate(), "proxy-revalidate"},
+	{SharedMaxAge(time.Hour * 13), "s-maxage=46800"},
+}
+
+func TestOptionFuncs(t *testing.T) {
+	for _, tt := range cacheOptionFuncTests {
+		co := CacheOptions{}
+		tt.f(&co)
+		if msg := co.String(); tt.h != msg {
+			t.Errorf("got '%s', wanted '%s'", msg, tt.h)
 		}
 	}
 }