writer_test.go

package zapio

import (
	"io"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"go.uber.org/zap/zaptest/observer"
)

func TestWriter(t *testing.T) {
	t.Parallel()

	tests := []struct {
		desc   string
		level  zapcore.Level // defaults to info
		writes []string
		want   []zapcore.Entry
	}{
		{
			desc: "simple",
			writes: []string{
				"foo\n",
				"bar\n",
				"baz\n",
			},
			want: []zapcore.Entry{
				{Level: zap.InfoLevel, Message: "foo"},
				{Level: zap.InfoLevel, Message: "bar"},
				{Level: zap.InfoLevel, Message: "baz"},
			},
		},
		{
			desc:  "level too low",
			level: zap.DebugLevel,
			writes: []string{
				"foo\n",
				"bar\n",
			},
			want: []zapcore.Entry{},
		},
		{
			desc:  "multiple newlines in a message",
			level: zap.WarnLevel,
			writes: []string{
				"foo\nbar\n",
				"baz\n",
				"qux\nquux\n",
			},
			want: []zapcore.Entry{
				{Level: zap.WarnLevel, Message: "foo"},
				{Level: zap.WarnLevel, Message: "bar"},
				{Level: zap.WarnLevel, Message: "baz"},
				{Level: zap.WarnLevel, Message: "qux"},
				{Level: zap.WarnLevel, Message: "quux"},
			},
		},
		{
			desc:  "message split across multiple writes",
			level: zap.ErrorLevel,
			writes: []string{
				"foo",
				"bar\nbaz",
				"qux",
			},
			want: []zapcore.Entry{
				{Level: zap.ErrorLevel, Message: "foobar"},
				{Level: zap.ErrorLevel, Message: "bazqux"},
			},
		},
		{
			desc: "blank lines in the middle",
			writes: []string{
				"foo\n\nbar\nbaz",
			},
			want: []zapcore.Entry{
				{Level: zap.InfoLevel, Message: "foo"},
				{Level: zap.InfoLevel, Message: ""},
				{Level: zap.InfoLevel, Message: "bar"},
				{Level: zap.InfoLevel, Message: "baz"},
			},
		},
		{
			desc: "blank line at the end",
			writes: []string{
				"foo\nbar\nbaz\n",
			},
			want: []zapcore.Entry{
				{Level: zap.InfoLevel, Message: "foo"},
				{Level: zap.InfoLevel, Message: "bar"},
				{Level: zap.InfoLevel, Message: "baz"},
			},
		},
		{
			desc: "multiple blank line at the end",
			writes: []string{
				"foo\nbar\nbaz\n\n",
			},
			want: []zapcore.Entry{
				{Level: zap.InfoLevel, Message: "foo"},
				{Level: zap.InfoLevel, Message: "bar"},
				{Level: zap.InfoLevel, Message: "baz"},
				{Level: zap.InfoLevel, Message: ""},
			},
		},
	}

	for _, tt := range tests {
		tt := tt // for t.Parallel
		t.Run(tt.desc, func(t *testing.T) {
			t.Parallel()

			core, observed := observer.New(zap.InfoLevel)

			w := Writer{
				Log:   zap.New(core),
				Level: tt.level,
			}

			for _, s := range tt.writes {
				_, err := io.WriteString(&w, s)
				require.NoError(t, err, "Writer.Write failed.")
			}

			assert.NoError(t, w.Close(), "Writer.Close failed.")

			// Turn []observer.LoggedEntry => []zapcore.Entry
			got := make([]zapcore.Entry, observed.Len())
			for i, ent := range observed.AllUntimed() {
				got[i] = ent.Entry
			}
			assert.Equal(t, tt.want, got, "Logged entries do not match.")
		})
	}
}