test: add tests for misc functions and functionurl

Author: its-felix

functionurl_test.go

@@ -0,0 +1,150 @@
+package aws_lambda_go_http_adapter
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/gofiber/fiber/v2"
+	"github.com/its-felix/aws-lambda-go-http-adapter/adapter"
+	"github.com/its-felix/aws-lambda-go-http-adapter/handler"
+	"github.com/labstack/echo/v4"
+	"io"
+	"net/http"
+	"reflect"
+	"testing"
+)
+
+func newFunctionURLRequest() events.LambdaFunctionURLRequest {
+	return events.LambdaFunctionURLRequest{
+		Version:               "2.0",
+		RawPath:               "/example",
+		RawQueryString:        "key=value",
+		Cookies:               []string{},
+		Headers:               map[string]string{},
+		QueryStringParameters: map[string]string{"key": "value"},
+		RequestContext: events.LambdaFunctionURLRequestContext{
+			AccountID:    "012345678912",
+			RequestID:    "abcdefg",
+			Authorizer:   nil,
+			APIID:        "0dhg9709da0dhg9709da0dhg9709da",
+			DomainName:   "0dhg9709da0dhg9709da0dhg9709da.lambda-url.eu-central-1.on.aws",
+			DomainPrefix: "",
+			Time:         "",
+			TimeEpoch:    0,
+			HTTP: events.LambdaFunctionURLRequestContextHTTPDescription{
+				Method:    "POST",
+				Path:      "/example",
+				Protocol:  "",
+				SourceIP:  "127.0.0.1",
+				UserAgent: "Go-http-client/1.1",
+			},
+		},
+		Body:            base64.StdEncoding.EncodeToString([]byte("hello world")),
+		IsBase64Encoded: true,
+	}
+}
+
+func newVanillaAdapter() handler.AdapterFunc {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+
+		result := make(map[string]string)
+		result["Method"] = r.Method
+		result["URL"] = r.URL.String()
+		result["RemoteAddr"] = r.RemoteAddr
+
+		defer r.Body.Close()
+		b, _ := io.ReadAll(r.Body)
+		result["Body"] = string(b)
+
+		enc := json.NewEncoder(w)
+		_ = enc.Encode(result)
+	})
+
+	return adapter.NewVanillaAdapter(mux)
+}
+
+func newEchoAdapter() handler.AdapterFunc {
+	app := echo.New()
+	app.Any("*", func(c echo.Context) error {
+		r := c.Request()
+
+		result := make(map[string]string)
+		result["Method"] = r.Method
+		result["URL"] = r.URL.String()
+		result["RemoteAddr"] = r.RemoteAddr
+
+		defer r.Body.Close()
+		b, _ := io.ReadAll(r.Body)
+		result["Body"] = string(b)
+
+		c.Response().Header().Set("Content-Type", "application/json")
+
+		return c.JSON(http.StatusOK, result)
+	})
+
+	return adapter.NewEchoAdapter(app)
+}
+
+func newFiberAdapter() handler.AdapterFunc {
+	app := fiber.New()
+	app.All("*", func(ctx *fiber.Ctx) error {
+		result := make(map[string]string)
+		result["Method"] = ctx.Method()
+		result["URL"] = ctx.Request().URI().String()
+		result["RemoteAddr"] = ctx.IP()
+		result["Body"] = string(ctx.Body())
+
+		return ctx.JSON(result)
+	})
+
+	return adapter.NewFiberAdapter(app)
+}
+
+func TestFunctionURLGET(t *testing.T) {
+	adapters := map[string]handler.AdapterFunc{
+		"vanilla": newVanillaAdapter(),
+		"echo":    newEchoAdapter(),
+	}
+
+	for name, a := range adapters {
+		t.Run(name, func(t *testing.T) {
+			h := handler.NewFunctionURLHandler(a)
+
+			req := newFunctionURLRequest()
+			res, err := h(context.Background(), req)
+			if err != nil {
+				t.Error(err)
+			}
+
+			if res.StatusCode != http.StatusOK {
+				t.Error("expected status to be 200")
+			}
+
+			if res.Headers["Content-Type"] != "application/json" {
+				t.Error("expected Content-Type to be application/json")
+			}
+
+			if res.IsBase64Encoded {
+				t.Error("expected body not to be base64 encoded")
+			}
+
+			body := make(map[string]string)
+			_ = json.Unmarshal([]byte(res.Body), &body)
+
+			expectedBody := map[string]string{
+				"Method":     "POST",
+				"URL":        "https://0dhg9709da0dhg9709da0dhg9709da.lambda-url.eu-central-1.on.aws/example?key=value",
+				"RemoteAddr": "127.0.0.1:http",
+				"Body":       "hello world",
+			}
+
+			if !reflect.DeepEqual(body, expectedBody) {
+				t.Error("request/response didnt match")
+			}
+		})
+	}
+}

handler/api.go

@@ -7,7 +7,7 @@ import (
 
 type httpContextKey string
 
-var sourceEventContextKey httpContextKey = "github.com/its-felix/aws-lambda-go-http-adapter/api::sourceEventContextKey"
+var sourceEventContextKey httpContextKey = "github.com/its-felix/aws-lambda-go-http-adapter/handler/api::sourceEventContextKey"
 
 type AdapterFunc func(ctx context.Context, r *http.Request, w http.ResponseWriter) error
 type HandlerFunc[In any, Out any] func(ctx context.Context, event In, adapter AdapterFunc) (Out, error)

handler/api_test.go

@@ -0,0 +1,73 @@
+package handler
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func newTestHandler(handlerFunc http.HandlerFunc) func(context.Context, *http.Request) (*http.Response, error) {
+	return NewHandler(
+		func(ctx context.Context, event *http.Request, adapter AdapterFunc) (*http.Response, error) {
+			w := httptest.NewRecorder()
+
+			if err := adapter(ctx, event, w); err != nil {
+				return nil, err
+			}
+
+			return w.Result(), nil
+		},
+		func(ctx context.Context, r *http.Request, w http.ResponseWriter) error {
+			handlerFunc(w, r.WithContext(ctx))
+			return nil
+		},
+	)
+}
+
+func TestGetSourceEvent(t *testing.T) {
+	var caughtRequest *http.Request
+
+	handler := newTestHandler(func(w http.ResponseWriter, r *http.Request) {
+		event := GetSourceEvent(r.Context()).(*http.Request)
+		caughtRequest = event
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/", strings.NewReader(""))
+	res, err := handler(context.Background(), req)
+
+	if caughtRequest != req {
+		t.Error("GetSourceEvent returned the wrong value")
+	}
+
+	if res == nil {
+		t.Error("response should not be nil")
+	}
+
+	if err != nil {
+		t.Error("expected err to be nil")
+	}
+}
+
+func TestWrapWithRecover(t *testing.T) {
+	handler := newTestHandler(func(w http.ResponseWriter, r *http.Request) {
+		panic("test panic value")
+	})
+
+	handler = WrapWithRecover(handler, func(ctx context.Context, event *http.Request, panicValue any) (*http.Response, error) {
+		return nil, errors.New(panicValue.(string))
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/", strings.NewReader(""))
+	res, err := handler(context.Background(), req)
+
+	if res != nil {
+		t.Error("expected nil response")
+	}
+
+	if err.Error() != "test panic value" {
+		t.Error("expected the handler to return an error 'test panic value'")
+	}
+}