Test our dispatcher implementations.

src/supervisor/process.py

@@ -696,28 +696,31 @@ def find_prefix_at_end(haystack, needle):
 
 class PDispatcher:
     """ Asyncore dispatcher for mainloop, representing a process channel
-    (stdin, stdout, or stderr) """
+    (stdin, stdout, or stderr).  This class is abstract. """
     def __init__(self, process, fd):
         self.process = process
         self.fd = fd
 
     def readable(self):
-        return False
+        raise NotImplementedError
 
     def writable(self):
-        return False
+        raise NotImplementedError
 
     def handle_read_event(self):
-        pass
+        raise NotImplementedError
 
     def handle_write_event(self):
-        pass
+        raise NotImplementedError
 
     def handle_error(self):
-        raise IOError
+        raise NotImplementedError
 
 class POutputDispatcher(PDispatcher):
     """ Output (stdout/stderr) dispatcher """
+    def writable(self):
+        return False
+    
     def readable(self):
         return True
 
@@ -731,6 +734,9 @@ class PInputDispatcher(PDispatcher):
             return True
         return False
 
+    def readable(self):
+        return False
+    
     def handle_write_event(self):
         self.process.drain_input_fd(self.fd)
 

src/supervisor/tests/base.py

@@ -318,6 +318,8 @@ class DummyProcess:
         self.finished = None
         self.logs_reopened = False
         self.execv_arg_exception = None
+        self.input_fd_drained = None
+        self.output_fd_drained = None
 
     def reopenlogs(self):
         self.logs_reopened = True
@@ -371,6 +373,12 @@ class DummyProcess:
         program = commandargs[0]
         return program, commandargs
 
+    def drain_output_fd(self, fd):
+        self.output_fd_drained = fd
+
+    def drain_input_fd(self, fd):
+        self.input_fd_drained = fd
+
 class DummyPConfig:
     def __init__(self, options, name, command, priority=999, autostart=True,
                  autorestart=True, startsecs=10, startretries=999,

src/supervisor/tests/test_process.py

@@ -974,6 +974,71 @@ class LoggingRecorderTests(unittest.TestCase):
             except (OSError, IOError):
                 pass
 
+class POutputDispatcherTests(unittest.TestCase):
+    def _getTargetClass(self):
+        from supervisor.process import POutputDispatcher
+        return POutputDispatcher
+
+    def _makeOne(self):
+        process = DummyProcess(None)
+        return self._getTargetClass()(process, 0)
+
+    def test_writable(self):
+        dispatcher = self._makeOne()
+        self.assertEqual(dispatcher.writable(), False)
+        
+    def test_readable(self):
+        dispatcher = self._makeOne()
+        self.assertEqual(dispatcher.readable(), True)
+
+    def test_handle_write_event(self):
+        dispatcher = self._makeOne()
+        self.assertRaises(NotImplementedError, dispatcher.handle_write_event)
+
+    def test_handle_read_event(self):
+        dispatcher = self._makeOne()
+        self.assertEqual(dispatcher.handle_read_event(), None)
+        self.assertEqual(dispatcher.process.output_fd_drained, 0)
+        
+    def test_handle_error(self):
+        dispatcher = self._makeOne()
+        self.assertRaises(NotImplementedError, dispatcher.handle_error)
+
+class PInputDispatcherTests(unittest.TestCase):
+    def _getTargetClass(self):
+        from supervisor.process import PInputDispatcher
+        return PInputDispatcher
+
+    def _makeOne(self):
+        process = DummyProcess(None)
+        return self._getTargetClass()(process, 0)
+
+    def test_writable_nodata(self):
+        dispatcher = self._makeOne()
+        dispatcher.process.stdin_buffer = 'a'
+        self.assertEqual(dispatcher.writable(), True)
+
+    def test_writable_withdata(self):
+        dispatcher = self._makeOne()
+        dispatcher.process.stdin_buffer = ''
+        self.assertEqual(dispatcher.writable(), False)
+
+    def test_readable(self):
+        dispatcher = self._makeOne()
+        self.assertEqual(dispatcher.readable(), False)
+
+    def test_handle_write_event(self):
+        dispatcher = self._makeOne()
+        self.assertEqual(dispatcher.handle_write_event(), None)
+        self.assertEqual(dispatcher.process.input_fd_drained, 0)
+
+    def test_handle_read_event(self):
+        dispatcher = self._makeOne()
+        self.assertRaises(NotImplementedError, dispatcher.handle_read_event)
+        
+    def test_handle_error(self):
+        dispatcher = self._makeOne()
+        self.assertRaises(NotImplementedError, dispatcher.handle_error)
 
 def test_suite():
     return unittest.findTestCases(sys.modules[__name__])