ezhandler/helper_test.go

package ezhandler_test

import (
	"errors"
	"net/http"
	"net/http/httptest"
	"testing"

	"codeberg.org/danjones000/ezhandler"
	"github.com/stretchr/testify/assert"
)

var errTest = errors.New("test error")

type handlerType string

const (
	handlerT     handlerType = "Handler"
	handlerFuncT handlerType = "HandlerFunc"
	respHandlerT handlerType = "ResponseHandler"
)

type testHandler struct {
	err error
}

func (th testHandler) ServeHTTP(http.ResponseWriter, *http.Request) error {
	return th.err
}

func TestNewHelper(t *testing.T) {
	mockErrorHandler := func(w http.ResponseWriter, r *http.Request, err error) {}
	helper := ezhandler.NewHelper(mockErrorHandler)
	assert.NotNil(t, helper)
}

func runHelperTest(t *testing.T, name string, handlerErr, expectedErr error, expectedErrorHandlerCalled bool, ht handlerType) {
	t.Run(name, func(t *testing.T) {
		var errorHandlerCalled bool
		mockErrorHandler := func(w http.ResponseWriter, r *http.Request, err error) {
			errorHandlerCalled = true
			assert.Equal(t, expectedErr, err)
		}
		helper := ezhandler.NewHelper(mockErrorHandler)

		req := httptest.NewRequest(http.MethodGet, "/", http.NoBody)
		rec := httptest.NewRecorder()

		var wrappedHandler http.Handler
		switch ht {
		case handlerT:
			mockHandler := testHandler{handlerErr}
			wrappedHandler = helper.Handler(mockHandler)
		case handlerFuncT:
			mockHandlerFunc := ezhandler.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
				return handlerErr
			})
			wrappedHandler = helper.HandlerFunc(mockHandlerFunc)
		case respHandlerT:
			mockResponseHandler := ezhandler.ResponseHandler(func(r *http.Request) (ezhandler.ResponseHelper, error) {
				if handlerErr != nil {
					return nil, handlerErr
				}
				return ezhandler.JSONResponse(map[string]string{"status": "ok"}), nil
			})
			wrappedHandler = helper.ResponderHandler(mockResponseHandler)
		default:
			assert.Fail(t, "Unknown test type: "+string(ht))
		}

		wrappedHandler.ServeHTTP(rec, req)

		assert.Equal(t, expectedErrorHandlerCalled, errorHandlerCalled)
	})
}

func TestHelper_Handler(t *testing.T) {
	runHelperTest(t, "no error", nil, nil, false, handlerT)
	runHelperTest(t, "with error", errTest, errTest, true, handlerT)
}

func TestHelper_HandlerFunc(t *testing.T) {
	runHelperTest(t, "no error", nil, nil, false, handlerFuncT)
	runHelperTest(t, "with error", errTest, errTest, true, handlerFuncT)
}

func TestHelper_ResponderHandler(t *testing.T) {
	runHelperTest(t, "no error", nil, nil, false, respHandlerT)
	runHelperTest(t, "with error", errTest, errTest, true, respHandlerT)
}