mirror of
https://github.com/gin-gonic/gin.git
synced 2026-11-21 01:43:38 +08:00
getValue resliced the backtrack stack to index+1 on the assumption that its capacity equals Engine.maxSections. The pool captures that capacity at allocation. Routes registered afterwards raise maxSections without resizing the pooled slice. The next request that needs one more frame panics inside the router, before Recovery. append grows the slice when the captured capacity is short and preserves the existing backtrack behaviour when it is already sufficient. The reset at entry stays: getValue still runs once per method tree on the same stack. Co-authored-by: hazyhaar <hazyhaarlabs@gmail.com> Co-authored-by: Bo-Yi Wu <appleboy.tw@gmail.com>
970 lines
30 KiB
Go
970 lines
30 KiB
Go
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
|
// Use of this source code is governed by a MIT style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package gin
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type header struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
|
|
// PerformRequest for testing gin router.
|
|
func PerformRequest(r http.Handler, method, path string, headers ...header) *httptest.ResponseRecorder {
|
|
req := httptest.NewRequest(method, path, nil)
|
|
for _, h := range headers {
|
|
req.Header.Add(h.Key, h.Value)
|
|
}
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
return w
|
|
}
|
|
|
|
func testRouteOK(method string, t *testing.T) {
|
|
passed := false
|
|
passedAny := false
|
|
r := New()
|
|
r.Any("/test2", func(c *Context) {
|
|
passedAny = true
|
|
})
|
|
r.Handle(method, "/test", func(c *Context) {
|
|
passed = true
|
|
})
|
|
|
|
w := PerformRequest(r, method, "/test")
|
|
assert.True(t, passed)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
PerformRequest(r, method, "/test2")
|
|
assert.True(t, passedAny)
|
|
}
|
|
|
|
// testRouteNotOK tests that a request with the wrong method returns a not found response.
|
|
func testRouteNotOK(method string, t *testing.T) {
|
|
passed := false
|
|
router := New()
|
|
router.Handle(method, "/test_2", func(c *Context) {
|
|
passed = true
|
|
})
|
|
|
|
w := PerformRequest(router, method, "/test")
|
|
|
|
assert.False(t, passed)
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
}
|
|
|
|
// testRouteNotOK2 tests that a request with the wrong method returns a method not allowed response.
|
|
func testRouteNotOK2(method string, t *testing.T) {
|
|
passed := false
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
var methodRoute string
|
|
if method == http.MethodPost {
|
|
methodRoute = http.MethodGet
|
|
} else {
|
|
methodRoute = http.MethodPost
|
|
}
|
|
router.Handle(methodRoute, "/test", func(c *Context) {
|
|
passed = true
|
|
})
|
|
|
|
w := PerformRequest(router, method, "/test")
|
|
|
|
assert.False(t, passed)
|
|
assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
|
|
}
|
|
|
|
// TestRouteQuery tests that a QUERY route is invoked and can read the request
|
|
// body, which is the whole point of the method (RFC 10008).
|
|
func TestRouteQuery(t *testing.T) {
|
|
type search struct {
|
|
Term string `json:"term"`
|
|
}
|
|
|
|
router := New()
|
|
router.QUERY("/search", func(c *Context) {
|
|
var body search
|
|
require.NoError(t, c.ShouldBindJSON(&body))
|
|
c.String(http.StatusOK, body.Term)
|
|
})
|
|
|
|
req := httptest.NewRequest(MethodQuery, "/search", strings.NewReader(`{"term":"gin"}`))
|
|
req.Header.Set("Content-Type", MIMEJSON)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, "gin", w.Body.String())
|
|
}
|
|
|
|
// TestRouteQueryRegisteredByAny documents that Any registers QUERY.
|
|
func TestRouteQueryRegisteredByAny(t *testing.T) {
|
|
router := New()
|
|
router.Any("/test", func(c *Context) {
|
|
c.Status(http.StatusOK)
|
|
})
|
|
|
|
w := PerformRequest(router, MethodQuery, "/test")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
}
|
|
|
|
// TestQueryRoutesInterface tests that a router reached through IRoutes can
|
|
// still register a QUERY route via the IQueryRoutes assertion.
|
|
func TestQueryRoutesInterface(t *testing.T) {
|
|
router := New()
|
|
|
|
var routes IRoutes = router.Group("/v1")
|
|
queryRoutes, ok := routes.(IQueryRoutes)
|
|
require.True(t, ok)
|
|
|
|
queryRoutes.QUERY("/search", func(c *Context) {
|
|
c.Status(http.StatusOK)
|
|
})
|
|
|
|
w := PerformRequest(router, MethodQuery, "/v1/search")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
}
|
|
|
|
func TestRouterMethod(t *testing.T) {
|
|
router := New()
|
|
router.PUT("/hey2", func(c *Context) {
|
|
c.String(http.StatusOK, "sup2")
|
|
})
|
|
|
|
router.PUT("/hey", func(c *Context) {
|
|
c.String(http.StatusOK, "called")
|
|
})
|
|
|
|
router.PUT("/hey3", func(c *Context) {
|
|
c.String(http.StatusOK, "sup3")
|
|
})
|
|
|
|
w := PerformRequest(router, http.MethodPut, "/hey")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, "called", w.Body.String())
|
|
}
|
|
|
|
func TestRouterGroupRouteOK(t *testing.T) {
|
|
testRouteOK(http.MethodGet, t)
|
|
testRouteOK(http.MethodPost, t)
|
|
testRouteOK(http.MethodPut, t)
|
|
testRouteOK(http.MethodPatch, t)
|
|
testRouteOK(http.MethodHead, t)
|
|
testRouteOK(http.MethodOptions, t)
|
|
testRouteOK(http.MethodDelete, t)
|
|
testRouteOK(http.MethodConnect, t)
|
|
testRouteOK(http.MethodTrace, t)
|
|
testRouteOK(MethodQuery, t)
|
|
}
|
|
|
|
func TestRouteNotOK(t *testing.T) {
|
|
testRouteNotOK(http.MethodGet, t)
|
|
testRouteNotOK(http.MethodPost, t)
|
|
testRouteNotOK(http.MethodPut, t)
|
|
testRouteNotOK(http.MethodPatch, t)
|
|
testRouteNotOK(http.MethodHead, t)
|
|
testRouteNotOK(http.MethodOptions, t)
|
|
testRouteNotOK(http.MethodDelete, t)
|
|
testRouteNotOK(http.MethodConnect, t)
|
|
testRouteNotOK(http.MethodTrace, t)
|
|
testRouteNotOK(MethodQuery, t)
|
|
}
|
|
|
|
func TestRouteNotOK2(t *testing.T) {
|
|
testRouteNotOK2(http.MethodGet, t)
|
|
testRouteNotOK2(http.MethodPost, t)
|
|
testRouteNotOK2(http.MethodPut, t)
|
|
testRouteNotOK2(http.MethodPatch, t)
|
|
testRouteNotOK2(http.MethodHead, t)
|
|
testRouteNotOK2(http.MethodOptions, t)
|
|
testRouteNotOK2(http.MethodDelete, t)
|
|
testRouteNotOK2(http.MethodConnect, t)
|
|
testRouteNotOK2(http.MethodTrace, t)
|
|
testRouteNotOK2(MethodQuery, t)
|
|
}
|
|
|
|
func TestRouteRedirectTrailingSlash(t *testing.T) {
|
|
router := New()
|
|
router.RedirectFixedPath = false
|
|
router.RedirectTrailingSlash = true
|
|
router.GET("/path", func(c *Context) {})
|
|
router.GET("/path2/", func(c *Context) {})
|
|
router.POST("/path3", func(c *Context) {})
|
|
router.PUT("/path4/", func(c *Context) {})
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/path/")
|
|
assert.Equal(t, "/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2")
|
|
assert.Equal(t, "/path2/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodPost, "/path3/")
|
|
assert.Equal(t, "/path3", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodPut, "/path4")
|
|
assert.Equal(t, "/path4/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path")
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2/")
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodPost, "/path3")
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodPut, "/path4/")
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2", header{Key: "X-Forwarded-Prefix", Value: "/api"})
|
|
assert.Equal(t, "/api/path2/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2/", header{Key: "X-Forwarded-Prefix", Value: "/api/"})
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "../../api#?"})
|
|
assert.Equal(t, "/api/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "../../api"})
|
|
assert.Equal(t, "/api/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2", header{Key: "X-Forwarded-Prefix", Value: "../../api"})
|
|
assert.Equal(t, "/api/path2/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2", header{Key: "X-Forwarded-Prefix", Value: "/../../api"})
|
|
assert.Equal(t, "/api/path2/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "api/../../"})
|
|
assert.Equal(t, "//path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "api/../../../"})
|
|
assert.Equal(t, "/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2", header{Key: "X-Forwarded-Prefix", Value: "../../gin-gonic.com"})
|
|
assert.Equal(t, "/gin-goniccom/path2/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2", header{Key: "X-Forwarded-Prefix", Value: "/../../gin-gonic.com"})
|
|
assert.Equal(t, "/gin-goniccom/path2/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "https://gin-gonic.com/#"})
|
|
assert.Equal(t, "https/gin-goniccom/https/gin-goniccom/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "#api"})
|
|
assert.Equal(t, "api/api/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "/nor-mal/#?a=1"})
|
|
assert.Equal(t, "/nor-mal/a1/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/", header{Key: "X-Forwarded-Prefix", Value: "/nor-mal/%2e%2e/"})
|
|
assert.Equal(t, "/nor-mal/2e2e/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
router.RedirectTrailingSlash = false
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path/")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
w = PerformRequest(router, http.MethodGet, "/path2")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
w = PerformRequest(router, http.MethodPost, "/path3/")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
w = PerformRequest(router, http.MethodPut, "/path4")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
}
|
|
|
|
func TestRouteRedirectFixedPath(t *testing.T) {
|
|
router := New()
|
|
router.RedirectFixedPath = true
|
|
router.RedirectTrailingSlash = false
|
|
|
|
router.GET("/path", func(c *Context) {})
|
|
router.GET("/Path2", func(c *Context) {})
|
|
router.POST("/PATH3", func(c *Context) {})
|
|
router.POST("/Path4/", func(c *Context) {})
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/PATH")
|
|
assert.Equal(t, "/path", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/path2")
|
|
assert.Equal(t, "/Path2", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusMovedPermanently, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodPost, "/path3")
|
|
assert.Equal(t, "/PATH3", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
|
|
|
|
w = PerformRequest(router, http.MethodPost, "/path4")
|
|
assert.Equal(t, "/Path4/", w.Header().Get("Location"))
|
|
assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
|
|
}
|
|
|
|
// TestRouteParamsByName tests that route parameters can be parsed by name.
|
|
func TestRouteParamsByName(t *testing.T) {
|
|
name := ""
|
|
lastName := ""
|
|
wild := ""
|
|
router := New()
|
|
router.GET("/test/:name/:last_name/*wild", func(c *Context) {
|
|
name = c.Params.ByName("name")
|
|
lastName = c.Params.ByName("last_name")
|
|
var ok bool
|
|
wild, ok = c.Params.Get("wild")
|
|
|
|
assert.True(t, ok)
|
|
assert.Equal(t, name, c.Param("name"))
|
|
assert.Equal(t, lastName, c.Param("last_name"))
|
|
|
|
assert.Empty(t, c.Param("wtf"))
|
|
assert.Empty(t, c.Params.ByName("wtf"))
|
|
|
|
wtf, ok := c.Params.Get("wtf")
|
|
assert.Empty(t, wtf)
|
|
assert.False(t, ok)
|
|
})
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/test/john/smith/is/super/great")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, "john", name)
|
|
assert.Equal(t, "smith", lastName)
|
|
assert.Equal(t, "/is/super/great", wild)
|
|
}
|
|
|
|
// TestRouteParamsByNameWithExtraSlash tests that route parameters can be parsed by name even with extra slashes.
|
|
func TestRouteParamsByNameWithExtraSlash(t *testing.T) {
|
|
name := ""
|
|
lastName := ""
|
|
wild := ""
|
|
router := New()
|
|
router.RemoveExtraSlash = true
|
|
router.GET("/test/:name/:last_name/*wild", func(c *Context) {
|
|
name = c.Params.ByName("name")
|
|
lastName = c.Params.ByName("last_name")
|
|
var ok bool
|
|
wild, ok = c.Params.Get("wild")
|
|
|
|
assert.True(t, ok)
|
|
assert.Equal(t, name, c.Param("name"))
|
|
assert.Equal(t, lastName, c.Param("last_name"))
|
|
|
|
assert.Empty(t, c.Param("wtf"))
|
|
assert.Empty(t, c.Params.ByName("wtf"))
|
|
|
|
wtf, ok := c.Params.Get("wtf")
|
|
assert.Empty(t, wtf)
|
|
assert.False(t, ok)
|
|
})
|
|
|
|
w := PerformRequest(router, http.MethodGet, "//test//john//smith//is//super//great")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, "john", name)
|
|
assert.Equal(t, "smith", lastName)
|
|
assert.Equal(t, "/is/super/great", wild)
|
|
}
|
|
|
|
// TestRouteParamsNotEmpty tests that context parameters will be set
|
|
// even if a route with params/wildcards is registered after the context
|
|
// initialisation (which happened in a previous requests).
|
|
func TestRouteParamsNotEmpty(t *testing.T) {
|
|
name := ""
|
|
lastName := ""
|
|
wild := ""
|
|
router := New()
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/test/john/smith/is/super/great")
|
|
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
|
|
router.GET("/test/:name/:last_name/*wild", func(c *Context) {
|
|
name = c.Params.ByName("name")
|
|
lastName = c.Params.ByName("last_name")
|
|
var ok bool
|
|
wild, ok = c.Params.Get("wild")
|
|
|
|
assert.True(t, ok)
|
|
assert.Equal(t, name, c.Param("name"))
|
|
assert.Equal(t, lastName, c.Param("last_name"))
|
|
|
|
assert.Empty(t, c.Param("wtf"))
|
|
assert.Empty(t, c.Params.ByName("wtf"))
|
|
|
|
wtf, ok := c.Params.Get("wtf")
|
|
assert.Empty(t, wtf)
|
|
assert.False(t, ok)
|
|
})
|
|
|
|
w = PerformRequest(router, http.MethodGet, "/test/john/smith/is/super/great")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, "john", name)
|
|
assert.Equal(t, "smith", lastName)
|
|
assert.Equal(t, "/is/super/great", wild)
|
|
}
|
|
|
|
// TestRouteStaticFile tests that a static file is served correctly.
|
|
func TestRouteStaticFile(t *testing.T) {
|
|
// SETUP file
|
|
testRoot, _ := os.Getwd()
|
|
f, err := os.CreateTemp(testRoot, "")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
defer os.Remove(f.Name())
|
|
_, err = f.WriteString("Gin Web Framework")
|
|
require.NoError(t, err)
|
|
f.Close()
|
|
|
|
dir, filename := filepath.Split(f.Name())
|
|
|
|
// SETUP gin
|
|
router := New()
|
|
router.Static("/using_static", dir)
|
|
router.StaticFile("/result", f.Name())
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/using_static/"+filename)
|
|
w2 := PerformRequest(router, http.MethodGet, "/result")
|
|
|
|
assert.Equal(t, w, w2)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, "Gin Web Framework", w.Body.String())
|
|
assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
|
|
|
|
w3 := PerformRequest(router, http.MethodHead, "/using_static/"+filename)
|
|
w4 := PerformRequest(router, http.MethodHead, "/result")
|
|
|
|
assert.Equal(t, w3, w4)
|
|
assert.Equal(t, http.StatusOK, w3.Code)
|
|
}
|
|
|
|
// TestRouteStaticFileFS tests that a static file from an http.FileSystem is served correctly.
|
|
func TestRouteStaticFileFS(t *testing.T) {
|
|
// SETUP file
|
|
testRoot, _ := os.Getwd()
|
|
f, err := os.CreateTemp(testRoot, "")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
defer os.Remove(f.Name())
|
|
_, err = f.WriteString("Gin Web Framework")
|
|
require.NoError(t, err)
|
|
f.Close()
|
|
|
|
dir, filename := filepath.Split(f.Name())
|
|
// SETUP gin
|
|
router := New()
|
|
router.Static("/using_static", dir)
|
|
router.StaticFileFS("/result_fs", filename, Dir(dir, false))
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/using_static/"+filename)
|
|
w2 := PerformRequest(router, http.MethodGet, "/result_fs")
|
|
|
|
assert.Equal(t, w, w2)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, "Gin Web Framework", w.Body.String())
|
|
assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
|
|
|
|
w3 := PerformRequest(router, http.MethodHead, "/using_static/"+filename)
|
|
w4 := PerformRequest(router, http.MethodHead, "/result_fs")
|
|
|
|
assert.Equal(t, w3, w4)
|
|
assert.Equal(t, http.StatusOK, w3.Code)
|
|
}
|
|
|
|
// TestRouteStaticListingDir tests that static directory listing is enabled when configured.
|
|
func TestRouteStaticListingDir(t *testing.T) {
|
|
router := New()
|
|
router.StaticFS("/", Dir("./", true))
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Contains(t, w.Body.String(), "gin.go")
|
|
assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
|
|
}
|
|
|
|
// TestRouteStaticNoListing tests that static directory listing is disabled by default.
|
|
func TestRouteStaticNoListing(t *testing.T) {
|
|
router := New()
|
|
router.Static("/", "./")
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/")
|
|
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
assert.NotContains(t, w.Body.String(), "gin.go")
|
|
}
|
|
|
|
func TestRouterMiddlewareAndStatic(t *testing.T) {
|
|
router := New()
|
|
static := router.Group("/", func(c *Context) {
|
|
c.Writer.Header().Add("Last-Modified", "Mon, 02 Jan 2006 15:04:05 MST")
|
|
c.Writer.Header().Add("Expires", "Mon, 02 Jan 2006 15:04:05 MST")
|
|
c.Writer.Header().Add("X-GIN", "Gin Framework")
|
|
})
|
|
static.Static("/", "./")
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/gin.go")
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Contains(t, w.Body.String(), "package gin")
|
|
// Content-Type='text/plain; charset=utf-8' when go version <= 1.16,
|
|
// else, Content-Type='text/x-go; charset=utf-8'
|
|
assert.NotEmpty(t, w.Header().Get("Content-Type"))
|
|
assert.NotEqual(t, "Mon, 02 Jan 2006 15:04:05 MST", w.Header().Get("Last-Modified"))
|
|
assert.Equal(t, "Mon, 02 Jan 2006 15:04:05 MST", w.Header().Get("Expires"))
|
|
assert.Equal(t, "Gin Framework", w.Header().Get("x-GIN"))
|
|
}
|
|
|
|
func TestRouteNotAllowedEnabled(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
router.POST("/path", func(c *Context) {})
|
|
w := PerformRequest(router, http.MethodGet, "/path")
|
|
assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
|
|
|
|
router.NoMethod(func(c *Context) {
|
|
c.String(http.StatusTeapot, "responseText")
|
|
})
|
|
w = PerformRequest(router, http.MethodGet, "/path")
|
|
assert.Equal(t, "responseText", w.Body.String())
|
|
assert.Equal(t, http.StatusTeapot, w.Code)
|
|
}
|
|
|
|
func TestRouteNotAllowedEnabled2(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
// add one methodTree to trees
|
|
router.addRoute(http.MethodPost, "/", HandlersChain{func(_ *Context) {}})
|
|
router.GET("/path2", func(c *Context) {})
|
|
w := PerformRequest(router, http.MethodPost, "/path2")
|
|
assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
|
|
}
|
|
|
|
func TestRouteNotAllowedEnabled3(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
router.GET("/path", func(c *Context) {})
|
|
router.POST("/path", func(c *Context) {})
|
|
w := PerformRequest(router, http.MethodPut, "/path")
|
|
assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
|
|
allowed := w.Header().Get("Allow")
|
|
assert.Contains(t, allowed, http.MethodGet)
|
|
assert.Contains(t, allowed, http.MethodPost)
|
|
}
|
|
|
|
func TestRouteNotAllowedDisabled(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = false
|
|
router.POST("/path", func(c *Context) {})
|
|
w := PerformRequest(router, http.MethodGet, "/path")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
|
|
router.NoMethod(func(c *Context) {
|
|
c.String(http.StatusTeapot, "responseText")
|
|
})
|
|
w = PerformRequest(router, http.MethodGet, "/path")
|
|
assert.Equal(t, "404 page not found", w.Body.String())
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
}
|
|
|
|
func TestRouterNotFoundWithRemoveExtraSlash(t *testing.T) {
|
|
router := New()
|
|
router.RemoveExtraSlash = true
|
|
router.GET("/path", func(c *Context) {})
|
|
router.GET("/", func(c *Context) {})
|
|
|
|
testRoutes := []struct {
|
|
route string
|
|
code int
|
|
location string
|
|
}{
|
|
{"/../path", http.StatusOK, ""}, // CleanPath
|
|
{"/nope", http.StatusNotFound, ""}, // NotFound
|
|
}
|
|
for _, tr := range testRoutes {
|
|
w := PerformRequest(router, http.MethodGet, tr.route)
|
|
assert.Equal(t, tr.code, w.Code)
|
|
if w.Code != http.StatusNotFound {
|
|
assert.Equal(t, tr.location, w.Header().Get("Location"))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRouterNotFound(t *testing.T) {
|
|
router := New()
|
|
router.RedirectFixedPath = true
|
|
router.GET("/path", func(c *Context) {})
|
|
router.GET("/dir/", func(c *Context) {})
|
|
router.GET("/", func(c *Context) {})
|
|
|
|
testRoutes := []struct {
|
|
route string
|
|
code int
|
|
location string
|
|
}{
|
|
{"/path/", http.StatusMovedPermanently, "/path"}, // TSR -/
|
|
{"/dir", http.StatusMovedPermanently, "/dir/"}, // TSR +/
|
|
{"/PATH", http.StatusMovedPermanently, "/path"}, // Fixed Case
|
|
{"/DIR/", http.StatusMovedPermanently, "/dir/"}, // Fixed Case
|
|
{"/PATH/", http.StatusMovedPermanently, "/path"}, // Fixed Case -/
|
|
{"/DIR", http.StatusMovedPermanently, "/dir/"}, // Fixed Case +/
|
|
{"/../path", http.StatusMovedPermanently, "/path"}, // Without CleanPath
|
|
{"/nope", http.StatusNotFound, ""}, // NotFound
|
|
}
|
|
for _, tr := range testRoutes {
|
|
w := PerformRequest(router, http.MethodGet, tr.route)
|
|
assert.Equal(t, tr.code, w.Code)
|
|
if w.Code != http.StatusNotFound {
|
|
assert.Equal(t, tr.location, w.Header().Get("Location"))
|
|
}
|
|
}
|
|
|
|
// Test custom not found handler
|
|
var notFound bool
|
|
router.NoRoute(func(c *Context) {
|
|
c.AbortWithStatus(http.StatusNotFound)
|
|
notFound = true
|
|
})
|
|
w := PerformRequest(router, http.MethodGet, "/nope")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
assert.True(t, notFound)
|
|
|
|
// Test other method than GET (want 307 instead of 301)
|
|
router.PATCH("/path", func(c *Context) {})
|
|
w = PerformRequest(router, http.MethodPatch, "/path/")
|
|
assert.Equal(t, http.StatusTemporaryRedirect, w.Code)
|
|
assert.Equal(t, "map[Location:[/path]]", fmt.Sprint(w.Header()))
|
|
|
|
// Test special case where no node for the prefix "/" exists
|
|
router = New()
|
|
router.GET("/a", func(c *Context) {})
|
|
w = PerformRequest(router, http.MethodGet, "/")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
|
|
// Reproduction test for the bug of issue #2843
|
|
router = New()
|
|
router.NoRoute(func(c *Context) {
|
|
if c.Request.RequestURI == "/login" {
|
|
c.String(http.StatusOK, "login")
|
|
}
|
|
})
|
|
router.GET("/logout", func(c *Context) {
|
|
c.String(http.StatusOK, "logout")
|
|
})
|
|
w = PerformRequest(router, http.MethodGet, "/login")
|
|
assert.Equal(t, "login", w.Body.String())
|
|
w = PerformRequest(router, http.MethodGet, "/logout")
|
|
assert.Equal(t, "logout", w.Body.String())
|
|
}
|
|
|
|
func TestRouterStaticFSNotFound(t *testing.T) {
|
|
router := New()
|
|
router.StaticFS("/", http.FileSystem(http.Dir("/thisreallydoesntexist/")))
|
|
router.NoRoute(func(c *Context) {
|
|
c.String(http.StatusNotFound, "non existent")
|
|
})
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/nonexistent")
|
|
assert.Equal(t, "non existent", w.Body.String())
|
|
|
|
w = PerformRequest(router, http.MethodHead, "/nonexistent")
|
|
assert.Equal(t, "non existent", w.Body.String())
|
|
}
|
|
|
|
func TestRouterStaticFSFileNotFound(t *testing.T) {
|
|
router := New()
|
|
|
|
router.StaticFS("/", http.FileSystem(http.Dir(".")))
|
|
|
|
assert.NotPanics(t, func() {
|
|
PerformRequest(router, http.MethodGet, "/nonexistent")
|
|
})
|
|
}
|
|
|
|
// TestMiddlewareCalledOnceByRouterStaticFSNotFound reproduces the bug reported in issue #1805.
|
|
func TestMiddlewareCalledOnceByRouterStaticFSNotFound(t *testing.T) {
|
|
router := New()
|
|
|
|
// Middleware must be called just only once by per request.
|
|
middlewareCalledNum := 0
|
|
router.Use(func(c *Context) {
|
|
middlewareCalledNum++
|
|
})
|
|
|
|
router.StaticFS("/", http.FileSystem(http.Dir("/thisreallydoesntexist/")))
|
|
|
|
// First access
|
|
PerformRequest(router, http.MethodGet, "/nonexistent")
|
|
assert.Equal(t, 1, middlewareCalledNum)
|
|
|
|
// Second access
|
|
PerformRequest(router, http.MethodHead, "/nonexistent")
|
|
assert.Equal(t, 2, middlewareCalledNum)
|
|
}
|
|
|
|
func TestRouteRawPath(t *testing.T) {
|
|
route := New()
|
|
route.UseRawPath = true
|
|
|
|
route.POST("/project/:name/build/:num", func(c *Context) {
|
|
name := c.Params.ByName("name")
|
|
num := c.Params.ByName("num")
|
|
|
|
assert.Equal(t, name, c.Param("name"))
|
|
assert.Equal(t, num, c.Param("num"))
|
|
|
|
assert.Equal(t, "Some/Other/Project", name)
|
|
assert.Equal(t, "222", num)
|
|
})
|
|
|
|
w := PerformRequest(route, http.MethodPost, "/project/Some%2FOther%2FProject/build/222")
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
}
|
|
|
|
func TestRouteRawPathNoUnescape(t *testing.T) {
|
|
route := New()
|
|
route.UseRawPath = true
|
|
route.UnescapePathValues = false
|
|
|
|
route.POST("/project/:name/build/:num", func(c *Context) {
|
|
name := c.Params.ByName("name")
|
|
num := c.Params.ByName("num")
|
|
|
|
assert.Equal(t, name, c.Param("name"))
|
|
assert.Equal(t, num, c.Param("num"))
|
|
|
|
assert.Equal(t, "Some%2FOther%2FProject", name)
|
|
assert.Equal(t, "333", num)
|
|
})
|
|
|
|
w := PerformRequest(route, http.MethodPost, "/project/Some%2FOther%2FProject/build/333")
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
}
|
|
|
|
func TestRouteServeErrorWithWriteHeader(t *testing.T) {
|
|
route := New()
|
|
route.Use(func(c *Context) {
|
|
c.Status(http.StatusMisdirectedRequest)
|
|
c.Next()
|
|
})
|
|
|
|
w := PerformRequest(route, http.MethodGet, "/NotFound")
|
|
assert.Equal(t, http.StatusMisdirectedRequest, w.Code)
|
|
assert.Equal(t, 0, w.Body.Len())
|
|
}
|
|
|
|
func TestRouteContextHoldsFullPath(t *testing.T) {
|
|
router := New()
|
|
|
|
// Test routes
|
|
routes := []string{
|
|
"/simple",
|
|
"/project/:name",
|
|
"/",
|
|
"/news/home",
|
|
"/news",
|
|
"/simple-two/one",
|
|
"/simple-two/one-two",
|
|
"/project/:name/build/*params",
|
|
"/project/:name/bui",
|
|
"/user/:id/status",
|
|
"/user/:id",
|
|
"/user/:id/profile",
|
|
}
|
|
|
|
for _, route := range routes {
|
|
actualRoute := route
|
|
router.GET(route, func(c *Context) {
|
|
// For each defined route context should contain its full path
|
|
assert.Equal(t, actualRoute, c.FullPath())
|
|
c.AbortWithStatus(http.StatusOK)
|
|
})
|
|
}
|
|
|
|
for _, route := range routes {
|
|
w := PerformRequest(router, http.MethodGet, route)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
}
|
|
|
|
// Test not found
|
|
router.Use(func(c *Context) {
|
|
// For not found routes full path is empty
|
|
assert.Empty(t, c.FullPath())
|
|
})
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/not-found")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
}
|
|
|
|
func TestEngineHandleMethodNotAllowedCornerCase(t *testing.T) {
|
|
r := New()
|
|
r.HandleMethodNotAllowed = true
|
|
|
|
base := r.Group("base")
|
|
base.GET("/metrics", handlerTest1)
|
|
|
|
v1 := base.Group("v1")
|
|
|
|
v1.GET("/:id/devices", handlerTest1)
|
|
v1.GET("/user/:id/groups", handlerTest1)
|
|
|
|
v1.GET("/orgs/:id", handlerTest1)
|
|
v1.DELETE("/orgs/:id", handlerTest1)
|
|
|
|
w := PerformRequest(r, http.MethodGet, "/base/v1/user/groups")
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
}
|
|
|
|
func TestLateRouteRegistrationSkippedNodes(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
router.GET("/a", func(c *Context) { c.Status(http.StatusOK) })
|
|
|
|
w := PerformRequest(router, http.MethodGet, "/a")
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("warmup status = %d, want 200", w.Code)
|
|
}
|
|
|
|
h := func(c *Context) {}
|
|
router.GET("/x/y/z/w", h)
|
|
router.GET("/x/y/:id/w", h)
|
|
router.GET("/x/:id/z/w", h)
|
|
router.GET("/:id/y/z/w", h)
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/x/y/z/w/extra", nil)
|
|
w = httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
if w.Code != http.StatusNotFound {
|
|
t.Fatalf("status = %d, want 404", w.Code)
|
|
}
|
|
}
|
|
|
|
// TestIssue4818_skippedNodesOverflow_Panic reproduces the panic from issue #4818:
|
|
// with HandleMethodNotAllowed enabled, getValue is called once per method tree
|
|
// reusing the same c.skippedNodes stack without resetting it, so residue
|
|
// accumulates until the reslice exceeds the capacity (engine.maxSections).
|
|
// The request must not panic and must fall through to the normal 404 path
|
|
// (the path genuinely matches no route, so 405 is not applicable here).
|
|
func TestIssue4818_skippedNodesOverflow_Panic(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
|
|
h := func(c *Context) {}
|
|
router.OPTIONS("/:p0/:p1/a/:p2", h)
|
|
router.GET("/:p0/:p1/a/:p2", h)
|
|
router.PATCH("/b/:p0/:p1/c", h)
|
|
router.DELETE("/b/:p0/:p1/d/:p3", h)
|
|
router.GET("/b/:p0/:p1/e/f", h)
|
|
router.POST("/b/:p0/:p1/g/:p4/h", h)
|
|
router.OPTIONS("/b/:p0/:p1/g/:p4/h", h)
|
|
router.DELETE("/b/cache", h)
|
|
router.GET("/b/clients/:p1/g", h)
|
|
router.POST("/b/clients/:p1/g", h)
|
|
router.PATCH("/b/clients/:p1/g/:p4", h)
|
|
router.OPTIONS("/b/clients/:p1/g/:p4", h)
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/b/clients/42", nil)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
// Must not panic; path matches no route, so 404 is the correct outcome.
|
|
if w.Code != http.StatusNotFound {
|
|
t.Fatalf("expected 404, got %d (a panic would have aborted the test)", w.Code)
|
|
}
|
|
}
|
|
|
|
// TestIssue4818_MethodNotAllowedStillWorks verifies the HandleMethodNotAllowed
|
|
// loop still produces a correct 405 with an Allow header after the fix, i.e.
|
|
// the reset does not break the loop across multiple method trees.
|
|
func TestIssue4818_MethodNotAllowedStillWorks(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
|
|
h := func(c *Context) {}
|
|
router.OPTIONS("/:p0/:p1/a/:p2", h)
|
|
router.GET("/:p0/:p1/a/:p2", h)
|
|
router.PATCH("/b/:p0/:p1/c", h)
|
|
router.DELETE("/b/:p0/:p1/d/:p3", h)
|
|
router.GET("/b/:p0/:p1/e/f", h)
|
|
router.POST("/b/:p0/:p1/g/:p4/h", h)
|
|
router.OPTIONS("/b/:p0/:p1/g/:p4/h", h)
|
|
router.DELETE("/b/cache", h)
|
|
router.GET("/b/clients/:p1/g", h)
|
|
router.POST("/b/clients/:p1/g", h)
|
|
router.PATCH("/b/clients/:p1/g/:p4", h)
|
|
router.OPTIONS("/b/clients/:p1/g/:p4", h)
|
|
|
|
// PATCH /b/clients/42/g is registered under GET but not under PATCH
|
|
// -> HandleMethodNotAllowed should yield 405 with an Allow header.
|
|
req := httptest.NewRequest(http.MethodPatch, "/b/clients/42/g", nil)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
if w.Code != http.StatusMethodNotAllowed {
|
|
t.Fatalf("expected 405, got %d", w.Code)
|
|
}
|
|
allow := w.Header().Get("Allow")
|
|
if allow == "" {
|
|
t.Fatal("expected Allow header to be set for 405")
|
|
}
|
|
}
|
|
|
|
// TestIssue4818_MethodNotAllowedManyTrees stresses the loop across many
|
|
// method trees to make sure the skipped-nodes accumulator can never overflow.
|
|
func TestIssue4818_MethodNotAllowedManyTrees(t *testing.T) {
|
|
router := New()
|
|
router.HandleMethodNotAllowed = true
|
|
|
|
h := func(c *Context) {}
|
|
for _, m := range []string{
|
|
http.MethodGet, http.MethodPost, http.MethodPut, http.MethodDelete,
|
|
http.MethodPatch, http.MethodOptions, http.MethodHead, http.MethodConnect,
|
|
http.MethodTrace,
|
|
} {
|
|
router.Handle(m, "/:p0/:p1/a/:p2", h)
|
|
router.Handle(m, "/s/:p0/:p1/:p2/:p3/:p4/:p5/d", h)
|
|
}
|
|
// GET route so that a POST to a GET-only path yields 405
|
|
router.GET("/only-get", h)
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/only-get", nil)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
if w.Code != http.StatusMethodNotAllowed {
|
|
t.Fatalf("expected 405, got %d", w.Code)
|
|
}
|
|
}
|