Fix deprecated assertions

supervisor/tests/test_datatypes.py

@@ -226,12 +226,12 @@ class DatatypesTest(unittest.TestCase):
     @patch("pwd.getpwnam", Mock(return_value=[0,0,42]))
     def test_name_to_uid_gets_uid_from_username(self):
         uid = datatypes.name_to_uid("foo")
-        self.assertEquals(uid, 42)
+        self.assertEqual(uid, 42)
 
     @patch("pwd.getpwuid", Mock(return_value=[0,0,42]))
     def test_name_to_uid_gets_uid_from_user_id(self):
         uid = datatypes.name_to_uid("42")
-        self.assertEquals(uid, 42)
+        self.assertEqual(uid, 42)
 
     @patch("pwd.getpwnam", Mock(side_effect=KeyError("bad username")))
     def test_name_to_uid_raises_for_bad_username(self):
@@ -244,12 +244,12 @@ class DatatypesTest(unittest.TestCase):
     @patch("grp.getgrnam", Mock(return_value=[0,0,42]))
     def test_name_to_gid_gets_gid_from_group_name(self):
         gid = datatypes.name_to_gid("foo")
-        self.assertEquals(gid, 42)
+        self.assertEqual(gid, 42)
 
     @patch("grp.getgrgid", Mock(return_value=[0,0,42]))
     def test_name_to_gid_gets_gid_from_group_id(self):
         gid = datatypes.name_to_gid("42")
-        self.assertEquals(gid, 42)
+        self.assertEqual(gid, 42)
 
     @patch("grp.getgrnam", Mock(side_effect=KeyError("bad group name")))
     def test_name_to_gid_raises_for_bad_group_name(self):
@@ -296,7 +296,7 @@ class InetStreamSocketConfigTests(unittest.TestCase):
         sock = conf.create_and_bind()
         reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
         self.assertTrue(reuse)
-        self.assertEquals(conf.addr(), sock.getsockname()) #verifies that bind was called
+        self.assertEqual(conf.addr(), sock.getsockname()) #verifies that bind was called
         sock.close()
 
     def test_same_urls_are_equal(self):
@@ -362,24 +362,24 @@ class UnixStreamSocketConfigTests(unittest.TestCase):
 
         sock = call_create_and_bind(conf)
         self.assertTrue(os.path.exists(tf_name))
-        self.assertEquals(conf.addr(), sock.getsockname()) #verifies that bind was called
+        self.assertEqual(conf.addr(), sock.getsockname()) #verifies that bind was called
         sock.close()
         self.assertTrue(os.path.exists(tf_name))
         os.unlink(tf_name)
         #Verify that os.chown was called with correct args
-        self.assertEquals(1, chown_mock.call_count)
+        self.assertEqual(1, chown_mock.call_count)
         path_arg = chown_mock.call_args[0][0]
         uid_arg = chown_mock.call_args[0][1]
         gid_arg = chown_mock.call_args[0][2]
-        self.assertEquals(tf_name, path_arg)
-        self.assertEquals(owner[0], uid_arg)
-        self.assertEquals(owner[1], gid_arg)
+        self.assertEqual(tf_name, path_arg)
+        self.assertEqual(owner[0], uid_arg)
+        self.assertEqual(owner[1], gid_arg)
         #Verify that os.chmod was called with correct args
-        self.assertEquals(1, chmod_mock.call_count)
+        self.assertEqual(1, chmod_mock.call_count)
         path_arg = chmod_mock.call_args[0][0]
         mode_arg = chmod_mock.call_args[0][1]
-        self.assertEquals(tf_name, path_arg)
-        self.assertEquals(mode, mode_arg)
+        self.assertEqual(tf_name, path_arg)
+        self.assertEqual(mode, mode_arg)
 
     def test_same_paths_are_equal(self):
         conf1 = self._makeOne('/tmp/foo.sock')
@@ -487,9 +487,9 @@ class TestColonSeparatedUserGroup(unittest.TestCase):
 
         uid, gid = colon_separated("foo:bar")
         name_to_uid.assert_called_with("foo")
-        self.assertEquals(12, uid)
+        self.assertEqual(12, uid)
         name_to_gid.assert_called_with("bar")
-        self.assertEquals(34, gid)
+        self.assertEqual(34, gid)
 
     def test_separated_user_group_returns_user_only(self):
         name_to_uid = Mock(return_value=42)
@@ -500,8 +500,8 @@ class TestColonSeparatedUserGroup(unittest.TestCase):
 
         uid, gid = colon_separated("foo")
         name_to_uid.assert_called_with("foo")
-        self.assertEquals(42, uid)
-        self.assertEquals(-1, gid)
+        self.assertEqual(42, uid)
+        self.assertEqual(-1, gid)
 
 class TestOctalType(unittest.TestCase):
     def _callFUT(self, arg):

supervisor/tests/test_options.py

@@ -58,7 +58,7 @@ class OptionTests(unittest.TestCase):
 
     def test_searchpaths(self):
         options = self._makeOptions()
-        self.assertEquals(len(options.searchpaths), 5)
+        self.assertEqual(len(options.searchpaths), 5)
         self.assertTrue('supervisord.conf' in options.searchpaths)
         self.assertTrue('etc/supervisord.conf' in options.searchpaths)
         self.assertTrue('/etc/supervisord.conf' in options.searchpaths)
@@ -67,28 +67,28 @@ class OptionTests(unittest.TestCase):
         # Only config file exists
         options = self._makeOptions()
         options.realize([])
-        self.assertEquals(options.anoption, 'default')
-        self.assertEquals(options.other, 41)
+        self.assertEqual(options.anoption, 'default')
+        self.assertEqual(options.other, 41)
 
         # Env should trump config
         options = self._makeOptions()
         os.environ['OTHER'] = '42'
         options.realize([])
-        self.assertEquals(options.other, 42)
+        self.assertEqual(options.other, 42)
 
         # Opt should trump both env (still set) and config
         options = self._makeOptions()
         options.realize(['-p', '43'])
-        self.assertEquals(options.other, 43)
+        self.assertEqual(options.other, 43)
         del os.environ['OTHER']
 
     def test_config_reload(self):
         options = self._makeOptions()
         options.realize([])
-        self.assertEquals(options.other, 41)
+        self.assertEqual(options.other, 41)
         options.master['other'] = 42
         options.process_config()
-        self.assertEquals(options.other, 42)
+        self.assertEqual(options.other, 42)
 
     def test_config_reload_do_usage_false(self):
         options = self._makeOptions(read_error='error')
@@ -112,16 +112,16 @@ class OptionTests(unittest.TestCase):
         from supervisor.options import Options
         options = Options()
         options._set('foo', 'bar', 0)
-        self.assertEquals(options.foo, 'bar')
-        self.assertEquals(options.attr_priorities['foo'], 0)
+        self.assertEqual(options.foo, 'bar')
+        self.assertEqual(options.attr_priorities['foo'], 0)
         options._set('foo', 'baz', 1)
-        self.assertEquals(options.foo, 'baz')
-        self.assertEquals(options.attr_priorities['foo'], 1)
+        self.assertEqual(options.foo, 'baz')
+        self.assertEqual(options.attr_priorities['foo'], 1)
         options._set('foo', 'gazonk', 0)
-        self.assertEquals(options.foo, 'baz')
-        self.assertEquals(options.attr_priorities['foo'], 1)
+        self.assertEqual(options.foo, 'baz')
+        self.assertEqual(options.attr_priorities['foo'], 1)
         options._set('foo', 'gazonk', 1)
-        self.assertEquals(options.foo, 'gazonk')
+        self.assertEqual(options.foo, 'gazonk')
 
 class ClientOptionsTests(unittest.TestCase):
     def _getTargetClass(self):
@@ -148,7 +148,7 @@ class ClientOptionsTests(unittest.TestCase):
         instance.realize(args=['-s', 'http://localhost:9001', '-u', 'chris',
                                '-p', '123'])
 
-        self.assertEquals(instance.interactive, 1)
+        self.assertEqual(instance.interactive, 1)
         self.assertEqual(instance.serverurl, 'http://localhost:9001')
         self.assertEqual(instance.username, 'chris')
         self.assertEqual(instance.password, '123')
@@ -198,7 +198,7 @@ class ClientOptionsTests(unittest.TestCase):
         try:
             instance.realize(args=['-c', fname])
         except DummyException, e:
-            self.assertEquals(e.exitcode, 2)
+            self.assertEqual(e.exitcode, 2)
         else:
             self.fail("expected exception")
 
@@ -517,7 +517,7 @@ class ServerOptionsTests(unittest.TestCase):
         except DummyException, e:
             # Caught expected exception
             import traceback
-            self.assertEquals(e.exitcode, 2,
+            self.assertEqual(e.exitcode, 2,
                               "Wrong exitcode for: %s" % traceback.format_exc(e))
         else:
             self.fail("Did not get a DummyException.")
@@ -628,7 +628,7 @@ class ServerOptionsTests(unittest.TestCase):
         try:
             instance.realize(args=['-c', fname])
         except DummyException, e:
-            self.assertEquals(e.exitcode, 2)
+            self.assertEqual(e.exitcode, 2)
         else:
             self.fail("expected exception")
 
@@ -1789,48 +1789,48 @@ class SignalReceiverTests(unittest.TestCase):
     def test_returns_None_initially(self):
         from supervisor.options import SignalReceiver
         sr = SignalReceiver()
-        self.assertEquals(sr.get_signal(), None)
+        self.assertEqual(sr.get_signal(), None)
 
     def test_returns_signals_in_order_received(self):
         from supervisor.options import SignalReceiver
         sr = SignalReceiver()
         sr.receive(signal.SIGTERM, 'frame')
         sr.receive(signal.SIGCHLD, 'frame')
-        self.assertEquals(sr.get_signal(), signal.SIGTERM)
-        self.assertEquals(sr.get_signal(), signal.SIGCHLD)
-        self.assertEquals(sr.get_signal(), None)
+        self.assertEqual(sr.get_signal(), signal.SIGTERM)
+        self.assertEqual(sr.get_signal(), signal.SIGCHLD)
+        self.assertEqual(sr.get_signal(), None)
 
     def test_does_not_queue_duplicate_signals(self):
         from supervisor.options import SignalReceiver
         sr = SignalReceiver()
         sr.receive(signal.SIGTERM, 'frame')
         sr.receive(signal.SIGTERM, 'frame')
-        self.assertEquals(sr.get_signal(), signal.SIGTERM)
-        self.assertEquals(sr.get_signal(), None)
+        self.assertEqual(sr.get_signal(), signal.SIGTERM)
+        self.assertEqual(sr.get_signal(), None)
 
     def test_queues_again_after_being_emptied(self):
         from supervisor.options import SignalReceiver
         sr = SignalReceiver()
         sr.receive(signal.SIGTERM, 'frame')
-        self.assertEquals(sr.get_signal(), signal.SIGTERM)
-        self.assertEquals(sr.get_signal(), None)
+        self.assertEqual(sr.get_signal(), signal.SIGTERM)
+        self.assertEqual(sr.get_signal(), None)
         sr.receive(signal.SIGCHLD, 'frame')
-        self.assertEquals(sr.get_signal(), signal.SIGCHLD)
-        self.assertEquals(sr.get_signal(), None)
+        self.assertEqual(sr.get_signal(), signal.SIGCHLD)
+        self.assertEqual(sr.get_signal(), None)
 
 class UtilFunctionsTests(unittest.TestCase):
     def test_make_namespec(self):
         from supervisor.options import make_namespec
-        self.assertEquals(make_namespec('group', 'process'), 'group:process')
-        self.assertEquals(make_namespec('process', 'process'), 'process')
+        self.assertEqual(make_namespec('group', 'process'), 'group:process')
+        self.assertEqual(make_namespec('process', 'process'), 'process')
 
     def test_split_namespec(self):
         from supervisor.options import split_namespec
         s = split_namespec
-        self.assertEquals(s('process:group'), ('process', 'group'))
-        self.assertEquals(s('process'), ('process', 'process'))
-        self.assertEquals(s('group:'), ('group', None))
-        self.assertEquals(s('group:*'), ('group', None))
+        self.assertEqual(s('process:group'), ('process', 'group'))
+        self.assertEqual(s('process'), ('process', 'process'))
+        self.assertEqual(s('group:'), ('group', None))
+        self.assertEqual(s('group:*'), ('group', None))
 
 def test_suite():
     return unittest.findTestCases(sys.modules[__name__])

supervisor/tests/test_process.py

@@ -1705,7 +1705,7 @@ class EventListenerPoolTests(ProcessGroupBaseTests):
         self.assertEqual(process1.transitioned, True)
         self.assertEqual(pool.event_buffer, [])
         header, payload = process1.stdin_buffer.split('\n', 1)
-        self.assertEquals(payload, 'dummy event', payload)
+        self.assertEqual(payload, 'dummy event', payload)
         self.assertEqual(process1.listener_state, EventListenerStates.BUSY)
         self.assertEqual(process1.event, event)
 

supervisor/tests/test_socket_manager.py

@@ -11,41 +11,41 @@ from supervisor.datatypes import UnixStreamSocketConfig
 from supervisor.datatypes import InetStreamSocketConfig
 
 class TestObject:
-    
+
     def __init__(self):
         self.value = 5
-    
+
     def getValue(self):
         return self.value
-        
+
     def setValue(self, val):
         self.value = val
 
 class ProxyTest(unittest.TestCase):
-    
+
     def setUp(self):
         self.on_deleteCalled = False
-    
+
     def _getTargetClass(self):
         from supervisor.socket_manager import Proxy
         return Proxy
 
     def _makeOne(self, *args, **kw):
         return self._getTargetClass()(*args, **kw)
-    
+
     def setOnDeleteCalled(self):
         self.on_deleteCalled = True
-    
+
     def test_proxy_getattr(self):
         proxy = self._makeOne(TestObject())
-        self.assertEquals(5, proxy.getValue())
-        
+        self.assertEqual(5, proxy.getValue())
+
     def test_on_delete(self):
         proxy = self._makeOne(TestObject(), on_delete=self.setOnDeleteCalled)
-        self.assertEquals(5, proxy.getValue())
+        self.assertEqual(5, proxy.getValue())
         proxy = None
         self.assertTrue(self.on_deleteCalled)
-        
+
 class ReferenceCounterTest(unittest.TestCase):
 
     def setUp(self):
@@ -53,7 +53,7 @@ class ReferenceCounterTest(unittest.TestCase):
 
     def start(self):
         self.running = True
-        
+
     def stop(self):
         self.running = False
 
@@ -69,21 +69,21 @@ class ReferenceCounterTest(unittest.TestCase):
         self.assertFalse(self.running)
         ctr.increment()
         self.assertTrue(self.running)
-        self.assertEquals(1, ctr.get_count())
+        self.assertEqual(1, ctr.get_count())
         ctr.increment()
         self.assertTrue(self.running)
-        self.assertEquals(2, ctr.get_count())
+        self.assertEqual(2, ctr.get_count())
         ctr.decrement()
         self.assertTrue(self.running)
-        self.assertEquals(1, ctr.get_count())
+        self.assertEqual(1, ctr.get_count())
         ctr.decrement()
         self.assertFalse(self.running)
-        self.assertEquals(0, ctr.get_count())
-    
+        self.assertEqual(0, ctr.get_count())
+
     def test_decr_at_zero_raises_error(self):
         ctr = self._makeOne(on_zero=self.stop,on_non_zero=self.start)
         self.assertRaises(Exception, ctr.decrement)
-        
+
 class SocketManagerTest(unittest.TestCase):
     def _getTargetClass(self):
         from supervisor.socket_manager import SocketManager
@@ -120,7 +120,7 @@ class SocketManagerTest(unittest.TestCase):
         self.assertEqual(sock.getsockname(), tf_name)
         sock = None
         os.close(tf_fd)
-        
+
     def test_socket_lifecycle(self):
         conf = DummySocketConfig(2)
         sock_manager = self._makeOne(conf)
@@ -147,7 +147,7 @@ class SocketManagerTest(unittest.TestCase):
         #Socket closed
         self.assertFalse(sock_manager.is_prepared())
         self.assertTrue(sock_manager.socket.close_called)
-        
+
         #Get a new socket reference
         sock3 = sock_manager.get_socket()
         self.assertTrue(sock_manager.is_prepared())
@@ -169,7 +169,7 @@ class SocketManagerTest(unittest.TestCase):
         self.assertTrue(sock.listen_called)
         self.assertEqual(sock.listen_backlog, socket.SOMAXCONN)
         self.assertFalse(sock.close_called)
-    
+
     def test_tcp_socket_already_taken(self):
         conf = InetStreamSocketConfig('127.0.0.1', 51041)
         sock_manager = self._makeOne(conf)
@@ -177,11 +177,11 @@ class SocketManagerTest(unittest.TestCase):
         sock_manager2 = self._makeOne(conf)
         self.assertRaises(socket.error, sock_manager2.get_socket)
         sock = None
-        
+
     def test_unix_bad_sock(self):
         conf = UnixStreamSocketConfig('/notthere/foo.sock')
         sock_manager = self._makeOne(conf)
-        self.assertRaises(socket.error, sock_manager.get_socket)        
+        self.assertRaises(socket.error, sock_manager.get_socket)
 
 def test_suite():
     return unittest.findTestCases(sys.modules[__name__])