Reimplement server.Error for composite handlers only

Author: colinodell

pkg/server/error.go

@@ -0,0 +1,32 @@
+// Copyright 2024 SeatGeek, Inc.
+//
+// Licensed under the terms of the Apache-2.0 license. See LICENSE file in project root for terms.
+
+package server
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Error is a custom error type that includes an HTTP status code
+type Error struct {
+	Code   int
+	Reason error
+}
+
+func (h *Error) Error() string {
+	if h.Reason != nil {
+		return fmt.Sprintf("internal %d: %v", h.Code, h.Reason.Error())
+	}
+	return fmt.Sprintf("internal %d: something happened, perhaps", h.Code)
+}
+
+func (h *Error) Is(target error) bool {
+	var err *Error
+	if ok := errors.As(target, &err); !ok {
+		return false
+	}
+
+	return err.Code == h.Code && (errors.Is(err.Reason, h.Reason) || err.Reason.Error() == h.Reason.Error())
+}

pkg/server/error_test.go

@@ -0,0 +1,98 @@
+// Copyright 2024 SeatGeek, Inc.
+//
+// Licensed under the terms of the Apache-2.0 license. See LICENSE file in project root for terms.
+
+package server
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestError_Error(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		err  *Error
+		want string
+	}{
+		{
+			name: "with reason",
+			err:  &Error{Code: 403, Reason: errors.New("forbidden")},
+			want: "internal 403: forbidden",
+		},
+		{
+			name: "without reason",
+			err:  &Error{Code: 403},
+			want: "internal 403: something happened, perhaps",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			assert.Equal(t, tt.want, tt.err.Error())
+		})
+	}
+}
+
+func TestError_Is(t *testing.T) {
+	t.Parallel()
+
+	target := &Error{Code: 403, Reason: errors.New("forbidden")}
+
+	tests := []struct {
+		name  string
+		other error
+		want  bool
+	}{
+		{
+			name:  "exact same object",
+			other: target,
+			want:  true,
+		},
+		{
+			name:  "different object, same values",
+			other: &Error{Code: 403, Reason: errors.New("forbidden")},
+			want:  true,
+		},
+		{
+			name:  "different code",
+			other: &Error{Code: 400, Reason: errors.New("forbidden")},
+			want:  false,
+		},
+		{
+			name:  "different reason",
+			other: &Error{Code: 403, Reason: errors.New("not allowed")},
+			want:  false,
+		},
+		{
+			name:  "different type",
+			other: errors.New("forbidden"),
+			want:  false,
+		},
+		{
+			name:  "wrapped",
+			other: fmt.Errorf("wrapped: %w", target),
+			want:  true,
+		},
+		{
+			name:  "inner reason",
+			other: target.Reason,
+			want:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			assert.Equal(t, tt.want, errors.Is(target, tt.other))
+		})
+	}
+}

pkg/server/handler.go

@@ -6,6 +6,7 @@
 package server
 
 import (
+	"errors"
 	"fmt"
 	"log/slog"
 	"net/http"
@@ -23,8 +24,7 @@ func CreateEventHandler(s handler.Handler, n notifier.Notifier) http.HandlerFunc
 
 		notifications, err := s.Process(request)
 		if err != nil {
-			slog.Error("failed to generate notifications", "handler", s.Key(), "error", err)
-			http.Error(writer, fmt.Sprintf("failed to generate notifications: %v", err), 500)
+			logAndSendErrorResponse(writer, s.Key(), "failed to generate notifications", err)
 			return
 		}
 
@@ -51,3 +51,21 @@ func CreateEventHandler(s handler.Handler, n notifier.Notifier) http.HandlerFunc
 		}
 	}
 }
+
+func logAndSendErrorResponse(writer http.ResponseWriter, handlerKey string, errorPrefix string, err error) {
+	statusCode := 500
+
+	var httpError *Error
+	if errors.As(err, &httpError) {
+		statusCode = httpError.Code
+		err = httpError.Reason
+	}
+
+	if statusCode < 500 {
+		slog.Warn(errorPrefix, "handler", handlerKey, "error", err)
+	} else {
+		slog.Error(errorPrefix, "handler", handlerKey, "error", err)
+	}
+
+	http.Error(writer, fmt.Sprintf("%s: %v", errorPrefix, err), statusCode)
+}

pkg/server/handler_test.go

@@ -49,6 +49,14 @@ func TestHandler(t *testing.T) {
 			handler:        handlerThatReturns(t, nil, someError),
 			wantStatusCode: 500,
 		},
+		{
+			name: "parse error with custom HTTP status code",
+			handler: handlerThatReturns(t, nil, &Error{
+				Code:   400,
+				Reason: someError,
+			}),
+			wantStatusCode: 400,
+		},
 		{
 			name:           "notifier error",
 			handler:        handlerThatReturns(t, someNotifications, nil),