Change the MementoHandler to store a dict.

Start testing the logger fixture.

4 files changed, 66 insertions, 4 deletions

diff --git a/lib/fixtures/__init__.py b/lib/fixtures/__init__.py
index c0b0d48..46f2139 100644
--- a/lib/fixtures/__init__.py
+++ b/lib/fixtures/__init__.py
@@ -46,6 +46,7 @@ __all__ = [
     'Fixture',
     'FunctionFixture',
     'LoggerFixture',
+    'MementoLogger',
     'MethodFixture',
     'MonkeyPatch',
     'NestedTempfile',
@@ -72,6 +73,7 @@ from fixtures._fixtures import (
     FakeLogger,
     FakePopen,
     LoggerFixture,
+    MementoLogger,
     MonkeyPatch,
     NestedTempfile,
     PackagePathEntry,
diff --git a/lib/fixtures/_fixtures/__init__.py b/lib/fixtures/_fixtures/__init__.py
index ec88780..da2a70b 100644
--- a/lib/fixtures/_fixtures/__init__.py
+++ b/lib/fixtures/_fixtures/__init__.py
@@ -22,6 +22,7 @@ __all__ = [
     'FakeLogger',
     'FakePopen',
     'LoggerFixture',
+    'MementoLogger',
     'MonkeyPatch',
     'NestedTempfile',
     'PackagePathEntry',
@@ -42,6 +43,7 @@ from fixtures._fixtures.environ import (
 from fixtures._fixtures.logger import (
     FakeLogger,
     LoggerFixture,
+    MementoLogger,
     )
 from fixtures._fixtures.monkeypatch import MonkeyPatch
 from fixtures._fixtures.popen import (
diff --git a/lib/fixtures/_fixtures/logger.py b/lib/fixtures/_fixtures/logger.py
index 1cd0ce2..2b60205 100644
--- a/lib/fixtures/_fixtures/logger.py
+++ b/lib/fixtures/_fixtures/logger.py
@@ -121,5 +121,32 @@ class MementoHandler(Handler):
         self.records = []
 
     def emit(self, record):
-        """Just add the record to self.records."""
-        self.records.append(record)
+        """Just add the dict of the record to self.records."""
+        # logging actually uses LogRecord.__dict__ regularly. Sheesh.
+        self.records.append(record.__dict__)
+
+
+class MementoLogger(Fixture):
+
+    def __init__(self, name="", level=INFO, nuke_handlers=True):
+        """Create a MementoLogger fixture.
+
+        :param name: The name of the logger to replace. Defaults to "".
+        :param level: The log level to set, defaults to INFO.
+        :param nuke_handlers: If True remove all existing handles (prevents
+            existing messages going to e.g. stdout). Defaults to True.
+        """
+        super(MementoLogger, self).__init__()
+        self._name = name
+        self._level = level
+        self._nuke_handlers = nuke_handlers
+
+    def setUp(self):
+        super(MementoLogger, self).setUp()
+        self._handler = MementoHandler()
+        self.useFixture(
+            LogHandler(self._handler, name=self._name, level=self._level,
+                       nuke_handlers=self._nuke_handlers))
+
+    def get_records(self):
+        return self._handler.records
diff --git a/lib/fixtures/tests/_fixtures/test_logger.py b/lib/fixtures/tests/_fixtures/test_logger.py
index b1e4615..361a377 100644
--- a/lib/fixtures/tests/_fixtures/test_logger.py
+++ b/lib/fixtures/tests/_fixtures/test_logger.py
@@ -16,10 +16,16 @@
 import logging
 
 from testtools import TestCase
+from testtools.matchers import (
+    ContainsDict,
+    Equals,
+    MatchesListwise,
+    )
 from cStringIO import StringIO
 
 from fixtures import (
     FakeLogger,
+    MementoLogger,
     TestWithFixtures,
     )
 from fixtures._fixtures.logger import MementoHandler
@@ -98,16 +104,41 @@ class FakeLoggerTest(TestCase, TestWithFixtures):
 
 class TestMementoHandler(TestCase):
 
+    class FakeRecord(object):
+        def __init__(self, **kw):
+            self.__dict__.update(kw)
+
     def test_initialy_no_records(self):
         handler = MementoHandler()
         self.assertEqual([], handler.records)
 
     def test_emit_stored_in_records(self):
         handler = MementoHandler()
-        marker = object()
+        marker = self.FakeRecord(foo='bar')
         handler.emit(marker)
-        self.assertEqual([marker], handler.records)
+        self.assertEqual([{'foo': 'bar'}], handler.records)
 
     def test_is_log_handler(self):
         handler = MementoHandler()
         self.assertIsInstance(handler, logging.Handler)
+
+
+class MementoLoggerTest(TestCase, TestWithFixtures):
+
+    def setUp(self):
+        super(MementoLoggerTest, self).setUp()
+        self.logger = logging.getLogger()
+        self.addCleanup(self.removeHandlers, self.logger)
+
+    def removeHandlers(self, logger):
+        for handler in logger.handlers:
+            logger.removeHandler(handler)
+
+    def test_get_records_has_records(self):
+        fixture = self.useFixture(MementoLogger())
+        logging.info("some message")
+        self.assertThat(
+            fixture.get_records(),
+            MatchesListwise(
+                [ContainsDict({'msg': Equals("some message"),
+                               'levelname': Equals('INFO')})]))