Merge pull request #9 from dave-malone/master

Support for Gorilla Mux, Negroni, and http.HandlerFunc

Author: sapessi

core/types.go

@@ -0,0 +1,19 @@
+package core
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/aws/aws-lambda-go/events"
+)
+
+// Returns a dafault Gateway Timeout (504) response
+func GatewayTimeout() events.APIGatewayProxyResponse {
+	return events.APIGatewayProxyResponse{StatusCode: http.StatusGatewayTimeout}
+}
+
+func NewLoggedError(format string, a ...interface{}) error {
+	err := fmt.Errorf(format, a...)
+	fmt.Println(err.Error())
+	return err
+}

gin/ginlambda.go gin/adapter.gogin/ginlambda.go renamed to gin/adapter.go

@@ -1,10 +1,9 @@
 // Packge ginlambda add Gin support for the aws-severless-go-api library.
 // Uses the core package behind the scenes and exposes the New method to
 // get a new instance and Proxy method to send request to the Gin engine.
-package ginlambda
+package ginadapter
 
 import (
-	"log"
 	"net/http"
 
 	"github.com/aws/aws-lambda-go/events"
@@ -35,25 +34,16 @@ func (g *GinLambda) Proxy(req events.APIGatewayProxyRequest) (events.APIGatewayP
 	ginRequest, err := g.ProxyEventToHTTPRequest(req)
 
 	if err != nil {
-		log.Println("Could not convert proxy event to request")
-		log.Println(err)
-		return gatewayTimeout(), err
+		return core.GatewayTimeout(), core.NewLoggedError("Could not convert proxy event to request: %v", err)
 	}
 
 	respWriter := core.NewProxyResponseWriter()
-
 	g.ginEngine.ServeHTTP(http.ResponseWriter(respWriter), ginRequest)
 
 	proxyResponse, err := respWriter.GetProxyResponse()
 	if err != nil {
-		log.Println("Error while generating proxy response")
-		log.Println(err)
-		return gatewayTimeout(), err
+		return core.GatewayTimeout(), core.NewLoggedError("Error while generating proxy response: %v", err)
 	}
-	return proxyResponse, nil
-}
 
-// Returns a dafault Gateway Timeout (504) response
-func gatewayTimeout() events.APIGatewayProxyResponse {
-	return events.APIGatewayProxyResponse{StatusCode: http.StatusGatewayTimeout}
+	return proxyResponse, nil
 }

gin/gin_suite_test.go

@@ -1,4 +1,4 @@
-package ginlambda_test
+package ginadapter_test
 
 import (
 	"testing"

gin/ginlambda_test.go

@@ -1,4 +1,4 @@
-package ginlambda_test
+package ginadapter_test
 
 import (
 	"log"
@@ -23,14 +23,14 @@ var _ = Describe("GinLambda tests", func() {
 				})
 			})
 
-			lambdaGin := ginlambda.New(r)
+			adapter := ginadapter.New(r)
 
 			req := events.APIGatewayProxyRequest{
 				Path:       "/ping",
 				HTTPMethod: "GET",
 			}
 
-			resp, err := lambdaGin.Proxy(req)
+			resp, err := adapter.Proxy(req)
 
 			Expect(err).To(BeNil())
 			Expect(resp.StatusCode).To(Equal(200))

gorillamux/adapter.go

@@ -0,0 +1,37 @@
+package gorillamux
+
+import (
+	"net/http"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/awslabs/aws-lambda-go-api-proxy/core"
+	"github.com/gorilla/mux"
+)
+
+type GorillaMuxAdapter struct {
+	core.RequestAccessor
+	router *mux.Router
+}
+
+func New(router *mux.Router) *GorillaMuxAdapter {
+	return &GorillaMuxAdapter{
+		router: router,
+	}
+}
+
+func (h *GorillaMuxAdapter) Proxy(event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
+	req, err := h.ProxyEventToHTTPRequest(event)
+	if err != nil {
+		return core.GatewayTimeout(), core.NewLoggedError("Could not convert proxy event to request: %v", err)
+	}
+
+	w := core.NewProxyResponseWriter()
+	h.router.ServeHTTP(http.ResponseWriter(w), req)
+
+	resp, err := w.GetProxyResponse()
+	if err != nil {
+		return core.GatewayTimeout(), core.NewLoggedError("Error while generating proxy response: %v", err)
+	}
+
+	return resp, nil
+}

gorillamux/adapter_test.go

@@ -0,0 +1,60 @@
+package gorillamux_test
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/awslabs/aws-lambda-go-api-proxy/gorillamux"
+	"github.com/gorilla/mux"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("GorillaMuxAdapter tests", func() {
+	Context("Simple ping request", func() {
+		It("Proxies the event correctly", func() {
+			log.Println("Starting test")
+
+			homeHandler := func(w http.ResponseWriter, req *http.Request) {
+				w.Header().Add("unfortunately-required-header", "")
+				fmt.Fprintf(w, "Home Page")
+			}
+
+			productsHandler := func(w http.ResponseWriter, req *http.Request) {
+				w.Header().Add("unfortunately-required-header", "")
+				fmt.Fprintf(w, "Products Page")
+			}
+
+			r := mux.NewRouter()
+			r.HandleFunc("/", homeHandler)
+			r.HandleFunc("/products", productsHandler)
+
+			adapter := gorillamux.New(r)
+
+			homePageReq := events.APIGatewayProxyRequest{
+				Path:       "/",
+				HTTPMethod: "GET",
+			}
+
+			homePageResp, homePageReqErr := adapter.Proxy(homePageReq)
+
+			Expect(homePageReqErr).To(BeNil())
+			Expect(homePageResp.StatusCode).To(Equal(200))
+			Expect(homePageResp.Body).To(Equal("Home Page"))
+
+			productsPageReq := events.APIGatewayProxyRequest{
+				Path:       "/products",
+				HTTPMethod: "GET",
+			}
+
+			productsPageResp, productsPageReqErr := adapter.Proxy(productsPageReq)
+
+			Expect(productsPageReqErr).To(BeNil())
+			Expect(productsPageResp.StatusCode).To(Equal(200))
+			Expect(productsPageResp.Body).To(Equal("Products Page"))
+		})
+	})
+})

gorillamux/gorilla_suite_test.go

@@ -0,0 +1,13 @@
+package gorillamux_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestGorillaMux(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Gorilla Mux Suite")
+}

handlerfunc/adapter.go

@@ -0,0 +1,36 @@
+package handlerfunc
+
+import (
+	"net/http"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/awslabs/aws-lambda-go-api-proxy/core"
+)
+
+type HandlerFuncAdapter struct {
+	core.RequestAccessor
+	handlerFunc http.HandlerFunc
+}
+
+func New(handlerFunc http.HandlerFunc) *HandlerFuncAdapter {
+	return &HandlerFuncAdapter{
+		handlerFunc: handlerFunc,
+	}
+}
+
+func (h *HandlerFuncAdapter) Proxy(event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
+	req, err := h.ProxyEventToHTTPRequest(event)
+	if err != nil {
+		return core.GatewayTimeout(), core.NewLoggedError("Could not convert proxy event to request: %v", err)
+	}
+
+	w := core.NewProxyResponseWriter()
+	h.handlerFunc.ServeHTTP(http.ResponseWriter(w), req)
+
+	resp, err := w.GetProxyResponse()
+	if err != nil {
+		return core.GatewayTimeout(), core.NewLoggedError("Error while generating proxy response: %v", err)
+	}
+
+	return resp, nil
+}

handlerfunc/adapter_test.go

@@ -0,0 +1,38 @@
+package handlerfunc_test
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/awslabs/aws-lambda-go-api-proxy/handlerfunc"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("HandlerFuncAdapter tests", func() {
+	Context("Simple ping request", func() {
+		It("Proxies the event correctly", func() {
+			log.Println("Starting test")
+
+			handler := func(w http.ResponseWriter, req *http.Request) {
+				w.Header().Add("unfortunately-required-header", "")
+				fmt.Fprintf(w, "Go Lambda!!")
+			}
+
+			adapter := handlerfunc.New(handler)
+
+			req := events.APIGatewayProxyRequest{
+				Path:       "/ping",
+				HTTPMethod: "GET",
+			}
+
+			resp, err := adapter.Proxy(req)
+
+			Expect(err).To(BeNil())
+			Expect(resp.StatusCode).To(Equal(200))
+		})
+	})
+})

handlerfunc/handlerfunc_suite_test.go

@@ -0,0 +1,13 @@
+package handlerfunc_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestHandlerFunc(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "HandlerFuncAdapter Suite")
+}