golib/hws/routes_test.go

package hws_test

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

	"git.haelnorr.com/h/golib/hws"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func Test_AddRoutes(t *testing.T) {
	var buf bytes.Buffer

	t.Run("No routes provided", func(t *testing.T) {
		server := createTestServer(t, &buf)
		err := server.AddRoutes()
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "No routes provided")
	})

	t.Run("Single valid route", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})
		err := server.AddRoutes(hws.Route{
			Path:    "/test",
			Method:  hws.MethodGET,
			Handler: handler,
		})
		assert.NoError(t, err)
	})

	t.Run("Multiple valid routes", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})
		err := server.AddRoutes(
			hws.Route{Path: "/test1", Method: hws.MethodGET, Handler: handler},
			hws.Route{Path: "/test2", Method: hws.MethodPOST, Handler: handler},
			hws.Route{Path: "/test3", Method: hws.MethodPUT, Handler: handler},
		)
		assert.NoError(t, err)
	})

	t.Run("Invalid method", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})
		err := server.AddRoutes(hws.Route{
			Path:    "/test",
			Method:  hws.Method("INVALID"),
			Handler: handler,
		})
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "Invalid method")
	})

	t.Run("No handler provided", func(t *testing.T) {
		server := createTestServer(t, &buf)
		err := server.AddRoutes(hws.Route{
			Path:    "/test",
			Method:  hws.MethodGET,
			Handler: nil,
		})
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "No handler provided")
	})

	t.Run("All HTTP methods are valid", func(t *testing.T) {
		methods := []hws.Method{
			hws.MethodGET,
			hws.MethodPOST,
			hws.MethodPUT,
			hws.MethodHEAD,
			hws.MethodDELETE,
			hws.MethodCONNECT,
			hws.MethodOPTIONS,
			hws.MethodTRACE,
			hws.MethodPATCH,
		}

		for _, method := range methods {
			t.Run(string(method), func(t *testing.T) {
				server := createTestServer(t, &buf)
				handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
					w.WriteHeader(http.StatusOK)
				})
				err := server.AddRoutes(hws.Route{
					Path:    "/test",
					Method:  method,
					Handler: handler,
				})
				assert.NoError(t, err)
			})
		}
	})

	t.Run("Healthz endpoint is automatically added", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})
		err := server.AddRoutes(hws.Route{
			Path:    "/test",
			Method:  hws.MethodGET,
			Handler: handler,
		})
		require.NoError(t, err)

		// Test using httptest instead of starting the server
		req := httptest.NewRequest("GET", "/healthz", nil)
		rr := httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)

		assert.Equal(t, http.StatusOK, rr.Code)
	})
}

func Test_AddRoutes_MultipleMethods(t *testing.T) {
	var buf bytes.Buffer

	t.Run("Single route with multiple methods", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
			w.Write([]byte(r.Method + " response"))
		})
		err := server.AddRoutes(hws.Route{
			Path:    "/api/resource",
			Methods: []hws.Method{hws.MethodGET, hws.MethodPOST, hws.MethodPUT},
			Handler: handler,
		})
		require.NoError(t, err)

		// Test GET request
		req := httptest.NewRequest("GET", "/api/resource", nil)
		rr := httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)
		assert.Equal(t, http.StatusOK, rr.Code)
		assert.Equal(t, "GET response", rr.Body.String())

		// Test POST request
		req = httptest.NewRequest("POST", "/api/resource", nil)
		rr = httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)
		assert.Equal(t, http.StatusOK, rr.Code)
		assert.Equal(t, "POST response", rr.Body.String())

		// Test PUT request
		req = httptest.NewRequest("PUT", "/api/resource", nil)
		rr = httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)
		assert.Equal(t, http.StatusOK, rr.Code)
		assert.Equal(t, "PUT response", rr.Body.String())
	})

	t.Run("Methods field takes precedence over Method field", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})
		err := server.AddRoutes(hws.Route{
			Path:    "/test",
			Method:  hws.MethodGET, // This should be ignored
			Methods: []hws.Method{hws.MethodPOST, hws.MethodPUT},
			Handler: handler,
		})
		require.NoError(t, err)

		// GET should not work (Method field ignored)
		req := httptest.NewRequest("GET", "/test", nil)
		rr := httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)
		assert.Equal(t, http.StatusMethodNotAllowed, rr.Code)

		// POST should work (from Methods field)
		req = httptest.NewRequest("POST", "/test", nil)
		rr = httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)
		assert.Equal(t, http.StatusOK, rr.Code)

		// PUT should work (from Methods field)
		req = httptest.NewRequest("PUT", "/test", nil)
		rr = httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)
		assert.Equal(t, http.StatusOK, rr.Code)
	})

	t.Run("Invalid method in Methods slice", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})
		err := server.AddRoutes(hws.Route{
			Path:    "/test",
			Methods: []hws.Method{hws.MethodGET, hws.Method("INVALID")},
			Handler: handler,
		})
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "Invalid method")
	})

	t.Run("Empty Methods slice falls back to Method field", func(t *testing.T) {
		server := createTestServer(t, &buf)
		handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
		})
		err := server.AddRoutes(hws.Route{
			Path:    "/test",
			Method:  hws.MethodGET,
			Methods: []hws.Method{}, // Empty slice
			Handler: handler,
		})
		require.NoError(t, err)

		// GET should work (from Method field)
		req := httptest.NewRequest("GET", "/test", nil)
		rr := httptest.NewRecorder()
		server.Handler().ServeHTTP(rr, req)
		assert.Equal(t, http.StatusOK, rr.Code)
	})
}

func Test_Routes_EndToEnd(t *testing.T) {
	var buf bytes.Buffer
	server := createTestServer(t, &buf)

	// Add multiple routes with different methods
	getHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("GET response"))
	})
	postHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusCreated)
		w.Write([]byte("POST response"))
	})

	err := server.AddRoutes(
		hws.Route{Path: "/get", Method: hws.MethodGET, Handler: getHandler},
		hws.Route{Path: "/post", Method: hws.MethodPOST, Handler: postHandler},
	)
	require.NoError(t, err)

	// Test GET request using httptest
	req := httptest.NewRequest("GET", "/get", nil)
	rr := httptest.NewRecorder()
	server.Handler().ServeHTTP(rr, req)

	assert.Equal(t, http.StatusOK, rr.Code)
	assert.Equal(t, "GET response", rr.Body.String())

	// Test POST request using httptest
	req = httptest.NewRequest("POST", "/post", nil)
	rr = httptest.NewRecorder()
	server.Handler().ServeHTTP(rr, req)

	assert.Equal(t, http.StatusCreated, rr.Code)
	assert.Equal(t, "POST response", rr.Body.String())
}