First commit to v3, #665

Signed-off-by: Vishal Rana <vr@labstack.com>
2025-06-23 00:38:07 +02:00 · 2016-09-22 22:53:44 -07:00
parent 04f45046b1
commit 2aec0353f5
66 changed files with 656 additions and 3264 deletions
--- a/context_test.go
+++ b/context_test.go
@ -6,6 +6,7 @@ import (
 	"io"
 	"mime/multipart"
 	"net/http"
+	"net/http/httptest"
 	"os"
 	"testing"
 	"text/template"
@ -19,7 +20,6 @@ import (

 	"encoding/xml"

-	"github.com/labstack/echo/test"
 	"github.com/stretchr/testify/assert"
 )

@ -35,185 +35,182 @@ func (t *Template) Render(w io.Writer, name string, data interface{}, c Context)

 func TestContext(t *testing.T) {
 	e := New()
-	req := test.NewRequest(POST, "/", strings.NewReader(userJSON))
-	rec := test.NewResponseRecorder()
+	req, _ := http.NewRequest(POST, "/", strings.NewReader(userJSON))
+	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec).(*echoContext)

 	// Echo
 	assert.Equal(t, e, c.Echo())

 	// Request
-	assert.Equal(t, req, c.Request())
+	assert.NotNil(t, c.Request())

 	// Response
-	assert.Equal(t, rec, c.Response())
-
-	// Logger
-	assert.Equal(t, e.logger, c.Logger())
+	assert.NotNil(t, c.Response())

 	//--------
 	// Render
 	//--------

-	tpl := &Template{
+	tmpl := &Template{
 		templates: template.Must(template.New("hello").Parse("Hello, {{.}}!")),
 	}
-	c.echo.SetRenderer(tpl)
+	c.echo.Renderer = tmpl
 	err := c.Render(http.StatusOK, "hello", "Jon Snow")
 	if assert.NoError(t, err) {
-		assert.Equal(t, http.StatusOK, rec.Status())
+		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, "Hello, Jon Snow!", rec.Body.String())
 	}

-	c.echo.renderer = nil
+	c.echo.Renderer = nil
 	err = c.Render(http.StatusOK, "hello", "Jon Snow")
 	assert.Error(t, err)

 	// JSON
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	err = c.JSON(http.StatusOK, user{1, "Jon Snow"})
 	if assert.NoError(t, err) {
-		assert.Equal(t, http.StatusOK, rec.Status())
+		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, MIMEApplicationJSONCharsetUTF8, rec.Header().Get(HeaderContentType))
 		assert.Equal(t, userJSON, rec.Body.String())
 	}

 	// JSON (error)
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	err = c.JSON(http.StatusOK, make(chan bool))
 	assert.Error(t, err)

 	// JSONP
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	callback := "callback"
 	err = c.JSONP(http.StatusOK, callback, user{1, "Jon Snow"})
 	if assert.NoError(t, err) {
-		assert.Equal(t, http.StatusOK, rec.Status())
+		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, MIMEApplicationJavaScriptCharsetUTF8, rec.Header().Get(HeaderContentType))
 		assert.Equal(t, callback+"("+userJSON+");", rec.Body.String())
 	}

 	// XML
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	err = c.XML(http.StatusOK, user{1, "Jon Snow"})
 	if assert.NoError(t, err) {
-		assert.Equal(t, http.StatusOK, rec.Status())
+		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, MIMEApplicationXMLCharsetUTF8, rec.Header().Get(HeaderContentType))
 		assert.Equal(t, xml.Header+userXML, rec.Body.String())
 	}

 	// XML (error)
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	err = c.XML(http.StatusOK, make(chan bool))
 	assert.Error(t, err)

 	// String
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	err = c.String(http.StatusOK, "Hello, World!")
 	if assert.NoError(t, err) {
-		assert.Equal(t, http.StatusOK, rec.Status())
+		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, MIMETextPlainCharsetUTF8, rec.Header().Get(HeaderContentType))
 		assert.Equal(t, "Hello, World!", rec.Body.String())
 	}

 	// HTML
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	err = c.HTML(http.StatusOK, "Hello, <strong>World!</strong>")
 	if assert.NoError(t, err) {
-		assert.Equal(t, http.StatusOK, rec.Status())
+		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, MIMETextHTMLCharsetUTF8, rec.Header().Get(HeaderContentType))
 		assert.Equal(t, "Hello, <strong>World!</strong>", rec.Body.String())
 	}

 	// Stream
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	r := strings.NewReader("response from a stream")
 	err = c.Stream(http.StatusOK, "application/octet-stream", r)
 	if assert.NoError(t, err) {
-		assert.Equal(t, http.StatusOK, rec.Status())
+		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, "application/octet-stream", rec.Header().Get(HeaderContentType))
 		assert.Equal(t, "response from a stream", rec.Body.String())
 	}

 	// Attachment
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	file, err := os.Open("_fixture/images/walle.png")
 	if assert.NoError(t, err) {
 		err = c.Attachment(file, "walle.png")
 		if assert.NoError(t, err) {
-			assert.Equal(t, http.StatusOK, rec.Status())
+			assert.Equal(t, http.StatusOK, rec.Code)
 			assert.Equal(t, "attachment; filename=walle.png", rec.Header().Get(HeaderContentDisposition))
 			assert.Equal(t, 219885, rec.Body.Len())
 		}
 	}

 	// Inline
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	file, err = os.Open("_fixture/images/walle.png")
 	if assert.NoError(t, err) {
 		err = c.Inline(file, "walle.png")
 		if assert.NoError(t, err) {
-			assert.Equal(t, http.StatusOK, rec.Status())
+			assert.Equal(t, http.StatusOK, rec.Code)
 			assert.Equal(t, "inline; filename=walle.png", rec.Header().Get(HeaderContentDisposition))
 			assert.Equal(t, 219885, rec.Body.Len())
 		}
 	}

 	// NoContent
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	c.NoContent(http.StatusOK)
-	assert.Equal(t, http.StatusOK, rec.Status())
+	assert.Equal(t, http.StatusOK, rec.Code)

 	// Error
-	rec = test.NewResponseRecorder()
+	rec = httptest.NewRecorder()
 	c = e.NewContext(req, rec).(*echoContext)
 	c.Error(errors.New("error"))
-	assert.Equal(t, http.StatusInternalServerError, rec.Status())
+	assert.Equal(t, http.StatusInternalServerError, rec.Code)

 	// Reset
-	c.Reset(req, test.NewResponseRecorder())
+	c.Reset(req, httptest.NewRecorder())
 }

 func TestContextCookie(t *testing.T) {
 	e := New()
-	req := test.NewRequest(GET, "/", nil)
+	req, _ := http.NewRequest(GET, "/", nil)
 	theme := "theme=light"
 	user := "user=Jon Snow"
-	req.Header().Add(HeaderCookie, theme)
-	req.Header().Add(HeaderCookie, user)
-	rec := test.NewResponseRecorder()
+	req.Header.Add(HeaderCookie, theme)
+	req.Header.Add(HeaderCookie, user)
+	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec).(*echoContext)

 	// Read single
 	cookie, err := c.Cookie("theme")
 	if assert.NoError(t, err) {
-		assert.Equal(t, "theme", cookie.Name())
-		assert.Equal(t, "light", cookie.Value())
+		assert.Equal(t, "theme", cookie.Name)
+		assert.Equal(t, "light", cookie.Value)
 	}

 	// Read multiple
 	for _, cookie := range c.Cookies() {
-		switch cookie.Name() {
+		switch cookie.Name {
 		case "theme":
-			assert.Equal(t, "light", cookie.Value())
+			assert.Equal(t, "light", cookie.Value)
 		case "user":
-			assert.Equal(t, "Jon Snow", cookie.Value())
+			assert.Equal(t, "Jon Snow", cookie.Value)
 		}
 	}

 	// Write
-	cookie = &test.Cookie{Cookie: &http.Cookie{
+	cookie = &http.Cookie{
 		Name:     "SSID",
 		Value:    "Ap4PGTEq",
 		Domain:   "labstack.com",
@ -221,7 +218,7 @@ func TestContextCookie(t *testing.T) {
 		Expires:  time.Now(),
 		Secure:   true,
 		HttpOnly: true,
-	}}
+	}
 	c.SetCookie(cookie)
 	assert.Contains(t, rec.Header().Get(HeaderSetCookie), "SSID")
 	assert.Contains(t, rec.Header().Get(HeaderSetCookie), "Ap4PGTEq")
@ -247,7 +244,7 @@ func TestContextPath(t *testing.T) {

 func TestContextPathParam(t *testing.T) {
 	e := New()
-	req := test.NewRequest(GET, "/", nil)
+	req, _ := http.NewRequest(GET, "/", nil)
 	c := e.NewContext(req, nil)

 	// ParamNames
@ -271,8 +268,8 @@ func TestContextFormValue(t *testing.T) {
 	f.Set("email", "jon@labstack.com")

 	e := New()
-	req := test.NewRequest(POST, "/", strings.NewReader(f.Encode()))
-	req.Header().Add(HeaderContentType, MIMEApplicationForm)
+	req, _ := http.NewRequest(POST, "/", strings.NewReader(f.Encode()))
+	req.Header.Add(HeaderContentType, MIMEApplicationForm)
 	c := e.NewContext(req, nil)

 	// FormValue
@ -280,17 +277,20 @@ func TestContextFormValue(t *testing.T) {
 	assert.Equal(t, "jon@labstack.com", c.FormValue("email"))

 	// FormParams
-	assert.Equal(t, map[string][]string{
-		"name":  []string{"Jon Snow"},
-		"email": []string{"jon@labstack.com"},
-	}, c.FormParams())
+	params, err := c.FormParams()
+	if assert.NoError(t, err) {
+		assert.Equal(t, url.Values{
+			"name":  []string{"Jon Snow"},
+			"email": []string{"jon@labstack.com"},
+		}, params)
+	}
 }

 func TestContextQueryParam(t *testing.T) {
 	q := make(url.Values)
 	q.Set("name", "Jon Snow")
 	q.Set("email", "jon@labstack.com")
-	req := test.NewRequest(GET, "/?"+q.Encode(), nil)
+	req, _ := http.NewRequest(GET, "/?"+q.Encode(), nil)
 	e := New()
 	c := e.NewContext(req, nil)

@ -299,7 +299,7 @@ func TestContextQueryParam(t *testing.T) {
 	assert.Equal(t, "jon@labstack.com", c.QueryParam("email"))

 	// QueryParams
-	assert.Equal(t, map[string][]string{
+	assert.Equal(t, url.Values{
 		"name":  []string{"Jon Snow"},
 		"email": []string{"jon@labstack.com"},
 	}, c.QueryParams())
@ -314,9 +314,9 @@ func TestContextFormFile(t *testing.T) {
 		w.Write([]byte("test"))
 	}
 	mr.Close()
-	req := test.NewRequest(POST, "/", buf)
-	req.Header().Set(HeaderContentType, mr.FormDataContentType())
-	rec := test.NewResponseRecorder()
+	req, _ := http.NewRequest(POST, "/", buf)
+	req.Header.Set(HeaderContentType, mr.FormDataContentType())
+	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec)
 	f, err := c.FormFile("file")
 	if assert.NoError(t, err) {
@ -330,9 +330,9 @@ func TestContextMultipartForm(t *testing.T) {
 	mw := multipart.NewWriter(buf)
 	mw.WriteField("name", "Jon Snow")
 	mw.Close()
-	req := test.NewRequest(POST, "/", buf)
-	req.Header().Set(HeaderContentType, mw.FormDataContentType())
-	rec := test.NewResponseRecorder()
+	req, _ := http.NewRequest(POST, "/", buf)
+	req.Header.Set(HeaderContentType, mw.FormDataContentType())
+	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec)
 	f, err := c.MultipartForm()
 	if assert.NoError(t, err) {
@ -342,11 +342,11 @@ func TestContextMultipartForm(t *testing.T) {

 func TestContextRedirect(t *testing.T) {
 	e := New()
-	req := test.NewRequest(GET, "/", nil)
-	rec := test.NewResponseRecorder()
+	req, _ := http.NewRequest(GET, "/", nil)
+	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec)
 	assert.Equal(t, nil, c.Redirect(http.StatusMovedPermanently, "http://labstack.github.io/echo"))
-	assert.Equal(t, http.StatusMovedPermanently, rec.Status())
+	assert.Equal(t, http.StatusMovedPermanently, rec.Code)
 	assert.Equal(t, "http://labstack.github.io/echo", rec.Header().Get(HeaderLocation))
 	assert.Error(t, c.Redirect(310, "http://labstack.github.io/echo"))
 }
@ -374,8 +374,8 @@ func TestContextStore(t *testing.T) {

 func TestContextServeContent(t *testing.T) {
 	e := New()
-	req := test.NewRequest(GET, "/", nil)
-	rec := test.NewResponseRecorder()
+	req, _ := http.NewRequest(GET, "/", nil)
+	rec := httptest.NewRecorder()
 	c := e.NewContext(req, rec)

 	fs := http.Dir("_fixture/images")
@ -385,15 +385,15 @@ func TestContextServeContent(t *testing.T) {
 		if assert.NoError(t, err) {
 			// Not cached
 			if assert.NoError(t, c.ServeContent(f, fi.Name(), fi.ModTime())) {
-				assert.Equal(t, http.StatusOK, rec.Status())
+				assert.Equal(t, http.StatusOK, rec.Code)
 			}

 			// Cached
-			rec = test.NewResponseRecorder()
+			rec = httptest.NewRecorder()
 			c = e.NewContext(req, rec)
-			req.Header().Set(HeaderIfModifiedSince, fi.ModTime().UTC().Format(http.TimeFormat))
+			req.Header.Set(HeaderIfModifiedSince, fi.ModTime().UTC().Format(http.TimeFormat))
 			if assert.NoError(t, c.ServeContent(f, fi.Name(), fi.ModTime())) {
-				assert.Equal(t, http.StatusNotModified, rec.Status())
+				assert.Equal(t, http.StatusNotModified, rec.Code)
 			}
 		}
 	}