From c05e16b6a0f8088a6701cc03f1d0122e66209134 Mon Sep 17 00:00:00 2001 From: Ingo Oppermann Date: Tue, 24 Jan 2023 21:04:24 +0100 Subject: [PATCH] Add tests --- log/log.go | 9 --- log/log_test.go | 82 ++++++++++++-------- log/writer_test.go | 181 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 233 insertions(+), 39 deletions(-) create mode 100644 log/writer_test.go diff --git a/log/log.go b/log/log.go index be226028..14a78e2c 100644 --- a/log/log.go +++ b/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 } diff --git a/log/log_test.go b/log/log_test.go index 1a04a1f0..3ed0910c 100644 --- a/log/log_test.go +++ b/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()) - assert.Equal(t, "ERROR", Lerror.String()) - assert.Equal(t, "WARN", Lwarn.String()) - assert.Equal(t, "INFO", Linfo.String()) - assert.Equal(t, `SILENT`, Lsilent.String()) + require.Equal(t, "DEBUG", Ldebug.String()) + require.Equal(t, "ERROR", Lerror.String()) + require.Equal(t, "WARN", Lwarn.String()) + require.Equal(t, "INFO", Linfo.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"]) +} diff --git a/log/writer_test.go b/log/writer_test.go new file mode 100644 index 00000000..7951cf29 --- /dev/null +++ b/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) +}