try config as functions

Author: rybit

router/options.go

@@ -0,0 +1,40 @@
+package router
+
+import (
+	"github.com/netlify/netlify-commons/tracing"
+	"github.com/rs/cors"
+	"github.com/sirupsen/logrus"
+)
+
+type Option func(r Router)
+
+func OptEnableCORS(r Router) {
+	corsMiddleware := cors.New(cors.Options{
+		AllowedMethods:   []string{"GET", "POST", "PATCH", "PUT", "DELETE"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type"},
+		ExposedHeaders:   []string{"Link", "X-Total-Count"},
+		AllowCredentials: true,
+	})
+	r.Use(corsMiddleware.Handler)
+}
+
+func OptHealthCheck(path string, checker APIHandler) Option {
+	return func(r Router) {
+		r.Use(HealthCheck(path, checker))
+	}
+}
+
+func OptVersionHeader(svcName, version string) Option {
+	return func(r Router) {
+		r.Use(VersionHeader(svcName, version))
+
+	}
+}
+
+func OptTracingMiddleware(log logrus.FieldLogger, svcName string) Option {
+	return func(r Router) {
+		r.Use(tracing.Middleware(log, svcName))
+	}
+}
+
+

router/router.go

@@ -4,8 +4,6 @@ import (
 	"net/http"
 
 	"github.com/go-chi/chi"
-	"github.com/netlify/netlify-commons/tracing"
-	"github.com/rs/cors"
 	"github.com/sebest/xff"
 	"github.com/sirupsen/logrus"
 )
@@ -14,15 +12,6 @@ type chiWrapper struct {
 	chi chi.Router
 }
 
-// Options configures specifics of the default router
-type Options struct {
-	EnableCORS      bool
-	Version         string
-	HealthCheckPath string
-	HealthChecker   APIHandler
-	Description     string
-}
-
 // Router wraps the chi router to make it slightly more accessible
 type Router interface {
 	// Use appends one middleware onto the Router stack.
@@ -47,33 +36,15 @@ type Router interface {
 }
 
 //  creates a router with sensible defaults (xff, request id, cors)
-func New(serviceName string, log logrus.FieldLogger, options Options) Router {
+func New(log logrus.FieldLogger, options ...Option) Router {
 	r := &chiWrapper{chi.NewRouter()}
 
 	xffmw, _ := xff.Default()
 	r.Use(xffmw.Handler)
-	// r.Use(middlewareFunc(Recoverer)) TODO
-
-	if options.EnableCORS {
-		corsMiddleware := cors.New(cors.Options{
-			AllowedMethods:   []string{"GET", "POST", "PATCH", "PUT", "DELETE"},
-			AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type"},
-			ExposedHeaders:   []string{"Link", "X-Total-Count"},
-			AllowCredentials: true,
-		})
-		r.Use(corsMiddleware.Handler)
+	for _, opt := range options {
+		opt(r)
 	}
 
-	if options.HealthCheckPath != "" {
-		r.Use(HealthCheck(options.HealthCheckPath, options.HealthChecker))
-	}
-
-	version := "unknown"
-	if options.Version != "" {
-		version = options.Version
-	}
-	r.Use(VersionHeader(serviceName, version))
-	r.Use(tracing.Middleware(log, serviceName))
 	return r
 }
 

router/router_test.go

@@ -17,7 +17,7 @@ func TestCORS(t *testing.T) {
 	req.Header.Set("Access-Control-Request-Method", "GET")
 	req.Header.Set("Access-Control-Request-Headers", "Content-Type")
 	t.Run("enabled", func(t *testing.T) {
-		rsp := do(t, &Options{EnableCORS: true}, "", "/", nil, req)
+		rsp := do(t, []Option{OptEnableCORS}, "", "/", nil, req)
 		assert.Equal(t, http.StatusOK, rsp.Code)
 	})
 	t.Run("disabled", func(t *testing.T) {
@@ -45,17 +45,20 @@ func TestHealthEndpoint(t *testing.T) {
 	require.NoError(t, err)
 
 	scenarios := map[string]struct {
-		opts *Options
+		opts []Option
 		code int
 	}{
-		"disabled": {&Options{HealthCheckPath: ""}, http.StatusNotFound},
-		"default":  {&Options{HealthCheckPath: "/health"}, http.StatusOK},
-		"custom": {&Options{
-			HealthCheckPath: "/health",
-			HealthChecker: func(_ http.ResponseWriter, r *http.Request) *HTTPError {
+		"disabled": {[]Option{OptHealthCheck("", nil)}, http.StatusNotFound},
+		"default":  {[]Option{OptHealthCheck("/health", nil)}, http.StatusOK},
+		"custom": {[]Option{OptHealthCheck(
+			"/health",
+			func(_ http.ResponseWriter, r *http.Request) *HTTPError {
 				return UnauthorizedError("")
-			}}, http.StatusUnauthorized},
+			})},
+			http.StatusUnauthorized},
 	}
+
+
 	for name, scene := range scenarios {
 		t.Run(name, func(t *testing.T) {
 			rsp := do(t, scene.opts, "", "/", nil, req)
@@ -79,20 +82,18 @@ func TestVersionHeader(t *testing.T) {
 	for name, scene := range scenes {
 
 		t.Run(name, func(t *testing.T) {
-			opts := &Options{
-				Version: scene.version,
-			}
+			opts := []Option{OptVersionHeader(scene.svc, scene.version)}
 			rsp := do(t, opts, scene.svc, "/", nil, req)
 			assert.Equal(t, scene.expected, rsp.Header().Get(scene.header), t.Name())
 		})
 	}
 }
 
-func do(t *testing.T, opts *Options, svcName, path string, handler APIHandler, req *http.Request) *httptest.ResponseRecorder {
+func do(t *testing.T, opts []Option, svcName, path string, handler APIHandler, req *http.Request) *httptest.ResponseRecorder {
 	if opts == nil {
-		opts = new(Options)
+		opts = []Option{}
 	}
-	r := New(svcName, logrus.WithField("test", t.Name()), *opts)
+	r := New(logrus.WithField("test", t.Name()), opts...)
 
 	if handler == nil {
 		handler = func(w http.ResponseWriter, r *http.Request) *HTTPError {