From d85245b5aabc0b09a5d5f46c8893279443dddc1d Mon Sep 17 00:00:00 2001 From: Manu Mtz-Almeida Date: Mon, 18 Aug 2014 19:48:48 +0200 Subject: [PATCH] Improves unit tests - Reusing much more code - More coverage - Cleanup - Fixes some cases --- auth_test.go | 4 +- context_test.go | 128 ++++++++++----------- gin_test.go | 288 ++++++++++++++++------------------------------- recovery_test.go | 54 +++------ 4 files changed, 168 insertions(+), 306 deletions(-) diff --git a/auth_test.go b/auth_test.go index d9b4f4d4..cc70bc08 100644 --- a/auth_test.go +++ b/auth_test.go @@ -11,7 +11,7 @@ func TestBasicAuthSucceed(t *testing.T) { req, _ := http.NewRequest("GET", "/login", nil) w := httptest.NewRecorder() - r := Default() + r := New() accounts := Accounts{"admin": "password"} r.Use(BasicAuth(accounts)) @@ -36,7 +36,7 @@ func TestBasicAuth401(t *testing.T) { req, _ := http.NewRequest("GET", "/login", nil) w := httptest.NewRecorder() - r := Default() + r := New() accounts := Accounts{"foo": "bar"} r.Use(BasicAuth(accounts)) diff --git a/context_test.go b/context_test.go index 9a2394a2..3b3302e8 100644 --- a/context_test.go +++ b/context_test.go @@ -15,7 +15,7 @@ func TestContextParamsByName(t *testing.T) { w := httptest.NewRecorder() name := "" - r := Default() + r := New() r.GET("/test/:name", func(c *Context) { name = c.Params.ByName("name") }) @@ -33,7 +33,7 @@ func TestContextSetGet(t *testing.T) { req, _ := http.NewRequest("GET", "/test", nil) w := httptest.NewRecorder() - r := Default() + r := New() r.GET("/test", func(c *Context) { // Key should be lazily created if c.Keys != nil { @@ -61,7 +61,7 @@ func TestContextJSON(t *testing.T) { req, _ := http.NewRequest("GET", "/test", nil) w := httptest.NewRecorder() - r := Default() + r := New() r.GET("/test", func(c *Context) { c.JSON(200, H{"foo": "bar"}) }) @@ -83,7 +83,7 @@ func TestContextHTML(t *testing.T) { req, _ := http.NewRequest("GET", "/test", nil) w := httptest.NewRecorder() - r := Default() + r := New() templ, _ := template.New("t").Parse(`Hello {{.Name}}`) r.SetHTMLTemplate(templ) @@ -110,7 +110,7 @@ func TestContextString(t *testing.T) { req, _ := http.NewRequest("GET", "/test", nil) w := httptest.NewRecorder() - r := Default() + r := New() r.GET("/test", func(c *Context) { c.String(200, "test") }) @@ -132,7 +132,7 @@ func TestContextXML(t *testing.T) { req, _ := http.NewRequest("GET", "/test", nil) w := httptest.NewRecorder() - r := Default() + r := New() r.GET("/test", func(c *Context) { c.XML(200, H{"foo": "bar"}) }) @@ -154,7 +154,7 @@ func TestContextData(t *testing.T) { req, _ := http.NewRequest("GET", "/test/csv", nil) w := httptest.NewRecorder() - r := Default() + r := New() r.GET("/test/csv", func(c *Context) { c.Data(200, "text/csv", []byte(`foo,bar`)) }) @@ -174,7 +174,7 @@ func TestContextFile(t *testing.T) { req, _ := http.NewRequest("GET", "/test/file", nil) w := httptest.NewRecorder() - r := Default() + r := New() r.GET("/test/file", func(c *Context) { c.File("./gin.go") }) @@ -198,7 +198,7 @@ func TestHandlerFunc(t *testing.T) { req, _ := http.NewRequest("GET", "/", nil) w := httptest.NewRecorder() - r := Default() + r := New() var stepsPassed int = 0 r.Use(func(context *Context) { @@ -220,109 +220,95 @@ func TestHandlerFunc(t *testing.T) { // TestBadAbortHandlersChain - ensure that Abort after switch context will not interrupt pending handlers func TestBadAbortHandlersChain(t *testing.T) { - - req, _ := http.NewRequest("GET", "/", nil) - w := httptest.NewRecorder() - - r := Default() + // SETUP var stepsPassed int = 0 - - r.Use(func(context *Context) { + r := New() + r.Use(func(c *Context) { stepsPassed += 1 - context.Next() + c.Next() stepsPassed += 1 // after check and abort - context.Abort(409) - }, - func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - context.Abort(403) - }, - ) + c.Abort(409) + }) + r.Use(func(c *Context) { + stepsPassed += 1 + c.Next() + stepsPassed += 1 + c.Abort(403) + }) - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "GET", "/") - if w.Code != 403 { - t.Errorf("Response code should be Forbiden, was: %s", w.Code) + // TEST + if w.Code != 409 { + t.Errorf("Response code should be Forbiden, was: %d", w.Code) } - if stepsPassed != 4 { - t.Errorf("Falied to switch context in handler function: %s", stepsPassed) + t.Errorf("Falied to switch context in handler function: %d", stepsPassed) } } // TestAbortHandlersChain - ensure that Abort interrupt used middlewares in fifo order func TestAbortHandlersChain(t *testing.T) { - - req, _ := http.NewRequest("GET", "/", nil) - w := httptest.NewRecorder() - - r := Default() + // SETUP var stepsPassed int = 0 - + r := New() r.Use(func(context *Context) { stepsPassed += 1 context.Abort(409) - }, - func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - }, - ) + }) + r.Use(func(context *Context) { + stepsPassed += 1 + context.Next() + stepsPassed += 1 + }) - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "GET", "/") + // TEST if w.Code != 409 { - t.Errorf("Response code should be Conflict, was: %s", w.Code) + t.Errorf("Response code should be Conflict, was: %d", w.Code) } - if stepsPassed != 1 { - t.Errorf("Falied to switch context in handler function: %s", stepsPassed) + t.Errorf("Falied to switch context in handler function: %d", stepsPassed) } } // TestFailHandlersChain - ensure that Fail interrupt used middlewares in fifo order as // as well as Abort func TestFailHandlersChain(t *testing.T) { - - req, _ := http.NewRequest("GET", "/", nil) - w := httptest.NewRecorder() - - r := Default() + // SETUP var stepsPassed int = 0 - + r := New() r.Use(func(context *Context) { stepsPassed += 1 - context.Fail(500, errors.New("foo")) - }, - func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - }, - ) + }) + r.Use(func(context *Context) { + stepsPassed += 1 + context.Next() + stepsPassed += 1 + }) - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "GET", "/") + // TEST if w.Code != 500 { - t.Errorf("Response code should be Server error, was: %s", w.Code) + t.Errorf("Response code should be Server error, was: %d", w.Code) } - if stepsPassed != 1 { - t.Errorf("Falied to switch context in handler function: %s", stepsPassed) + t.Errorf("Falied to switch context in handler function: %d", stepsPassed) } - } func TestBindingJSON(t *testing.T) { body := bytes.NewBuffer([]byte("{\"foo\":\"bar\"}")) - r := Default() + r := New() r.POST("/binding/json", func(c *Context) { var body struct { Foo string `json:"foo"` @@ -355,7 +341,7 @@ func TestBindingJSONEncoding(t *testing.T) { body := bytes.NewBuffer([]byte("{\"foo\":\"嘉\"}")) - r := Default() + r := New() r.POST("/binding/json", func(c *Context) { var body struct { Foo string `json:"foo"` @@ -388,7 +374,7 @@ func TestBindingJSONNoContentType(t *testing.T) { body := bytes.NewBuffer([]byte("{\"foo\":\"bar\"}")) - r := Default() + r := New() r.POST("/binding/json", func(c *Context) { var body struct { Foo string `json:"foo"` @@ -421,7 +407,7 @@ func TestBindingJSONMalformed(t *testing.T) { body := bytes.NewBuffer([]byte("\"foo\":\"bar\"\n")) - r := Default() + r := New() r.POST("/binding/json", func(c *Context) { var body struct { Foo string `json:"foo"` diff --git a/gin_test.go b/gin_test.go index 61b3c351..0cd5bf1b 100644 --- a/gin_test.go +++ b/gin_test.go @@ -10,224 +10,139 @@ import ( "testing" ) -// TestRouterGroupGETRouteOK tests that GET route is correctly invoked. -func TestRouterGroupGETRouteOK(t *testing.T) { - req, _ := http.NewRequest("GET", "/test", nil) +func PerformRequest(r http.Handler, method, path string) *httptest.ResponseRecorder { + req, _ := http.NewRequest(method, path, nil) w := httptest.NewRecorder() - passed := false - - r := Default() - r.GET("/test", func(c *Context) { - passed = true - }) - r.ServeHTTP(w, req) + return w +} +// TestSingleRouteOK tests that POST route is correctly invoked. +func testRouteOK(method string, t *testing.T) { + // SETUP + passed := false + r := New() + r.Handle(method, "/test", []HandlerFunc{func(c *Context) { + passed = true + }}) + + // RUN + w := PerformRequest(r, method, "/test") + + // TEST if passed == false { - t.Errorf("GET route handler was not invoked.") + t.Errorf(method + " route handler was not invoked.") } - if w.Code != http.StatusOK { t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) } } +func TestRouterGroupRouteOK(t *testing.T) { + testRouteOK("POST", t) + testRouteOK("DELETE", t) + testRouteOK("PATCH", t) + testRouteOK("PUT", t) + testRouteOK("OPTIONS", t) + testRouteOK("HEAD", t) +} -// TestRouterGroupGETNoRootExistsRouteOK tests that a GET requse to root is correctly -// handled (404) when no root route exists. -func TestRouterGroupGETNoRootExistsRouteOK(t *testing.T) { - req, _ := http.NewRequest("GET", "/", nil) - w := httptest.NewRecorder() +// TestSingleRouteOK tests that POST route is correctly invoked. +func testRouteNotOK(method string, t *testing.T) { + // SETUP + passed := false + r := New() + r.Handle(method, "/test_2", []HandlerFunc{func(c *Context) { + passed = true + }}) - r := Default() - r.GET("/test", func(c *Context) { - }) - - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, method, "/test") + // TEST + if passed == true { + t.Errorf(method + " route handler was invoked, when it should not") + } if w.Code != http.StatusNotFound { // If this fails, it's because httprouter needs to be updated to at least f78f58a0db t.Errorf("Status code should be %v, was %d. Location: %s", http.StatusNotFound, w.Code, w.HeaderMap.Get("Location")) } } -// TestRouterGroupPOSTRouteOK tests that POST route is correctly invoked. -func TestRouterGroupPOSTRouteOK(t *testing.T) { - req, _ := http.NewRequest("POST", "/test", nil) - w := httptest.NewRecorder() - passed := false - - r := Default() - r.POST("/test", func(c *Context) { - passed = true - }) - - r.ServeHTTP(w, req) - - if passed == false { - t.Errorf("POST route handler was not invoked.") - } - - if w.Code != http.StatusOK { - t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) - } +// TestSingleRouteOK tests that POST route is correctly invoked. +func TestRouteNotOK(t *testing.T) { + testRouteNotOK("POST", t) + testRouteNotOK("DELETE", t) + testRouteNotOK("PATCH", t) + testRouteNotOK("PUT", t) + testRouteNotOK("OPTIONS", t) + testRouteNotOK("HEAD", t) } -// TestRouterGroupDELETERouteOK tests that DELETE route is correctly invoked. -func TestRouterGroupDELETERouteOK(t *testing.T) { - req, _ := http.NewRequest("DELETE", "/test", nil) - w := httptest.NewRecorder() +// TestSingleRouteOK tests that POST route is correctly invoked. +func testRouteNotOK2(method string, t *testing.T) { + // SETUP passed := false - - r := Default() - r.DELETE("/test", func(c *Context) { + r := New() + var methodRoute string + if method == "POST" { + methodRoute = "GET" + } else { + methodRoute = "POST" + } + r.Handle(methodRoute, "/test", []HandlerFunc{func(c *Context) { passed = true - }) + }}) - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, method, "/test") - if passed == false { - t.Errorf("DELETE route handler was not invoked.") + // TEST + if passed == true { + t.Errorf(method + " route handler was invoked, when it should not") } - - if w.Code != http.StatusOK { - t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) - } -} - -// TestRouterGroupPATCHRouteOK tests that PATCH route is correctly invoked. -func TestRouterGroupPATCHRouteOK(t *testing.T) { - req, _ := http.NewRequest("PATCH", "/test", nil) - w := httptest.NewRecorder() - passed := false - - r := Default() - r.PATCH("/test", func(c *Context) { - passed = true - }) - - r.ServeHTTP(w, req) - - if passed == false { - t.Errorf("PATCH route handler was not invoked.") - } - - if w.Code != http.StatusOK { - t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) - } -} - -// TestRouterGroupPUTRouteOK tests that PUT route is correctly invoked. -func TestRouterGroupPUTRouteOK(t *testing.T) { - req, _ := http.NewRequest("PUT", "/test", nil) - w := httptest.NewRecorder() - passed := false - - r := Default() - r.PUT("/test", func(c *Context) { - passed = true - }) - - r.ServeHTTP(w, req) - - if passed == false { - t.Errorf("PUT route handler was not invoked.") - } - - if w.Code != http.StatusOK { - t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) - } -} - -// TestRouterGroupOPTIONSRouteOK tests that OPTIONS route is correctly invoked. -func TestRouterGroupOPTIONSRouteOK(t *testing.T) { - req, _ := http.NewRequest("OPTIONS", "/test", nil) - w := httptest.NewRecorder() - passed := false - - r := Default() - r.OPTIONS("/test", func(c *Context) { - passed = true - }) - - r.ServeHTTP(w, req) - - if passed == false { - t.Errorf("OPTIONS route handler was not invoked.") - } - - if w.Code != http.StatusOK { - t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) - } -} - -// TestRouterGroupHEADRouteOK tests that HEAD route is correctly invoked. -func TestRouterGroupHEADRouteOK(t *testing.T) { - req, _ := http.NewRequest("HEAD", "/test", nil) - w := httptest.NewRecorder() - passed := false - - r := Default() - r.HEAD("/test", func(c *Context) { - passed = true - }) - - r.ServeHTTP(w, req) - - if passed == false { - t.Errorf("HEAD route handler was not invoked.") - } - - if w.Code != http.StatusOK { - t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) - } -} - -// TestRouterGroup404 tests that 404 is returned for a route that does not exist. -func TestEngine404(t *testing.T) { - req, _ := http.NewRequest("GET", "/", nil) - w := httptest.NewRecorder() - - r := Default() - r.ServeHTTP(w, req) - if w.Code != http.StatusNotFound { - t.Errorf("Response code should be %v, was %d", http.StatusNotFound, w.Code) + // If this fails, it's because httprouter needs to be updated to at least f78f58a0db + t.Errorf("Status code should be %v, was %d. Location: %s", http.StatusNotFound, w.Code, w.HeaderMap.Get("Location")) } } +// TestSingleRouteOK tests that POST route is correctly invoked. +func TestRouteNotOK2(t *testing.T) { + testRouteNotOK2("POST", t) + testRouteNotOK2("DELETE", t) + testRouteNotOK2("PATCH", t) + testRouteNotOK2("PUT", t) + testRouteNotOK2("OPTIONS", t) + testRouteNotOK2("HEAD", t) +} + // TestHandleStaticFile - ensure the static file handles properly func TestHandleStaticFile(t *testing.T) { - + // SETUP file testRoot, _ := os.Getwd() - f, err := ioutil.TempFile(testRoot, "") - defer os.Remove(f.Name()) - if err != nil { t.Error(err) } - + defer os.Remove(f.Name()) filePath := path.Join("/", path.Base(f.Name())) - req, _ := http.NewRequest("GET", filePath, nil) - f.WriteString("Gin Web Framework") f.Close() - w := httptest.NewRecorder() - - r := Default() + // SETUP gin + r := New() r.Static("./", testRoot) - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "GET", filePath) + // TEST if w.Code != 200 { t.Errorf("Response code should be Ok, was: %s", w.Code) } - if w.Body.String() != "Gin Web Framework" { t.Errorf("Response should be test, was: %s", w.Body.String()) } - if w.HeaderMap.Get("Content-Type") != "text/plain; charset=utf-8" { t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) } @@ -235,30 +150,24 @@ func TestHandleStaticFile(t *testing.T) { // TestHandleStaticDir - ensure the root/sub dir handles properly func TestHandleStaticDir(t *testing.T) { - - req, _ := http.NewRequest("GET", "/", nil) - - w := httptest.NewRecorder() - - r := Default() + // SETUP + r := New() r.Static("/", "./") - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "GET", "/") + // TEST + bodyAsString := w.Body.String() if w.Code != 200 { t.Errorf("Response code should be Ok, was: %s", w.Code) } - - bodyAsString := w.Body.String() - if len(bodyAsString) == 0 { t.Errorf("Got empty body instead of file tree") } - if !strings.Contains(bodyAsString, "gin.go") { t.Errorf("Can't find:`gin.go` in file tree: %s", bodyAsString) } - if w.HeaderMap.Get("Content-Type") != "text/html; charset=utf-8" { t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) } @@ -266,29 +175,24 @@ func TestHandleStaticDir(t *testing.T) { // TestHandleHeadToDir - ensure the root/sub dir handles properly func TestHandleHeadToDir(t *testing.T) { - - req, _ := http.NewRequest("HEAD", "/", nil) - - w := httptest.NewRecorder() - - r := Default() + // SETUP + r := New() r.Static("/", "./") - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "HEAD", "/") + // TEST + bodyAsString := w.Body.String() if w.Code != 200 { t.Errorf("Response code should be Ok, was: %s", w.Code) } - - bodyAsString := w.Body.String() - if len(bodyAsString) == 0 { t.Errorf("Got empty body instead of file tree") } if !strings.Contains(bodyAsString, "gin.go") { t.Errorf("Can't find:`gin.go` in file tree: %s", bodyAsString) } - if w.HeaderMap.Get("Content-Type") != "text/html; charset=utf-8" { t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) } diff --git a/recovery_test.go b/recovery_test.go index 7383a1df..9d3d0880 100644 --- a/recovery_test.go +++ b/recovery_test.go @@ -3,26 +3,22 @@ package gin import ( "bytes" "log" - "net/http" - "net/http/httptest" "os" "testing" ) // TestPanicInHandler assert that panic has been recovered. func TestPanicInHandler(t *testing.T) { - req, _ := http.NewRequest("GET", "/recovery", nil) - w := httptest.NewRecorder() - - // Disable panic logs for testing - log.SetOutput(bytes.NewBuffer(nil)) - - r := Default() + // SETUP + log.SetOutput(bytes.NewBuffer(nil)) // Disable panic logs for testing + r := New() + r.Use(Recovery()) r.GET("/recovery", func(_ *Context) { panic("Oupps, Houston, we have a problem") }) - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "GET", "/recovery") // restore logging log.SetOutput(os.Stderr) @@ -30,51 +26,27 @@ func TestPanicInHandler(t *testing.T) { if w.Code != 500 { t.Errorf("Response code should be Internal Server Error, was: %s", w.Code) } - bodyAsString := w.Body.String() - - //fixme: no message provided? - if bodyAsString != "" { - t.Errorf("Response body should be empty, was %s", bodyAsString) - } - //fixme: - if len(w.HeaderMap) != 0 { - t.Errorf("No headers should be provided, was %s", w.HeaderMap) - } - } // TestPanicWithAbort assert that panic has been recovered even if context.Abort was used. func TestPanicWithAbort(t *testing.T) { - req, _ := http.NewRequest("GET", "/recovery", nil) - w := httptest.NewRecorder() - - // Disable panic logs for testing + // SETUP log.SetOutput(bytes.NewBuffer(nil)) - - r := Default() + r := New() + r.Use(Recovery()) r.GET("/recovery", func(c *Context) { c.Abort(400) panic("Oupps, Houston, we have a problem") }) - r.ServeHTTP(w, req) + // RUN + w := PerformRequest(r, "GET", "/recovery") // restore logging log.SetOutput(os.Stderr) - // fixme: why not 500? - if w.Code != 400 { + // TEST + if w.Code != 500 { t.Errorf("Response code should be Bad request, was: %s", w.Code) } - bodyAsString := w.Body.String() - - //fixme: no message provided? - if bodyAsString != "" { - t.Errorf("Response body should be empty, was %s", bodyAsString) - } - //fixme: - if len(w.HeaderMap) != 0 { - t.Errorf("No headers should be provided, was %s", w.HeaderMap) - } - }