From 6abe841c1fc6306f7d9f1ee6aed527dd195deb9e Mon Sep 17 00:00:00 2001 From: Sasha Myasoedov Date: Fri, 8 Aug 2014 14:48:15 +0300 Subject: [PATCH] Splited tests into separate files --- context_test.go | 252 ++++++++++++++++++++++++++++++++++++++++++++++++ gin_test.go | 245 ---------------------------------------------- 2 files changed, 252 insertions(+), 245 deletions(-) create mode 100644 context_test.go diff --git a/context_test.go b/context_test.go new file mode 100644 index 00000000..84801273 --- /dev/null +++ b/context_test.go @@ -0,0 +1,252 @@ +package gin + +import ( + "errors" + "html/template" + "net/http" + "net/http/httptest" + "testing" +) + +// TestContextParamsGet tests that a parameter can be parsed from the URL. +func TestContextParamsByName(t *testing.T) { + req, _ := http.NewRequest("GET", "/test/alexandernyquist", nil) + w := httptest.NewRecorder() + name := "" + + r := Default() + r.GET("/test/:name", func(c *Context) { + name = c.Params.ByName("name") + }) + + r.ServeHTTP(w, req) + + if name != "alexandernyquist" { + t.Errorf("Url parameter was not correctly parsed. Should be alexandernyquist, was %s.", name) + } +} + +// TestContextSetGet tests that a parameter is set correctly on the +// current context and can be retrieved using Get. +func TestContextSetGet(t *testing.T) { + req, _ := http.NewRequest("GET", "/test", nil) + w := httptest.NewRecorder() + + r := Default() + r.GET("/test", func(c *Context) { + // Key should be lazily created + if c.Keys != nil { + t.Error("Keys should be nil") + } + + // Set + c.Set("foo", "bar") + + v, err := c.Get("foo") + if err != nil { + t.Errorf("Error on exist key") + } + if v != "bar" { + t.Errorf("Value should be bar, was %s", v) + } + }) + + r.ServeHTTP(w, req) +} + +// TestContextJSON tests that the response is serialized as JSON +// and Content-Type is set to application/json +func TestContextJSON(t *testing.T) { + req, _ := http.NewRequest("GET", "/test", nil) + w := httptest.NewRecorder() + + r := Default() + r.GET("/test", func(c *Context) { + c.JSON(200, H{"foo": "bar"}) + }) + + r.ServeHTTP(w, req) + + if w.Body.String() != "{\"foo\":\"bar\"}\n" { + t.Errorf("Response should be {\"foo\":\"bar\"}, was: %s", w.Body.String()) + } + + if w.HeaderMap.Get("Content-Type") != "application/json" { + t.Errorf("Content-Type should be application/json, was %s", w.HeaderMap.Get("Content-Type")) + } +} + +// TestContextHTML tests that the response executes the templates +// and responds with Content-Type set to text/html +func TestContextHTML(t *testing.T) { + req, _ := http.NewRequest("GET", "/test", nil) + w := httptest.NewRecorder() + + r := Default() + templ, _ := template.New("t").Parse(`Hello {{.Name}}`) + r.SetHTMLTemplate(templ) + + type TestData struct{ Name string } + + r.GET("/test", func(c *Context) { + c.HTML(200, "t", TestData{"alexandernyquist"}) + }) + + r.ServeHTTP(w, req) + + if w.Body.String() != "Hello alexandernyquist" { + t.Errorf("Response should be Hello alexandernyquist, was: %s", w.Body.String()) + } + + if w.HeaderMap.Get("Content-Type") != "text/html" { + t.Errorf("Content-Type should be text/html, was %s", w.HeaderMap.Get("Content-Type")) + } +} + +// TestContextString tests that the response is returned +// with Content-Type set to text/plain +func TestContextString(t *testing.T) { + req, _ := http.NewRequest("GET", "/test", nil) + w := httptest.NewRecorder() + + r := Default() + r.GET("/test", func(c *Context) { + c.String(200, "test") + }) + + r.ServeHTTP(w, req) + + if w.Body.String() != "test" { + t.Errorf("Response should be test, was: %s", w.Body.String()) + } + + if w.HeaderMap.Get("Content-Type") != "text/plain" { + t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) + } +} + +// TestHandlerFunc - ensure that custom middleware works properly +func TestHandlerFunc(t *testing.T) { + + req, _ := http.NewRequest("GET", "/", nil) + w := httptest.NewRecorder() + + r := Default() + var stepsPassed int = 0 + + r.Use(func(context *Context) { + stepsPassed += 1 + context.Next() + stepsPassed += 1 + }) + + r.ServeHTTP(w, req) + + if w.Code != 404 { + t.Errorf("Response code should be Not found, was: %s", w.Code) + } + + if stepsPassed != 2 { + t.Errorf("Falied to switch context in handler function: %s", stepsPassed) + } +} + +// 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() + var stepsPassed int = 0 + + r.Use(func(context *Context) { + stepsPassed += 1 + context.Next() + stepsPassed += 1 + // after check and abort + context.Abort(409) + }, + func(context *Context) { + stepsPassed += 1 + context.Next() + stepsPassed += 1 + context.Abort(403) + }, + ) + + r.ServeHTTP(w, req) + + if w.Code != 403 { + t.Errorf("Response code should be Forbiden, was: %s", w.Code) + } + + if stepsPassed != 4 { + t.Errorf("Falied to switch context in handler function: %s", 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() + var stepsPassed int = 0 + + r.Use(func(context *Context) { + stepsPassed += 1 + context.Abort(409) + }, + func(context *Context) { + stepsPassed += 1 + context.Next() + stepsPassed += 1 + }, + ) + + r.ServeHTTP(w, req) + + if w.Code != 409 { + t.Errorf("Response code should be Conflict, was: %s", w.Code) + } + + if stepsPassed != 1 { + t.Errorf("Falied to switch context in handler function: %s", 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() + var stepsPassed int = 0 + + r.Use(func(context *Context) { + stepsPassed += 1 + + context.Fail(500, errors.New("foo")) + }, + func(context *Context) { + stepsPassed += 1 + context.Next() + stepsPassed += 1 + }, + ) + + r.ServeHTTP(w, req) + + if w.Code != 500 { + t.Errorf("Response code should be Server error, was: %s", w.Code) + } + + if stepsPassed != 1 { + t.Errorf("Falied to switch context in handler function: %s", stepsPassed) + } + +} diff --git a/gin_test.go b/gin_test.go index 60fa148f..61b3c351 100644 --- a/gin_test.go +++ b/gin_test.go @@ -1,8 +1,6 @@ package gin import ( - "errors" - "html/template" "io/ioutil" "net/http" "net/http/httptest" @@ -197,123 +195,6 @@ func TestEngine404(t *testing.T) { } } -// TestContextParamsGet tests that a parameter can be parsed from the URL. -func TestContextParamsByName(t *testing.T) { - req, _ := http.NewRequest("GET", "/test/alexandernyquist", nil) - w := httptest.NewRecorder() - name := "" - - r := Default() - r.GET("/test/:name", func(c *Context) { - name = c.Params.ByName("name") - }) - - r.ServeHTTP(w, req) - - if name != "alexandernyquist" { - t.Errorf("Url parameter was not correctly parsed. Should be alexandernyquist, was %s.", name) - } -} - -// TestContextSetGet tests that a parameter is set correctly on the -// current context and can be retrieved using Get. -func TestContextSetGet(t *testing.T) { - req, _ := http.NewRequest("GET", "/test", nil) - w := httptest.NewRecorder() - - r := Default() - r.GET("/test", func(c *Context) { - // Key should be lazily created - if c.Keys != nil { - t.Error("Keys should be nil") - } - - // Set - c.Set("foo", "bar") - - v, err := c.Get("foo") - if err != nil { - t.Errorf("Error on exist key") - } - if v != "bar" { - t.Errorf("Value should be bar, was %s", v) - } - }) - - r.ServeHTTP(w, req) -} - -// TestContextJSON tests that the response is serialized as JSON -// and Content-Type is set to application/json -func TestContextJSON(t *testing.T) { - req, _ := http.NewRequest("GET", "/test", nil) - w := httptest.NewRecorder() - - r := Default() - r.GET("/test", func(c *Context) { - c.JSON(200, H{"foo": "bar"}) - }) - - r.ServeHTTP(w, req) - - if w.Body.String() != "{\"foo\":\"bar\"}\n" { - t.Errorf("Response should be {\"foo\":\"bar\"}, was: %s", w.Body.String()) - } - - if w.HeaderMap.Get("Content-Type") != "application/json" { - t.Errorf("Content-Type should be application/json, was %s", w.HeaderMap.Get("Content-Type")) - } -} - -// TestContextHTML tests that the response executes the templates -// and responds with Content-Type set to text/html -func TestContextHTML(t *testing.T) { - req, _ := http.NewRequest("GET", "/test", nil) - w := httptest.NewRecorder() - - r := Default() - templ, _ := template.New("t").Parse(`Hello {{.Name}}`) - r.SetHTMLTemplate(templ) - - type TestData struct{ Name string } - - r.GET("/test", func(c *Context) { - c.HTML(200, "t", TestData{"alexandernyquist"}) - }) - - r.ServeHTTP(w, req) - - if w.Body.String() != "Hello alexandernyquist" { - t.Errorf("Response should be Hello alexandernyquist, was: %s", w.Body.String()) - } - - if w.HeaderMap.Get("Content-Type") != "text/html" { - t.Errorf("Content-Type should be text/html, was %s", w.HeaderMap.Get("Content-Type")) - } -} - -// TestContextString tests that the response is returned -// with Content-Type set to text/plain -func TestContextString(t *testing.T) { - req, _ := http.NewRequest("GET", "/test", nil) - w := httptest.NewRecorder() - - r := Default() - r.GET("/test", func(c *Context) { - c.String(200, "test") - }) - - r.ServeHTTP(w, req) - - if w.Body.String() != "test" { - t.Errorf("Response should be test, was: %s", w.Body.String()) - } - - if w.HeaderMap.Get("Content-Type") != "text/plain" { - t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) - } -} - // TestHandleStaticFile - ensure the static file handles properly func TestHandleStaticFile(t *testing.T) { @@ -412,129 +293,3 @@ func TestHandleHeadToDir(t *testing.T) { t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) } } - -// TestHandlerFunc - ensure that custom middleware works properly -func TestHandlerFunc(t *testing.T) { - - req, _ := http.NewRequest("GET", "/", nil) - w := httptest.NewRecorder() - - r := Default() - var stepsPassed int = 0 - - r.Use(func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - }) - - r.ServeHTTP(w, req) - - if w.Code != 404 { - t.Errorf("Response code should be Not found, was: %s", w.Code) - } - - if stepsPassed != 2 { - t.Errorf("Falied to switch context in handler function: %s", stepsPassed) - } -} - -// 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() - var stepsPassed int = 0 - - r.Use(func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - // after check and abort - context.Abort(409) - }, - func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - context.Abort(403) - }, - ) - - r.ServeHTTP(w, req) - - if w.Code != 403 { - t.Errorf("Response code should be Forbiden, was: %s", w.Code) - } - - if stepsPassed != 4 { - t.Errorf("Falied to switch context in handler function: %s", 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() - var stepsPassed int = 0 - - r.Use(func(context *Context) { - stepsPassed += 1 - context.Abort(409) - }, - func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - }, - ) - - r.ServeHTTP(w, req) - - if w.Code != 409 { - t.Errorf("Response code should be Conflict, was: %s", w.Code) - } - - if stepsPassed != 1 { - t.Errorf("Falied to switch context in handler function: %s", 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() - var stepsPassed int = 0 - - r.Use(func(context *Context) { - stepsPassed += 1 - - context.Fail(500, errors.New("foo")) - }, - func(context *Context) { - stepsPassed += 1 - context.Next() - stepsPassed += 1 - }, - ) - - r.ServeHTTP(w, req) - - if w.Code != 500 { - t.Errorf("Response code should be Server error, was: %s", w.Code) - } - - if stepsPassed != 1 { - t.Errorf("Falied to switch context in handler function: %s", stepsPassed) - } - -}