log_test.go

package logo

import (
	"fmt"
	"log"
	"reflect"
	"testing"
	"time"
)

// IMPORTANT: Keep this as the first test to ensure line number remains the same
func TestLoggerOutputSetsMessageLine(t *testing.T) {
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	want := 20 // the next line
	l.Debug("A test message")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count got %d, want 1", len(messages))
		return
	}

	got := messages[0].line
	if got != want {
		t.Errorf("Message.line got %d, want %d", got, want)
	}
}

// IMPORTANT: Keep this as the second test to ensure line number remains the same
func TestDefaultLoggerOutputSetsMessageLine(t *testing.T) {
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	SetAppenders("test")

	want := 43 // the next line
	Debug("A test message")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count got %d, want 1", len(messages))
		return
	}

	got := messages[0].line
	if got != want {
		t.Errorf("Message.line got %d, want %d", got, want)
	}
}

// IMPORTANT: Keep this as the second test to ensure line number remains the same
func TestContextLoggerOutputSetsMessageLine(t *testing.T) {
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	cl := l.WithContext(logContext{correlationID: 45})

	want := 69 // the next line
	cl.Debug("A test message")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count got %d, want 1", len(messages))
		return
	}

	got := messages[0].line
	if got != want {
		t.Errorf("Message.line got %d, want %d", got, want)
	}
}

func TestNewLoggerSetsLoggerName(t *testing.T) {
	want := "Test"
	defer reset()

	logger := New("Test", "test")
	got := logger.name

	if got != want {
		t.Errorf("Logger Name got %q, want %q", got, want)
	}
}

func TestLoggerByNameReturnsLogger(t *testing.T) {
	want := true
	defer reset()

	logger := New("Test", "test")

	named := LoggerByName("Test")
	got := named == logger
	if got != want {
		t.Errorf("LoggerByName same logger got %t, want %t", got, want)
	}
}

func TestLoggerByNameReturnsNewLoggerWhenNotFound(t *testing.T) {
	want := "Test"
	defer reset()

	named := LoggerByName("Test")
	got := named.name
	if got != want {
		t.Errorf("Logger name got %q, want %q", got, want)
	}
}

func TestLoggerNewPanicsWhenDuplicateName(t *testing.T) {
	want := `duplicate logger name, "Test"`
	defer reset()
	defer func() {
		if r := recover(); r != nil {
			got := r
			if got != want {
				t.Errorf("LoggerByName panic: got %q, want %q", got, want)
			}
		} else {
			t.Errorf("the code did not panic")
		}
	}()

	New("Test", "test")
	New("Test", "test")
}

func TestNewLoggerSetsLoggerSeverityLevel(t *testing.T) {
	want := info
	defer reset()
	logger := New("Test", "INFO")
	got := logger.level

	if got != want {
		t.Errorf("Severity Level got %v, want %v", got, want)
	}
}

func TestNewLoggerSetsLoggerSeverityLevelRegardlessOfCase(t *testing.T) {
	want := info
	defer reset()

	logger := New("Test", "info")
	got := logger.level

	if got != want {
		t.Errorf("Severity Level got %v, want %v", got, want)
	}
}

func TestNewLoggerSetsLoggerSeverityLevelToNoneIfNotRecognised(t *testing.T) {
	want := none
	defer reset()
	logger := New("Test", "unknown")
	got := logger.level

	if got != want {
		t.Errorf("Severity Level got %v, want %v", got, want)
	}
}

func TestInitialUseOfManagerReturnsLogManagerWithLevelDebug(t *testing.T) {
	want := debug
	got := manager.level

	if got != want {
		t.Errorf("Level got %v, want %v", got, want)
	}
}

func TestInitialUseOfManagerReturnsLogManagerWithInitializedAppendersMap(t *testing.T) {
	got := manager.appenders

	if got == nil {
		t.Errorf("Appenders got <nil>, want map[]")
	}
}

func TestInitialUseOfManagerReturnsLogManagerWithConsoleAppender(t *testing.T) {
	want := reflect.TypeOf(&consoleAppender{})
	appenders := manager.appenders
	a, _ := appenders["console"]
	got := reflect.TypeOf(a)

	if got != want {
		t.Errorf("ConsoleAppender got %v, want %v", got, want)
	}
}

func TestInitialUseOfDefaultLoggerHasSeverityLevelDebug(t *testing.T) {
	want := debug
	dl := defaultLogger

	if dl == nil {
		t.Errorf("DefaultLogger is <nil>")
		return
	}

	got := dl.level
	if got != want {
		t.Errorf("Level got %v, want %v", got, want)
	}
}

func TestDefaultLoggerHasEmptyName(t *testing.T) {
	want := ""
	dl := defaultLogger

	if dl == nil {
		t.Errorf("DefaultLogger is <nil>")
		return
	}

	got := dl.name
	if got != want {
		t.Errorf("DefaultLogger name got %q, want %q", got, want)
	}
}

func TestAddAppenderAddsToCollection(t *testing.T) {
	want := reflect.TypeOf(&emptyAppender{})
	defer reset()
	AddAppender("Test", EmptyAppender)
	appenders := manager.appenders
	if len(appenders) != 2 {
		t.Errorf("Appenders count got %d, want 2", len(appenders))
		return
	}

	a, _ := appenders["Test"]
	got := reflect.TypeOf(a)

	if got != want {
		t.Errorf("Test appender got %v, want %v", got, want)
	}
}

func TestAddAppenderReturnsErrorWhenCalledWithSameName(t *testing.T) {
	want := "appender already exist"
	defer reset()

	err := AddAppender("console", EmptyAppender)
	if err == nil {
		t.Errorf("AddAppender error got <nil>, want %q", want)
	}
	got := err.Error()

	if got != want {
		t.Errorf("AddAppender error got %q, want %q", got, want)
	}
}

func TestAddAppenderUpdatesAppenderWithSameName(t *testing.T) {
	want := ConsoleAppender
	defer reset()
	//conApp := ConsoleAppender
	AddAppender("console", EmptyAppender)

	appenders := manager.appenders
	if len(appenders) != 1 {
		t.Errorf("Appenders count got %d, want 1", len(appenders))
		return
	}

	a, _ := appenders["console"]
	got := a

	if got != want {
		t.Errorf("Console appender got %v, want %v", got, want)
	}
}

func TestNewLoggerAddsConsoleAppender(t *testing.T) {
	want := reflect.TypeOf(&consoleAppender{})
	defer reset()
	l := New("Test", "debug")
	appenders := l.appenders
	if len(appenders) != 1 {
		t.Errorf("Appenders count got %d, want 1", len(appenders))
		return
	}
	got := reflect.TypeOf(appenders[0])

	if got != want {
		t.Errorf("Appender got %v, want %v", got, want)
	}
}

func TestLoggerSetAppendersOverwritesExisting(t *testing.T) {
	want := reflect.TypeOf(&emptyAppender{})
	defer reset()
	AddAppender("TestAppender", EmptyAppender)
	l := New("Test", "debug")
	l.SetAppenders("TestAppender")

	appenders := l.appenders
	if len(appenders) != 1 {
		t.Errorf("Appenders count got %d, want 1", len(appenders))
		return
	}
	got := reflect.TypeOf(appenders[0])

	if got != want {
		t.Errorf("Appender got %v, want %v", got, want)
	}
}

func TestLoggerSetAppendersAcceptsMultipleAppenders(t *testing.T) {
	want := "*logo.emptyAppender-*logo.consoleAppender"
	defer reset()
	AddAppender("TestAppender", EmptyAppender)
	l := New("Test", "debug")
	l.SetAppenders("TestAppender", "console")

	appenders := l.appenders
	if len(appenders) != 2 {
		t.Errorf("Appenders count got %d, want 1", len(appenders))
		return
	}
	n1 := reflect.TypeOf(appenders[0]).String()
	n2 := reflect.TypeOf(appenders[1]).String()
	got := n1 + "-" + n2

	if got != want {
		t.Errorf("Appenders got %v, want %v", got, want)
	}
}

func TestLoggerSetAppendersreturnsErrorWhenUnrecognisedAppender(t *testing.T) {
	want := `unrecognised appender, [UnknownAppender]`
	l := New("Test", "debug")
	err := l.SetAppenders("UnknownAppender")
	if err == nil {
		t.Errorf("Error got <nil>, want %q", want)
		return
	}
	got := err.Error()
	if got != want {
		t.Errorf("Error got %q, want %q", got, want)
	}
}

func TestLogManagerCloseCallsAllAppenders(t *testing.T) {
	defer reset()
	appenders := []Appender{newTestAppender(), newTestAppender(), newTestAppender(), newTestAppender()}
	names := []string{}
	for i, a := range appenders {
		n := fmt.Sprintf("testAppender%d", i)
		AddAppender(n, a)
		names = append(names, n)
	}
	Close()

	want := true
	for i, a := range appenders {
		got := (a.(*testAppender)).Closed

		if got != want {
			t.Errorf("%s.Close() called: got %t, want %t", names[i], got, want)
		}
	}
}

func TestLoggerDebugfSendsPopulatedMsgToAppender(t *testing.T) {
	defer reset()
	timenow = func() time.Time {
		t, _ := time.Parse("2006-01-02T15:04:05.999999999", "2016-11-19T15:14:15.123456789")
		return t
	}

	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")
	l.Debugf("A test message %d", 56)

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	var tests = []struct {
		property string
		f        func(*LogMessage) interface{}
		want     interface{}
	}{
		{"format", func(m *LogMessage) interface{} { return m.format }, "A test message %d"},
		{"args.Count()", func(m *LogMessage) interface{} { return len(m.args) }, 1},
		{"args[0]", func(m *LogMessage) interface{} {
			if len(m.args) > 0 {
				return m.args[0]
			}
			return 0
		}, 56},
		{"severity", func(m *LogMessage) interface{} { return m.severity }, debug},
		{"name", func(m *LogMessage) interface{} { return m.name }, "Test"},
		{"file", func(m *LogMessage) interface{} { return m.file }, "log_test.go"},
		{"ctx", func(m *LogMessage) interface{} { return m.ctx }, ""},
		{"timestamp", func(m *LogMessage) interface{} { return m.timestamp.Format("2006-01-02 15:04:05.000000") }, "2016-11-19 15:14:15.123456"},
	}

	for _, test := range tests {
		if got := test.f(messages[0]); got != test.want {
			t.Errorf("Message.%s: got %v, want %v", test.property, got, test.want)
		}
	}
}

func TestDefaultLoggerDebugfSendsPopulatedMsgToAppender(t *testing.T) {
	defer reset()
	timenow = func() time.Time {
		t, _ := time.Parse("2006-01-02T15:04:05.999999999", "2016-11-19T15:14:15.123456789")
		return t
	}

	appender := newTestAppender()
	AddAppender("test", appender)
	SetAppenders("test")
	Debugf("A test message %d", 56)

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	var tests = []struct {
		property string
		f        func(*LogMessage) interface{}
		want     interface{}
	}{
		{"format", func(m *LogMessage) interface{} { return m.format }, "A test message %d"},
		{"args.Count()", func(m *LogMessage) interface{} { return len(m.args) }, 1},
		{"args[0]", func(m *LogMessage) interface{} {
			if len(m.args) > 0 {
				return m.args[0]
			}
			return 0
		}, 56},
		{"severity", func(m *LogMessage) interface{} { return m.severity }, debug},
		{"name", func(m *LogMessage) interface{} { return m.name }, ""},
		{"file", func(m *LogMessage) interface{} { return m.file }, "log_test.go"},
		{"ctx", func(m *LogMessage) interface{} { return m.ctx }, ""},
		{"timestamp", func(m *LogMessage) interface{} { return m.timestamp.Format("2006-01-02 15:04:05.000000") }, "2016-11-19 15:14:15.123456"},
	}

	for _, test := range tests {
		if got := test.f(messages[0]); got != test.want {
			t.Errorf("Message.%s: got %v, want %v", test.property, got, test.want)
		}
	}
}

func TestLoggerSendsMsgToEachAppender(t *testing.T) {
	defer reset()
	appenders := []Appender{newTestAppender(), newTestAppender(), newTestAppender(), newTestAppender()}
	names := []string{}
	for i, a := range appenders {
		n := fmt.Sprintf("testAppender%d", i)
		AddAppender(n, a)
		names = append(names, n)
	}

	l := New("Test", "debug")
	l.SetAppenders(names...)
	l.Debugf("A test message %d", 56)

	var tests = []struct {
		property string
		f        func(*LogMessage) interface{}
		want     interface{}
	}{
		{"format", func(m *LogMessage) interface{} { return m.format }, "A test message %d"},
		{"args.Count()", func(m *LogMessage) interface{} { return len(m.args) }, 1},
		{"args[0]", func(m *LogMessage) interface{} {
			if len(m.args) > 0 {
				return m.args[0]
			}
			return 0
		}, 56},
		{"severity", func(m *LogMessage) interface{} { return m.severity }, debug},
		{"name", func(m *LogMessage) interface{} { return m.name }, "Test"},
		{"file", func(m *LogMessage) interface{} { return m.file }, "log_test.go"},
	}

	for i, a := range appenders {
		messages := (a.(*testAppender)).logMessages

		if len(messages) != 1 {
			t.Errorf("%s messages count got %d, want 1", names[i], len(messages))
			return
		}
		for _, test := range tests {
			if got := test.f(messages[0]); got != test.want {
				t.Errorf("Message.%s got %v, want %v", test.property, got, test.want)
			}
		}
	}
}

func TestLoggerOutputPadsDateElementsWithLeadingZeros(t *testing.T) {
	want := "2016-01-09 05:04:05.000456"

	timenow = func() time.Time {
		t, _ := time.Parse("2006-01-02T15:04:05.999999999", "2016-01-09T05:04:05.000456789")
		return t
	}
	defer reset()

	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	l.Debug("A test message")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}
	got := messages[0].timestamp.Format("2006-01-02 15:04:05.000000")
	if got != want {
		t.Errorf("Message.timestamp: got %q, want %q", got, want)
	}
}

func TestGlobalPropertiesAreAddedToOutput(t *testing.T) {
	want := "Guavas"
	defer reset()

	SetGlobalProperty("Fruit", "Guavas")

	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	l.Debug("More Cheese")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	props := messages[0].properties

	got, ok := props["Fruit"]

	if !ok || got != want {
		t.Errorf("Fruit property: got %v, want %q", got, want)
	}
}

func TestLoggerContextPropertiesAreAddedToOutput(t *testing.T) {
	want := "Lychees"
	defer reset()

	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	cp := map[string]interface{}{"Fruit": "Lychees"}
	cl := l.WithContextProperties(cp)

	cl.Debug("More Cheese")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	props := messages[0].properties

	got, ok := props["Fruit"]

	if !ok || got != want {
		t.Errorf("Fruit property: got %v, want %q", got, want)
	}
}

func TestLoggerContextPropertiesOverrideGlobalProperties(t *testing.T) {
	want := "Lychees"
	defer reset()

	SetGlobalProperty("Fruit", "Guavas")

	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	cp := map[string]interface{}{"Fruit": "Lychees"}
	cl := l.WithContextProperties(cp)

	cl.Debug("More Cheese")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	props := messages[0].properties

	got, ok := props["Fruit"]

	if !ok || got != want {
		t.Errorf("Fruit property: got %v, want %q", got, want)
	}
}

func TestLoggerSetContextProperty(t *testing.T) {
	want := "Lychees"
	defer reset()

	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	cp := map[string]interface{}{"Fruit": "Guavas"}
	cl := l.WithContextProperties(cp)

	cl.SetContextProperty("Fruit", "Lychees")
	cl.Debug("More Cheese")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	props := messages[0].properties

	got, ok := props["Fruit"]

	if !ok || got != want {
		t.Errorf("Fruit property: got %v, want %q", got, want)
	}
}

func TestLoggerContextPropertiesOverrideGlobalProperties2(t *testing.T) {
	want := "Guavas"
	defer reset()

	SetGlobalProperty("Fruit", "Guavas")

	appender := newTestAppender()
	AddAppender("test", appender)
	appender.SetFormat("%m and %property{Fruit}")
	l := New("Test", "debug")
	l.SetAppenders("test")

	l.Debug("More Cheese")

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	props := messages[0].properties

	got, ok := props["Fruit"]

	if !ok || got != want {
		t.Errorf("Fruit property: got %v, want %q", got, want)
	}
}

type logContext struct {
	correlationID int
}

func (l logContext) String() string {
	return fmt.Sprintf("CorrelationId: %d", l.correlationID)
}

func TestLoggerWithContextSetsLogMessageContext(t *testing.T) {
	want := "CorrelationId: 45"
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	cl := l.WithContext(logContext{correlationID: 45})
	cl.Debugf("A test message %d", 56)

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	got := messages[0].ctx
	if got != want {
		t.Errorf("Message.ctx: got %q, want %q", got, want)
	}
}

func TestLoggerWithContextUsesParentAppenders(t *testing.T) {
	want := "A test message %dAnother test message %d"
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	cl := l.WithContext(logContext{correlationID: 45})
	cl.Debugf("A test message %d", 56)
	l.Debugf("Another test message %d", 23)

	messages := appender.logMessages

	if len(messages) != 2 {
		t.Errorf("Messages count: got %d, want 2", len(messages))
		return
	}

	got := messages[0].format + messages[1].format
	if got != want {
		t.Errorf("Message formats: got %q, want %q", got, want)
	}
}

func TestLoggerDebugfIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "info")
	l.SetAppenders("test")

	l.Debugf("A test message %d", 56)

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerWithContextIgnoresIfParentLoggerLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "info")
	l.SetAppenders("test")

	cl := l.WithContext(logContext{correlationID: 45})
	cl.Debugf("A test message %d", 56)

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerDebugIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "info")
	l.SetAppenders("test")

	l.Debug("A test message")

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerInfofIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	l.Infof("A test message %d", 56)

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerInfoIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	l.Info("A test message")

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerWarnfIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	l.Warnf("A test message %d", 56)

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerWarnIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	l.Warn("A test message")

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerErrorfIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	l.Errorf("A test message %d", 56)

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerErrorIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	l.Error("A test message")

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerPanicfIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	func() {
		defer func() { recover() }()
		l.Panicf("A test message %d", 56)
	}()

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerPanicIgnoresWhenLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	func() {
		defer func() { recover() }()
		l.Panic("A test message")
	}()

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerIgnoresWhenManagerLevelSetAbove(t *testing.T) {
	want := 0
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	SetManagerLevel("fatal")

	l.Info("A test message")

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerDoesNotIgnoreWhenManagerLevelSetEqual(t *testing.T) {
	want := 1
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")

	SetManagerLevel("info")

	l.Info("A test message")

	got := len(appender.logMessages)

	if got != want {
		t.Errorf("Messages count: got %d, want %d", got, want)
	}
}

func TestLoggerSetsLogMessageSeverity(t *testing.T) {
	exit = func(i int) {}
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")
	s := "test"

	var tests = []struct {
		property string
		f        func()
		want     string
	}{
		{"Debug", func() { l.Debug("") }, "DEBUG"},
		{"Debugf", func() { l.Debugf(s, 8) }, "DEBUG"},
		{"Info", func() { l.Info("") }, "INFO"},
		{"infof", func() { l.Infof(s, 8) }, "INFO"},
		{"Warn", func() { l.Warn("") }, "WARN"},
		{"Warnf", func() { l.Warnf(s, 8) }, "WARN"},
		{"Error", func() { l.Error("") }, "ERROR"},
		{"Errorf", func() { l.Errorf(s, 8) }, "ERROR"},
		{"Panic", func() { l.Panic("") }, "PANIC"},
		{"Panicf", func() { l.Panicf(s, 8) }, "PANIC"},
		{"Fatal", func() { l.Fatal("") }, "FATAL"},
		{"Fatalf", func() { l.Fatalf(s, 8) }, "FATAL"},
	}

	for i, test := range tests {
		// run test in isolation for log.Panic and log.Panicf
		func() {
			defer func() { recover() }()
			test.f()
		}()
		sev := appender.logMessages[i].severity
		if got := severityName[sev]; got != test.want {
			t.Errorf("%s: got %v, want %v", test.property, got, test.want)
		}
	}
}

func TestLoggerFatalExitsWithCorrectCode(t *testing.T) {
	var ec int
	exit = func(i int) { ec = i }
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "debug")
	l.SetAppenders("test")
	s := "test"

	var tests = []struct {
		property string
		f        func()
		want     int
	}{
		{"Fatal", func() {
			ec = 0
			l.Fatal("")
		}, 1},
		{"Fatalf", func() {
			ec = 0
			l.Fatalf(s, 8)
		}, 1},
	}

	for _, test := range tests {
		test.f()

		if got := ec; got != test.want {
			t.Errorf("%s: got %v, want %v", test.property, got, test.want)
		}
	}
}

func TestLoggerPanicCallsStillPanicWhenSeverityAbovePanic(t *testing.T) {
	exit = func(i int) {}
	defer reset()
	appender := newTestAppender()
	AddAppender("test", appender)
	l := New("Test", "fatal")
	l.SetAppenders("test")

	var tests = []struct {
		property string
		f        func()
		want     string
	}{
		{"Panic", func() { l.Panic("chickens have escaped") }, "chickens have escaped"},
		{"Panicf", func() { l.Panicf("invalid %s type, %s", "chicken", "fish") }, "invalid chicken type, fish"},
	}

	for _, test := range tests {
		func() {
			defer func() {
				if r := recover(); r != nil {
					got := r
					if got != test.want {
						t.Errorf("%s: got %v, want %v", test.property, got, test.want)
					}
				} else {
					t.Errorf("%s did not panic", test.property)
				}
			}()
			test.f()
		}()

	}
}

func TestDefaultLoggerSetsLogMessageSeverity(t *testing.T) {
	defer reset()
	exit = func(i int) {}

	appender := newTestAppender()
	AddAppender("test", appender)
	SetAppenders("test")

	s := "test"

	var tests = []struct {
		property string
		f        func()
		want     string
	}{
		{"Debug", func() { Debug("") }, "DEBUG"},
		{"Debugf", func() { Debugf(s, 8) }, "DEBUG"},
		{"Info", func() { Info("") }, "INFO"},
		{"infof", func() { Infof(s, 8) }, "INFO"},
		{"Warn", func() { Warn("") }, "WARN"},
		{"Warnf", func() { Warnf(s, 8) }, "WARN"},
		{"Error", func() { Error("") }, "ERROR"},
		{"Errorf", func() { Errorf(s, 8) }, "ERROR"},
		{"Panic", func() { Panic("") }, "PANIC"},
		{"Panicf", func() { Panicf(s, 8) }, "PANIC"},
		{"Fatal", func() { Fatal("") }, "FATAL"},
		{"Fatalf", func() { Fatalf(s, 8) }, "FATAL"},
	}

	for i, test := range tests {
		// run test in isolation for log.Panic and log.Panicf
		func() {
			defer func() { recover() }()
			test.f()
		}()
		sev := appender.logMessages[i].severity
		if got := severityName[sev]; got != test.want {
			t.Errorf("%s: got %v, want %v", test.property, got, test.want)
		}
	}
}

func TestCaptureStandardLogSendsPopulatedMsgToAppender(t *testing.T) {
	defer reset()
	timenow = func() time.Time {
		t, _ := time.Parse("2006-01-02T15:04:05.999999999", "2016-11-19T15:14:15.123456789")
		return t
	}

	appender := newTestAppender()
	AddAppender("test", appender)

	CaptureStandardLog("test")
	log.Printf("A test message %d", 56)

	//Debugf("A test message %d", 56)

	messages := appender.logMessages

	if len(messages) != 1 {
		t.Errorf("Messages count: got %d, want 1", len(messages))
		return
	}

	var tests = []struct {
		property string
		f        func(*LogMessage) interface{}
		want     interface{}
	}{
		{"format", func(m *LogMessage) interface{} { return m.format }, "A test message 56"},
		{"args.Count()", func(m *LogMessage) interface{} { return len(m.args) }, 0},
		{"severity", func(m *LogMessage) interface{} { return m.severity }, none},
		{"name", func(m *LogMessage) interface{} { return m.name }, ""},
		{"file", func(m *LogMessage) interface{} { return m.file }, "log_test.go"},
		{"ctx", func(m *LogMessage) interface{} { return m.ctx }, ""},
		{"timestamp", func(m *LogMessage) interface{} { return m.timestamp.Format("2006-01-02 15:04:05.000000") }, "2016-11-19 15:14:15.123456"},
	}

	for _, test := range tests {
		if got := test.f(messages[0]); got != test.want {
			t.Errorf("Message.%s: got %v, want %v", test.property, got, test.want)
		}
	}
}

func reset() {
	manager = newLogManager()
	defaultLogger = newDefaultLogger()
	timenow = time.Now
}