123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533 |
- // 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.
- package render
- import (
- "bytes"
- "encoding/xml"
- "errors"
- "html/template"
- "net/http"
- "net/http/httptest"
- "strconv"
- "strings"
- "testing"
- "github.com/golang/protobuf/proto"
- "github.com/stretchr/testify/assert"
- "github.com/ugorji/go/codec"
- testdata "github.com/gin-gonic/gin/testdata/protoexample"
- )
- // TODO unit tests
- // test errors
- func TestRenderMsgPack(t *testing.T) {
- w := httptest.NewRecorder()
- data := map[string]interface{}{
- "foo": "bar",
- }
- (MsgPack{data}).WriteContentType(w)
- assert.Equal(t, "application/msgpack; charset=utf-8", w.Header().Get("Content-Type"))
- err := (MsgPack{data}).Render(w)
- assert.NoError(t, err)
- h := new(codec.MsgpackHandle)
- assert.NotNil(t, h)
- buf := bytes.NewBuffer([]byte{})
- assert.NotNil(t, buf)
- err = codec.NewEncoder(buf, h).Encode(data)
- assert.NoError(t, err)
- assert.Equal(t, w.Body.String(), buf.String())
- assert.Equal(t, "application/msgpack; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderJSON(t *testing.T) {
- w := httptest.NewRecorder()
- data := map[string]interface{}{
- "foo": "bar",
- "html": "<b>",
- }
- (JSON{data}).WriteContentType(w)
- assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
- err := (JSON{data}).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}\n", w.Body.String())
- assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderJSONPanics(t *testing.T) {
- w := httptest.NewRecorder()
- data := make(chan int)
- // json: unsupported type: chan int
- assert.Panics(t, func() { assert.NoError(t, (JSON{data}).Render(w)) })
- }
- func TestRenderIndentedJSON(t *testing.T) {
- w := httptest.NewRecorder()
- data := map[string]interface{}{
- "foo": "bar",
- "bar": "foo",
- }
- err := (IndentedJSON{data}).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "{\n \"bar\": \"foo\",\n \"foo\": \"bar\"\n}", w.Body.String())
- assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderIndentedJSONPanics(t *testing.T) {
- w := httptest.NewRecorder()
- data := make(chan int)
- // json: unsupported type: chan int
- err := (IndentedJSON{data}).Render(w)
- assert.Error(t, err)
- }
- func TestRenderSecureJSON(t *testing.T) {
- w1 := httptest.NewRecorder()
- data := map[string]interface{}{
- "foo": "bar",
- }
- (SecureJSON{"while(1);", data}).WriteContentType(w1)
- assert.Equal(t, "application/json; charset=utf-8", w1.Header().Get("Content-Type"))
- err1 := (SecureJSON{"while(1);", data}).Render(w1)
- assert.NoError(t, err1)
- assert.Equal(t, "{\"foo\":\"bar\"}", w1.Body.String())
- assert.Equal(t, "application/json; charset=utf-8", w1.Header().Get("Content-Type"))
- w2 := httptest.NewRecorder()
- datas := []map[string]interface{}{{
- "foo": "bar",
- }, {
- "bar": "foo",
- }}
- err2 := (SecureJSON{"while(1);", datas}).Render(w2)
- assert.NoError(t, err2)
- assert.Equal(t, "while(1);[{\"foo\":\"bar\"},{\"bar\":\"foo\"}]", w2.Body.String())
- assert.Equal(t, "application/json; charset=utf-8", w2.Header().Get("Content-Type"))
- }
- func TestRenderSecureJSONFail(t *testing.T) {
- w := httptest.NewRecorder()
- data := make(chan int)
- // json: unsupported type: chan int
- err := (SecureJSON{"while(1);", data}).Render(w)
- assert.Error(t, err)
- }
- func TestRenderJsonpJSON(t *testing.T) {
- w1 := httptest.NewRecorder()
- data := map[string]interface{}{
- "foo": "bar",
- }
- (JsonpJSON{"x", data}).WriteContentType(w1)
- assert.Equal(t, "application/javascript; charset=utf-8", w1.Header().Get("Content-Type"))
- err1 := (JsonpJSON{"x", data}).Render(w1)
- assert.NoError(t, err1)
- assert.Equal(t, "x({\"foo\":\"bar\"});", w1.Body.String())
- assert.Equal(t, "application/javascript; charset=utf-8", w1.Header().Get("Content-Type"))
- w2 := httptest.NewRecorder()
- datas := []map[string]interface{}{{
- "foo": "bar",
- }, {
- "bar": "foo",
- }}
- err2 := (JsonpJSON{"x", datas}).Render(w2)
- assert.NoError(t, err2)
- assert.Equal(t, "x([{\"foo\":\"bar\"},{\"bar\":\"foo\"}]);", w2.Body.String())
- assert.Equal(t, "application/javascript; charset=utf-8", w2.Header().Get("Content-Type"))
- }
- func TestRenderJsonpJSONError2(t *testing.T) {
- w := httptest.NewRecorder()
- data := map[string]interface{}{
- "foo": "bar",
- }
- (JsonpJSON{"", data}).WriteContentType(w)
- assert.Equal(t, "application/javascript; charset=utf-8", w.Header().Get("Content-Type"))
- e := (JsonpJSON{"", data}).Render(w)
- assert.NoError(t, e)
- assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
- assert.Equal(t, "application/javascript; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderJsonpJSONFail(t *testing.T) {
- w := httptest.NewRecorder()
- data := make(chan int)
- // json: unsupported type: chan int
- err := (JsonpJSON{"x", data}).Render(w)
- assert.Error(t, err)
- }
- func TestRenderAsciiJSON(t *testing.T) {
- w1 := httptest.NewRecorder()
- data1 := map[string]interface{}{
- "lang": "GO语言",
- "tag": "<br>",
- }
- err := (AsciiJSON{data1}).Render(w1)
- assert.NoError(t, err)
- assert.Equal(t, "{\"lang\":\"GO\\u8bed\\u8a00\",\"tag\":\"\\u003cbr\\u003e\"}", w1.Body.String())
- assert.Equal(t, "application/json", w1.Header().Get("Content-Type"))
- w2 := httptest.NewRecorder()
- data2 := float64(3.1415926)
- err = (AsciiJSON{data2}).Render(w2)
- assert.NoError(t, err)
- assert.Equal(t, "3.1415926", w2.Body.String())
- }
- func TestRenderAsciiJSONFail(t *testing.T) {
- w := httptest.NewRecorder()
- data := make(chan int)
- // json: unsupported type: chan int
- assert.Error(t, (AsciiJSON{data}).Render(w))
- }
- func TestRenderPureJSON(t *testing.T) {
- w := httptest.NewRecorder()
- data := map[string]interface{}{
- "foo": "bar",
- "html": "<b>",
- }
- err := (PureJSON{data}).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"<b>\"}\n", w.Body.String())
- assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
- }
- type xmlmap map[string]interface{}
- // Allows type H to be used with xml.Marshal
- func (h xmlmap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- start.Name = xml.Name{
- Space: "",
- Local: "map",
- }
- if err := e.EncodeToken(start); err != nil {
- return err
- }
- for key, value := range h {
- elem := xml.StartElement{
- Name: xml.Name{Space: "", Local: key},
- Attr: []xml.Attr{},
- }
- if err := e.EncodeElement(value, elem); err != nil {
- return err
- }
- }
- return e.EncodeToken(xml.EndElement{Name: start.Name})
- }
- func TestRenderYAML(t *testing.T) {
- w := httptest.NewRecorder()
- data := `
- a : Easy!
- b:
- c: 2
- d: [3, 4]
- `
- (YAML{data}).WriteContentType(w)
- assert.Equal(t, "application/x-yaml; charset=utf-8", w.Header().Get("Content-Type"))
- err := (YAML{data}).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "\"\\na : Easy!\\nb:\\n\\tc: 2\\n\\td: [3, 4]\\n\\t\"\n", w.Body.String())
- assert.Equal(t, "application/x-yaml; charset=utf-8", w.Header().Get("Content-Type"))
- }
- type fail struct{}
- // Hook MarshalYAML
- func (ft *fail) MarshalYAML() (interface{}, error) {
- return nil, errors.New("fail")
- }
- func TestRenderYAMLFail(t *testing.T) {
- w := httptest.NewRecorder()
- err := (YAML{&fail{}}).Render(w)
- assert.Error(t, err)
- }
- // test Protobuf rendering
- func TestRenderProtoBuf(t *testing.T) {
- w := httptest.NewRecorder()
- reps := []int64{int64(1), int64(2)}
- label := "test"
- data := &testdata.Test{
- Label: &label,
- Reps: reps,
- }
- (ProtoBuf{data}).WriteContentType(w)
- protoData, err := proto.Marshal(data)
- assert.NoError(t, err)
- assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
- err = (ProtoBuf{data}).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, string(protoData), w.Body.String())
- assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
- }
- func TestRenderProtoBufFail(t *testing.T) {
- w := httptest.NewRecorder()
- data := &testdata.Test{}
- err := (ProtoBuf{data}).Render(w)
- assert.Error(t, err)
- }
- func TestRenderXML(t *testing.T) {
- w := httptest.NewRecorder()
- data := xmlmap{
- "foo": "bar",
- }
- (XML{data}).WriteContentType(w)
- assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
- err := (XML{data}).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
- assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderRedirect(t *testing.T) {
- req, err := http.NewRequest("GET", "/test-redirect", nil)
- assert.NoError(t, err)
- data1 := Redirect{
- Code: http.StatusMovedPermanently,
- Request: req,
- Location: "/new/location",
- }
- w := httptest.NewRecorder()
- err = data1.Render(w)
- assert.NoError(t, err)
- data2 := Redirect{
- Code: http.StatusOK,
- Request: req,
- Location: "/new/location",
- }
- w = httptest.NewRecorder()
- assert.PanicsWithValue(t, "Cannot redirect with status code 200", func() { data2.Render(w) })
- data3 := Redirect{
- Code: http.StatusCreated,
- Request: req,
- Location: "/new/location",
- }
- w = httptest.NewRecorder()
- err = data3.Render(w)
- assert.NoError(t, err)
- // only improve coverage
- data2.WriteContentType(w)
- }
- func TestRenderData(t *testing.T) {
- w := httptest.NewRecorder()
- data := []byte("#!PNG some raw data")
- err := (Data{
- ContentType: "image/png",
- Data: data,
- }).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "#!PNG some raw data", w.Body.String())
- assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
- }
- func TestRenderString(t *testing.T) {
- w := httptest.NewRecorder()
- (String{
- Format: "hello %s %d",
- Data: []interface{}{},
- }).WriteContentType(w)
- assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
- err := (String{
- Format: "hola %s %d",
- Data: []interface{}{"manu", 2},
- }).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "hola manu 2", w.Body.String())
- assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderStringLenZero(t *testing.T) {
- w := httptest.NewRecorder()
- err := (String{
- Format: "hola %s %d",
- Data: []interface{}{},
- }).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "hola %s %d", w.Body.String())
- assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderHTMLTemplate(t *testing.T) {
- w := httptest.NewRecorder()
- templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
- htmlRender := HTMLProduction{Template: templ}
- instance := htmlRender.Instance("t", map[string]interface{}{
- "name": "alexandernyquist",
- })
- err := instance.Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "Hello alexandernyquist", w.Body.String())
- assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderHTMLTemplateEmptyName(t *testing.T) {
- w := httptest.NewRecorder()
- templ := template.Must(template.New("").Parse(`Hello {{.name}}`))
- htmlRender := HTMLProduction{Template: templ}
- instance := htmlRender.Instance("", map[string]interface{}{
- "name": "alexandernyquist",
- })
- err := instance.Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "Hello alexandernyquist", w.Body.String())
- assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderHTMLDebugFiles(t *testing.T) {
- w := httptest.NewRecorder()
- htmlRender := HTMLDebug{Files: []string{"../testdata/template/hello.tmpl"},
- Glob: "",
- Delims: Delims{Left: "{[{", Right: "}]}"},
- FuncMap: nil,
- }
- instance := htmlRender.Instance("hello.tmpl", map[string]interface{}{
- "name": "thinkerou",
- })
- err := instance.Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "<h1>Hello thinkerou</h1>", w.Body.String())
- assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderHTMLDebugGlob(t *testing.T) {
- w := httptest.NewRecorder()
- htmlRender := HTMLDebug{Files: nil,
- Glob: "../testdata/template/hello*",
- Delims: Delims{Left: "{[{", Right: "}]}"},
- FuncMap: nil,
- }
- instance := htmlRender.Instance("hello.tmpl", map[string]interface{}{
- "name": "thinkerou",
- })
- err := instance.Render(w)
- assert.NoError(t, err)
- assert.Equal(t, "<h1>Hello thinkerou</h1>", w.Body.String())
- assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
- }
- func TestRenderHTMLDebugPanics(t *testing.T) {
- htmlRender := HTMLDebug{Files: nil,
- Glob: "",
- Delims: Delims{"{{", "}}"},
- FuncMap: nil,
- }
- assert.Panics(t, func() { htmlRender.Instance("", nil) })
- }
- func TestRenderReader(t *testing.T) {
- w := httptest.NewRecorder()
- body := "#!PNG some raw data"
- headers := make(map[string]string)
- headers["Content-Disposition"] = `attachment; filename="filename.png"`
- headers["x-request-id"] = "requestId"
- err := (Reader{
- ContentLength: int64(len(body)),
- ContentType: "image/png",
- Reader: strings.NewReader(body),
- Headers: headers,
- }).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, body, w.Body.String())
- assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
- assert.Equal(t, strconv.Itoa(len(body)), w.Header().Get("Content-Length"))
- assert.Equal(t, headers["Content-Disposition"], w.Header().Get("Content-Disposition"))
- assert.Equal(t, headers["x-request-id"], w.Header().Get("x-request-id"))
- }
- func TestRenderReaderNoContentLength(t *testing.T) {
- w := httptest.NewRecorder()
- body := "#!PNG some raw data"
- headers := make(map[string]string)
- headers["Content-Disposition"] = `attachment; filename="filename.png"`
- headers["x-request-id"] = "requestId"
- err := (Reader{
- ContentLength: -1,
- ContentType: "image/png",
- Reader: strings.NewReader(body),
- Headers: headers,
- }).Render(w)
- assert.NoError(t, err)
- assert.Equal(t, body, w.Body.String())
- assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
- assert.NotContains(t, "Content-Length", w.Header())
- assert.Equal(t, headers["Content-Disposition"], w.Header().Get("Content-Disposition"))
- assert.Equal(t, headers["x-request-id"], w.Header().Get("x-request-id"))
- }
|