// ⚡️ Fiber is an Express inspired web framework written in Go with ☕️

// 🤖 GitHub Repository: https://github.com/gofiber/fiber

// 📌 API Documentation: https://docs.gofiber.io

package fiber

import (

"bufio"

"bytes"

"context"

"crypto/tls"

"errors"

"fmt"

"io"

"mime/multipart"

"net"

"net/http"

"net/http/httptest"

"os"

"path/filepath"

"reflect"

"regexp"

"runtime"

"strconv"

"strings"

"sync"

"testing"

"time"

"unsafe"

"github.com/gofiber/utils/v2"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

"github.com/valyala/fasthttp"

"github.com/valyala/fasthttp/fasthttputil"

)

type fileView struct {

path string

content string

loads int

}

func (v *fileView) Load() error {

contents, err := os.ReadFile(v.path)

if err != nil {

return fmt.Errorf("read template: %w", err)

}

v.content = string(contents)

v.loads++

return nil

}

func (*fileView) Render(io.Writer, string, any, ...string) error { return nil }

func testEmptyHandler(_ Ctx) error {

return nil

}

func testStatus200(t *testing.T, app *App, url, method string) {

t.Helper()

req := httptest.NewRequest(method, url, http.NoBody)

resp, err := app.Test(req)

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

}

func testErrorResponse(t *testing.T, err error, resp *http.Response, expectedBodyError string) {

t.Helper()

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 500, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, expectedBodyError, string(body), "Response body")

}

func Test_App_Test_Goroutine_Leak_Compare(t *testing.T) {

t.Parallel()

testCases := []struct {

handler Handler

name string

timeout time.Duration

sleepTime time.Duration

expectLeak bool

}{

{

name: "With timeout (potential leak)",

handler: func(c Ctx) error {

time.Sleep(300 * time.Millisecond) // Simulate time-consuming operation

return c.SendString("ok")

},

timeout: 50 * time.Millisecond, // // Short timeout to ensure triggering

sleepTime: 500 * time.Millisecond, // Wait time longer than handler execution time

expectLeak: true,

},

{

name: "Without timeout (no leak)",

handler: func(c Ctx) error {

return c.SendString("ok") // Return immediately

},

timeout: 0, // Disable timeout

sleepTime: 100 * time.Millisecond,

expectLeak: false,

},

}

for _, tc := range testCases {

t.Run(tc.name, func(t *testing.T) {

t.Parallel()

app := New()

// Record initial goroutine count

initialGoroutines := runtime.NumGoroutine()

t.Logf("[%s] Initial goroutines: %d", tc.name, initialGoroutines)

app.Get("/", tc.handler)

// Send 10 requests

numRequests := 10

for range numRequests {

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

if tc.timeout > 0 {

_, err := app.Test(req, TestConfig{

Timeout: tc.timeout,

FailOnTimeout: true,

})

require.Error(t, err)

require.ErrorIs(t, err, os.ErrDeadlineExceeded)

} else if resp, err := app.Test(req); err != nil {

t.Errorf("unexpected error: %v", err)

} else {

require.Equal(t, 200, resp.StatusCode)

}

}

// Wait for normal goroutines to complete

time.Sleep(tc.sleepTime)

// Check final goroutine count

finalGoroutines := runtime.NumGoroutine()

leakedGoroutines := finalGoroutines - initialGoroutines

if leakedGoroutines < 0 {

leakedGoroutines = 0

}

t.Logf("[%s] Final goroutines: %d (leaked: %d)",

tc.name, finalGoroutines, leakedGoroutines)

if tc.expectLeak {

// We allow up to 3x the request count to account for noise; zero is tolerated.

maxLeak := numRequests * 3

if leakedGoroutines > maxLeak {

t.Errorf("[%s] Expected at most %d leaked goroutines, but got %d",

tc.name, maxLeak, leakedGoroutines)

}

return

}

// No-leak scenario: allow a small buffer for runtime noise.

// Increase slack to reduce flakes from background goroutines.

if leakedGoroutines > numRequests {

t.Errorf("[%s] Expected at most %d leaked goroutines, but got %d",

tc.name, numRequests, leakedGoroutines)

}

})

}

}

func Test_App_MethodNotAllowed(t *testing.T) {

t.Parallel()

app := New()

app.Use(func(c Ctx) error {

return c.Next()

})

app.Post("/", testEmptyHandler)

app.Options("/", testEmptyHandler)

resp, err := app.Test(httptest.NewRequest(MethodPost, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 200, resp.StatusCode)

require.Empty(t, resp.Header.Get(HeaderAllow))

resp, err = app.Test(httptest.NewRequest(MethodGet, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 405, resp.StatusCode)

require.Equal(t, "POST, OPTIONS", resp.Header.Get(HeaderAllow))

resp, err = app.Test(httptest.NewRequest(MethodPatch, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 405, resp.StatusCode)

require.Equal(t, "POST, OPTIONS", resp.Header.Get(HeaderAllow))

resp, err = app.Test(httptest.NewRequest(MethodPut, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 405, resp.StatusCode)

require.Equal(t, "POST, OPTIONS", resp.Header.Get(HeaderAllow))

app.Get("/", testEmptyHandler)

resp, err = app.Test(httptest.NewRequest(MethodTrace, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 405, resp.StatusCode)

require.Equal(t, "GET, HEAD, POST, OPTIONS", resp.Header.Get(HeaderAllow))

resp, err = app.Test(httptest.NewRequest(MethodPatch, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 405, resp.StatusCode)

require.Equal(t, "GET, HEAD, POST, OPTIONS", resp.Header.Get(HeaderAllow))

app.Head("/", testEmptyHandler)

resp, err = app.Test(httptest.NewRequest(MethodPut, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 405, resp.StatusCode)

require.Equal(t, "GET, HEAD, POST, OPTIONS", resp.Header.Get(HeaderAllow))

}

func Test_App_RegisterNetHTTPHandler(t *testing.T) {

t.Parallel()

tests := []struct {

name string

register func(app *App, path string, handler any)

method string

expectBody bool

}{

{

name: "Get",

register: func(app *App, path string, handler any) {

app.Get(path, handler)

},

method: http.MethodGet,

expectBody: true,

},

{

name: "Head",

register: func(app *App, path string, handler any) {

app.Head(path, handler)

},

method: http.MethodHead,

},

{

name: "Post",

register: func(app *App, path string, handler any) {

app.Post(path, handler)

},

method: http.MethodPost,

expectBody: true,

},

{

name: "Put",

register: func(app *App, path string, handler any) {

app.Put(path, handler)

},

method: http.MethodPut,

expectBody: true,

},

{

name: "Delete",

register: func(app *App, path string, handler any) {

app.Delete(path, handler)

},

method: http.MethodDelete,

expectBody: true,

},

{

name: "Connect",

register: func(app *App, path string, handler any) {

app.Connect(path, handler)

},

method: http.MethodConnect,

expectBody: true,

},

{

name: "Options",

register: func(app *App, path string, handler any) {

app.Options(path, handler)

},

method: http.MethodOptions,

expectBody: true,

},

{

name: "Trace",

register: func(app *App, path string, handler any) {

app.Trace(path, handler)

},

method: http.MethodTrace,

expectBody: true,

},

{

name: "Patch",

register: func(app *App, path string, handler any) {

app.Patch(path, handler)

},

method: http.MethodPatch,

expectBody: true,

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

t.Parallel()

app := New()

handler := func(w http.ResponseWriter, r *http.Request) {

w.Header().Set("X-Test", r.Method)

w.WriteHeader(http.StatusAccepted)

if r.Method == http.MethodHead {

return

}

_, err := w.Write([]byte("hello from net/http " + r.Method))

assert.NoError(t, err)

}

tt.register(app, "/foo", http.HandlerFunc(handler))

req := httptest.NewRequest(tt.method, "/foo", http.NoBody)

if tt.method == http.MethodConnect {

req.URL.Scheme = "http"

req.URL.Host = "example.com"

}

resp, err := app.Test(req)

require.NoError(t, err)

require.Equal(t, http.StatusAccepted, resp.StatusCode)

require.Equal(t, tt.method, resp.Header.Get("X-Test"))

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

if tt.expectBody {

require.Equal(t, "hello from net/http "+tt.method, string(body))

} else {

require.Empty(t, body)

}

})

}

}

func Test_App_Custom_Middleware_404_Should_Not_SetMethodNotAllowed(t *testing.T) {

t.Parallel()

app := New()

app.Use(func(c Ctx) error {

return c.SendStatus(404)

})

app.Post("/", testEmptyHandler)

resp, err := app.Test(httptest.NewRequest(MethodGet, "/", http.NoBody))

require.NoError(t, err)

require.Equal(t, 404, resp.StatusCode)

require.Equal(t, MIMETextPlainCharsetUTF8, resp.Header.Get(HeaderContentType))

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "Not Found", string(body))

require.Equal(t, strconv.Itoa(len("Not Found")), resp.Header.Get(HeaderContentLength))

g := app.Group("/with-next", func(c Ctx) error {

return c.Status(404).Next()

})

g.Post("/", testEmptyHandler)

resp, err = app.Test(httptest.NewRequest(MethodGet, "/with-next", http.NoBody))

require.NoError(t, err)

require.Equal(t, 404, resp.StatusCode)

require.Equal(t, MIMETextPlainCharsetUTF8, resp.Header.Get(HeaderContentType))

body, err = io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "Not Found", string(body))

require.Equal(t, strconv.Itoa(len("Not Found")), resp.Header.Get(HeaderContentLength))

}

func Test_App_ServerErrorHandler_SmallReadBuffer(t *testing.T) {

t.Parallel()

expectedError := regexp.MustCompile(

`error when reading request headers: small read buffer\. Increase ReadBufferSize\. Buffer size=4096, contents: "GET / HTTP/1.1\\r\\nHost: example\.com\\r\\nVery-Long-Header: -+`,

)

app := New()

app.Get("/", func(_ Ctx) error {

panic(errors.New("should never called"))

})

request := httptest.NewRequest(MethodGet, "/", http.NoBody)

logHeaderSlice := make([]string, 5000)

request.Header.Set("Very-Long-Header", strings.Join(logHeaderSlice, "-"))

_, err := app.Test(request)

if err == nil {

t.Error("Expect an error at app.Test(request)")

}

require.Regexp(t, expectedError, err.Error())

}

func Test_App_Errors(t *testing.T) {

t.Parallel()

app := New(Config{

BodyLimit: 4,

})

app.Get("/", func(_ Ctx) error {

return errors.New("hi, i'm an error")

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 500, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "hi, i'm an error", string(body))

_, err = app.Test(httptest.NewRequest(MethodGet, "/", strings.NewReader("big body")))

if err != nil {

require.Equal(t, "body size exceeds the given limit", err.Error(), "app.Test(req)")

}

}

func Test_App_BodyLimit_Negative(t *testing.T) {

t.Parallel()

limits := []int{-1, -512}

for _, limit := range limits {

app := New(Config{BodyLimit: limit})

app.Post("/", func(c Ctx) error {

return c.SendStatus(StatusOK)

})

largeBody := bytes.Repeat([]byte{'a'}, DefaultBodyLimit+1)

req := httptest.NewRequest(MethodPost, "/", bytes.NewReader(largeBody))

_, err := app.Test(req)

require.ErrorIs(t, err, fasthttp.ErrBodyTooLarge)

smallBody := bytes.Repeat([]byte{'a'}, DefaultBodyLimit-1)

req = httptest.NewRequest(MethodPost, "/", bytes.NewReader(smallBody))

resp, err := app.Test(req)

require.NoError(t, err)

require.Equal(t, StatusOK, resp.StatusCode)

}

}

func Test_App_BodyLimit_Zero(t *testing.T) {

t.Parallel()

app := New(Config{BodyLimit: 0})

app.Post("/", func(c Ctx) error {

return c.SendStatus(StatusOK)

})

largeBody := bytes.Repeat([]byte{'a'}, DefaultBodyLimit+1)

req := httptest.NewRequest(MethodPost, "/", bytes.NewReader(largeBody))

_, err := app.Test(req)

require.ErrorIs(t, err, fasthttp.ErrBodyTooLarge)

smallBody := bytes.Repeat([]byte{'a'}, DefaultBodyLimit-1)

req = httptest.NewRequest(MethodPost, "/", bytes.NewReader(smallBody))

resp, err := app.Test(req)

require.NoError(t, err)

require.Equal(t, StatusOK, resp.StatusCode)

}

func Test_App_BodyLimit_LargerThanDefault(t *testing.T) {

t.Parallel()

limit := DefaultBodyLimit*2 + 1024 // slightly above double the default

app := New(Config{BodyLimit: limit})

app.Post("/", func(c Ctx) error {

return c.SendStatus(StatusOK)

})

// Body larger than the default but within our custom limit should succeed

midBody := bytes.Repeat([]byte{'a'}, DefaultBodyLimit+512)

req := httptest.NewRequest(MethodPost, "/", bytes.NewReader(midBody))

resp, err := app.Test(req)

require.NoError(t, err)

require.Equal(t, StatusOK, resp.StatusCode)

// Body above the custom limit should fail

largeBody := bytes.Repeat([]byte{'a'}, limit+1)

req = httptest.NewRequest(MethodPost, "/", bytes.NewReader(largeBody))

_, err = app.Test(req)

require.ErrorIs(t, err, fasthttp.ErrBodyTooLarge)

}

type customConstraint struct{}

func (*customConstraint) Name() string {

return "test"

}

func (*customConstraint) Execute(param string, args ...string) bool {

if param == "test" && len(args) == 1 && args[0] == "test" {

return true

}

if len(args) == 0 && param == "c" {

return true

}

return false

}

func Test_App_CustomConstraint(t *testing.T) {

t.Parallel()

app := New()

app.RegisterCustomConstraint(&customConstraint{})

app.Get("/test/:param<test(test)>", func(c Ctx) error {

return c.SendString("test")

})

app.Get("/test2/:param<test>", func(c Ctx) error {

return c.SendString("test")

})

app.Get("/test3/:param<test()>", func(c Ctx) error {

return c.SendString("test")

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/test/test", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/test/test2", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 404, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/test2/c", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/test2/cc", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 404, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/test3/cc", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 404, resp.StatusCode, "Status code")

}

func Test_App_ErrorHandler_Custom(t *testing.T) {

t.Parallel()

app := New(Config{

ErrorHandler: func(c Ctx, _ error) error {

return c.Status(200).SendString("hi, i'm a custom error")

},

})

app.Get("/", func(_ Ctx) error {

return errors.New("hi, i'm an error")

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "hi, i'm a custom error", string(body))

}

func Test_App_ErrorHandler_HandlerStack(t *testing.T) {

t.Parallel()

app := New(Config{

ErrorHandler: func(c Ctx, err error) error {

require.Equal(t, "1: USE error", err.Error())

return DefaultErrorHandler(c, err)

},

})

app.Use("/", func(c Ctx) error {

err := c.Next() // call next USE

require.Equal(t, "2: USE error", err.Error())

return errors.New("1: USE error")

}, func(c Ctx) error {

err := c.Next() // call [0] GET

require.Equal(t, "0: GET error", err.Error())

return errors.New("2: USE error")

})

app.Get("/", func(_ Ctx) error {

return errors.New("0: GET error")

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 500, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "1: USE error", string(body))

}

func Test_App_ErrorHandler_RouteStack(t *testing.T) {

t.Parallel()

app := New(Config{

ErrorHandler: func(c Ctx, err error) error {

require.Equal(t, "1: USE error", err.Error())

return DefaultErrorHandler(c, err)

},

})

app.Use("/", func(c Ctx) error {

err := c.Next()

require.Equal(t, "0: GET error", err.Error())

return errors.New("1: USE error") // [2] call ErrorHandler

})

app.Get("/test", func(_ Ctx) error {

return errors.New("0: GET error") // [1] return to USE

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/test", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 500, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "1: USE error", string(body))

}

func Test_App_serverErrorHandler_Internal_Error(t *testing.T) {

t.Parallel()

app := New()

msg := "test err"

c := app.AcquireCtx(&fasthttp.RequestCtx{}).(*DefaultCtx) //nolint:errcheck,forcetypeassert // not needed

app.serverErrorHandler(c.fasthttp, errors.New(msg))

require.Equal(t, string(c.fasthttp.Response.Body()), msg)

require.Equal(t, StatusBadRequest, c.fasthttp.Response.StatusCode())

}

func Test_App_serverErrorHandler_Network_Error(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{}).(*DefaultCtx) //nolint:errcheck,forcetypeassert // not needed

app.serverErrorHandler(c.fasthttp, &net.DNSError{

Err: "test error",

Name: "test host",

IsTimeout: false,

})

require.Equal(t, string(c.fasthttp.Response.Body()), utils.StatusMessage(StatusBadGateway))

require.Equal(t, StatusBadGateway, c.fasthttp.Response.StatusCode())

}

func Test_App_serverErrorHandler_Unsupported_Method_Error(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{}).(*DefaultCtx) //nolint:errcheck,forcetypeassert // not needed

app.serverErrorHandler(c.fasthttp, errors.New("unsupported http request method 'FOO'"))

require.Equal(t, utils.StatusMessage(StatusNotImplemented), string(c.fasthttp.Response.Body()))

require.Equal(t, StatusNotImplemented, c.fasthttp.Response.StatusCode())

}

func Test_App_serverErrorHandler_Unsupported_Method_Request(t *testing.T) {

t.Parallel()

app := New()

app.Get("/bar", func(c Ctx) error {

return c.SendString("bar")

})

ln := fasthttputil.NewInmemoryListener()

serverStarted := make(chan struct{}, 1)

serverErr := make(chan error, 1)

go func() {

serverStarted <- struct{}{}

if err := app.Listener(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {

serverErr <- err

return

}

serverErr <- nil

}()

<-serverStarted

conn, err := ln.Dial()

require.NoError(t, err)

require.NoError(t, conn.SetDeadline(time.Now().Add(5*time.Second)))

_, err = conn.Write([]byte("FOO /bar HTTP/1.1\r\nHost: example.com\r\n\r\n"))

require.NoError(t, err)

resp, err := http.ReadResponse(bufio.NewReader(conn), nil)

require.NoError(t, err)

require.Equal(t, StatusNotImplemented, resp.StatusCode)

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, utils.StatusMessage(StatusNotImplemented), string(body))

require.NoError(t, resp.Body.Close())

require.NoError(t, conn.Close())

require.NoError(t, app.Shutdown())

require.NoError(t, <-serverErr)

}

func Test_App_Nested_Params(t *testing.T) {

t.Parallel()

app := New()

app.Get("/test", func(c Ctx) error {

return c.Status(400).Send([]byte("Should move on"))

})

app.Get("/test/:param", func(c Ctx) error {

return c.Status(400).Send([]byte("Should move on"))

})

app.Get("/test/:param/test", func(c Ctx) error {

return c.Status(400).Send([]byte("Should move on"))

})

app.Get("/test/:param/test/:param2", func(c Ctx) error {

return c.Status(200).Send([]byte("Good job"))

})

req := httptest.NewRequest(MethodGet, "/test/john/test/doe", http.NoBody)

resp, err := app.Test(req)

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

}

func Test_App_Use_Params(t *testing.T) {

t.Parallel()

app := New()

app.Use("/prefix/:param", func(c Ctx) error {

require.Equal(t, "john", c.Params("param"))

return nil

})

app.Use("/foo/:bar?", func(c Ctx) error {

require.Equal(t, "foobar", c.Params("bar", "foobar"))

return nil

})

app.Use("/:param/*", func(c Ctx) error {

require.Equal(t, "john", c.Params("param"))

require.Equal(t, "doe", c.Params("*"))

return nil

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/prefix/john", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/john/doe", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/foo", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, 200, resp.StatusCode, "Status code")

require.PanicsWithValue(t, "use: invalid handler func()\n", func() {

app.Use("/:param/*", func() {

// this should panic

})

})

}

func Test_App_Use_UnescapedPath(t *testing.T) {

t.Parallel()

app := New(Config{UnescapePath: true, CaseSensitive: true})

app.Use("/cRéeR/:param", func(c Ctx) error {

require.Equal(t, "/cRéeR/اختبار", c.Path())

return c.SendString(c.Params("param"))

})

app.Use("/abc", func(c Ctx) error {

require.Equal(t, "/AbC", c.Path())

return nil

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/cR%C3%A9eR/%D8%A7%D8%AE%D8%AA%D8%A8%D8%A7%D8%B1", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err, "app.Test(req)")

// check the param result

require.Equal(t, "اختبار", app.toString(body))

// with lowercase letters

resp, err = app.Test(httptest.NewRequest(MethodGet, "/cr%C3%A9er/%D8%A7%D8%AE%D8%AA%D8%A8%D8%A7%D8%B1", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusNotFound, resp.StatusCode, "Status code")

}

func Test_App_Use_CaseSensitive(t *testing.T) {

t.Parallel()

app := New(Config{CaseSensitive: true})

app.Use("/abc", func(c Ctx) error {

return c.SendString(c.Path())

})

// wrong letters in the requested route -> 404

resp, err := app.Test(httptest.NewRequest(MethodGet, "/AbC", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusNotFound, resp.StatusCode, "Status code")

// right letters in the requested route -> 200

resp, err = app.Test(httptest.NewRequest(MethodGet, "/abc", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

// check the detected path when the case-insensitive recognition is activated

app.config.CaseSensitive = false

// check the case-sensitive feature

resp, err = app.Test(httptest.NewRequest(MethodGet, "/AbC", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err, "app.Test(req)")

// check the detected path result

require.Equal(t, "/AbC", app.toString(body))

}

func Test_App_Not_Use_StrictRouting(t *testing.T) {

t.Parallel()

app := New()

app.Use("/abc", func(c Ctx) error {

return c.SendString(c.Path())

})

g := app.Group("/foo")

g.Use("/", func(c Ctx) error {

return c.SendString(c.Path())

})

// wrong path in the requested route -> 404

resp, err := app.Test(httptest.NewRequest(MethodGet, "/abc/", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

// right path in the requested route -> 200

resp, err = app.Test(httptest.NewRequest(MethodGet, "/abc", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

// wrong path with group in the requested route -> 404

resp, err = app.Test(httptest.NewRequest(MethodGet, "/foo", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

// right path with group in the requested route -> 200

resp, err = app.Test(httptest.NewRequest(MethodGet, "/foo/", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

}

func Test_App_Use_MultiplePrefix(t *testing.T) {

t.Parallel()

app := New()

app.Use([]string{"/john", "/doe"}, func(c Ctx) error {

return c.SendString(c.Path())

})

g := app.Group("/test")

g.Use([]string{"/john", "/doe"}, func(c Ctx) error {

return c.SendString(c.Path())

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/john", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

body, err := io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "/john", string(body))

resp, err = app.Test(httptest.NewRequest(MethodGet, "/doe", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

body, err = io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "/doe", string(body))

resp, err = app.Test(httptest.NewRequest(MethodGet, "/test/john", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

body, err = io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "/test/john", string(body))

resp, err = app.Test(httptest.NewRequest(MethodGet, "/test/doe", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

body, err = io.ReadAll(resp.Body)

require.NoError(t, err)

require.Equal(t, "/test/doe", string(body))

}

func Test_Group_Use_NoBoundary(t *testing.T) {

t.Parallel()

app := New()

grp := app.Group("/api")

grp.Use("/foo", func(c Ctx) error {

return c.SendStatus(StatusOK)

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/api/foo/bar", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/api/foobar", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusNotFound, resp.StatusCode, "Status code")

}

func Test_App_Use_StrictRouting(t *testing.T) {

t.Parallel()

app := New(Config{StrictRouting: true})

app.Get("/abc", func(c Ctx) error {

return c.SendString(c.Path())

})

g := app.Group("/foo")

g.Get("/", func(c Ctx) error {

return c.SendString(c.Path())

})

// wrong path in the requested route -> 404

resp, err := app.Test(httptest.NewRequest(MethodGet, "/abc/", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusNotFound, resp.StatusCode, "Status code")

// right path in the requested route -> 200

resp, err = app.Test(httptest.NewRequest(MethodGet, "/abc", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

// wrong path with group in the requested route -> 404

resp, err = app.Test(httptest.NewRequest(MethodGet, "/foo", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusNotFound, resp.StatusCode, "Status code")

// right path with group in the requested route -> 200

resp, err = app.Test(httptest.NewRequest(MethodGet, "/foo/", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

}

func Test_App_Add_Method_Test(t *testing.T) {

t.Parallel()

methods := append(DefaultMethods, "JOHN") //nolint:gocritic // We want a new slice here

app := New(Config{

RequestMethods: methods,

})

app.Add([]string{"JOHN"}, "/john", testEmptyHandler)

resp, err := app.Test(httptest.NewRequest("JOHN", "/john", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusOK, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest(MethodGet, "/john", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusMethodNotAllowed, resp.StatusCode, "Status code")

resp, err = app.Test(httptest.NewRequest("UNKNOWN", "/john", http.NoBody))

require.NoError(t, err, "app.Test(req)")

require.Equal(t, StatusNotImplemented, resp.StatusCode, "Status code")

// Add a new method

require.Panics(t, func() {

app.Add([]string{"JANE"}, "/jane", testEmptyHandler)

})

}

func Test_App_All_Method_Test(t *testing.T) {

t.Parallel()