json_encoder_test.go

// Copyright (c) 2016 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

package zap

import (
	"bytes"
	"io"
	"strings"
	"testing"
	"time"

	"github.com/uber-common/zap/spy"

	"github.com/stretchr/testify/assert"
)

func assertJSON(t *testing.T, expected string, enc *jsonEncoder) {
	assert.Equal(t, expected, string(enc.bytes), "Encoded JSON didn't match expectations.")
}

func withJSONEncoder(f func(*jsonEncoder)) {
	enc := newJSONEncoder()
	enc.AddString("foo", "bar")
	f(enc)
	enc.Free()
}

func TestJSONAddString(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		enc.AddString("baz", "bing")
		assertJSON(t, `"foo":"bar","baz":"bing"`, enc)

		// Keys and values should be escaped.
		enc.truncate()
		enc.AddString(`foo\`, `bar\`)
		assertJSON(t, `"foo\\":"bar\\"`, enc)
	})
}

func TestJSONAddBool(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		enc.AddBool("baz", true)
		assertJSON(t, `"foo":"bar","baz":true`, enc)

		// Keys should be escaped.
		enc.truncate()
		enc.AddBool(`foo\`, false)
		assertJSON(t, `"foo\\":false`, enc)
	})
}

func TestJSONAddInt(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		enc.AddInt("baz", 2)
		assertJSON(t, `"foo":"bar","baz":2`, enc)

		// Keys should be escaped.
		enc.truncate()
		enc.AddInt(`foo\`, 1)
		assertJSON(t, `"foo\\":1`, enc)
	})
}

func TestJSONAddInt64(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		enc.AddInt64("baz", 2)
		assertJSON(t, `"foo":"bar","baz":2`, enc)

		// Keys should be escaped.
		enc.truncate()
		enc.AddInt64(`foo\`, 1)
		assertJSON(t, `"foo\\":1`, enc)
	})
}

func TestJSONAddFloat64(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		enc.AddFloat64("baz", 1e10)
		assertJSON(t, `"foo":"bar","baz":1e+10`, enc)

		// Keys should be escaped.
		enc.truncate()
		enc.AddFloat64(`foo\`, 1.0)
		assertJSON(t, `"foo\\":1`, enc)
	})
}

func TestJSONWriteMessage(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		sink := bytes.NewBuffer(nil)

		// Messages should be escaped.
		err := enc.WriteMessage(sink, "info", `hello\`, time.Unix(0, 0))
		assert.NoError(t, err, "WriteMessage returned an unexpected error.")
		assert.Equal(t,
			`{"msg":"hello\\","level":"info","ts":0,"fields":{"foo":"bar"}}`,
			strings.TrimRight(sink.String(), "\n"),
		)

		// We should be able to re-use the encoder, preserving the accumulated
		// fields.
		sink.Reset()
		err = enc.WriteMessage(sink, "debug", "fake msg", time.Unix(0, 100))
		assert.NoError(t, err, "WriteMessage returned an unexpected error.")
		assert.Equal(t,
			`{"msg":"fake msg","level":"debug","ts":100,"fields":{"foo":"bar"}}`,
			strings.TrimRight(sink.String(), "\n"),
		)
	})
}

func TestJSONNest(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		closer := enc.Nest("nested")
		enc.AddString("sub-foo", "sub-bar")
		closer.CloseField()
		enc.AddString("baz", "bing")

		assertJSON(t, `"foo":"bar","nested":{"sub-foo":"sub-bar"},"baz":"bing"`, enc)
	})
}

func TestJSONClone(t *testing.T) {
	// The parent encoder is created with plenty of excess capacity.
	parent := &jsonEncoder{bytes: make([]byte, 0, 128)}
	clone := parent.Clone()

	// Adding to the parent shouldn't affect the clone, and vice versa.
	parent.AddString("foo", "bar")
	clone.AddString("baz", "bing")

	assertJSON(t, `"foo":"bar"`, parent)
	assertJSON(t, `"baz":"bing"`, clone.(*jsonEncoder))
}

func TestJSONWriteMessageFailure(t *testing.T) {
	withJSONEncoder(func(enc *jsonEncoder) {
		tests := []struct {
			sink io.Writer
			msg  string
		}{
			{spy.FailWriter{}, "Expected an error when writing to sink fails."},
			{spy.ShortWriter{}, "Expected an error on partial writes to sink."},
		}
		for _, tt := range tests {
			err := enc.WriteMessage(tt.sink, "info", "hello", time.Unix(0, 0))
			assert.Error(t, err, tt.msg)
		}
	})
}

func TestJSONJSONEscaping(t *testing.T) {
	// Test all the edge cases of JSON escaping directly.
	cases := map[string]string{
		// ASCII.
		`foo`: `foo`,
		// Special-cased characters.
		`"`: `\"`,
		`\`: `\\`,
		`/`: `\/`,
		// Special-cased characters within everyday ASCII.
		`foo"foo`: `foo\"foo`,
		"foo\n":   `foo\n`,
		// Special-cased control characters.
		"\n": `\n`,
		"\r": `\r`,
		"\t": `\t`,
		// \b and \f are special-cased in the JSON spec, but this representation
		// is also conformant.
		"\b": `\u0008`,
		"\f": `\u000c`,
		// The standard lib special-cases angle brackets and ampersands, because
		// it wants to protect users from browser exploits. In a logging
		// context, we shouldn't special-case these characters.
		"<": "<",
		">": ">",
		"&": "&",
		// ASCII bell - not special-cased.
		string(byte(0x07)): `\u0007`,
		// Astral-plane unicode.
		`☃`: `☃`,
		// Decodes to (RuneError, 1)
		"\xed\xa0\x80":    `\ufffd\ufffd\ufffd`,
		"foo\xed\xa0\x80": `foo\ufffd\ufffd\ufffd`,
	}
	enc := newJSONEncoder()
	for input, output := range cases {
		enc.truncate()
		enc.safeAddString(input)
		assertJSON(t, output, enc)
	}
}