// ⚡️ 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"

"compress/gzip"

"compress/zlib"

"context"

"crypto/tls"

"embed"

"encoding/hex"

"encoding/xml"

"errors"

"fmt"

"io"

"math"

"mime/multipart"

"net"

"net/http"

"net/http/httptest"

"os"

"path/filepath"

"runtime"

"strconv"

"strings"

"sync/atomic"

"testing"

"text/template"

"time"

"github.com/fxamacker/cbor/v2"

"github.com/gofiber/utils/v2"

"github.com/shamaton/msgpack/v3"

"github.com/stretchr/testify/require"

"github.com/valyala/bytebufferpool"

"github.com/valyala/fasthttp"

"github.com/gofiber/fiber/v3/internal/storage/memory"

)

const epsilon = 0.001

type testContextKey struct{}

type testNetAddr struct {

network string

address string

}

func (t testNetAddr) Network() string {

return t.network

}

func (t testNetAddr) String() string {

return t.address

}

// go test -run Test_Ctx_Accepts

func Test_Ctx_Accepts(t *testing.T) {

t.Parallel()

app := New(Config{

CBOREncoder: cbor.Marshal,

CBORDecoder: cbor.Unmarshal,

})

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAccept, "text/html,application/xhtml+xml,application/xml;q=0.9")

require.Empty(t, c.Accepts(""))

require.Empty(t, c.Req().Accepts())

require.Equal(t, ".xml", c.Accepts(".xml"))

require.Empty(t, c.Accepts(".john"))

require.Equal(t, "application/xhtml+xml", c.Accepts("application/xml", "application/xml+rss", "application/yaml", "application/xhtml+xml"), "must use client-preferred mime type")

c.Request().Header.Set(HeaderAccept, "application/json, text/plain, */*;q=0")

require.Empty(t, c.Accepts("html"), "must treat */*;q=0 as not acceptable")

c.Request().Header.Set(HeaderAccept, "text/*, application/json")

require.Equal(t, "html", c.Accepts("html"))

require.Equal(t, "text/html", c.Accepts("text/html"))

require.Equal(t, "json", c.Req().Accepts("json", "text"))

require.Equal(t, "application/json", c.Accepts("application/json"))

require.Empty(t, c.Accepts("image/png"))

require.Empty(t, c.Accepts("png"))

c.Request().Header.Set(HeaderAccept, "text/html, application/json")

require.Equal(t, "text/*", c.Req().Accepts("text/*"))

c.Request().Header.Set(HeaderAccept, "*/*")

require.Equal(t, "html", c.Accepts("html"))

c.Request().Header.Del(HeaderAccept)

require.Equal(t, "json", c.Accepts("json", "html"))

require.Equal(t, "application/json", c.Accepts("application/json", "text/html"))

}

// go test -run Test_Ctx_AcceptsHelpers

func Test_Ctx_AcceptsHelpers(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAccept, "text/html,application/json;q=0.9")

require.True(t, c.AcceptsHTML())

require.True(t, c.AcceptsJSON())

require.False(t, c.AcceptsXML())

require.False(t, c.AcceptsEventStream())

c.Request().Header.Set(HeaderAccept, "application/xml")

require.True(t, c.AcceptsXML())

require.False(t, c.AcceptsJSON())

c.Request().Header.Set(HeaderAccept, "text/event-stream")

require.True(t, c.AcceptsEventStream())

}

// go test -run Test_Ctx_ContentTypeHelpers

func Test_Ctx_ContentTypeHelpers(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

require.Empty(t, c.MediaType())

require.Empty(t, c.Charset())

require.False(t, c.IsJSON())

c.Request().Header.Set(HeaderContentType, "application/json; charset=utf-8")

//nolint:testifylint // This is a MIME type string, not JSON payload.

require.Equal(t, MIMEApplicationJSON, c.MediaType())

require.Equal(t, "utf-8", c.Charset())

require.True(t, c.IsJSON())

require.False(t, c.IsForm())

require.False(t, c.IsMultipart())

c.Request().Header.Set(HeaderContentType, "text/html ; charset=\"UTF-8\"")

require.Equal(t, MIMETextHTML, c.MediaType())

require.Equal(t, "UTF-8", c.Charset())

c.Request().Header.Set(HeaderContentType, MIMEApplicationForm)

require.Equal(t, MIMEApplicationForm, c.MediaType())

require.Empty(t, c.Charset())

require.True(t, c.IsForm())

require.False(t, c.IsMultipart())

c.Request().Header.Set(HeaderContentType, MIMEMultipartForm+"; boundary=abc123")

require.Equal(t, MIMEMultipartForm, c.MediaType())

require.Empty(t, c.Charset())

require.True(t, c.IsMultipart())

require.False(t, c.IsForm())

}

// go test -run Test_Ctx_Charset

func Test_Ctx_Charset(t *testing.T) {

t.Parallel()

testCases := []struct {

name string

contentType string

expected string

}{

{

name: "no_parameters",

contentType: "text/plain",

expected: "",

},

{

name: "trailing_semicolon",

contentType: "text/plain;",

expected: "",

},

{

name: "empty_param_before_charset",

contentType: "text/plain; ; charset=utf-8",

expected: "utf-8",

},

{

name: "charset_with_spaces",

contentType: "text/plain; charset = utf-8",

expected: "utf-8",

},

{

name: "charset_in_middle",

contentType: "text/plain; foo=bar; charset=iso-8859-1; baz=qux",

expected: "iso-8859-1",

},

{

name: "charset_quoted",

contentType: "text/plain; charset=\"utf-8\"; foo=bar",

expected: "utf-8",

},

{

name: "non_charset_only",

contentType: "text/plain; foo=bar",

expected: "",

},

{

name: "missing_equals",

contentType: "text/plain; charset",

expected: "",

},

{

name: "empty_charset_value",

contentType: "text/plain; charset=",

expected: "",

},

{

name: "case_insensitive_charset",

contentType: "text/plain; chArSet=Shift_JIS",

expected: "Shift_JIS",

},

}

for _, testCase := range testCases {

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

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderContentType, testCase.contentType)

require.Equal(t, testCase.expected, c.Charset())

})

}

}

// go test -run Test_Ctx_HeaderHelpers

func Test_Ctx_HeaderHelpers(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.SetHost("example.com")

c.Request().SetRequestURI("/search?q=fiber")

require.Equal(t, "http://example.com/search?q=fiber", c.FullURL())

c.Request().Header.Set(HeaderUserAgent, "fiber-agent")

c.Request().Header.Set(HeaderReferer, "https://example.com")

c.Request().Header.Set(HeaderAcceptLanguage, "en-US,en;q=0.9")

c.Request().Header.Set(HeaderAcceptEncoding, "gzip, br")

c.Request().Header.Set("X-Trace-Id", "trace")

require.True(t, c.HasHeader("X-Trace-Id"))

require.True(t, c.HasHeader("x-trace-id"))

require.Equal(t, "fiber-agent", c.UserAgent())

require.Equal(t, "https://example.com", c.Referer())

require.Equal(t, "en-US,en;q=0.9", c.AcceptLanguage())

require.Equal(t, "gzip, br", c.AcceptEncoding())

c.Request().Header.Set(HeaderXRequestID, "request-id")

c.Response().Header.Set(HeaderXRequestID, "response-id")

require.Equal(t, "response-id", c.RequestID())

c.Response().Header.Del(HeaderXRequestID)

require.Equal(t, "request-id", c.RequestID())

c.Request().Header.Del("X-Trace-Id")

require.False(t, c.HasHeader("X-Trace-Id"))

}

// go test -run Test_Ctx_FullURL_DoesNotAliasPooledBuffer

func Test_Ctx_FullURL_DoesNotAliasPooledBuffer(t *testing.T) {

t.Parallel()

const bufferPoolReuseAttempts = 128

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.SetHost("example.com")

c.Request().SetRequestURI("/search?q=fiber")

fullURL := c.FullURL()

require.Equal(t, "http://example.com/search?q=fiber", fullURL)

for range bufferPoolReuseAttempts {

buf := bytebufferpool.Get()

buf.Reset()

buf.WriteString("https://mutated.example/rewritten")

bytebufferpool.Put(buf)

}

require.Equal(t, "http://example.com/search?q=fiber", fullURL)

}

// go test -run Test_Ctx_TypedParsingDefaults

func Test_Ctx_TypedParsingDefaults(t *testing.T) {

t.Parallel()

app := New()

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

require.Equal(t, 5, Query[int](c, "count", 1))

require.Equal(t, 9, Query[int](c, "missing", 9))

require.Equal(t, 3, Query[int](c, "bad", 3))

require.Equal(t, 42, Params[int](c, "id", 7))

require.Equal(t, 7, Params[int](c, "missing", 7))

require.Equal(t, 11, GetReqHeader[int](c, "X-Limit", 4))

require.Equal(t, 4, GetReqHeader[int](c, "X-Bad", 4))

return c.SendStatus(StatusOK)

})

req := httptest.NewRequest(MethodGet, "/42?count=5&bad=oops", http.NoBody)

req.Header.Set("X-Limit", "11")

req.Header.Set("X-Bad", "oops")

resp, err := app.Test(req)

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

defer func() { require.NoError(t, resp.Body.Close()) }()

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

}

// go test -v -run=^$ -bench=Benchmark_Ctx_Accepts -benchmem -count=4

func Benchmark_Ctx_Accepts(b *testing.B) {

app := New(Config{

CBOREncoder: cbor.Marshal,

CBORDecoder: cbor.Unmarshal,

})

c := app.AcquireCtx(&fasthttp.RequestCtx{})

acceptHeader := "text/html,application/xhtml+xml,application/xml;q=0.9"

c.Request().Header.Set("Accept", acceptHeader)

acceptValues := [][]string{

{".xml"},

{"json", "xml"},

{"application/json", "application/xml"},

}

expectedResults := []string{".xml", "xml", "application/xml"}

for i := range acceptValues {

b.Run(fmt.Sprintf("run-%#v", acceptValues[i]), func(bb *testing.B) {

var res string

bb.ReportAllocs()

for bb.Loop() {

res = c.Accepts(acceptValues[i]...)

}

require.Equal(bb, expectedResults[i], res)

})

}

}

type customCtx struct {

DefaultCtx

}

func (c *customCtx) Params(key string, defaultValue ...string) string { //revive:disable-line:unused-parameter // We need defaultValue for some cases

return "prefix_" + c.DefaultCtx.Params(key)

}

// go test -run Test_Ctx_CustomCtx

func Test_Ctx_CustomCtx(t *testing.T) {

t.Parallel()

app := NewWithCustomCtx(func(app *App) CustomCtx {

return &customCtx{

DefaultCtx: *NewDefaultCtx(app),

}

})

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

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

})

resp, err := app.Test(httptest.NewRequest(MethodGet, "/v3", &bytes.Buffer{}))

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

defer func() { require.NoError(t, resp.Body.Close()) }()

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

require.NoError(t, err, "io.ReadAll(resp.Body)")

require.Len(t, body, len("prefix_v3"))

require.Equal(t, "prefix_v3", string(body))

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

require.Equal(t, int64(len(body)), resp.ContentLength)

}

func Test_App_AcquireDefaultCtx_CustomCtxFallback(t *testing.T) {

t.Parallel()

app := New()

ctx, ok := app.prepareDefaultCtx(&customCtx{

DefaultCtx: *NewDefaultCtx(app),

}, &fasthttp.RequestCtx{})

require.False(t, ok)

require.Nil(t, ctx)

}

func Test_App_SetHandlerCtxIfNeeded_CustomCtxFallback(t *testing.T) {

t.Parallel()

app := New()

ctx := &customCtx{

DefaultCtx: *NewDefaultCtx(app),

}

app.setHandlerCtxIfNeeded(ctx)

require.Same(t, ctx, ctx.handlerCtx)

}

func Test_Ctx_Release_UserContextSetWithoutFastHTTP(t *testing.T) {

t.Parallel()

ctx := NewDefaultCtx(New())

ctx.isUserContextSet = true

require.NotPanics(t, ctx.release)

require.False(t, ctx.isUserContextSet)

}

func Test_Ctx_CustomCtx_WithMiddleware(t *testing.T) {

t.Parallel()

app := NewWithCustomCtx(func(app *App) CustomCtx {

return &customCtx{

DefaultCtx: *NewDefaultCtx(app),

}

})

app.Use(func(c Ctx) error {

_, ok := c.(*customCtx)

require.True(t, ok)

return c.Next()

})

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

custom, ok := c.(*customCtx)

require.True(t, ok)

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

})

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

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

defer func() { require.NoError(t, resp.Body.Close()) }()

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

require.NoError(t, err, "io.ReadAll(resp.Body)")

require.Equal(t, "prefix_", string(body))

}

// go test -run Test_Ctx_CustomCtx

func Test_Ctx_CustomCtx_and_Method(t *testing.T) {

t.Parallel()

// Create app with custom request methods

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

app := NewWithCustomCtx(func(app *App) CustomCtx {

return &customCtx{

DefaultCtx: *NewDefaultCtx(app),

}

}, Config{

RequestMethods: methods,

})

// Add route with custom method

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

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

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

defer func() { require.NoError(t, resp.Body.Close()) }()

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

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

require.NoError(t, err, "io.ReadAll(resp.Body)")

require.Empty(t, body)

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

require.Equal(t, int64(0), resp.ContentLength)

// Add a new method

require.Panics(t, func() {

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

})

}

// go test -run Test_Ctx_Accepts_EmptyAccept

func Test_Ctx_Accepts_EmptyAccept(t *testing.T) {

t.Parallel()

app := New(Config{

CBOREncoder: cbor.Marshal,

CBORDecoder: cbor.Unmarshal,

})

c := app.AcquireCtx(&fasthttp.RequestCtx{})

require.Equal(t, ".forwarded", c.Accepts(".forwarded"))

}

// go test -run Test_Ctx_Accepts_Wildcard

func Test_Ctx_Accepts_Wildcard(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAccept, "*/*;q=0.9")

require.Equal(t, "html", c.Accepts("html"))

require.Equal(t, "foo", c.Accepts("foo"))

require.Equal(t, ".bar", c.Accepts(".bar"))

c.Request().Header.Set(HeaderAccept, "text/html,application/*;q=0.9")

require.Equal(t, "xml", c.Accepts("xml"))

}

// go test -run Test_Ctx_Accepts_MultiHeader

func Test_Ctx_Accepts_MultiHeader(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Add(HeaderAccept, "text/plain;q=0.5")

c.Request().Header.Add(HeaderAccept, "application/json")

require.Equal(t, "application/json", c.Accepts("text/plain", "application/json"))

}

// go test -run Test_Ctx_AcceptsCharsets

func Test_Ctx_AcceptsCharsets(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAcceptCharset, "utf-8, iso-8859-1;q=0.5")

require.Equal(t, "utf-8", c.AcceptsCharsets("utf-8"))

}

// go test -run Test_Ctx_AcceptsCharsets_MultiHeader

func Test_Ctx_AcceptsCharsets_MultiHeader(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Add(HeaderAcceptCharset, "utf-8;q=0.1")

c.Request().Header.Add(HeaderAcceptCharset, "iso-8859-1")

require.Equal(t, "iso-8859-1", c.AcceptsCharsets("utf-8", "iso-8859-1"))

}

// go test -v -run=^$ -bench=Benchmark_Ctx_AcceptsCharsets -benchmem -count=4

func Benchmark_Ctx_AcceptsCharsets(b *testing.B) {

app := New()

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

c.Request().Header.Set("Accept-Charset", "utf-8, iso-8859-1;q=0.5")

var res string

b.ReportAllocs()

for b.Loop() {

res = c.AcceptsCharsets("utf-8")

}

require.Equal(b, "utf-8", res)

}

// go test -run Test_Ctx_AcceptsEncodings

func Test_Ctx_AcceptsEncodings(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAcceptEncoding, "deflate, gzip;q=1.0, *;q=0.5")

require.Equal(t, "gzip", c.AcceptsEncodings("gzip"))

require.Equal(t, "abc", c.AcceptsEncodings("abc"))

}

// go test -run Test_Ctx_AcceptsEncodings_MultiHeader

func Test_Ctx_AcceptsEncodings_MultiHeader(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Add(HeaderAcceptEncoding, "deflate;q=0.3")

c.Request().Header.Add(HeaderAcceptEncoding, "gzip")

require.Equal(t, "gzip", c.AcceptsEncodings("deflate", "gzip"))

}

// go test -v -run=^$ -bench=Benchmark_Ctx_AcceptsEncodings -benchmem -count=4

func Benchmark_Ctx_AcceptsEncodings(b *testing.B) {

app := New()

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

c.Request().Header.Set(HeaderAcceptEncoding, "deflate, gzip;q=1.0, *;q=0.5")

var res string

b.ReportAllocs()

for b.Loop() {

res = c.AcceptsEncodings("gzip")

}

require.Equal(b, "gzip", res)

}

// go test -run Test_Ctx_AcceptsLanguages

func Test_Ctx_AcceptsLanguages(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAcceptLanguage, "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5")

require.Equal(t, "fr", c.AcceptsLanguages("fr"))

}

// go test -run Test_Ctx_AcceptsLanguages_MultiHeader

func Test_Ctx_AcceptsLanguages_MultiHeader(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Add(HeaderAcceptLanguage, "de;q=0.4")

c.Request().Header.Add(HeaderAcceptLanguage, "en")

require.Equal(t, "en", c.AcceptsLanguages("de", "en"))

}

// go test -run Test_Ctx_AcceptsLanguages_BasicFiltering

func Test_Ctx_AcceptsLanguages_BasicFiltering(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAcceptLanguage, "en-US")

require.Equal(t, "en-US", c.AcceptsLanguages("en", "en-US"))

require.Empty(t, c.AcceptsLanguages("en"))

c.Request().Header.Set(HeaderAcceptLanguage, "en-US, fr")

require.Equal(t, "en-US", c.AcceptsLanguages("de", "en-US", "fr"))

c.Request().Header.Set(HeaderAcceptLanguage, "en")

require.Equal(t, "en-US", c.AcceptsLanguages("en-US"))

c.Request().Header.Set(HeaderAcceptLanguage, "*")

require.Equal(t, "en", c.AcceptsLanguages("en", "fr"))

c.Request().Header.Set(HeaderAcceptLanguage, "en_US")

require.Empty(t, c.AcceptsLanguages("en-US"))

c.Request().Header.Set(HeaderAcceptLanguage, "en-*")

require.Empty(t, c.AcceptsLanguages("en-US"))

}

// go test -run Test_Ctx_AcceptsLanguages_CaseInsensitive

func Test_Ctx_AcceptsLanguages_CaseInsensitive(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAcceptLanguage, "EN-us")

require.Equal(t, "en-US", c.AcceptsLanguages("en-US"))

}

// go test -run Test_Ctx_AcceptsLanguagesExtended

func Test_Ctx_AcceptsLanguagesExtended(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().Header.Set(HeaderAcceptLanguage, "en-*")

require.Equal(t, "en-US", c.AcceptsLanguagesExtended("en-US"))

c.Request().Header.Set(HeaderAcceptLanguage, "*-US")

require.Equal(t, "en-US", c.AcceptsLanguagesExtended("en-US", "fr-CA"))

c.Request().Header.Set(HeaderAcceptLanguage, "en-US-*")

require.Equal(t, "en-US", c.AcceptsLanguagesExtended("en-US"))

c.Request().Header.Set(HeaderAcceptLanguage, "en")

require.Equal(t, "en-US", c.AcceptsLanguagesExtended("en-US"))

c.Request().Header.Set(HeaderAcceptLanguage, "*")

require.Equal(t, "en-US", c.AcceptsLanguagesExtended("en-US", "fr-CA"))

c.Request().Header.Set(HeaderAcceptLanguage, "en-US")

require.Equal(t, "en-US-CA", c.AcceptsLanguagesExtended("en-US-CA"))

c.Request().Header.Set(HeaderAcceptLanguage, "en-*")

require.Equal(t, "en-US-CA", c.AcceptsLanguagesExtended("en-US-CA"))

}

// go test -v -run=^$ -bench=Benchmark_Ctx_AcceptsLanguages -benchmem -count=4

func Benchmark_Ctx_AcceptsLanguages(b *testing.B) {

app := New()

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

c.Request().Header.Set(HeaderAcceptLanguage, "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5")

var res string

b.ReportAllocs()

for b.Loop() {

res = c.AcceptsLanguages("fr")

}

require.Equal(b, "fr", res)

}

// go test -run Test_Ctx_App

func Test_Ctx_App(t *testing.T) {

t.Parallel()

app := New()

app.config.BodyLimit = 1000

c := app.AcquireCtx(&fasthttp.RequestCtx{})

require.Equal(t, 1000, c.App().config.BodyLimit)

}

// go test -run Test_Ctx_Append

func Test_Ctx_Append(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Append("X-Test", "Hello")

c.Append("X-Test", "World")

c.Append("X-Test", "Hello", "World")

// similar value in the middle

c.Append("X2-Test", "World")

c.Append("X2-Test", "XHello")

c.Append("X2-Test", "Hello", "World")

// similar value at the start

c.Append("X3-Test", "XHello")

c.Append("X3-Test", "World")

c.Append("X3-Test", "Hello", "World")

// try it with multiple similar values

c.Append("X4-Test", "XHello")

c.Append("X4-Test", "Hello")

c.Append("X4-Test", "HelloZ")

c.Append("X4-Test", "YHello")

c.Append("X4-Test", "Hello")

c.Append("X4-Test", "YHello")

c.Append("X4-Test", "HelloZ")

c.Append("X4-Test", "XHello")

// without append value

c.Append("X-Custom-Header")

require.Equal(t, "Hello, World", string(c.Response().Header.Peek("X-Test")))

require.Equal(t, "World, XHello, Hello", string(c.Response().Header.Peek("X2-Test")))

require.Equal(t, "XHello, World, Hello", string(c.Response().Header.Peek("X3-Test")))

require.Equal(t, "XHello, Hello, HelloZ, YHello", string(c.Response().Header.Peek("X4-Test")))

require.Empty(t, string(c.Response().Header.Peek("x-custom-header")))

}

// go test -v -run=^$ -bench=Benchmark_Ctx_Append -benchmem -count=4

func Benchmark_Ctx_Append(b *testing.B) {

app := New()

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

b.ReportAllocs()

for b.Loop() {

c.Append("X-Custom-Header", "Hello")

c.Append("X-Custom-Header", "World")

c.Append("X-Custom-Header", "Hello")

}

require.Equal(b, "Hello, World", app.toString(c.Response().Header.Peek("X-Custom-Header")))

}

// go test -run Test_Ctx_Attachment

func Test_Ctx_Attachment(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

// empty

c.Attachment()

require.Equal(t, `attachment`, string(c.Response().Header.Peek(HeaderContentDisposition)))

// real filename

c.Attachment("./static/img/logo.png")

require.Equal(t, `attachment; filename="logo.png"`, string(c.Response().Header.Peek(HeaderContentDisposition)))

require.Equal(t, "image/png", string(c.Response().Header.Peek(HeaderContentType)))

// filename with spaces

c.Attachment("report 2024.txt")

require.Equal(t, `attachment; filename="report+2024.txt"`, string(c.Response().Header.Peek(HeaderContentDisposition)))

// filename with nested path

c.Attachment("../docs/archive.tar.gz")

require.Equal(t, `attachment; filename="archive.tar.gz"`, string(c.Response().Header.Peek(HeaderContentDisposition)))

// check quoting

c.Attachment("another document.pdf\"\r\nBla: \"fasel")

require.Equal(t, `attachment; filename="another+document.pdf%22Bla%3A+%22fasel"`, string(c.Response().Header.Peek(HeaderContentDisposition)))

c.Attachment("файл.txt")

header := string(c.Response().Header.Peek(HeaderContentDisposition))

require.Contains(t, header, `filename="файл.txt"`)

require.Contains(t, header, `filename*=UTF-8''%D1%84%D0%B0%D0%B9%D0%BB.txt`)

}

// go test -run Test_Ctx_Attachment_SanitizesFilenameControls

func Test_Ctx_Attachment_SanitizesFilenameControls(t *testing.T) {

t.Parallel()

app := New()

testCases := []struct {

name string

filename string

expected string

}{

{

name: "base name only",

filename: "../docs/archive.tar.gz",

expected: `attachment; filename="archive.tar.gz"`,

},

{

name: "controls stripped",

filename: "down\r\nload\t\x00.txt",

expected: `attachment; filename="download.txt"`,

},

{

name: "controls stripped without extension",

filename: "report\r\n\t\x00",

expected: `attachment; filename="report"`,

},

{

name: "empty after sanitize",

filename: "\r\n\t\x00",

expected: `attachment; filename="download"`,

},

{

name: "controls stripped in middle",

filename: "file\rname\n\t\x00.bin",

expected: `attachment; filename="filename.bin"`,

},

{

name: "dot fallback",

filename: ".",

expected: `attachment; filename="download"`,

},

}

for _, tc := range testCases {

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

t.Parallel()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Attachment(tc.filename)

header := string(c.Response().Header.Peek(HeaderContentDisposition))

require.Equal(t, tc.expected, header)

require.NotContains(t, header, "\r")

require.NotContains(t, header, "\n")

require.NotContains(t, header, "\t")

require.NotContains(t, header, "\x00")

})

}

}

// go test -v -run=^$ -bench=Benchmark_Ctx_Attachment -benchmem -count=4

func Benchmark_Ctx_Attachment(b *testing.B) {

app := New()

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

b.ReportAllocs()

for b.Loop() {

// example with quote params

c.Attachment("another document.pdf\"\r\nBla: \"fasel")

}

require.Equal(b, `attachment; filename="another+document.pdf%22Bla%3A+%22fasel"`, string(c.Response().Header.Peek(HeaderContentDisposition)))

}

// go test -run Test_Ctx_BaseURL

func Test_Ctx_BaseURL(t *testing.T) {

t.Parallel()

app := New()

c := app.AcquireCtx(&fasthttp.RequestCtx{})

c.Request().SetRequestURI("http://google.com/test")

require.Equal(t, "http://google.com", c.BaseURL())

// Check cache

require.Equal(t, "http://google.com", c.BaseURL())

}

// go test -v -run=^$ -bench=Benchmark_Ctx_BaseURL -benchmem

func Benchmark_Ctx_BaseURL(b *testing.B) {

app := New()

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

c.Request().SetHost("google.com:1337")

c.Request().URI().SetPath("/haha/oke/lol")

var res string

b.ReportAllocs()

for b.Loop() {

res = c.BaseURL()

}

require.Equal(b, "http://google.com:1337", res)

}

func Benchmark_Ctx_BaseURL_Uncached(b *testing.B) {

app := New()

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

c.Request().SetHost("google.com:1337")

c.Request().URI().SetPath("/haha/oke/lol")

var res string

b.ReportAllocs()

for b.Loop() {

c.baseURI = ""

res = c.BaseURL()

}

require.Equal(b, "http://google.com:1337", res)

}

func Benchmark_Ctx_FullURL(b *testing.B) {

app := New()

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

c.Request().SetRequestURI("/haha/oke/lol?name=fiber")

c.Request().URI().SetHost("google.com:1337")

var res string

b.ReportAllocs()

for b.Loop() {

res = c.FullURL()

}

require.Equal(b, "http://google.com:1337/haha/oke/lol?name=fiber", res)

}

// go test -run Test_Ctx_Body

func Test_Ctx_Body(t *testing.T) {

t.Parallel()

app := New()

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

c.Request().SetBody([]byte("john=doe"))

require.Equal(t, []byte("john=doe"), c.Body())

}

// go test -run Test_Ctx_BodyRaw

func Test_Ctx_BodyRaw(t *testing.T) {

t.Parallel()

app := New()

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

c.Request().SetBodyRaw([]byte("john=doe"))

require.Equal(t, []byte("john=doe"), c.BodyRaw())

}

// go test -run Test_Ctx_BodyRaw_Immutable

func Test_Ctx_BodyRaw_Immutable(t *testing.T) {

t.Parallel()

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

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

c.Request().SetBodyRaw([]byte("john=doe"))

require.Equal(t, []byte("john=doe"), c.BodyRaw())

}

// go test -v -run=^$ -bench=Benchmark_Ctx_Body -benchmem -count=4

func Benchmark_Ctx_Body(b *testing.B) {

const input = "john=doe"

app := New()

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

c.Request().SetBody([]byte(input))

b.ReportAllocs()

for b.Loop() {

_ = c.Body()

}

require.Equal(b, []byte(input), c.Body())

}

// go test -v -run=^$ -bench=Benchmark_Ctx_BodyRaw -benchmem -count=4

func Benchmark_Ctx_BodyRaw(b *testing.B) {

const input = "john=doe"

app := New()

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

c.Request().SetBodyRaw([]byte(input))

b.ReportAllocs()

for b.Loop() {

_ = c.BodyRaw()

}

require.Equal(b, []byte(input), c.BodyRaw())

}

// go test -v -run=^$ -bench=Benchmark_Ctx_BodyRaw_Immutable -benchmem -count=4

func Benchmark_Ctx_BodyRaw_Immutable(b *testing.B) {

const input = "john=doe"

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

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

c.Request().SetBodyRaw([]byte(input))

b.ReportAllocs()

for b.Loop() {

_ = c.BodyRaw()

}

require.Equal(b, []byte(input), c.BodyRaw())

}

// go test -run Test_Ctx_Body_Immutable

func Test_Ctx_Body_Immutable(t *testing.T) {

t.Parallel()

app := New()

app.config.Immutable = true

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

c.Request().SetBody([]byte("john=doe"))

require.Equal(t, []byte("john=doe"), c.Body())

}

// go test -v -run=^$ -bench=Benchmark_Ctx_Body_Immutable -benchmem -count=4

func Benchmark_Ctx_Body_Immutable(b *testing.B) {

const input = "john=doe"

app := New()

app.config.Immutable = true

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

c.Request().SetBody([]byte(input))

b.ReportAllocs()

for b.Loop() {

_ = c.Body()

}