Add more assertions for current kill() behavior

Author: mnaberez

supervisor/tests/test_process.py

@@ -812,31 +812,26 @@ def test_kill_nopid(self):
               'attempted to kill test with sig SIGTERM but it wasn\'t running')
         self.assertFalse(instance.killing)
 
-    def test_kill_error(self):
+    def test_kill_from_starting(self):
         options = DummyOptions()
         config = DummyPConfig(options, 'test', '/test')
-        options.kill_exception = OSError(errno.EPERM)
         instance = self._makeOne(config)
+        instance.pid = 11
         L = []
         from supervisor.states import ProcessStates
         from supervisor import events
         events.subscribe(events.ProcessStateEvent, lambda x: L.append(x))
-        instance.pid = 11
-        instance.state = ProcessStates.RUNNING
+        instance.state = ProcessStates.STARTING
         instance.kill(signal.SIGTERM)
         self.assertEqual(options.logger.data[0], 'killing test (pid 11) with '
                          'signal SIGTERM')
-        self.assertTrue(options.logger.data[1].startswith(
-            'unknown problem killing test'))
-        self.assertTrue('Traceback' in options.logger.data[1])
-        self.assertFalse(instance.killing)
-        self.assertEqual(len(L), 2)
-        event1 = L[0]
-        event2 = L[1]
-        self.assertEqual(event1.__class__, events.ProcessStateStoppingEvent)
-        self.assertEqual(event2.__class__, events.ProcessStateUnknownEvent)
+        self.assertTrue(instance.killing)
+        self.assertEqual(options.kills[11], signal.SIGTERM)
+        self.assertEqual(len(L), 1)
+        event = L[0]
+        self.assertEqual(event.__class__, events.ProcessStateStoppingEvent)
 
-    def test_kill_from_starting(self):
+    def test_kill_from_running(self):
         options = DummyOptions()
         config = DummyPConfig(options, 'test', '/test')
         instance = self._makeOne(config)
@@ -845,7 +840,7 @@ def test_kill_from_starting(self):
         from supervisor.states import ProcessStates
         from supervisor import events
         events.subscribe(events.ProcessStateEvent, lambda x: L.append(x))
-        instance.state = ProcessStates.STARTING
+        instance.state = ProcessStates.RUNNING
         instance.kill(signal.SIGTERM)
         self.assertEqual(options.logger.data[0], 'killing test (pid 11) with '
                          'signal SIGTERM')
@@ -855,24 +850,31 @@ def test_kill_from_starting(self):
         event = L[0]
         self.assertEqual(event.__class__, events.ProcessStateStoppingEvent)
 
-    def test_kill_from_running(self):
+    def test_kill_from_running_error(self):
         options = DummyOptions()
         config = DummyPConfig(options, 'test', '/test')
+        options.kill_exception = OSError(errno.EPERM)
         instance = self._makeOne(config)
-        instance.pid = 11
         L = []
         from supervisor.states import ProcessStates
         from supervisor import events
         events.subscribe(events.ProcessStateEvent, lambda x: L.append(x))
+        instance.pid = 11
         instance.state = ProcessStates.RUNNING
         instance.kill(signal.SIGTERM)
         self.assertEqual(options.logger.data[0], 'killing test (pid 11) with '
                          'signal SIGTERM')
-        self.assertTrue(instance.killing)
-        self.assertEqual(options.kills[11], signal.SIGTERM)
-        self.assertEqual(len(L), 1)
-        event = L[0]
-        self.assertEqual(event.__class__, events.ProcessStateStoppingEvent)
+        self.assertTrue(options.logger.data[1].startswith(
+            'unknown problem killing test'))
+        self.assertTrue('Traceback' in options.logger.data[1])
+        self.assertFalse(instance.killing)
+        self.assertEqual(instance.pid, 0)
+        self.assertEqual(instance.state, ProcessStates.UNKNOWN)
+        self.assertEqual(len(L), 2)
+        event1 = L[0]
+        event2 = L[1]
+        self.assertEqual(event1.__class__, events.ProcessStateStoppingEvent)
+        self.assertEqual(event2.__class__, events.ProcessStateUnknownEvent)
 
     def test_kill_from_stopping(self):
         options = DummyOptions()
@@ -945,7 +947,7 @@ def test_stopasgroup(self):
         self.assertEqual(event.extra_values, [('pid', 11)])
         self.assertEqual(event.from_state, ProcessStates.RUNNING)
 
-    def test_signal(self):
+    def test_signal_from_stopped(self):
         options = DummyOptions()
 
         killedpid = []
@@ -955,23 +957,23 @@ def kill(pid, sig):
             killedpid.append(pid)
             killedsig.append(sig)
 
-        options.kill = kill
+        options.kill = kill #don't actually start killing random processes...
 
         config = DummyPConfig(options, 'test', '/test')
         instance = self._makeOne(config)
-        instance.pid = 11
+        instance.pid = None
 
         from supervisor.states import ProcessStates
-        instance.state = ProcessStates.RUNNING
+        instance.state = ProcessStates.STOPPED
 
         instance.signal(signal.SIGWINCH )
 
-        self.assertEqual(killedpid, [instance.pid,])
-        self.assertEqual(killedsig, [signal.SIGWINCH,])
+        self.assertEqual(options.logger.data[0], "attempted to send test sig SIGWINCH "
+                                                    "but it wasn't running")
 
-        self.assertEqual(options.logger.data[0], 'sending test (pid 11) sig SIGWINCH')
+        self.assertEqual(killedpid, [])
 
-    def test_signal_stopped(self):
+    def test_signal_from_running(self):
         options = DummyOptions()
 
         killedpid = []
@@ -981,23 +983,23 @@ def kill(pid, sig):
             killedpid.append(pid)
             killedsig.append(sig)
 
-        options.kill = kill #don't actually start killing random processes...
+        options.kill = kill
 
         config = DummyPConfig(options, 'test', '/test')
         instance = self._makeOne(config)
-        instance.pid = None
+        instance.pid = 11
 
         from supervisor.states import ProcessStates
-        instance.state = ProcessStates.STOPPED
+        instance.state = ProcessStates.RUNNING
 
         instance.signal(signal.SIGWINCH )
 
-        self.assertEqual(options.logger.data[0], "attempted to send test sig SIGWINCH "
-                                                    "but it wasn't running")
+        self.assertEqual(killedpid, [instance.pid,])
+        self.assertEqual(killedsig, [signal.SIGWINCH,])
 
-        self.assertEqual(killedpid, [])
+        self.assertEqual(options.logger.data[0], 'sending test (pid 11) sig SIGWINCH')
 
-    def test_signal_error(self):
+    def test_signal_from_running_error(self):
         options = DummyOptions()
         config = DummyPConfig(options, 'test', '/test')
         options.kill_exception = OSError(errno.EPERM)
@@ -1015,6 +1017,8 @@ def test_signal_error(self):
             'unknown problem sending sig test (11)'))
         self.assertTrue('Traceback' in options.logger.data[1])
         self.assertFalse(instance.killing)
+        self.assertEqual(instance.state, ProcessStates.UNKNOWN)
+        self.assertEqual(instance.pid, 0)
         self.assertEqual(len(L), 1)
         event = L[0]
         self.assertEqual(event.__class__, events.ProcessStateUnknownEvent)