From 2467e5cc93f89f55c94e752cb26f5cc4613ac5aa Mon Sep 17 00:00:00 2001 From: Alex Bramley Date: Sat, 22 Oct 2011 15:43:13 +0100 Subject: [PATCH] More tests for the logging package. --- logging/log.go | 5 ++-- logging/log_test.go | 62 ++++++++++++++++++++++++++++++++------------- 2 files changed, 47 insertions(+), 20 deletions(-) diff --git a/logging/log.go b/logging/log.go index b632932..66f314f 100644 --- a/logging/log.go +++ b/logging/log.go @@ -181,16 +181,15 @@ func (l *logger) write(lv LogLevel, fm string, v ...interface{}) { return } fm = fmt.Sprintf(LogString(lv)+" "+fm, v...) - if _, ok := logString[lv]; !ok { + if lv > Debug || lv < Fatal { // This is an unrecognised log level, so log it to Debug lv = Debug } l.Lock() defer l.Unlock() - _log := l.log[lv] // Writing the log is deceptively simple - _log.Output(3, fm) + l.log[lv].Output(3, fm) if lv == Fatal { // Always fatal to stderr too. Use panic so (a) we get a backtrace, // and (b) it's trappable for testing (and maybe other times too). diff --git a/logging/log_test.go b/logging/log_test.go index 82e99c6..faebb2c 100644 --- a/logging/log_test.go +++ b/logging/log_test.go @@ -9,7 +9,7 @@ import ( // Note: the below is deliberately PLACED AT THE TOP OF THIS FILE because // it is fragile. It ensures the right file:line is logged. Sorry! func TestLogCorrectLineNumbers(t *testing.T) { - l, m := setUp() + l, m := SetUp() l.Log(Error, "Error!") if s := string(m[Error].written); s[20:] != "log_test.go:13: ERROR Error!\n" { t.Errorf("Error incorrectly logged (check line numbers!)") @@ -31,7 +31,8 @@ func (w *mockWriter) reset() { w.written = w.written[:0] } -func setUp() (*logger, writerMap) { +// Make these accessible for other packages doing logging testing +func SetUp() (*logger, writerMap) { wMap := writerMap{ Debug: &mockWriter{make([]byte, 0)}, Info: &mockWriter{make([]byte, 0)}, @@ -46,7 +47,7 @@ func setUp() (*logger, writerMap) { return New(logMap, Error, false), wMap } -func (m writerMap) checkNothingWritten(t *testing.T) { +func (m writerMap) CheckNothingWritten(t *testing.T) { for lv, w := range m { if len(w.written) > 0 { t.Errorf("%d bytes logged at level %s, expected none:", @@ -57,7 +58,7 @@ func (m writerMap) checkNothingWritten(t *testing.T) { } } -func (m writerMap) checkWrittenAtLevel(t *testing.T, lv LogLevel, exp string) { +func (m writerMap) CheckWrittenAtLevel(t *testing.T, lv LogLevel, exp string) { var w *mockWriter if _, ok := m[lv]; !ok { w = m[Debug] @@ -69,37 +70,64 @@ func (m writerMap) checkWrittenAtLevel(t *testing.T, lv LogLevel, exp string) { t.Errorf("\t%s", exp) } // 32 bytes covers the date, time and filename up to the colon in - // 2011/10/22 10:22:57 log_test.go:: + // 2011/10/22 10:22:57 log_test.go:: s := string(w.written[32:]) - // 3 covers the : itself and the two extra spaces - idx := strings.Index(s, ":") + len(LogString(lv)) + 3 + // 2 covers the : itself and the extra space + idx := strings.Index(s, ":") + 2 // s will end in "\n", so -1 to chop that off too s = s[idx:len(s)-1] + // expected won't contain the log level prefix, so prepend that + exp = LogString(lv) + " " + exp if s != exp { t.Errorf("Log message at level %s differed.", LogString(lv)) t.Errorf("\texp: %s\n\tgot: %s", exp, s) } w.reset() + // Calling checkNothingWritten here both tests that w.reset() works + // and verifies that nothing was written at any other levels. + m.CheckNothingWritten(t) } -func TestLogging(t *testing.T) { - l, m := setUp() +func TestStandardLogging(t *testing.T) { + l, m := SetUp() l.Log(4, "Nothing should be logged yet") - m.checkNothingWritten(t) + m.CheckNothingWritten(t) l.Log(Debug, "or yet...") - m.checkNothingWritten(t) + m.CheckNothingWritten(t) l.Log(Info, "or yet...") - m.checkNothingWritten(t) + m.CheckNothingWritten(t) l.Log(Warn, "or yet!") - m.checkNothingWritten(t) + m.CheckNothingWritten(t) l.Log(Error, "Error!") - m.checkWrittenAtLevel(t, Error, "Error!") - // Calling checkNothingWritten here both tests that w.reset() works - // and verifies that nothing was written at any other levels than Error. - m.checkNothingWritten(t) + m.CheckWrittenAtLevel(t, Error, "Error!") +} + +func TestAllLoggingLevels(t *testing.T) { + l, m := SetUp() + l.SetLogLevel(5) + + l.Log(4, "Log to level 4.") + m.CheckWrittenAtLevel(t, 4, "Log to level 4.") + + l.Debug("Log to debug.") + m.CheckWrittenAtLevel(t, Debug, "Log to debug.") + + l.Info("Log to info.") + m.CheckWrittenAtLevel(t, Info, "Log to info.") + + l.Warn("Log to warning.") + m.CheckWrittenAtLevel(t, Warn, "Log to warning.") + + l.Error("Log to error.") + m.CheckWrittenAtLevel(t, Error, "Log to error.") + + // recover to track the panic caused by Fatal. + defer func() { recover() }() + l.Fatal("Log to fatal.") + m.CheckWrittenAtLevel(t, Fatal, "Log to fatal.") }