func TestMiddlewareAbort(t *testing.T) { signature := "" router := New() router.Use(func(c *Context) { signature += "A" }) router.Use(func(c *Context) { signature += "C" c.AbortWithStatus(401) c.Next() signature += "D" }) router.GET("/", func(c *Context) { signature += " X " c.Next() signature += " XX " }) // RUN w := performRequest(router, "GET", "/") // TEST assert.Equal(t, w.Code, 401) assert.Equal(t, signature, "ACD") }
func TestBasicAuthSearchCredential(t *testing.T) { pairs := processAccounts(Accounts{ "admin": "password", "foo": "bar", "bar": "foo", }) user, found := pairs.searchCredential(authorizationHeader("admin", "password")) assert.Equal(t, user, "admin") assert.True(t, found) user, found = pairs.searchCredential(authorizationHeader("foo", "bar")) assert.Equal(t, user, "foo") assert.True(t, found) user, found = pairs.searchCredential(authorizationHeader("bar", "foo")) assert.Equal(t, user, "bar") assert.True(t, found) user, found = pairs.searchCredential(authorizationHeader("admins", "password")) assert.Empty(t, user) assert.False(t, found) user, found = pairs.searchCredential(authorizationHeader("foo", "bar ")) assert.Empty(t, user) assert.False(t, found) user, found = pairs.searchCredential("") assert.Empty(t, user) assert.False(t, found) }
func TestChooseData(t *testing.T) { A := "a" B := "b" assert.Equal(t, chooseData(A, B), A) assert.Equal(t, chooseData(nil, B), B) assert.Panics(t, func() { chooseData(nil, nil) }) }
func TestMiddlewareNoMethod(t *testing.T) { signature := "" router := New() router.Use(func(c *Context) { signature += "A" c.Next() signature += "B" }) router.Use(func(c *Context) { signature += "C" c.Next() signature += "D" }) router.NoMethod(func(c *Context) { signature += "E" c.Next() signature += "F" }, func(c *Context) { signature += "G" c.Next() signature += "H" }) router.NoRoute(func(c *Context) { signature += " X " }) router.POST("/", func(c *Context) { signature += " XX " }) // RUN w := performRequest(router, "GET", "/") // TEST assert.Equal(t, w.Code, 405) assert.Equal(t, signature, "ACEGHFDB") }
func TestNoRouteWithGlobalHandlers(t *testing.T) { middleware0 := func(c *Context) {} middleware1 := func(c *Context) {} middleware2 := func(c *Context) {} 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) assert.Equal(t, router.Handlers[0], middleware2) assert.Equal(t, router.noRoute[0], middleware0) assert.Equal(t, router.allNoRoute[0], middleware2) assert.Equal(t, router.allNoRoute[1], middleware0) router.Use(middleware1) assert.Len(t, router.allNoRoute, 3) assert.Len(t, router.Handlers, 2) assert.Len(t, router.noRoute, 1) assert.Equal(t, router.Handlers[0], middleware2) assert.Equal(t, router.Handlers[1], middleware1) assert.Equal(t, router.noRoute[0], middleware0) assert.Equal(t, router.allNoRoute[0], middleware2) assert.Equal(t, router.allNoRoute[1], middleware1) assert.Equal(t, router.allNoRoute[2], middleware0) }
func TestFilterFlags(t *testing.T) { result := filterFlags("text/html ") assert.Equal(t, result, "text/html") result = filterFlags("text/html;") assert.Equal(t, result, "text/html") }
func TestMiddlewareWrite(t *testing.T) { router := New() router.Use(func(c *Context) { c.String(400, "hola\n") }) router.Use(func(c *Context) { c.XML(400, H{"foo": "bar"}) }) router.Use(func(c *Context) { c.JSON(400, H{"foo": "bar"}) }) router.GET("/", func(c *Context) { c.JSON(400, H{"foo": "bar"}) }, func(c *Context) { c.Render(400, sse.Event{ Event: "test", Data: "message", }) }) w := performRequest(router, "GET", "/") assert.Equal(t, w.Code, 400) assert.Equal(t, w.Body.String(), `hola <map><foo>bar</foo></map>{"foo":"bar"} {"foo":"bar"} event: test data: message `) }
func TestMiddlewareGeneralCase(t *testing.T) { signature := "" router := New() router.Use(func(c *Context) { signature += "A" c.Next() signature += "B" }) router.Use(func(c *Context) { signature += "C" }) router.GET("/", func(c *Context) { signature += "D" }) router.NoRoute(func(c *Context) { signature += " X " }) router.NoMethod(func(c *Context) { signature += " XX " }) // RUN w := performRequest(router, "GET", "/") // TEST assert.Equal(t, w.Code, 200) assert.Equal(t, signature, "ACDB") }
func TestContextNegotiationFormat(t *testing.T) { c, _, _ := createTestContext() c.Request, _ = http.NewRequest("POST", "", nil) assert.Panics(t, func() { c.NegotiateFormat() }) assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEJSON) assert.Equal(t, c.NegotiateFormat(MIMEHTML, MIMEJSON), MIMEHTML) }
// TestContextData tests that the response can be written from `bytesting` // with specified MIME type func TestContextRenderData(t *testing.T) { c, w, _ := createTestContext() c.Data(201, "text/csv", []byte(`foo,bar`)) assert.Equal(t, w.Code, 201) assert.Equal(t, w.Body.String(), "foo,bar") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/csv") }
// TestContextString tests that the response is returned // with Content-Type set to text/plain func TestContextRenderString(t *testing.T) { c, w, _ := createTestContext() c.String(201, "test %s %d", "string", 2) assert.Equal(t, w.Code, 201) assert.Equal(t, w.Body.String(), "test string 2") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8") }
// TestContextXML tests that the response is serialized as XML // and Content-Type is set to application/xml func TestContextRenderXML(t *testing.T) { c, w, _ := createTestContext() c.XML(201, H{"foo": "bar"}) assert.Equal(t, w.Code, 201) assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/xml; charset=utf-8") }
// Tests that the response is serialized as JSON // and Content-Type is set to application/json func TestContextRenderIndentedJSON(t *testing.T) { c, w, _ := createTestContext() c.IndentedJSON(201, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}}) assert.Equal(t, w.Code, 201) assert.Equal(t, w.Body.String(), "{\n \"bar\": \"foo\",\n \"foo\": \"bar\",\n \"nested\": {\n \"foo\": \"bar\"\n }\n}") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8") }
// Tests that the response is serialized as JSON // and Content-Type is set to application/json func TestContextRenderJSON(t *testing.T) { c, w, _ := createTestContext() c.JSON(201, H{"foo": "bar"}) assert.Equal(t, w.Code, 201) assert.Equal(t, w.Body.String(), "{\"foo\":\"bar\"}\n") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8") }
func TestParseAccept(t *testing.T) { parts := parseAccept("text/html , application/xhtml+xml,application/xml;q=0.9, */* ;q=0.8") assert.Len(t, parts, 4) assert.Equal(t, parts[0], "text/html") assert.Equal(t, parts[1], "application/xhtml+xml") assert.Equal(t, parts[2], "application/xml") assert.Equal(t, parts[3], "*/*") }
func TestContextRenderRedirectWithAbsolutePath(t *testing.T) { c, w, _ := createTestContext() c.Request, _ = http.NewRequest("POST", "http://example.com", nil) c.Redirect(302, "http://google.com") c.Writer.WriteHeaderNow() assert.Equal(t, w.Code, 302) assert.Equal(t, w.Header().Get("Location"), "http://google.com") }
func TestContextNegotiationFormatWithAccept(t *testing.T) { c, _, _ := createTestContext() c.Request, _ = http.NewRequest("POST", "/", nil) c.Request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8") assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEXML) assert.Equal(t, c.NegotiateFormat(MIMEXML, MIMEHTML), MIMEHTML) assert.Equal(t, c.NegotiateFormat(MIMEJSON), "") }
// TestContextString tests that the response is returned // with Content-Type set to text/html func TestContextRenderHTMLString(t *testing.T) { c, w, _ := createTestContext() c.Header("Content-Type", "text/html; charset=utf-8") c.String(201, "<html>%s %d</html>", "string", 3) assert.Equal(t, w.Code, 201) assert.Equal(t, w.Body.String(), "<html>string 3</html>") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8") }
func TestContextAbortWithError(t *testing.T) { c, w, _ := createTestContext() c.AbortWithError(401, errors.New("bad input")).SetMeta("some input") c.Writer.WriteHeaderNow() assert.Equal(t, w.Code, 401) assert.Equal(t, c.index, AbortIndex) assert.True(t, c.IsAborted()) }
func TestContextRenderFile(t *testing.T) { c, w, _ := createTestContext() c.Request, _ = http.NewRequest("GET", "/", nil) c.File("./gin.go") assert.Equal(t, w.Code, 200) assert.Contains(t, w.Body.String(), "func New() *Engine {") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8") }
// TestHandleStaticDir - ensure the root/sub dir handles properly func TestRouteStaticListingDir(t *testing.T) { router := New() router.StaticFS("/", Dir("./", true)) w := performRequest(router, "GET", "/") assert.Equal(t, w.Code, 200) assert.Contains(t, w.Body.String(), "gin.go") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8") }
// Tests that the response executes the templates // and responds with Content-Type set to text/html func TestContextRenderHTML(t *testing.T) { c, w, router := createTestContext() templ := template.Must(template.New("t").Parse(`Hello {{.name}}`)) router.SetHTMLTemplate(templ) c.HTML(201, "t", H{"name": "alexandernyquist"}) assert.Equal(t, w.Code, 201) assert.Equal(t, w.Body.String(), "Hello alexandernyquist") assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8") }
// TestContextData tests that the response can be written from `bytesting` // with specified MIME type func TestContextAbortWithStatus(t *testing.T) { c, w, _ := createTestContext() c.index = 4 c.AbortWithStatus(401) c.Writer.WriteHeaderNow() assert.Equal(t, c.index, AbortIndex) assert.Equal(t, c.Writer.Status(), 401) assert.Equal(t, w.Code, 401) assert.True(t, c.IsAborted()) }
// TODO func TestContextRenderRedirectWithRelativePath(t *testing.T) { c, w, _ := createTestContext() c.Request, _ = http.NewRequest("POST", "http://example.com", nil) assert.Panics(t, func() { c.Redirect(299, "/new_path") }) assert.Panics(t, func() { c.Redirect(309, "/new_path") }) c.Redirect(302, "/path") c.Writer.WriteHeaderNow() assert.Equal(t, w.Code, 302) assert.Equal(t, w.Header().Get("Location"), "/path") }
func TestRenderXML(t *testing.T) { w := httptest.NewRecorder() data := xmlmap{ "foo": "bar", } err := (XML{data}).Write(w) assert.NoError(t, err) assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>") assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8") }
func TestRenderJSON(t *testing.T) { w := httptest.NewRecorder() data := map[string]interface{}{ "foo": "bar", } err := (JSON{data}).Write(w) assert.NoError(t, err) assert.Equal(t, w.Body.String(), "{\"foo\":\"bar\"}\n") assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8") }
func TestRenderString(t *testing.T) { w := httptest.NewRecorder() err := (String{ Format: "hola %s %d", Data: []interface{}{"manu", 2}, }).Write(w) assert.NoError(t, err) assert.Equal(t, w.Body.String(), "hola manu 2") assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8") }
func TestJoinPaths(t *testing.T) { assert.Equal(t, joinPaths("", ""), "") assert.Equal(t, joinPaths("", "/"), "/") assert.Equal(t, joinPaths("/a", ""), "/a") assert.Equal(t, joinPaths("/a/", ""), "/a/") assert.Equal(t, joinPaths("/a/", "/"), "/a/") assert.Equal(t, joinPaths("/a", "/"), "/a/") assert.Equal(t, joinPaths("/a", "/hola"), "/a/hola") assert.Equal(t, joinPaths("/a/", "/hola"), "/a/hola") assert.Equal(t, joinPaths("/a/", "/hola/"), "/a/hola/") assert.Equal(t, joinPaths("/a/", "/hola//"), "/a/hola/") }
func TestCreateEngine(t *testing.T) { router := New() assert.Equal(t, "/", router.BasePath) assert.Equal(t, router.engine, router) assert.Empty(t, router.Handlers) assert.True(t, router.RedirectTrailingSlash) assert.True(t, router.RedirectFixedPath) assert.True(t, router.HandleMethodNotAllowed) 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{}) }) }
func TestRenderData(t *testing.T) { w := httptest.NewRecorder() data := []byte("#!PNG some raw data") err := (Data{ ContentType: "image/png", Data: data, }).Write(w) assert.NoError(t, err) assert.Equal(t, w.Body.String(), "#!PNG some raw data") assert.Equal(t, w.Header().Get("Content-Type"), "image/png") }