133 lines
2.5 KiB
Go
133 lines
2.5 KiB
Go
package logger
|
|
|
|
import (
|
|
"io"
|
|
"testing"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/rs/zerolog"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
type mockedWriter struct {
|
|
wantErr bool
|
|
writeCalls int
|
|
}
|
|
|
|
func (c *mockedWriter) Write(p []byte) (int, error) {
|
|
c.writeCalls++
|
|
|
|
if c.wantErr {
|
|
return -1, errors.New("Expected error")
|
|
}
|
|
|
|
return len(p), nil
|
|
}
|
|
|
|
// Tests that a new writer is only used if it actually works.
|
|
func TestResilientMultiWriter_Errors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
writers []*mockedWriter
|
|
}{
|
|
{
|
|
name: "All valid writers",
|
|
writers: []*mockedWriter{
|
|
{
|
|
wantErr: false,
|
|
},
|
|
{
|
|
wantErr: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "All invalid writers",
|
|
writers: []*mockedWriter{
|
|
{
|
|
wantErr: true,
|
|
},
|
|
{
|
|
wantErr: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "First invalid writer",
|
|
writers: []*mockedWriter{
|
|
{
|
|
wantErr: true,
|
|
},
|
|
{
|
|
wantErr: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "First valid writer",
|
|
writers: []*mockedWriter{
|
|
{
|
|
wantErr: false,
|
|
},
|
|
{
|
|
wantErr: true,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
writers := []io.Writer{}
|
|
for _, w := range test.writers {
|
|
writers = append(writers, w)
|
|
}
|
|
multiWriter := resilientMultiWriter{zerolog.InfoLevel, writers, nil}
|
|
|
|
logger := zerolog.New(multiWriter).With().Timestamp().Logger()
|
|
logger.Info().Msg("Test msg")
|
|
|
|
for _, w := range test.writers {
|
|
// Expect each writer to be written to regardless of the previous writers returning an error
|
|
assert.Equal(t, 1, w.writeCalls)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type mockedManagementWriter struct {
|
|
WriteCalls int
|
|
}
|
|
|
|
func (c *mockedManagementWriter) Write(p []byte) (int, error) {
|
|
return len(p), nil
|
|
}
|
|
|
|
func (c *mockedManagementWriter) WriteLevel(level zerolog.Level, p []byte) (int, error) {
|
|
c.WriteCalls++
|
|
return len(p), nil
|
|
}
|
|
|
|
// Tests that management writer receives write calls of all levels except Disabled
|
|
func TestResilientMultiWriter_Management(t *testing.T) {
|
|
for _, level := range []zerolog.Level{
|
|
zerolog.DebugLevel,
|
|
zerolog.InfoLevel,
|
|
zerolog.WarnLevel,
|
|
zerolog.ErrorLevel,
|
|
zerolog.FatalLevel,
|
|
zerolog.PanicLevel,
|
|
} {
|
|
t.Run(level.String(), func(t *testing.T) {
|
|
managementWriter := mockedManagementWriter{}
|
|
multiWriter := resilientMultiWriter{level, []io.Writer{&mockedWriter{}}, &managementWriter}
|
|
|
|
logger := zerolog.New(multiWriter).With().Timestamp().Logger()
|
|
logger.Info().Msg("Test msg")
|
|
|
|
// Always write to management
|
|
assert.Equal(t, 1, managementWriter.WriteCalls)
|
|
})
|
|
}
|
|
}
|