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

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

// go test -run Test_Ctx

import (

"bufio"

"bytes"

"compress/gzip"

"context"

"crypto/tls"

"encoding/xml"

"errors"

"fmt"

"io"

"mime/multipart"

"net/http/httptest"

"net/url"

"os"

"path/filepath"

"reflect"

"strconv"

"strings"

"testing"

"text/template"

"time"

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

"github.com/gofiber/fiber/v2/utils"

"github.com/valyala/bytebufferpool"

"github.com/valyala/fasthttp"

)

// go test -run Test_Ctx_Accepts

func Test_Ctx_Accepts(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

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

utils.AssertEqual(t, "", c.Accepts(""))

utils.AssertEqual(t, "", c.Accepts())

utils.AssertEqual(t, ".xml", c.Accepts(".xml"))

utils.AssertEqual(t, "", c.Accepts(".john"))

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

utils.AssertEqual(t, "html", c.Accepts("html"))

utils.AssertEqual(t, "text/html", c.Accepts("text/html"))

utils.AssertEqual(t, "json", c.Accepts("json", "text"))

utils.AssertEqual(t, "application/json", c.Accepts("application/json"))

utils.AssertEqual(t, "", c.Accepts("image/png"))

utils.AssertEqual(t, "", c.Accepts("png"))

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

utils.AssertEqual(t, "text/*", c.Accepts("text/*"))

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

utils.AssertEqual(t, "html", c.Accepts("html"))

}

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

func Benchmark_Ctx_Accepts(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

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

var res string

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

res = c.Accepts(".xml")

}

utils.AssertEqual(b, ".xml", res)

}

// go test -run Test_Ctx_Accepts_EmptyAccept

func Test_Ctx_Accepts_EmptyAccept(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

utils.AssertEqual(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{})

defer app.ReleaseCtx(c)

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

utils.AssertEqual(t, "html", c.Accepts("html"))

utils.AssertEqual(t, "foo", c.Accepts("foo"))

utils.AssertEqual(t, ".bar", c.Accepts(".bar"))

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

utils.AssertEqual(t, "xml", c.Accepts("xml"))

}

// go test -run Test_Ctx_AcceptsCharsets

func Test_Ctx_AcceptsCharsets(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

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

utils.AssertEqual(t, "utf-8", c.AcceptsCharsets("utf-8"))

}

// 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{})

defer app.ReleaseCtx(c)

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

var res string

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

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

}

utils.AssertEqual(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{})

defer app.ReleaseCtx(c)

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

utils.AssertEqual(t, "gzip", c.AcceptsEncodings("gzip"))

utils.AssertEqual(t, "abc", c.AcceptsEncodings("abc"))

}

// 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{})

defer app.ReleaseCtx(c)

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

var res string

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

res = c.AcceptsEncodings("gzip")

}

utils.AssertEqual(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{})

defer app.ReleaseCtx(c)

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

utils.AssertEqual(t, "fr", c.AcceptsLanguages("fr"))

}

// 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{})

defer app.ReleaseCtx(c)

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()

b.ResetTimer()

for n := 0; n < b.N; n++ {

res = c.AcceptsLanguages("fr")

}

utils.AssertEqual(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{})

defer app.ReleaseCtx(c)

utils.AssertEqual(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{})

defer app.ReleaseCtx(c)

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")

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

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

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

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

utils.AssertEqual(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{})

defer app.ReleaseCtx(c)

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

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

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

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

}

utils.AssertEqual(b, "Hello, World", app.getString(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{})

defer app.ReleaseCtx(c)

// empty

c.Attachment()

utils.AssertEqual(t, `attachment`, string(c.Response().Header.Peek(HeaderContentDisposition)))

// real filename

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

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

utils.AssertEqual(t, "image/png", string(c.Response().Header.Peek(HeaderContentType)))

// check quoting

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

utils.AssertEqual(t, `attachment; filename="another+document.pdf%22%0D%0ABla%3A+%22fasel"`, string(c.Response().Header.Peek(HeaderContentDisposition)))

}

// 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{})

defer app.ReleaseCtx(c)

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

// example with quote params

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

}

utils.AssertEqual(b, `attachment; filename="another+document.pdf%22%0D%0ABla%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{})

defer app.ReleaseCtx(c)

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

utils.AssertEqual(t, "http://google.com", c.BaseURL())

// Check cache

utils.AssertEqual(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{})

defer app.ReleaseCtx(c)

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

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

var res string

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

res = c.BaseURL()

}

utils.AssertEqual(b, "http://google.com:1337", res)

}

// go test -run Test_Ctx_Body

func Test_Ctx_Body(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

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

utils.AssertEqual(t, []byte("john=doe"), c.Body())

}

// go test -run Test_Ctx_Body_With_Compression

func Test_Ctx_Body_With_Compression(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

c.Request().Header.Set("Content-Encoding", "gzip")

var b bytes.Buffer

gz := gzip.NewWriter(&b)

_, err := gz.Write([]byte("john=doe"))

utils.AssertEqual(t, nil, err)

err = gz.Flush()

utils.AssertEqual(t, nil, err)

err = gz.Close()

utils.AssertEqual(t, nil, err)

c.Request().SetBody(b.Bytes())

utils.AssertEqual(t, []byte("john=doe"), c.Body())

}

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

func Benchmark_Ctx_Body_With_Compression(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

c.Request().Header.Set("Content-Encoding", "gzip")

var buf bytes.Buffer

gz := gzip.NewWriter(&buf)

_, err := gz.Write([]byte("john=doe"))

utils.AssertEqual(b, nil, err)

err = gz.Flush()

utils.AssertEqual(b, nil, err)

err = gz.Close()

utils.AssertEqual(b, nil, err)

c.Request().SetBody(buf.Bytes())

for i := 0; i < b.N; i++ {

_ = c.Body()

}

utils.AssertEqual(b, []byte("john=doe"), c.Body())

}

// go test -run Test_Ctx_BodyParser

func Test_Ctx_BodyParser(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

type Demo struct {

Name string `json:"name" xml:"name" form:"name" query:"name"`

}

{

var gzipJSON bytes.Buffer

w := gzip.NewWriter(&gzipJSON)

_, _ = w.Write([]byte(`{"name":"john"}`))

_ = w.Close()

c.Request().Header.SetContentType(MIMEApplicationJSON)

c.Request().Header.Set(HeaderContentEncoding, "gzip")

c.Request().SetBody(gzipJSON.Bytes())

c.Request().Header.SetContentLength(len(gzipJSON.Bytes()))

d := new(Demo)

utils.AssertEqual(t, nil, c.BodyParser(d))

utils.AssertEqual(t, "john", d.Name)

c.Request().Header.Del(HeaderContentEncoding)

}

testDecodeParser := func(contentType, body string) {

c.Request().Header.SetContentType(contentType)

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

c.Request().Header.SetContentLength(len(body))

d := new(Demo)

utils.AssertEqual(t, nil, c.BodyParser(d))

utils.AssertEqual(t, "john", d.Name)

}

testDecodeParser(MIMEApplicationJSON, `{"name":"john"}`)

testDecodeParser(MIMEApplicationXML, `<Demo><name>john</name></Demo>`)

testDecodeParser(MIMEApplicationForm, "name=john")

testDecodeParser(MIMEMultipartForm+`;boundary="b"`, "--b\r\nContent-Disposition: form-data; name=\"name\"\r\n\r\njohn\r\n--b--")

testDecodeParserError := func(contentType, body string) {

c.Request().Header.SetContentType(contentType)

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

c.Request().Header.SetContentLength(len(body))

utils.AssertEqual(t, false, c.BodyParser(nil) == nil)

}

testDecodeParserError("invalid-content-type", "")

testDecodeParserError(MIMEMultipartForm+`;boundary="b"`, "--b")

type CollectionQuery struct {

Data []Demo `query:"data"`

}

c.Request().Reset()

c.Request().Header.SetContentType(MIMEApplicationForm)

c.Request().SetBody([]byte("data[0][name]=john&data[1][name]=doe"))

c.Request().Header.SetContentLength(len(c.Body()))

cq := new(CollectionQuery)

utils.AssertEqual(t, nil, c.BodyParser(cq))

utils.AssertEqual(t, 2, len(cq.Data))

utils.AssertEqual(t, "john", cq.Data[0].Name)

utils.AssertEqual(t, "doe", cq.Data[1].Name)

c.Request().Reset()

c.Request().Header.SetContentType(MIMEApplicationForm)

c.Request().SetBody([]byte("data.0.name=john&data.1.name=doe"))

c.Request().Header.SetContentLength(len(c.Body()))

cq = new(CollectionQuery)

utils.AssertEqual(t, nil, c.BodyParser(cq))

utils.AssertEqual(t, 2, len(cq.Data))

utils.AssertEqual(t, "john", cq.Data[0].Name)

utils.AssertEqual(t, "doe", cq.Data[1].Name)

}

func Test_Ctx_ParamParser(t *testing.T) {

t.Parallel()

app := New()

app.Get("/test1/:userId/role/:roleId", func(ctx *Ctx) error {

type Demo struct {

UserID uint `params:"userId"`

RoleID uint `params:"roleId"`

}

var (

d = new(Demo)

)

if err := ctx.ParamsParser(d); err != nil {

t.Fatal(err)

}

utils.AssertEqual(t, uint(111), d.UserID)

utils.AssertEqual(t, uint(222), d.RoleID)

return nil

})

_, err := app.Test(httptest.NewRequest(MethodGet, "/test1/111/role/222", nil))

utils.AssertEqual(t, nil, err)

_, err = app.Test(httptest.NewRequest(MethodGet, "/test2/111/role/222", nil))

utils.AssertEqual(t, nil, err)

}

// go test -run Test_Ctx_BodyParser_WithSetParserDecoder

func Test_Ctx_BodyParser_WithSetParserDecoder(t *testing.T) {

type CustomTime time.Time

timeConverter := func(value string) reflect.Value {

if v, err := time.Parse("2006-01-02", value); err == nil {

return reflect.ValueOf(v)

}

return reflect.Value{}

}

customTime := ParserType{

Customtype: CustomTime{},

Converter: timeConverter,

}

SetParserDecoder(ParserConfig{

IgnoreUnknownKeys: true,

ParserType: []ParserType{customTime},

ZeroEmpty: true,

SetAliasTag: "form",

})

app := New()

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

defer app.ReleaseCtx(c)

type Demo struct {

Date CustomTime `form:"date"`

Title string `form:"title"`

Body string `form:"body"`

}

testDecodeParser := func(contentType, body string) {

c.Request().Header.SetContentType(contentType)

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

c.Request().Header.SetContentLength(len(body))

d := Demo{

Title: "Existing title",

Body: "Existing Body",

}

utils.AssertEqual(t, nil, c.BodyParser(&d))

date := fmt.Sprintf("%v", d.Date)

utils.AssertEqual(t, "{0 63743587200 <nil>}", date)

utils.AssertEqual(t, "", d.Title)

utils.AssertEqual(t, "New Body", d.Body)

}

testDecodeParser(MIMEApplicationForm, "date=2020-12-15&title=&body=New Body")

testDecodeParser(MIMEMultipartForm+`; boundary="b"`, "--b\r\nContent-Disposition: form-data; name=\"date\"\r\n\r\n2020-12-15\r\n--b\r\nContent-Disposition: form-data; name=\"title\"\r\n\r\n\r\n--b\r\nContent-Disposition: form-data; name=\"body\"\r\n\r\nNew Body\r\n--b--")

}

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

func Benchmark_Ctx_BodyParser_JSON(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

type Demo struct {

Name string `json:"name"`

}

body := []byte(`{"name":"john"}`)

c.Request().SetBody(body)

c.Request().Header.SetContentType(MIMEApplicationJSON)

c.Request().Header.SetContentLength(len(body))

d := new(Demo)

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

_ = c.BodyParser(d)

}

utils.AssertEqual(b, nil, c.BodyParser(d))

utils.AssertEqual(b, "john", d.Name)

}

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

func Benchmark_Ctx_BodyParser_XML(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

type Demo struct {

Name string `xml:"name"`

}

body := []byte("<Demo><name>john</name></Demo>")

c.Request().SetBody(body)

c.Request().Header.SetContentType(MIMEApplicationXML)

c.Request().Header.SetContentLength(len(body))

d := new(Demo)

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

_ = c.BodyParser(d)

}

utils.AssertEqual(b, nil, c.BodyParser(d))

utils.AssertEqual(b, "john", d.Name)

}

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

func Benchmark_Ctx_BodyParser_Form(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

type Demo struct {

Name string `form:"name"`

}

body := []byte("name=john")

c.Request().SetBody(body)

c.Request().Header.SetContentType(MIMEApplicationForm)

c.Request().Header.SetContentLength(len(body))

d := new(Demo)

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

_ = c.BodyParser(d)

}

utils.AssertEqual(b, nil, c.BodyParser(d))

utils.AssertEqual(b, "john", d.Name)

}

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

func Benchmark_Ctx_BodyParser_MultipartForm(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

type Demo struct {

Name string `form:"name"`

}

body := []byte("--b\r\nContent-Disposition: form-data; name=\"name\"\r\n\r\njohn\r\n--b--")

c.Request().SetBody(body)

c.Request().Header.SetContentType(MIMEMultipartForm + `;boundary="b"`)

c.Request().Header.SetContentLength(len(body))

d := new(Demo)

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

_ = c.BodyParser(d)

}

utils.AssertEqual(b, nil, c.BodyParser(d))

utils.AssertEqual(b, "john", d.Name)

}

// go test -run Test_Ctx_Context

func Test_Ctx_Context(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

utils.AssertEqual(t, "*fasthttp.RequestCtx", fmt.Sprintf("%T", c.Context()))

}

// go test -run Test_Ctx_UserContext

func Test_Ctx_UserContext(t *testing.T) {

app := New()

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

defer app.ReleaseCtx(c)

t.Run("Nil_Context", func(t *testing.T) {

ctx := c.UserContext()

utils.AssertEqual(t, ctx, context.Background())

})

t.Run("ValueContext", func(t *testing.T) {

testKey := struct{}{}

testValue := "Test Value"

ctx := context.WithValue(context.Background(), testKey, testValue)

utils.AssertEqual(t, testValue, ctx.Value(testKey))

})

}

// go test -run Test_Ctx_SetUserContext

func Test_Ctx_SetUserContext(t *testing.T) {

app := New()

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

defer app.ReleaseCtx(c)

testKey := struct{}{}

testValue := "Test Value"

ctx := context.WithValue(context.Background(), testKey, testValue)

c.SetUserContext(ctx)

utils.AssertEqual(t, testValue, c.UserContext().Value(testKey))

}

// go test -run Test_Ctx_UserContext_Multiple_Requests

func Test_Ctx_UserContext_Multiple_Requests(t *testing.T) {

testKey := struct{}{}

testValue := "foobar-value"

app := New()

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

ctx := c.UserContext()

if ctx.Value(testKey) != nil {

return c.SendStatus(StatusInternalServerError)

}

input := utils.CopyString(c.Query("input", "NO_VALUE"))

ctx = context.WithValue(ctx, testKey, fmt.Sprintf("%s_%s", testValue, input))

c.SetUserContext(ctx)

return c.Status(StatusOK).SendString(fmt.Sprintf("resp_%s_returned", input))

})

// Consecutive Requests

for i := 1; i <= 10; i++ {

t.Run(fmt.Sprintf("request_%d", i), func(t *testing.T) {

resp, err := app.Test(httptest.NewRequest(MethodGet, fmt.Sprintf("/?input=%d", i), nil))

utils.AssertEqual(t, nil, err, "Unexpected error from response")

utils.AssertEqual(t, StatusOK, resp.StatusCode, "context.Context returned from c.UserContext() is reused")

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

utils.AssertEqual(t, nil, err, "Unexpected error from reading response body")

utils.AssertEqual(t, fmt.Sprintf("resp_%d_returned", i), string(b), "response text incorrect")

})

}

}

// go test -run Test_Ctx_Cookie

func Test_Ctx_Cookie(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

expire := time.Now().Add(24 * time.Hour)

var dst []byte

dst = expire.In(time.UTC).AppendFormat(dst, time.RFC1123)

httpdate := strings.ReplaceAll(string(dst), "UTC", "GMT")

cookie := &Cookie{

Name: "username",

Value: "john",

Expires: expire,

// SameSite: CookieSameSiteStrictMode, // default is "lax"

}

c.Cookie(cookie)

expect := "username=john; expires=" + httpdate + "; path=/; SameSite=Lax"

utils.AssertEqual(t, expect, string(c.Response().Header.Peek(HeaderSetCookie)))

expect = "username=john; expires=" + httpdate + "; path=/"

cookie.SameSite = CookieSameSiteDisabled

c.Cookie(cookie)

utils.AssertEqual(t, expect, string(c.Response().Header.Peek(HeaderSetCookie)))

expect = "username=john; expires=" + httpdate + "; path=/; SameSite=Strict"

cookie.SameSite = CookieSameSiteStrictMode

c.Cookie(cookie)

utils.AssertEqual(t, expect, string(c.Response().Header.Peek(HeaderSetCookie)))

expect = "username=john; expires=" + httpdate + "; path=/; secure; SameSite=None"

cookie.Secure = true

cookie.SameSite = CookieSameSiteNoneMode

c.Cookie(cookie)

utils.AssertEqual(t, expect, string(c.Response().Header.Peek(HeaderSetCookie)))

expect = "username=john; path=/; secure; SameSite=None"

// should remove expires and max-age headers

cookie.SessionOnly = true

cookie.Expires = expire

cookie.MaxAge = 10000

c.Cookie(cookie)

utils.AssertEqual(t, expect, string(c.Response().Header.Peek(HeaderSetCookie)))

}

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

func Benchmark_Ctx_Cookie(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

b.ReportAllocs()

b.ResetTimer()

for n := 0; n < b.N; n++ {

c.Cookie(&Cookie{

Name: "John",

Value: "Doe",

})

}

utils.AssertEqual(b, "John=Doe; path=/; SameSite=Lax", app.getString(c.Response().Header.Peek("Set-Cookie")))

}

// go test -run Test_Ctx_Cookies

func Test_Ctx_Cookies(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

c.Request().Header.Set("Cookie", "john=doe")

utils.AssertEqual(t, "doe", c.Cookies("john"))

utils.AssertEqual(t, "default", c.Cookies("unknown", "default"))

}

// go test -run Test_Ctx_Format

func Test_Ctx_Format(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

c.Request().Header.Set(HeaderAccept, MIMETextPlain)

err := c.Format([]byte("Hello, World!"))

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, "Hello, World!", string(c.Response().Body()))

c.Request().Header.Set(HeaderAccept, MIMETextHTML)

err = c.Format("Hello, World!")

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, "<p>Hello, World!</p>", string(c.Response().Body()))

c.Request().Header.Set(HeaderAccept, MIMEApplicationJSON)

err = c.Format("Hello, World!")

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, `"Hello, World!"`, string(c.Response().Body()))

c.Request().Header.Set(HeaderAccept, MIMETextPlain)

err = c.Format(complex(1, 1))

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, "(1+1i)", string(c.Response().Body()))

c.Request().Header.Set(HeaderAccept, MIMEApplicationXML)

err = c.Format("Hello, World!")

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, `<string>Hello, World!</string>`, string(c.Response().Body()))

err = c.Format(complex(1, 1))

utils.AssertEqual(t, true, err != nil)

c.Request().Header.Set(HeaderAccept, MIMETextPlain)

err = c.Format(Map{})

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, "map[]", string(c.Response().Body()))

type broken string

c.Request().Header.Set(HeaderAccept, "broken/accept")

err = c.Format(broken("Hello, World!"))

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, `Hello, World!`, string(c.Response().Body()))

}

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

func Benchmark_Ctx_Format(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

c.Request().Header.Set("Accept", "text/plain")

b.ReportAllocs()

b.ResetTimer()

var err error

for n := 0; n < b.N; n++ {

err = c.Format("Hello, World!")

}

utils.AssertEqual(b, nil, err)

utils.AssertEqual(b, `Hello, World!`, string(c.Response().Body()))

}

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

func Benchmark_Ctx_Format_HTML(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

c.Request().Header.Set("Accept", "text/html")

b.ReportAllocs()

b.ResetTimer()

var err error

for n := 0; n < b.N; n++ {

err = c.Format("Hello, World!")

}

utils.AssertEqual(b, nil, err)

utils.AssertEqual(b, "<p>Hello, World!</p>", string(c.Response().Body()))

}

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

func Benchmark_Ctx_Format_JSON(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

c.Request().Header.Set("Accept", "application/json")

b.ReportAllocs()

b.ResetTimer()

var err error

for n := 0; n < b.N; n++ {

err = c.Format("Hello, World!")

}

utils.AssertEqual(b, nil, err)

utils.AssertEqual(b, `"Hello, World!"`, string(c.Response().Body()))

}

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

func Benchmark_Ctx_Format_XML(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

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

b.ReportAllocs()

b.ResetTimer()

var err error

for n := 0; n < b.N; n++ {

err = c.Format("Hello, World!")

}

utils.AssertEqual(b, nil, err)

utils.AssertEqual(b, `<string>Hello, World!</string>`, string(c.Response().Body()))

}

// go test -run Test_Ctx_FormFile

func Test_Ctx_FormFile(t *testing.T) {

// TODO: We should clean this up

t.Parallel()

app := New()

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

fh, err := c.FormFile("file")

utils.AssertEqual(t, nil, err)

utils.AssertEqual(t, "test", fh.Filename)

f, err := fh.Open()

utils.AssertEqual(t, nil, err)

b := new(bytes.Buffer)

_, err = io.Copy(b, f)

utils.AssertEqual(t, nil, err)

f.Close()

utils.AssertEqual(t, "hello world", b.String())

return nil

})

body := &bytes.Buffer{}

writer := multipart.NewWriter(body)

ioWriter, err := writer.CreateFormFile("file", "test")

utils.AssertEqual(t, nil, err)

_, err = ioWriter.Write([]byte("hello world"))

utils.AssertEqual(t, nil, err)

writer.Close()

req := httptest.NewRequest(MethodPost, "/test", body)

req.Header.Set(HeaderContentType, writer.FormDataContentType())

req.Header.Set(HeaderContentLength, strconv.Itoa(len(body.Bytes())))

resp, err := app.Test(req)

utils.AssertEqual(t, nil, err, "app.Test(req)")

utils.AssertEqual(t, StatusOK, resp.StatusCode, "Status code")

}

// go test -run Test_Ctx_FormValue

func Test_Ctx_FormValue(t *testing.T) {

t.Parallel()

app := New()

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

utils.AssertEqual(t, "john", c.FormValue("name"))

return nil

})

body := &bytes.Buffer{}

writer := multipart.NewWriter(body)

utils.AssertEqual(t, nil, writer.WriteField("name", "john"))

writer.Close()

req := httptest.NewRequest(MethodPost, "/test", body)

req.Header.Set("Content-Type", fmt.Sprintf("multipart/form-data; boundary=%s", writer.Boundary()))

req.Header.Set("Content-Length", strconv.Itoa(len(body.Bytes())))

resp, err := app.Test(req)

utils.AssertEqual(t, nil, err, "app.Test(req)")

utils.AssertEqual(t, StatusOK, resp.StatusCode, "Status code")

}

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

func Benchmark_Ctx_Fresh_StaleEtag(b *testing.B) {

app := New()

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

defer app.ReleaseCtx(c)

for n := 0; n < b.N; n++ {

c.Request().Header.Set(HeaderIfNoneMatch, "a, b, c, d")

c.Request().Header.Set(HeaderCacheControl, "c")

c.Fresh()

c.Request().Header.Set(HeaderIfNoneMatch, "a, b, c, d")

c.Request().Header.Set(HeaderCacheControl, "e")

c.Fresh()

}

}

// go test -run Test_Ctx_Fresh

func Test_Ctx_Fresh(t *testing.T) {

t.Parallel()

app := New()

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

defer app.ReleaseCtx(c)

utils.AssertEqual(t, false, c.Fresh())

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

c.Request().Header.Set(HeaderCacheControl, "no-cache")

utils.AssertEqual(t, false, c.Fresh())

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

c.Request().Header.Set(HeaderCacheControl, ",no-cache,")

utils.AssertEqual(t, false, c.Fresh())

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

c.Request().Header.Set(HeaderCacheControl, "aa,no-cache,")

utils.AssertEqual(t, false, c.Fresh())

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

c.Request().Header.Set(HeaderCacheControl, ",no-cache,bb")

utils.AssertEqual(t, false, c.Fresh())

c.Request().Header.Set(HeaderIfNoneMatch, "675af34563dc-tr34")

c.Request().Header.Set(HeaderCacheControl, "public")

utils.AssertEqual(t, false, c.Fresh())

c.Request().Header.Set(HeaderIfNoneMatch, "a, b")

c.Response().Header.Set(HeaderETag, "c")

utils.AssertEqual(t, false, c.Fresh())

c.Response().Header.Set(HeaderETag, "a")

utils.AssertEqual(t, true, c.Fresh())

c.Request().Header.Set(HeaderIfModifiedSince, "xxWed, 21 Oct 2015 07:28:00 GMT")

c.Response().Header.Set(HeaderLastModified, "xxWed, 21 Oct 2015 07:28:00 GMT")

utils.AssertEqual(t, false, c.Fresh())

c.Response().Header.Set(HeaderLastModified, "Wed, 21 Oct 2015 07:28:00 GMT")

utils.AssertEqual(t, false, c.Fresh())

c.Request().Header.Set(HeaderIfModifiedSince, "Wed, 21 Oct 2015 07:28:00 GMT")

utils.AssertEqual(t, false, c.Fresh())

}

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