gin/gin_test.go

366 lines
9.9 KiB
Go
Raw Normal View History

2014-08-29 17:49:50 +00:00
// 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.
2014-07-04 08:12:28 +00:00
package gin
2014-07-05 15:04:11 +00:00
import (
"fmt"
"html/template"
"io/ioutil"
"net/http"
2015-05-31 20:35:49 +00:00
"reflect"
2014-07-05 15:04:11 +00:00
"testing"
"time"
2015-04-08 00:58:35 +00:00
"github.com/stretchr/testify/assert"
2014-07-04 08:12:28 +00:00
)
func formatAsDate(t time.Time) string {
year, month, day := t.Date()
return fmt.Sprintf("%d/%02d/%02d", year, month, day)
}
func setupHTMLFiles(t *testing.T) func() {
go func() {
SetMode(TestMode)
router := New()
router.Delims("{[{", "}]}")
router.SetFuncMap(template.FuncMap{
"formatAsDate": formatAsDate,
})
router.LoadHTMLFiles("./fixtures/basic/hello.tmpl", "./fixtures/basic/raw.tmpl")
router.GET("/test", func(c *Context) {
c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
})
router.GET("/raw", func(c *Context) {
c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
"now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
})
})
router.Run(":8888")
}()
t.Log("waiting 1 second for server startup")
time.Sleep(1 * time.Second)
return func() {}
}
func setupHTMLGlob(t *testing.T) func() {
go func() {
SetMode(DebugMode)
router := New()
router.Delims("{[{", "}]}")
router.SetFuncMap(template.FuncMap{
"formatAsDate": formatAsDate,
})
router.LoadHTMLGlob("./fixtures/basic/*")
router.GET("/test", func(c *Context) {
c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"})
})
router.GET("/raw", func(c *Context) {
c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
"now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
})
})
router.Run(":8888")
}()
t.Log("waiting 1 second for server startup")
time.Sleep(1 * time.Second)
return func() {}
}
2015-04-09 10:15:02 +00:00
//TODO
func TestLoadHTMLGlob(t *testing.T) {
td := setupHTMLGlob(t)
res, err := http.Get("http://127.0.0.1:8888/test")
if err != nil {
fmt.Println(err)
}
resp, _ := ioutil.ReadAll(res.Body)
assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
td()
}
func TestLoadHTMLGlobFromFuncMap(t *testing.T) {
time.Now()
td := setupHTMLGlob(t)
res, err := http.Get("http://127.0.0.1:8888/raw")
if err != nil {
fmt.Println(err)
}
resp, _ := ioutil.ReadAll(res.Body)
assert.Equal(t, "Date: 2017/07/01\n", string(resp[:]))
td()
}
2015-04-09 10:15:02 +00:00
// func (engine *Engine) LoadHTMLFiles(files ...string) {
// func (engine *Engine) RunTLS(addr string, cert string, key string) error {
2014-08-20 23:01:42 +00:00
func init() {
SetMode(TestMode)
}
2015-04-08 00:58:35 +00:00
func TestCreateEngine(t *testing.T) {
router := New()
assert.Equal(t, "/", router.basePath)
2015-04-08 00:58:35 +00:00
assert.Equal(t, router.engine, router)
assert.Empty(t, router.Handlers)
2015-06-04 02:32:18 +00:00
}
2015-08-16 14:36:47 +00:00
// func TestLoadHTMLDebugMode(t *testing.T) {
// router := New()
// SetMode(DebugMode)
// router.LoadHTMLGlob("*.testtmpl")
// r := router.HTMLRender.(render.HTMLDebug)
// assert.Empty(t, r.Files)
// assert.Equal(t, r.Glob, "*.testtmpl")
//
// router.LoadHTMLFiles("index.html.testtmpl", "login.html.testtmpl")
// r = router.HTMLRender.(render.HTMLDebug)
// assert.Empty(t, r.Glob)
// assert.Equal(t, r.Files, []string{"index.html", "login.html"})
// SetMode(TestMode)
// }
func TestLoadHTMLFiles(t *testing.T) {
td := setupHTMLFiles(t)
res, err := http.Get("http://127.0.0.1:8888/test")
if err != nil {
fmt.Println(err)
}
resp, _ := ioutil.ReadAll(res.Body)
assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
td()
}
func TestLoadHTMLFilesFuncMap(t *testing.T) {
time.Now()
td := setupHTMLFiles(t)
res, err := http.Get("http://127.0.0.1:8888/raw")
if err != nil {
fmt.Println(err)
}
resp, _ := ioutil.ReadAll(res.Body)
assert.Equal(t, "Date: 2017/07/01\n", string(resp[:]))
td()
}
func TestLoadHTMLReleaseMode(t *testing.T) {
}
2015-06-04 02:32:18 +00:00
func TestAddRoute(t *testing.T) {
router := New()
router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}})
assert.Len(t, router.trees, 1)
assert.NotNil(t, router.trees.get("GET"))
assert.Nil(t, router.trees.get("POST"))
router.addRoute("POST", "/", HandlersChain{func(_ *Context) {}})
2014-07-04 08:12:28 +00:00
2015-06-04 02:32:18 +00:00
assert.Len(t, router.trees, 2)
assert.NotNil(t, router.trees.get("GET"))
assert.NotNil(t, router.trees.get("POST"))
router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}})
assert.Len(t, router.trees, 2)
}
func TestAddRouteFails(t *testing.T) {
router := New()
2015-05-19 21:22:35 +00:00
assert.Panics(t, func() { router.addRoute("", "/", HandlersChain{func(_ *Context) {}}) })
assert.Panics(t, func() { router.addRoute("GET", "a", HandlersChain{func(_ *Context) {}}) })
assert.Panics(t, func() { router.addRoute("GET", "/", HandlersChain{}) })
2015-06-04 02:32:18 +00:00
router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}})
assert.Panics(t, func() {
router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}})
})
2014-07-04 08:12:28 +00:00
}
2015-04-08 00:58:35 +00:00
func TestCreateDefaultRouter(t *testing.T) {
router := Default()
assert.Len(t, router.Handlers, 2)
2014-07-04 08:12:28 +00:00
}
2015-04-08 00:58:35 +00:00
func TestNoRouteWithoutGlobalHandlers(t *testing.T) {
2015-05-31 20:35:49 +00:00
var middleware0 HandlerFunc = func(c *Context) {}
var middleware1 HandlerFunc = func(c *Context) {}
2015-04-08 00:58:35 +00:00
router := New()
router.NoRoute(middleware0)
assert.Nil(t, router.Handlers)
assert.Len(t, router.noRoute, 1)
assert.Len(t, router.allNoRoute, 1)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.noRoute[0], middleware0)
compareFunc(t, router.allNoRoute[0], middleware0)
2015-04-08 00:58:35 +00:00
router.NoRoute(middleware1, middleware0)
assert.Len(t, router.noRoute, 2)
assert.Len(t, router.allNoRoute, 2)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.noRoute[0], middleware1)
compareFunc(t, router.allNoRoute[0], middleware1)
compareFunc(t, router.noRoute[1], middleware0)
compareFunc(t, router.allNoRoute[1], middleware0)
2014-07-04 08:12:28 +00:00
}
2015-04-08 00:58:35 +00:00
func TestNoRouteWithGlobalHandlers(t *testing.T) {
2015-05-31 20:35:49 +00:00
var middleware0 HandlerFunc = func(c *Context) {}
var middleware1 HandlerFunc = func(c *Context) {}
var middleware2 HandlerFunc = func(c *Context) {}
2015-04-08 00:58:35 +00:00
router := New()
router.Use(middleware2)
router.NoRoute(middleware0)
assert.Len(t, router.allNoRoute, 2)
assert.Len(t, router.Handlers, 1)
assert.Len(t, router.noRoute, 1)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.Handlers[0], middleware2)
compareFunc(t, router.noRoute[0], middleware0)
compareFunc(t, router.allNoRoute[0], middleware2)
compareFunc(t, router.allNoRoute[1], middleware0)
2015-04-08 00:58:35 +00:00
router.Use(middleware1)
assert.Len(t, router.allNoRoute, 3)
assert.Len(t, router.Handlers, 2)
assert.Len(t, router.noRoute, 1)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.Handlers[0], middleware2)
compareFunc(t, router.Handlers[1], middleware1)
compareFunc(t, router.noRoute[0], middleware0)
compareFunc(t, router.allNoRoute[0], middleware2)
compareFunc(t, router.allNoRoute[1], middleware1)
compareFunc(t, router.allNoRoute[2], middleware0)
2014-07-04 08:12:28 +00:00
}
2015-04-08 00:58:35 +00:00
func TestNoMethodWithoutGlobalHandlers(t *testing.T) {
2015-05-31 20:35:49 +00:00
var middleware0 HandlerFunc = func(c *Context) {}
var middleware1 HandlerFunc = func(c *Context) {}
2015-04-08 00:58:35 +00:00
router := New()
router.NoMethod(middleware0)
assert.Empty(t, router.Handlers)
assert.Len(t, router.noMethod, 1)
assert.Len(t, router.allNoMethod, 1)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.noMethod[0], middleware0)
compareFunc(t, router.allNoMethod[0], middleware0)
2015-04-08 00:58:35 +00:00
router.NoMethod(middleware1, middleware0)
assert.Len(t, router.noMethod, 2)
assert.Len(t, router.allNoMethod, 2)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.noMethod[0], middleware1)
compareFunc(t, router.allNoMethod[0], middleware1)
compareFunc(t, router.noMethod[1], middleware0)
compareFunc(t, router.allNoMethod[1], middleware0)
2014-07-04 08:12:28 +00:00
}
2015-04-08 00:58:35 +00:00
func TestRebuild404Handlers(t *testing.T) {
2014-07-05 15:04:11 +00:00
}
2014-07-28 10:05:23 +00:00
2015-04-08 00:58:35 +00:00
func TestNoMethodWithGlobalHandlers(t *testing.T) {
2015-05-31 20:35:49 +00:00
var middleware0 HandlerFunc = func(c *Context) {}
var middleware1 HandlerFunc = func(c *Context) {}
var middleware2 HandlerFunc = func(c *Context) {}
2015-04-08 00:58:35 +00:00
router := New()
router.Use(middleware2)
router.NoMethod(middleware0)
assert.Len(t, router.allNoMethod, 2)
assert.Len(t, router.Handlers, 1)
assert.Len(t, router.noMethod, 1)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.Handlers[0], middleware2)
compareFunc(t, router.noMethod[0], middleware0)
compareFunc(t, router.allNoMethod[0], middleware2)
compareFunc(t, router.allNoMethod[1], middleware0)
2015-04-08 00:58:35 +00:00
router.Use(middleware1)
assert.Len(t, router.allNoMethod, 3)
assert.Len(t, router.Handlers, 2)
assert.Len(t, router.noMethod, 1)
2015-05-31 20:35:49 +00:00
compareFunc(t, router.Handlers[0], middleware2)
compareFunc(t, router.Handlers[1], middleware1)
compareFunc(t, router.noMethod[0], middleware0)
compareFunc(t, router.allNoMethod[0], middleware2)
compareFunc(t, router.allNoMethod[1], middleware1)
compareFunc(t, router.allNoMethod[2], middleware0)
}
func compareFunc(t *testing.T, a, b interface{}) {
sf1 := reflect.ValueOf(a)
sf2 := reflect.ValueOf(b)
if sf1.Pointer() != sf2.Pointer() {
t.Error("different functions")
}
2014-07-28 10:05:23 +00:00
}
2015-06-07 02:20:39 +00:00
func TestListOfRoutes(t *testing.T) {
router := New()
2016-04-14 23:16:46 +00:00
router.GET("/favicon.ico", handlerTest1)
router.GET("/", handlerTest1)
2015-06-07 02:20:39 +00:00
group := router.Group("/users")
{
2016-04-14 23:16:46 +00:00
group.GET("/", handlerTest2)
group.GET("/:id", handlerTest1)
group.POST("/:id", handlerTest2)
2015-06-07 02:20:39 +00:00
}
router.Static("/static", ".")
list := router.Routes()
assert.Len(t, list, 7)
assertRoutePresent(t, list, RouteInfo{
2015-06-18 15:17:22 +00:00
Method: "GET",
Path: "/favicon.ico",
2016-04-14 23:35:22 +00:00
Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest1$",
2015-06-07 02:20:39 +00:00
})
assertRoutePresent(t, list, RouteInfo{
2015-06-18 15:17:22 +00:00
Method: "GET",
Path: "/",
2016-04-14 23:35:22 +00:00
Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest1$",
2015-06-07 02:20:39 +00:00
})
assertRoutePresent(t, list, RouteInfo{
2015-06-18 15:17:22 +00:00
Method: "GET",
Path: "/users/",
2016-04-14 23:35:22 +00:00
Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest2$",
2015-06-07 02:20:39 +00:00
})
assertRoutePresent(t, list, RouteInfo{
2015-06-18 15:17:22 +00:00
Method: "GET",
Path: "/users/:id",
2016-04-14 23:35:22 +00:00
Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest1$",
2015-06-07 02:20:39 +00:00
})
assertRoutePresent(t, list, RouteInfo{
2015-06-18 15:17:22 +00:00
Method: "POST",
Path: "/users/:id",
2016-04-14 23:35:22 +00:00
Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest2$",
2015-06-07 02:20:39 +00:00
})
}
2015-06-18 15:17:22 +00:00
func assertRoutePresent(t *testing.T, gotRoutes RoutesInfo, wantRoute RouteInfo) {
for _, gotRoute := range gotRoutes {
if gotRoute.Path == wantRoute.Path && gotRoute.Method == wantRoute.Method {
assert.Regexp(t, wantRoute.Handler, gotRoute.Handler)
return
}
}
t.Errorf("route not found: %v", wantRoute)
}
2016-04-14 23:16:46 +00:00
func handlerTest1(c *Context) {}
func handlerTest2(c *Context) {}