Allow exception object to be passed to mock directly

Author: mnaberez

supervisor/tests/base.py

@@ -23,13 +23,16 @@
     import mock
 
 class DummyOptions:
-
-    make_pipes_error = None
-    fork_error = None
-    execv_error = None
-    kill_error = None
-    minfds = 5
     loglevel = 20
+    minfds = 5
+
+    chdir_exception = None
+    fork_exception = None
+    execv_exception = None
+    kill_exception = None
+    make_pipes_exception = None
+    remove_exception = None
+    write_exception = None
 
     def __init__(self):
         self.identifier = 'supervisor'
@@ -76,9 +79,7 @@ def __init__(self):
         self.logs_reopened = False
         self.environment_processed = False
         self.write_accept = None
-        self.write_error = None
         self.tempfile_name = '/foo/bar'
-        self.remove_error = None
         self.removed = []
         self.existing = []
         self.openreturn = None
@@ -88,7 +89,6 @@ def __init__(self):
         self.parse_infos = []
         self.serverurl = 'http://localhost:9001'
         self.changed_directory = False
-        self.chdir_error = None
         self.umaskset = None
         self.poller = DummyPoller(self)
         self.silent = False
@@ -151,8 +151,8 @@ def waitpid(self):
         return self.waitpid_return
 
     def kill(self, pid, sig):
-        if self.kill_error:
-            raise OSError(self.kill_error)
+        if self.kill_exception is not None:
+            raise self.kill_exception
         self.kills[pid] = sig
 
     def stat(self, filename):
@@ -172,8 +172,8 @@ def check_execv_args(self, filename, argv, st):
             raise NotFound('bad filename')
 
     def make_pipes(self, stderr=True):
-        if self.make_pipes_error:
-            raise OSError(self.make_pipes_error)
+        if self.make_pipes_exception is not None:
+            raise self.make_pipes_exception
         pipes = {'child_stdin': 3, 'stdin': 4, 'stdout': 5, 'child_stdout': 6}
         if stderr:
             pipes['stderr'], pipes['child_stderr'] = (7, 8)
@@ -182,8 +182,8 @@ def make_pipes(self, stderr=True):
         return pipes
 
     def write(self, fd, chars):
-        if self.write_error:
-            raise OSError(self.write_error)
+        if self.write_exception is not None:
+            raise self.write_exception
         if self.write_accept:
             chars = chars[self.write_accept]
         data = self.written.setdefault(fd, '')
@@ -192,8 +192,8 @@ def write(self, fd, chars):
         return len(chars)
 
     def fork(self):
-        if self.fork_error:
-            raise OSError(self.fork_error)
+        if self.fork_exception is not None:
+            raise self.fork_exception
         return self.forkpid
 
     def close_fd(self, fd):
@@ -216,11 +216,8 @@ def _exit(self, code):
 
     def execve(self, filename, argv, environment):
         self.execve_called = True
-        if self.execv_error:
-            if self.execv_error == errno.EPERM:
-                raise OSError(self.execv_error)
-            else:
-                raise RuntimeError(self.execv_error)
+        if self.execv_exception is not None:
+            raise self.execv_exception
         self.execv_args = (filename, argv)
         self.execv_environment = environment
 
@@ -243,8 +240,8 @@ def mktempfile(self, prefix, suffix, dir):
 
     def remove(self, path):
         import os
-        if self.remove_error:
-            raise os.error(self.remove_error)
+        if self.remove_exception is not None:
+            raise self.remove_exception
         self.removed.append(path)
 
     def exists(self, path):
@@ -258,8 +255,8 @@ def open(self, name, mode='r'):
         return open(name, mode)
 
     def chdir(self, dir):
-        if self.chdir_error:
-            raise OSError(self.chdir_error)
+        if self.chdir_exception is not None:
+            raise self.chdir_exception
         self.changed_directory = True
 
     def setumask(self, mask):
@@ -378,6 +375,8 @@ def get_socket(self):
 
 @functools.total_ordering
 class DummyProcess(object):
+    write_exception = None
+
     # Initial state; overridden by instance variables
     pid = 0 # Subprocess pid; 0 when not running
     laststart = 0 # Last time the subprocess was started; 0 if never
@@ -430,7 +429,6 @@ def __init__(self, config, state=None):
         self.input_fd_drained = None
         self.output_fd_drained = None
         self.transitioned = False
-        self.write_error = None
 
     def reopenlogs(self):
         self.logs_reopened = True
@@ -499,8 +497,8 @@ def drain_input_fd(self, fd):
         self.input_fd_drained = fd
 
     def write(self, chars):
-        if self.write_error:
-            raise OSError(self.write_error)
+        if self.write_exception is not None:
+            raise self.write_exception
         self.stdin_buffer += chars
 
     def transition(self):
@@ -1106,14 +1104,16 @@ def reap(self):
         self.reaped = True
 
 class DummyDispatcher:
+    flush_exception = None
+
     write_event_handled = False
     read_event_handled = False
     error_handled = False
     logs_reopened = False
     logs_removed = False
     closed = False
-    flush_error = None
     flushed = False
+
     def __init__(self, readable=False, writable=False, error=False):
         self._readable = readable
         self._writable = writable
@@ -1145,8 +1145,8 @@ def handle_error(self):
     def close(self):
         self.closed = True
     def flush(self):
-        if self.flush_error:
-            raise OSError(self.flush_error)
+        if self.flush_exception:
+            raise self.flush_exception
         self.flushed = True
 
 class DummyStream:

supervisor/tests/test_dispatchers.py

@@ -639,7 +639,7 @@ def test_handle_write_event_epipe_raised(self):
         dispatcher = self._makeOne(process)
         dispatcher.input_buffer = 'halloooo'
         import errno
-        options.write_error = errno.EPIPE
+        options.write_exception = OSError(errno.EPIPE)
         dispatcher.handle_write_event()
         self.assertEqual(dispatcher.input_buffer, b'')
         self.assertTrue(options.logger.data[0].startswith(
@@ -653,7 +653,7 @@ def test_handle_write_event_uncaught_raised(self):
         dispatcher = self._makeOne(process)
         dispatcher.input_buffer = 'halloooo'
         import errno
-        options.write_error = errno.EBADF
+        options.write_exception = OSError(errno.EBADF)
         self.assertRaises(OSError, dispatcher.handle_write_event)
 
     def test_handle_write_event_over_os_limit(self):

supervisor/tests/test_process.py

@@ -225,7 +225,7 @@ def test_spawn_fail_check_execv_args(self):
 
     def test_spawn_fail_make_pipes_emfile(self):
         options = DummyOptions()
-        options.make_pipes_error = errno.EMFILE
+        options.make_pipes_exception = OSError(errno.EMFILE)
         config = DummyPConfig(options, 'good', '/good/filename')
         instance = self._makeOne(config)
         from supervisor.states import ProcessStates
@@ -250,7 +250,7 @@ def test_spawn_fail_make_pipes_emfile(self):
 
     def test_spawn_fail_make_pipes_other(self):
         options = DummyOptions()
-        options.make_pipes_error = errno.EPERM
+        options.make_pipes_exception = OSError(errno.EPERM)
         config = DummyPConfig(options, 'good', '/good/filename')
         instance = self._makeOne(config)
         from supervisor.states import ProcessStates
@@ -301,7 +301,7 @@ def raise_eisdir(envelope):
 
     def test_spawn_fork_fail_eagain(self):
         options = DummyOptions()
-        options.fork_error = errno.EAGAIN
+        options.fork_exception = OSError(errno.EAGAIN)
         config = DummyPConfig(options, 'good', '/good/filename')
         instance = self._makeOne(config)
         from supervisor.states import ProcessStates
@@ -327,7 +327,7 @@ def test_spawn_fork_fail_eagain(self):
 
     def test_spawn_fork_fail_other(self):
         options = DummyOptions()
-        options.fork_error = errno.EPERM
+        options.fork_exception = OSError(errno.EPERM)
         config = DummyPConfig(options, 'good', '/good/filename')
         instance = self._makeOne(config)
         from supervisor.states import ProcessStates
@@ -436,7 +436,7 @@ def test_spawn_as_child_sets_umask(self):
     def test_spawn_as_child_cwd_fail(self):
         options = DummyOptions()
         options.forkpid = 0
-        options.chdir_error = errno.ENOENT
+        options.chdir_exception = OSError(errno.ENOENT)
         config = DummyPConfig(options, 'good', '/good/filename',
                               directory='/tmp')
         instance = self._makeOne(config)
@@ -458,7 +458,7 @@ def test_spawn_as_child_cwd_fail(self):
     def test_spawn_as_child_execv_fail_oserror(self):
         options = DummyOptions()
         options.forkpid = 0
-        options.execv_error = errno.EPERM
+        options.execv_exception = OSError(errno.EPERM)
         config = DummyPConfig(options, 'good', '/good/filename')
         instance = self._makeOne(config)
         result = instance.spawn()
@@ -477,7 +477,7 @@ def test_spawn_as_child_execv_fail_oserror(self):
     def test_spawn_as_child_execv_fail_runtime_error(self):
         options = DummyOptions()
         options.forkpid = 0
-        options.execv_error = errno.ENOENT
+        options.execv_exception = RuntimeError(errno.ENOENT)
         config = DummyPConfig(options, 'good', '/good/filename')
         instance = self._makeOne(config)
         result = instance.spawn()
@@ -641,7 +641,7 @@ def test_write_dispatcher_flush_raises_epipe(self):
         options.forkpid = 1
         instance.spawn()
         stdin_fd = instance.pipes['stdin']
-        instance.dispatchers[stdin_fd].flush_error = errno.EPIPE
+        instance.dispatchers[stdin_fd].flush_exception = OSError(errno.EPIPE)
         self.assertRaises(OSError, instance.write, sent)
 
     def _dont_test_spawn_and_kill(self):
@@ -815,7 +815,7 @@ def test_kill_nopid(self):
     def test_kill_error(self):
         options = DummyOptions()
         config = DummyPConfig(options, 'test', '/test')
-        options.kill_error = errno.EPERM
+        options.kill_exception = OSError(errno.EPERM)
         instance = self._makeOne(config)
         L = []
         from supervisor.states import ProcessStates
@@ -1000,7 +1000,7 @@ def kill(pid, sig):
     def test_signal_error(self):
         options = DummyOptions()
         config = DummyPConfig(options, 'test', '/test')
-        options.kill_error = errno.EPERM
+        options.kill_exception = OSError(errno.EPERM)
         instance = self._makeOne(config)
         L = []
         from supervisor.states import ProcessStates
@@ -2085,7 +2085,7 @@ def test_dispatch_pipe_error(self):
         gconfig = DummyPGroupConfig(options, pconfigs=[pconfig1])
         pool = self._makeOne(gconfig)
         process1 = pool.processes['process1']
-        process1.write_error = errno.EPIPE
+        process1.write_exception = OSError(errno.EPIPE)
         process1.listener_state = EventListenerStates.READY
         event = DummyEvent()
         pool._acceptEvent(event)

supervisor/tests/test_rpcinterfaces.py

@@ -187,7 +187,7 @@ def test_clearLog_unremoveable(self):
         from supervisor import xmlrpc
         options = DummyOptions()
         options.existing = [options.logfile]
-        options.remove_error = 1
+        options.remove_exception = os.error(errno.EPERM)
         supervisord = DummySupervisor(options)
         interface = self._makeOne(supervisord)
         self.assertRaises(xmlrpc.RPCError, interface.clearLog)
@@ -1999,7 +1999,7 @@ def test_sendProcessStdin_raises_no_file_when_write_raises_epipe(self):
         supervisord = PopulatedDummySupervisor(options, 'process1', pconfig1)
         supervisord.set_procattr('process1', 'pid', 42)
         supervisord.set_procattr('process1', 'killing', False)
-        supervisord.set_procattr('process1', 'write_error', errno.EPIPE)
+        supervisord.set_procattr('process1', 'write_exception', OSError(errno.EPIPE))
         interface   = self._makeOne(supervisord)
         from supervisor import xmlrpc
         self._assertRPCError(xmlrpc.Faults.NO_FILE,
@@ -2012,7 +2012,7 @@ def test_sendProcessStdin_reraises_other_oserrors(self):
         supervisord = PopulatedDummySupervisor(options, 'process1', pconfig1)
         supervisord.set_procattr('process1', 'pid', 42)
         supervisord.set_procattr('process1', 'killing', False)
-        supervisord.set_procattr('process1', 'write_error', errno.EINTR)
+        supervisord.set_procattr('process1', 'write_exception', OSError(errno.EINTR))
         interface   = self._makeOne(supervisord)
         self.assertRaises(OSError,
                           interface.sendProcessStdin,