cloudflared-mirror/logger/create_test.go

133 lines
2.5 KiB
Go
Raw Permalink Normal View History

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)
})
}
}