Add tests

log/log.go

@@ -103,7 +103,6 @@ type Logger interface {
 type logger struct {
 	output    Writer
 	component string
-	topics    map[string]struct{}
 }
 
 // New returns an implementation of the Logger interface.
@@ -121,14 +120,6 @@ func (l *logger) clone() *logger {
 		component: l.component,
 	}
 
-	if len(l.topics) != 0 {
-		clone.topics = make(map[string]struct{})
-
-		for topic := range l.topics {
-			clone.topics[topic] = struct{}{}
-		}
-	}
-
 	return clone
 }
 

log/log_test.go

@@ -5,15 +5,15 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestLoglevelNames(t *testing.T) {
-	assert.Equal(t, "DEBUG", Ldebug.String())
+	require.Equal(t, "DEBUG", Ldebug.String())
-	assert.Equal(t, "ERROR", Lerror.String())
+	require.Equal(t, "ERROR", Lerror.String())
-	assert.Equal(t, "WARN", Lwarn.String())
+	require.Equal(t, "WARN", Lwarn.String())
-	assert.Equal(t, "INFO", Linfo.String())
+	require.Equal(t, "INFO", Linfo.String())
-	assert.Equal(t, `SILENT`, Lsilent.String())
+	require.Equal(t, `SILENT`, Lsilent.String())
 }
 
 func TestLogColorToNotTTY(t *testing.T) {
@@ -23,7 +23,7 @@ func TestLogColorToNotTTY(t *testing.T) {
 	w := NewConsoleWriter(writer, Linfo, true).(*syncWriter)
 	formatter := w.writer.(*consoleWriter).formatter.(*consoleFormatter)
 
-	assert.NotEqual(t, true, formatter.color, "Color should not be used on a buffer logger")
+	require.NotEqual(t, true, formatter.color, "Color should not be used on a buffer logger")
 }
 
 func TestLogContext(t *testing.T) {
@@ -53,7 +53,7 @@ func TestLogContext(t *testing.T) {
 	lenWithoutCtx := buffer.Len()
 	buffer.Reset()
 
-	assert.Greater(t, lenWithCtx, lenWithoutCtx, "Log line length without context is not shorter than with context")
+	require.Greater(t, lenWithCtx, lenWithoutCtx, "Log line length without context is not shorter than with context")
 }
 
 func TestLogClone(t *testing.T) {
@@ -65,7 +65,7 @@ func TestLogClone(t *testing.T) {
 	logger.Info().Log("info")
 	writer.Flush()
 
-	assert.Contains(t, buffer.String(), `component="test"`)
+	require.Contains(t, buffer.String(), `component="test"`)
 
 	buffer.Reset()
 
@@ -74,7 +74,7 @@ func TestLogClone(t *testing.T) {
 	logger2.Info().Log("info")
 	writer.Flush()
 
-	assert.Contains(t, buffer.String(), `component="tset"`)
+	require.Contains(t, buffer.String(), `component="tset"`)
 }
 
 func TestLogSilent(t *testing.T) {
@@ -85,22 +85,22 @@ func TestLogSilent(t *testing.T) {
 
 	logger.Debug().Log("debug")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Info().Log("info")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Warn().Log("warn")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Error().Log("error")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 }
 
@@ -112,22 +112,22 @@ func TestLogDebug(t *testing.T) {
 
 	logger.Debug().Log("debug")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 
 	logger.Info().Log("info")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 
 	logger.Warn().Log("warn")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 
 	logger.Error().Log("error")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 }
 
@@ -139,22 +139,22 @@ func TestLogInfo(t *testing.T) {
 
 	logger.Debug().Log("debug")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Info().Log("info")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 
 	logger.Warn().Log("warn")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 
 	logger.Error().Log("error")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 }
 
@@ -166,22 +166,22 @@ func TestLogWarn(t *testing.T) {
 
 	logger.Debug().Log("debug")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Info().Log("info")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Warn().Log("warn")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 
 	logger.Error().Log("error")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 }
 
@@ -193,21 +193,43 @@ func TestLogError(t *testing.T) {
 
 	logger.Debug().Log("debug")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Info().Log("info")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Warn().Log("warn")
 	writer.Flush()
-	assert.Equal(t, 0, buffer.Len(), "Buffer should be empty")
+	require.Equal(t, 0, buffer.Len(), "Buffer should be empty")
 	buffer.Reset()
 
 	logger.Error().Log("error")
 	writer.Flush()
-	assert.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
+	require.NotEqual(t, 0, buffer.Len(), "Buffer should not be empty")
 	buffer.Reset()
 }
+
+func TestLogWithField(t *testing.T) {
+	bufwriter := NewBufferWriter(Linfo, 10)
+
+	logger := New("test").WithOutput(bufwriter)
+	logger = logger.WithField("foo", "bar")
+	logger.Info().Log("hello")
+
+	events := bufwriter.Events()
+
+	require.Equal(t, 1, len(events))
+	require.Empty(t, events[0].err)
+	require.Equal(t, "bar", events[0].Data["foo"])
+
+	logger = logger.WithField("func", func() bool { return true })
+	logger.Info().Log("hello")
+
+	events = bufwriter.Events()
+	require.Equal(t, 2, len(events))
+	require.NotEmpty(t, events[1].err)
+	require.Equal(t, "bar", events[0].Data["foo"])
+}

log/writer_test.go

@@ -0,0 +1,181 @@
+package log
+
+import (
+	"bytes"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestJSONWriter(t *testing.T) {
+	buffer := bytes.Buffer{}
+
+	writer := NewJSONWriter(&buffer, Linfo)
+	writer.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "test",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	require.Equal(t, `{"Time":"2009-11-10T23:00:00Z","Level":"INFO","Component":"test","Caller":"me","Message":"hello world","Data":{"caller":"me","component":"test","foo":"bar","message":"hello world","ts":"2009-11-10T23:00:00Z"}}`, buffer.String())
+}
+
+func TestConsoleWriter(t *testing.T) {
+	buffer := bytes.Buffer{}
+
+	writer := NewConsoleWriter(&buffer, Linfo, false)
+	writer.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "test",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	require.Equal(t, `ts=2009-11-10T23:00:00Z level=INFO component="test" msg="hello world" foo="bar"`+"\n", buffer.String())
+}
+
+func TestTopicWriter(t *testing.T) {
+	bufwriter := NewBufferWriter(Linfo, 10)
+	writer1 := NewTopicWriter(bufwriter, []string{})
+	writer2 := NewTopicWriter(bufwriter, []string{"foobar"})
+
+	writer1.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "test",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	writer2.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "test",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	require.Equal(t, 1, len(bufwriter.Events()))
+
+	writer1.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "foobar",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	writer2.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "foobar",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	require.Equal(t, 3, len(bufwriter.Events()))
+}
+
+func TestMultiwriter(t *testing.T) {
+	bufwriter1 := NewBufferWriter(Linfo, 10)
+	bufwriter2 := NewBufferWriter(Linfo, 10)
+
+	writer := NewMultiWriter(bufwriter1, bufwriter2)
+
+	writer.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "foobar",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	require.Equal(t, 1, len(bufwriter1.Events()))
+	require.Equal(t, 1, len(bufwriter2.Events()))
+}
+
+func TestLevelRewriter(t *testing.T) {
+	bufwriter := NewBufferWriter(Linfo, 10)
+
+	rule := LevelRewriteRule{
+		Level:     Lwarn,
+		Component: "foobar",
+		Match: map[string]string{
+			"foo": "bar",
+		},
+	}
+
+	writer := NewLevelRewriter(bufwriter, []LevelRewriteRule{rule})
+	writer.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "foobar",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	events := bufwriter.Events()
+
+	require.Equal(t, 1, len(events))
+	require.Equal(t, Lwarn, events[0].Level)
+
+	writer.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "foobar",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"bar": "foo"},
+	})
+
+	events = bufwriter.Events()
+
+	require.Equal(t, 2, len(events))
+	require.Equal(t, Linfo, events[1].Level)
+
+	writer.Write(&Event{
+		logger:    &logger{},
+		Time:      time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
+		Level:     Linfo,
+		Component: "test",
+		Caller:    "me",
+		Message:   "hello world",
+		err:       "",
+		Data:      map[string]interface{}{"foo": "bar"},
+	})
+
+	events = bufwriter.Events()
+
+	require.Equal(t, 3, len(events))
+	require.Equal(t, Linfo, events[2].Level)
+}