addunittests

Author: dza89

Diff for: core/requestFunctionUrl.go

@@ -26,15 +26,15 @@ const (
 	FuContextHeader = "X-GoLambdaProxy-Fu-Context"
 )
 
-// RequestAccessorV2 objects give access to custom API Gateway properties
+// RequestAccessorFu objects give access to custom API Gateway properties
 // in the request.
 type RequestAccessorFu struct {
 	stripBasePath string
 }
 
-// GetAPIGatewayContextV2 extracts the API Gateway context object from a
+// GetFunctionUrlContext extracts the API Gateway context object from a
 // request's custom header.
-// Returns a populated events.APIGatewayProxyRequestContext object from
+// Returns a populated events.LambdaFunctionURLRequestContext object from
 // the request.
 func (r *RequestAccessorFu) GetFunctionUrlContext(req *http.Request) (events.LambdaFunctionURLRequestContext, error) {
 	if req.Header.Get(APIGwContextHeader) == "" {
@@ -74,9 +74,9 @@ func (r *RequestAccessorFu) StripBasePath(basePath string) string {
 	return newBasePath
 }
 
-// ProxyEventToHTTPRequest converts an API Gateway proxy event into a http.Request object.
-// Returns the populated http request with additional two custom headers for the stage variables and API Gateway context.
-// To access these properties use the GetAPIGatewayStageVars and GetAPIGatewayContext method of the RequestAccessor object.
+// ProxyEventToHTTPRequest converts an Function URL proxy event into a http.Request object.
+// Returns the populated http request with additional two custom headers for the stage variables and Function Url context.
+// To access these properties use GetFunctionUrlContext method of the RequestAccessor object.
 func (r *RequestAccessorFu) ProxyEventToHTTPRequest(req events.LambdaFunctionURLRequest) (*http.Request, error) {
 	httpRequest, err := r.EventToRequest(req)
 	if err != nil {
@@ -86,9 +86,9 @@ func (r *RequestAccessorFu) ProxyEventToHTTPRequest(req events.LambdaFunctionURL
 	return addToHeaderFu(httpRequest, req)
 }
 
-// EventToRequestWithContext converts an API Gateway proxy event and context into an http.Request object.
+// EventToRequestWithContext converts an Function URL proxy event and context into an http.Request object.
 // Returns the populated http request with lambda context, stage variables and APIGatewayProxyRequestContext as part of its context.
-// Access those using GetAPIGatewayContextFromContext, GetStageVarsFromContext and GetRuntimeContextFromContext functions in this package.
+// Access those using GetFunctionUrlContextFromContext and GetRuntimeContextFromContext functions in this package.
 func (r *RequestAccessorFu) EventToRequestWithContext(ctx context.Context, req events.LambdaFunctionURLRequest) (*http.Request, error) {
 	httpRequest, err := r.EventToRequest(req)
 	if err != nil {
@@ -98,7 +98,7 @@ func (r *RequestAccessorFu) EventToRequestWithContext(ctx context.Context, req e
 	return addToContextFu(ctx, httpRequest, req), nil
 }
 
-// EventToRequest converts an API Gateway proxy event into an http.Request object.
+// EventToRequest converts an Function URL proxy event into an http.Request object.
 // Returns the populated request maintaining headers
 func (r *RequestAccessorFu) EventToRequest(req events.LambdaFunctionURLRequest) (*http.Request, error) {
 	decodedBody := []byte(req.Body)
@@ -111,7 +111,6 @@ func (r *RequestAccessorFu) EventToRequest(req events.LambdaFunctionURLRequest)
 	}
 
 	path := req.RawPath
-
 	// if RawPath empty is, populate from request context
 	if len(path) == 0 {
 		path = req.RequestContext.HTTP.Path
@@ -121,6 +120,7 @@ func (r *RequestAccessorFu) EventToRequest(req events.LambdaFunctionURLRequest)
 		if strings.HasPrefix(path, r.stripBasePath) {
 			path = strings.Replace(path, r.stripBasePath, "", 1)
 		}
+		fmt.Printf("%v", path)
 	}
 	if !strings.HasPrefix(path, "/") {
 		path = "/" + path
@@ -187,13 +187,13 @@ func addToContextFu(ctx context.Context, req *http.Request, functionUrlRequest e
 	return req.WithContext(ctx)
 }
 
-// GetAPIGatewayV2ContextFromContext retrieve APIGatewayProxyRequestContext from context.Context
+// GetFunctionUrlContextFromContext retrieve APIGatewayProxyRequestContext from context.Context
 func GetFunctionUrlContextFromContext(ctx context.Context) (events.LambdaFunctionURLRequestContext, bool) {
 	v, ok := ctx.Value(ctxKey{}).(requestContextFu)
 	return v.functionUrlProxyContext, ok
 }
 
-// GetRuntimeContextFromContextV2 retrieve Lambda Runtime Context from context.Context
+// GetRuntimeContextFromContextFu retrieve Lambda Runtime Context from context.Context
 func GetRuntimeContextFromContextFu(ctx context.Context) (*lambdacontext.LambdaContext, bool) {
 	v, ok := ctx.Value(ctxKey{}).(requestContextFu)
 	return v.lambdaContext, ok

Diff for: core/requestFunctionUrl_test.go

@@ -0,0 +1,133 @@
+package core_test
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/awslabs/aws-lambda-go-api-proxy/core"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("RequestAccessorFu tests", func() {
+	Context("Function URL event conversion", func() {
+		accessor := core.RequestAccessorFu{}
+		qs := make(map[string]string)
+		mvqs := make(map[string][]string)
+		hdr := make(map[string]string)
+		qs["UniqueId"] = "12345"
+		hdr["header1"] = "Testhdr1"
+		hdr["header2"] = "Testhdr2"
+		// Multivalue query strings
+		mvqs["k1"] = []string{"t1"}
+		mvqs["k2"] = []string{"t2"}
+		bdy := "Test BODY"
+		basePathRequest := getFunctionUrlProxyRequest("/hello", getFunctionUrlRequestContext("/hello", "GET"), false, hdr, bdy, qs, mvqs)
+
+		It("Correctly converts a basic event", func() {
+			httpReq, err := accessor.EventToRequestWithContext(context.Background(), basePathRequest)
+			Expect(err).To(BeNil())
+			Expect("/hello").To(Equal(httpReq.URL.Path))
+			Expect("/hello?UniqueId=12345").To(Equal(httpReq.RequestURI))
+			Expect("GET").To(Equal(httpReq.Method))
+			headers := basePathRequest.Headers
+			Expect(2).To(Equal(len(headers)))
+		})
+
+		binaryBody := make([]byte, 256)
+		_, err := rand.Read(binaryBody)
+		if err != nil {
+			Fail("Could not generate random binary body")
+		}
+
+		encodedBody := base64.StdEncoding.EncodeToString(binaryBody)
+
+		binaryRequest := getFunctionUrlProxyRequest("/hello", getFunctionUrlRequestContext("/hello", "POST"), true, hdr, bdy, qs, mvqs)
+		binaryRequest.Body = encodedBody
+		binaryRequest.IsBase64Encoded = true
+
+		It("Decodes a base64 encoded body", func() {
+			httpReq, err := accessor.EventToRequestWithContext(context.Background(), binaryRequest)
+			Expect(err).To(BeNil())
+			Expect("/hello").To(Equal(httpReq.URL.Path))
+			Expect("/hello?UniqueId=12345").To(Equal(httpReq.RequestURI))
+			Expect("POST").To(Equal(httpReq.Method))
+		})
+
+		mqsRequest := getFunctionUrlProxyRequest("/hello", getFunctionUrlRequestContext("/hello", "GET"), false, hdr, bdy, qs, mvqs)
+		mqsRequest.RawQueryString = "hello=1&world=2&world=3"
+		mqsRequest.QueryStringParameters = map[string]string{
+			"hello": "1",
+			"world": "2",
+		}
+
+		It("Populates query string correctly", func() {
+			httpReq, err := accessor.EventToRequestWithContext(context.Background(), mqsRequest)
+			Expect(err).To(BeNil())
+			Expect("/hello").To(Equal(httpReq.URL.Path))
+			fmt.Println("SDYFSDKFJDL")
+			fmt.Printf("%v", httpReq.RequestURI)
+			Expect(httpReq.RequestURI).To(ContainSubstring("hello=1"))
+			Expect(httpReq.RequestURI).To(ContainSubstring("world=2"))
+			Expect("GET").To(Equal(httpReq.Method))
+			query := httpReq.URL.Query()
+			Expect(2).To(Equal(len(query)))
+			Expect(query["hello"]).ToNot(BeNil())
+			Expect(query["world"]).ToNot(BeNil())
+		})
+	})
+
+	Context("StripBasePath tests", func() {
+		accessor := core.RequestAccessorFu{}
+		It("Adds prefix slash", func() {
+			basePath := accessor.StripBasePath("app1")
+			Expect("/app1").To(Equal(basePath))
+		})
+
+		It("Removes trailing slash", func() {
+			basePath := accessor.StripBasePath("/app1/")
+			Expect("/app1").To(Equal(basePath))
+		})
+
+		It("Ignores blank strings", func() {
+			basePath := accessor.StripBasePath("  ")
+			Expect("").To(Equal(basePath))
+		})
+	})
+})
+
+func getFunctionUrlProxyRequest(path string, requestCtx events.LambdaFunctionURLRequestContext,
+	is64 bool, header map[string]string, body string, qs map[string]string, mvqs map[string][]string) events.LambdaFunctionURLRequest {
+	return events.LambdaFunctionURLRequest{
+		RequestContext:  requestCtx,
+		RawPath:         path,
+		RawQueryString:  generateQueryString(qs),
+		Headers:         header,
+		Body:            body,
+		IsBase64Encoded: is64,
+	}
+}
+
+func getFunctionUrlRequestContext(path, method string) events.LambdaFunctionURLRequestContext {
+	return events.LambdaFunctionURLRequestContext{
+		DomainName: "example.com",
+		HTTP: events.LambdaFunctionURLRequestContextHTTPDescription{
+			Method: method,
+			Path:   path,
+		},
+	}
+}
+
+func generateQueryString(queryParameters map[string]string) string {
+	var queryString string
+	for key, value := range queryParameters {
+		if queryString != "" {
+			queryString += "&"
+		}
+		queryString += fmt.Sprintf("%s=%s", key, value)
+	}
+	return queryString
+}

Diff for: core/requestv2_test.go

@@ -3,12 +3,14 @@ package core_test
 import (
 	"context"
 	"encoding/base64"
-	"github.com/onsi/gomega/gstruct"
+	"fmt"
 	"io/ioutil"
 	"math/rand"
 	"os"
 	"strings"
 
+	"github.com/onsi/gomega/gstruct"
+
 	"github.com/aws/aws-lambda-go/events"
 	"github.com/aws/aws-lambda-go/lambdacontext"
 	"github.com/awslabs/aws-lambda-go-api-proxy/core"
@@ -74,6 +76,8 @@ var _ = Describe("RequestAccessorV2 tests", func() {
 		It("Populates multiple value query string correctly", func() {
 			httpReq, err := accessor.EventToRequestWithContext(context.Background(), mqsRequest)
 			Expect(err).To(BeNil())
+			fmt.Println("SDY!@$#!@FSDKFJDL")
+			fmt.Printf("%v", httpReq.RequestURI)
 			Expect("/hello").To(Equal(httpReq.URL.Path))
 			Expect(httpReq.RequestURI).To(ContainSubstring("hello=1"))
 			Expect(httpReq.RequestURI).To(ContainSubstring("world=2"))

Diff for: core/responseFunctionUrl_test.go

@@ -0,0 +1,118 @@
+package core
+
+import (
+	"math/rand"
+	"net/http"
+	"strings"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("FunctionUrlResponseWriter tests", func() {
+	Context("writing to response object", func() {
+		response := NewFunctionUrlResponseWriter()
+
+		It("Sets the correct default status", func() {
+			Expect(defaultStatusCode).To(Equal(response.status))
+		})
+
+		It("Initializes the headers map", func() {
+			Expect(response.headers).ToNot(BeNil())
+			Expect(0).To(Equal(len(response.headers)))
+		})
+
+		It("Writes headers correctly", func() {
+			response.Header().Add("Content-Type", "application/json")
+
+			Expect(1).To(Equal(len(response.headers)))
+			Expect("application/json").To(Equal(response.headers["Content-Type"][0]))
+		})
+
+		It("Writes body content correctly", func() {
+			binaryBody := make([]byte, 256)
+			_, err := rand.Read(binaryBody)
+			Expect(err).To(BeNil())
+
+			written, err := response.Write(binaryBody)
+			Expect(err).To(BeNil())
+			Expect(len(binaryBody)).To(Equal(written))
+		})
+
+		It("Automatically set the status code to 200", func() {
+			Expect(http.StatusOK).To(Equal(response.status))
+		})
+
+		It("Forces the status to a new code", func() {
+			response.WriteHeader(http.StatusAccepted)
+			Expect(http.StatusAccepted).To(Equal(response.status))
+		})
+	})
+
+	Context("Automatically set response content type", func() {
+		xmlBodyContent := "<?xml version=\"1.0\" encoding=\"UTF-8\"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>"
+		htmlBodyContent := " <!DOCTYPE html><html><head><meta charset=\"UTF-8\"><title>Title of the document</title></head><body>Content of the document......</body></html>"
+
+		It("Does not set the content type if it's already set", func() {
+			resp := NewFunctionUrlResponseWriter()
+			resp.Header().Add("Content-Type", "application/json")
+
+			resp.Write([]byte(xmlBodyContent))
+
+			Expect("application/json").To(Equal(resp.Header().Get("Content-Type")))
+			proxyResp, err := resp.GetFunctionUrlResponse()
+			Expect(err).To(BeNil())
+			Expect(1).To(Equal(len(proxyResp.Headers)))
+			Expect("application/json").To(Equal(proxyResp.Headers["Content-Type"]))
+			Expect(xmlBodyContent).To(Equal(proxyResp.Body))
+		})
+
+		It("Sets the content type to text/xml given the body", func() {
+			resp := NewFunctionUrlResponseWriter()
+			resp.Write([]byte(xmlBodyContent))
+
+			Expect("").ToNot(Equal(resp.Header().Get("Content-Type")))
+			Expect(true).To(Equal(strings.HasPrefix(resp.Header().Get("Content-Type"), "text/xml;")))
+			proxyResp, err := resp.GetFunctionUrlResponse()
+			Expect(err).To(BeNil())
+			Expect(1).To(Equal(len(proxyResp.Headers)))
+			Expect(true).To(Equal(strings.HasPrefix(proxyResp.Headers["Content-Type"], "text/xml;")))
+			Expect(xmlBodyContent).To(Equal(proxyResp.Body))
+		})
+
+		It("Sets the content type to text/html given the body", func() {
+			resp := NewFunctionUrlResponseWriter()
+			resp.Write([]byte(htmlBodyContent))
+
+			Expect("").ToNot(Equal(resp.Header().Get("Content-Type")))
+			Expect(true).To(Equal(strings.HasPrefix(resp.Header().Get("Content-Type"), "text/html;")))
+			proxyResp, err := resp.GetFunctionUrlResponse()
+			Expect(err).To(BeNil())
+			Expect(1).To(Equal(len(proxyResp.Headers)))
+			Expect(true).To(Equal(strings.HasPrefix(proxyResp.Headers["Content-Type"], "text/html;")))
+			Expect(htmlBodyContent).To(Equal(proxyResp.Body))
+		})
+	})
+
+	Context("Export Lambda Function URL response", func() {
+		emptyResponse := NewFunctionUrlResponseWriter()
+		emptyResponse.Header().Add("Content-Type", "application/json")
+
+		It("Refuses empty responses with default status code", func() {
+			_, err := emptyResponse.GetFunctionUrlResponse()
+			Expect(err).ToNot(BeNil())
+			Expect("Status code not set on response").To(Equal(err.Error()))
+		})
+
+		simpleResponse := NewFunctionUrlResponseWriter()
+		simpleResponse.Write([]byte("https://example.com"))
+		simpleResponse.WriteHeader(http.StatusAccepted)
+
+		It("Writes function URL response correctly", func() {
+			functionUrlResponse, err := simpleResponse.GetFunctionUrlResponse()
+			Expect(err).To(BeNil())
+			Expect(functionUrlResponse).ToNot(BeNil())
+			Expect(http.StatusAccepted).To(Equal(functionUrlResponse.StatusCode))
+		})
+	})
+})