add some tests for the base Handler class

supervisor/tests/base.py

@@ -3,6 +3,7 @@ _TIMEFORMAT = '%b %d %I:%M %p'
 
 from supervisor.compat import total_ordering
 from supervisor.compat import Fault
+from supervisor.compat import as_string
 
 class DummyOptions:
 
@@ -1040,25 +1041,32 @@ class DummyDispatcher:
         self.flushed = True
 
 class DummyStream:
-    def __init__(self, error=None):
+    def __init__(self, error=None, fileno=20):
         self.error = error
         self.closed = False
         self.flushed = False
         self.written = ''
+        self._fileno = fileno
     def close(self):
         if self.error:
             raise self.error
         self.closed = True
     def flush(self):
+        if self.error:
+            raise self.error
         self.flushed = True
     def write(self, msg):
         if self.error:
-            raise self.error
-        self.written +=msg
+            error = self.error
+            self.error = None
+            raise error
+        self.written += as_string(msg)
     def seek(self, num, whence=0):
         pass
     def tell(self):
         return len(self.written)
+    def fileno(self):
+        return self._fileno
 
 class DummyEvent:
     def __init__(self, serial='abc'):

supervisor/tests/test_loggers.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import errno
 import sys
 import unittest
 import tempfile
@@ -41,6 +42,67 @@ class HandlerTests:
                                    exc_info=None)
         return record
 
+class BareHandlerTests(HandlerTests, unittest.TestCase):
+    def _getTargetClass(self):
+        from supervisor.loggers import Handler
+        return Handler
+
+    def test_flush_stream_flush_raises_IOError_EPIPE(self):
+        stream = DummyStream(error=IOError(errno.EPIPE))
+        inst = self._makeOne(stream=stream)
+        self.assertEqual(inst.flush(), None) # does not raise
+
+    def test_flush_stream_flush_raises_IOError_not_EPIPE(self):
+        stream = DummyStream(error=IOError(errno.EALREADY))
+        inst = self._makeOne(stream=stream)
+        self.assertRaises(IOError, inst.flush) # non-EPIPE IOError raises
+
+    def test_close_already_closed(self):
+        stream = DummyStream()
+        inst = self._makeOne(stream=stream)
+        inst.closed = True
+        self.assertEqual(inst.close(), None)
+        
+    def test_close_stream_fileno_above_3(self):
+        stream = DummyStream(fileno=50)
+        inst = self._makeOne(stream=stream)
+        self.assertEqual(inst.close(), None)
+        self.assertTrue(inst.closed)
+        self.assertTrue(inst.stream.closed)
+
+    def test_close_stream_fileno_below_3(self):
+        stream = DummyStream(fileno=0)
+        inst = self._makeOne(stream=stream)
+        self.assertEqual(inst.close(), None)
+        self.assertFalse(inst.closed)
+        self.assertFalse(inst.stream.closed)
+
+    def test_emit_gardenpath(self):
+        stream = DummyStream()
+        inst = self._makeOne(stream=stream)
+        record = self._makeLogRecord('foo')
+        inst.emit(record)
+        self.assertEqual(stream.flushed, True)
+        self.assertEqual(stream.written, 'foo')
+
+    def test_emit_unicode_error(self):
+        stream = DummyStream(error=UnicodeError)
+        inst = self._makeOne(stream=stream)
+        record = self._makeLogRecord('foo')
+        inst.emit(record)
+        self.assertEqual(stream.flushed, True)
+        self.assertEqual(stream.written, 'foo')
+
+    def test_emit_other_error(self):
+        stream = DummyStream(error=TypeError)
+        inst = self._makeOne(stream=stream)
+        handled = []
+        inst.handleError = lambda: handled.append(True)
+        record = self._makeLogRecord('foo')
+        inst.emit(record)
+        self.assertEqual(stream.flushed, False)
+        self.assertEqual(stream.written, '')
+        
 class FileHandlerTests(HandlerTests, unittest.TestCase):
     def _getTargetClass(self):
         from supervisor.loggers import FileHandler