go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/web/route_tree_test.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package web

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"net/url"
	"strings"
	"sync/atomic"
	"testing"

	. "go.charczuk.com/sdk/assert"
)

func handlerNoOp(rw http.ResponseWriter, _ *http.Request, _ *Route, _ RouteParameters) {
	rw.WriteHeader(http.StatusOK)
	fmt.Fprintf(rw, "OK!\n")
}

func Test_RouteTree_allowed(t *testing.T) {
	rt := new(RouteTree)
	rt.Handle(http.MethodGet, "/test", nil)

	allowed := strings.Split(rt.allowed("*", ""), ", ")
	ItsLen(t, allowed, 1)
	ItsEqual(t, "GET", allowed[0])

	rt.Handle(http.MethodPost, "/hello", nil)
	allowed = strings.Split(rt.allowed("*", ""), ", ")
	ItsLen(t, allowed, 2)
	ItsAny(t, allowed, func(s string) bool {
		return s == http.MethodGet
	})
	ItsAny(t, allowed, func(s string) bool {
		return s == http.MethodPost
	})

	rt = new(RouteTree)

	rt.Handle(http.MethodGet, "/hello", handlerNoOp)
	allowed = strings.Split(rt.allowed("/hello", ""), ", ")
	ItsLen(t, allowed, 2)
	ItsAny(t, allowed, func(s string) bool {
		return s == "GET"
	})
	ItsAny(t, allowed, func(s string) bool {
		return s == "OPTIONS"
	})
	rt.Handle(http.MethodPost, "/hello", handlerNoOp)
	allowed = strings.Split(rt.allowed("/hello", ""), ", ")
	ItsLen(t, allowed, 3)

	rt.Handle(http.MethodOptions, "/hello", handlerNoOp)
	rt.Handle(http.MethodHead, "/hello", handlerNoOp)
	rt.Handle(http.MethodPut, "/hello", handlerNoOp)
	rt.Handle(http.MethodDelete, "/hello", handlerNoOp)

	rt.Handle(http.MethodPatch, "/hi", handlerNoOp)
	rt.Handle(http.MethodPatch, "/there", handlerNoOp)
	allowed = strings.Split(rt.allowed("/hello", ""), ", ")
	ItsLen(t, allowed, 6)

	rt.Handle(http.MethodPatch, "/hello", handlerNoOp)
	allowed = strings.Split(rt.allowed("/hello", ""), ", ")
	ItsLen(t, allowed, 7)
}

func Test_RouteTree_Route(t *testing.T) {
	rt := new(RouteTree)

	rt.Handle(http.MethodGet, "/", handlerNoOp)
	rt.Handle(http.MethodGet, "/foo", handlerNoOp)
	rt.Handle(http.MethodGet, "/foo/:id", handlerNoOp)
	rt.Handle(http.MethodPost, "/foo", handlerNoOp)
	rt.Handle(http.MethodGet, "/bar", handlerNoOp)

	// explicitly register a slash suffixed url here
	rt.Handle(http.MethodGet, "/slash/", handlerNoOp)

	req := &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/",
		},
	}
	route, params := rt.Route(req)
	ItsNotNil(t, route)
	ItsEqual(t, "/", route.Path)
	ItsEmpty(t, params)
	ItsEqual(t, "/", req.URL.Path)

	req = &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/foo",
		},
	}
	route, params = rt.Route(req)
	ItsNotNil(t, route)
	ItsEqual(t, "/foo", route.Path)
	ItsEqual(t, http.MethodGet, route.Method)
	ItsEmpty(t, params)
	ItsEqual(t, "/foo", req.URL.Path)

	req = &http.Request{
		Method: http.MethodPost,
		URL: &url.URL{
			Path: "/foo",
		},
	}
	route, params = rt.Route(req)
	ItsNotNil(t, route)
	ItsEqual(t, "/foo", route.Path)
	ItsEqual(t, http.MethodPost, route.Method)
	ItsEmpty(t, params)
	ItsEqual(t, "/foo", req.URL.Path)

	// explicitly test matching with an extra slash
	req = &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/foo/",
		},
	}
	route, params = rt.Route(req)
	ItsNotNil(t, route)
	ItsEqual(t, "/foo", route.Path)
	ItsEmpty(t, params)
	ItsEqual(t, "/foo/", req.URL.Path)

	req = &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/foo/test",
		},
	}
	route, params = rt.Route(req)
	ItsNotNil(t, route)
	ItsEqual(t, "/foo/:id", route.Path)
	ItsNotEmpty(t, params)
	id, _ := params.Get("id")
	ItsEqual(t, "test", id)
	ItsEqual(t, "/foo/test", req.URL.Path)

	req = &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/bar",
		},
	}
	route, params = rt.Route(req)
	ItsNotNil(t, route)
	ItsEqual(t, "/bar", route.Path)
	ItsEmpty(t, params)
	ItsEqual(t, "/bar", req.URL.Path)

	req = &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/slash",
		},
	}
	route, params = rt.Route(req)
	ItsNotNil(t, route)
	ItsEqual(t, "/slash/", route.Path)
	ItsEmpty(t, params)
	ItsEqual(t, "/slash", req.URL.Path)

	req = &http.Request{
		Method: http.MethodConnect,
		URL: &url.URL{
			Path: "/slash",
		},
	}
	route, params = rt.Route(req)
	ItsNil(t, route)
	ItsEmpty(t, params)
	ItsEqual(t, "/slash", req.URL.Path)

	req = &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/slash",
		},
	}
	rt.SkipTrailingSlashRedirects = true
	route, params = rt.Route(req)
	ItsNil(t, route)
	ItsEmpty(t, params)
	ItsEqual(t, "/slash", req.URL.Path)
}

func Test_RouteTree_Route_slash(t *testing.T) {
	rt := new(RouteTree)

	req := &http.Request{
		Method: http.MethodGet,
		URL: &url.URL{
			Path: "/",
		},
	}
	route, params := rt.Route(req)
	ItsNil(t, route)
	ItsEmpty(t, params)
	ItsEqual(t, "/", req.URL.Path)
}

func Test_RouteTree_withPathAlternateTrailingSlash(t *testing.T) {
	ItsEqual(t, "/foo", new(RouteTree).withPathAlternateTrailingSlash("/foo/"))
	ItsEqual(t, "/foo/", new(RouteTree).withPathAlternateTrailingSlash("/foo"))
	ItsEqual(t, "", new(RouteTree).withPathAlternateTrailingSlash(""))
}

func routeExpectsPath(method, path string) Handler {
	return func(rw http.ResponseWriter, req *http.Request, _ *Route, _ RouteParameters) {
		if req.Method != method {
			http.Error(rw, "expects method: "+method, http.StatusBadRequest)
			return
		}
		if req.URL.Path != path {
			http.Error(rw, "expects path: "+path, http.StatusBadRequest)
			return
		}
		rw.WriteHeader(http.StatusOK)
		fmt.Fprintf(rw, "OK!\n")
	}
}

func callCounter(counter *int32, statusCode int) Handler {
	return func(rw http.ResponseWriter, req *http.Request, _ *Route, _ RouteParameters) {
		defer atomic.AddInt32(counter, 1)
		rw.WriteHeader(statusCode)
		fmt.Fprintf(rw, "counted call!\n")
	}
}

func Test_RouteTree_ServeHTTP(t *testing.T) {
	rt := new(RouteTree)

	rt.Handle(http.MethodGet, "/", routeExpectsPath(http.MethodGet, "/"))
	rt.Handle(http.MethodGet, "/foo", routeExpectsPath(http.MethodGet, "/foo"))
	rt.Handle(http.MethodGet, "/foo/:id", routeExpectsPath(http.MethodGet, "/foo/test-id"))
	rt.Handle(http.MethodPost, "/foo", routeExpectsPath(http.MethodPost, "/foo"))
	rt.Handle(http.MethodGet, "/bar", routeExpectsPath(http.MethodGet, "/bar"))

	// explicitly register a slash url here
	rt.Handle(http.MethodGet, "/slash/", handlerNoOp)

	mock := httptest.NewServer(rt)
	defer mock.Close()

	res, err := mock.Client().Get(mock.URL + "/")
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)

	res, err = mock.Client().Get(mock.URL + "/foo")
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)

	res, err = mock.Client().Get(mock.URL + "/foo/")
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)

	res, err = mock.Client().Post(mock.URL+"/foo/", "", nil)
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)

	res, err = mock.Client().Get(mock.URL + "/foo/test-id")
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)

	res, err = mock.Client().Get(mock.URL + "/foo/not-test-id")
	ItsNil(t, err)
	ItsEqual(t, http.StatusBadRequest, res.StatusCode)

	res, err = mock.Client().Get(mock.URL + "/bar/")
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)

	optionsReq, _ := http.NewRequest(http.MethodOptions, mock.URL, nil)
	// now handle the super weird stuff
	res, err = mock.Client().Do(optionsReq)
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)
	allowedHeader := res.Header.Get(HeaderAllow)
	ItsNotEmpty(t, allowedHeader)
	ItsEqual(t, "GET, OPTIONS", allowedHeader)

	rt.SkipHandlingMethodOptions = true
	res, err = mock.Client().Do(optionsReq)
	ItsNil(t, err)
	ItsEqual(t, http.StatusNotFound, res.StatusCode)
	allowedHeader = res.Header.Get(HeaderAllow)
	ItsEmpty(t, allowedHeader)

	var notFoundCalls int32
	rt.NotFoundHandler = callCounter(&notFoundCalls, http.StatusNotFound)
	res, err = mock.Client().Do(optionsReq)
	ItsNil(t, err)
	ItsEqual(t, http.StatusNotFound, res.StatusCode)
	allowedHeader = res.Header.Get(HeaderAllow)
	ItsEmpty(t, allowedHeader)
	ItsEqual(t, 1, notFoundCalls)

	headReq, _ := http.NewRequest(http.MethodHead, mock.URL, nil)
	res, err = mock.Client().Do(headReq)
	ItsNil(t, err)
	ItsEqual(t, http.StatusMethodNotAllowed, res.StatusCode)
	allowedHeader = res.Header.Get(HeaderAllow)
	ItsNotEmpty(t, allowedHeader)
	ItsEqual(t, "GET, OPTIONS", allowedHeader)

	var methodNotAllowedCalls int32
	rt.MethodNotAllowedHandler = callCounter(&methodNotAllowedCalls, http.StatusMethodNotAllowed)
	res, err = mock.Client().Do(headReq)
	ItsNil(t, err)
	ItsEqual(t, http.StatusMethodNotAllowed, res.StatusCode)
	allowedHeader = res.Header.Get(HeaderAllow)
	ItsNotEmpty(t, allowedHeader)
	ItsEqual(t, "GET, OPTIONS", allowedHeader)
	ItsEqual(t, 1, notFoundCalls)
	ItsEqual(t, 1, methodNotAllowedCalls)

	rt.SkipMethodNotAllowed = true
	rt.NotFoundHandler = nil
	res, err = mock.Client().Do(optionsReq)
	ItsNil(t, err)
	ItsEqual(t, http.StatusNotFound, res.StatusCode)
	allowedHeader = res.Header.Get(HeaderAllow)
	ItsEmpty(t, allowedHeader)

	rt.NotFoundHandler = callCounter(&notFoundCalls, http.StatusNotFound)
	res, err = mock.Client().Do(optionsReq)
	ItsNil(t, err)
	ItsEqual(t, http.StatusNotFound, res.StatusCode)
	allowedHeader = res.Header.Get(HeaderAllow)
	ItsEmpty(t, allowedHeader)
	ItsEqual(t, 2, notFoundCalls)
}