render_json_test.go

package render

import (
	"encoding/json"
	"io"
	"math"
	"net/http"
	"net/http/httptest"
	"testing"
)

type Greeting struct {
	One string `json:"one"`
	Two string `json:"two"`
}

type TestEncoder struct {
	w io.Writer
}

func (e TestEncoder) Encode(_ interface{}) error {
	_, _ = e.w.Write([]byte(e.String()))

	return nil
}

func (e TestEncoder) SetEscapeHTML(_ bool) {}

func (e TestEncoder) SetIndent(_, _ string) {}

func (e TestEncoder) String() string {
	return "{\"one\":\"world\",\"two\":\"hello\"}"
}

func TestJSONBasic(t *testing.T) {
	render := New()

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 299, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, 299)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
	expect(t, res.Body.String(), "{\"one\":\"hello\",\"two\":\"world\"}")
}

func TestJSONPrefix(t *testing.T) {
	prefix := ")]}',\n"
	render := New(Options{
		PrefixJSON: []byte(prefix),
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 300, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, 300)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
	expect(t, res.Body.String(), prefix+"{\"one\":\"hello\",\"two\":\"world\"}")
}

func TestJSONIndented(t *testing.T) {
	render := New(Options{
		IndentJSON: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, http.StatusOK)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
	expect(t, res.Body.String(), "{\n  \"one\": \"hello\",\n  \"two\": \"world\"\n}\n")
}

func TestJSONConsumeIndented(t *testing.T) {
	render := New(Options{
		IndentJSON: true,
	})

	var renErr error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		renErr = render.JSON(w, http.StatusOK, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	var output Greeting
	err := json.Unmarshal(res.Body.Bytes(), &output)
	expectNil(t, err)
	expectNil(t, renErr)
	expect(t, output.One, "hello")
	expect(t, output.Two, "world")
}

func TestJSONWithError(t *testing.T) {
	render := New(Options{}, Options{}, Options{}, Options{})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 299, math.NaN())
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNotNil(t, err)
	expect(t, res.Code, 500)
}

func TestJSONWithOutUnEscapeHTML(t *testing.T) {
	render := New(Options{
		// UnEscapeHTML: false, // The default value is false.
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"<span>test&test</span>", "<div>test&test</div>"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Body.String(), `{"one":"\u003cspan\u003etest\u0026test\u003c/span\u003e","two":"\u003cdiv\u003etest\u0026test\u003c/div\u003e"}`)
}

func TestJSONWithUnEscapeHTML(t *testing.T) {
	render := New(Options{
		UnEscapeHTML: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"<span>test&test</span>", "<div>test&test</div>"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Body.String(), "{\"one\":\"<span>test&test</span>\",\"two\":\"<div>test&test</div>\"}")
}

func TestJSONStream(t *testing.T) {
	render := New(Options{
		StreamingJSON: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 299, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, 299)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
	expect(t, res.Body.String(), "{\"one\":\"hello\",\"two\":\"world\"}\n")
}

func TestJSONStreamPrefix(t *testing.T) {
	prefix := ")]}',\n"
	render := New(Options{
		PrefixJSON:    []byte(prefix),
		StreamingJSON: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 300, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, 300)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
	expect(t, res.Body.String(), prefix+"{\"one\":\"hello\",\"two\":\"world\"}\n")
}

func TestJSONStreamWithError(t *testing.T) {
	render := New(Options{
		StreamingJSON: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 299, math.NaN())
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNotNil(t, err)
	expect(t, res.Code, 299)

	// Because this is streaming, we can not catch the error.
	expect(t, res.Body.String(), "json: unsupported value: NaN\n")
	// Also the header will be incorrect.
	expect(t, res.Header().Get(ContentType), "text/plain; charset=utf-8")
}

func TestJSONStreamWithOutUnEscapeHTML(t *testing.T) {
	render := New(Options{
		// UnEscapeHTML: false, // The default value is false.
		StreamingJSON: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"<span>test&test</span>", "<div>test&test</div>"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Body.String(), `{"one":"\u003cspan\u003etest\u0026test\u003c/span\u003e","two":"\u003cdiv\u003etest\u0026test\u003c/div\u003e"}`+"\n")
}

func TestJSONStreamWithUnEscapeHTML(t *testing.T) {
	render := New(Options{
		UnEscapeHTML:  true,
		StreamingJSON: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"<span>test&test</span>", "<div>test&test</div>"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Body.String(), "{\"one\":\"<span>test&test</span>\",\"two\":\"<div>test&test</div>\"}\n")
}

func TestJSONStreamIndented(t *testing.T) {
	render := New(Options{
		IndentJSON:     true,
		StreamingJSON:  true,
		DisableCharset: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, http.StatusOK)
	expect(t, res.Header().Get(ContentType), ContentJSON)
	expect(t, res.Body.String(), "{\n  \"one\": \"hello\",\n  \"two\": \"world\"\n}\n")
}

func TestJSONCharset(t *testing.T) {
	render := New(Options{
		Charset: "foobar",
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 300, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, 300)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=foobar")
	expect(t, res.Body.String(), "{\"one\":\"hello\",\"two\":\"world\"}")
}

func TestJSONCustomContentType(t *testing.T) {
	render := New(Options{
		JSONContentType: "application/vnd.api+json",
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, http.StatusOK)
	expect(t, res.Header().Get(ContentType), "application/vnd.api+json; charset=UTF-8")
	expect(t, res.Body.String(), "{\"one\":\"hello\",\"two\":\"world\"}")
}

func TestJSONDisabledCharset(t *testing.T) {
	render := New(Options{
		DisableCharset: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, http.StatusOK, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, http.StatusOK)
	expect(t, res.Header().Get(ContentType), ContentJSON)
	expect(t, res.Body.String(), "{\"one\":\"hello\",\"two\":\"world\"}")
}

func TestJSONEncoder(t *testing.T) {
	render := New(Options{
		JSONEncoder: func(w io.Writer) JSONEncoder {
			return TestEncoder{w: w}
		},
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 299, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, 299)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
	expect(t, res.Body.String(), TestEncoder{}.String())
}

func TestJSONEncoderStream(t *testing.T) {
	render := New(Options{
		JSONEncoder: func(w io.Writer) JSONEncoder {
			return TestEncoder{w: w}
		},
		StreamingJSON: true,
	})

	var err error

	h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		err = render.JSON(w, 299, Greeting{"hello", "world"})
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "/foo", nil)
	h.ServeHTTP(res, req)

	expectNil(t, err)
	expect(t, res.Code, 299)
	expect(t, res.Header().Get(ContentType), ContentJSON+"; charset=UTF-8")
	expect(t, res.Body.String(), TestEncoder{}.String())
}