Replaces assertEquals to assertEqual

assertEquals() has been deprecated in 2.7
Replaced assertEquals to assertEqual in all test scripts

Change-Id: I04b4ac873e151837ade9127f8c1eba32f4707dd4

diff --git a/quantum/tests/unit/bigswitch/test_restproxy_plugin.py b/quantum/tests/unit/bigswitch/test_restproxy_plugin.py
index bfa1e6bcddf9019b3a738c96f87d4d4516b21f07..f41d6385a250cae6b2e293a5a021f39e3a3c5543 100644 (file)
--- a/quantum/tests/unit/bigswitch/test_restproxy_plugin.py
+++ b/quantum/tests/unit/bigswitch/test_restproxy_plugin.py
@@ -109,4 +109,4 @@ class TestBigSwitchProxySync(BigSwitchProxyPluginV2TestCase):
     def test_send_data(self):
         plugin_obj = QuantumManager.get_plugin()
         result = plugin_obj._send_all_data()
-        self.assertEquals(result[0], 200)
+        self.assertEqual(result[0], 200)

diff --git a/quantum/tests/unit/test_agent_linux_utils.py b/quantum/tests/unit/test_agent_linux_utils.py
index f7b3a98830b45120779066f0175017e31adad758..92677ef67344cb794f50926bb3bfc7e1008d78e5 100644 (file)
--- a/quantum/tests/unit/test_agent_linux_utils.py
+++ b/quantum/tests/unit/test_agent_linux_utils.py
@@ -69,4 +69,4 @@ class AgentUtilsGetInterfaceMAC(unittest.TestCase):
                                           '\x01\x02\x03\x04\x05\x06',
                                           '\x00' * 232])
             actual_val = utils.get_interface_mac('eth0')
-        self.assertEquals(actual_val, expect_val)
+        self.assertEqual(actual_val, expect_val)

diff --git a/quantum/tests/unit/test_agent_netns_cleanup.py b/quantum/tests/unit/test_agent_netns_cleanup.py
index 5cddbbd30e2e73ba3de68f972d62fe7c0ded48b4..8c864548631bfe2dc062409c7d93bbdb1e6f2978 100644 (file)
--- a/quantum/tests/unit/test_agent_netns_cleanup.py
+++ b/quantum/tests/unit/test_agent_netns_cleanup.py
@@ -141,7 +141,7 @@ class TestNetnsCleanup(unittest.TestCase):
 
                     mock_get_bridge_for_iface.assert_called_once_with(
                         conf.root_helper, 'tap1')
-                    self.assertEquals(ovs_br_cls.mock_calls, [])
+                    self.assertEqual(ovs_br_cls.mock_calls, [])
                     self.assertTrue(debug.called)
 
     def _test_destroy_namespace_helper(self, force, num_devices):

diff --git a/quantum/tests/unit/test_attributes.py b/quantum/tests/unit/test_attributes.py
index 72e7da0f1d0751fe8c3450a4d4fb9be3be7d42b7..447cbf6478cf159429085664e779bb3da9a8a17c 100644 (file)
--- a/quantum/tests/unit/test_attributes.py
+++ b/quantum/tests/unit/test_attributes.py
@@ -41,14 +41,14 @@ class TestAttributes(unittest2.TestCase):
         self.assertIsNone(msg)
 
         msg = attributes._validate_values(7, [4, 6])
-        self.assertEquals(msg, "'7' is not in [4, 6]")
+        self.assertEqual(msg, "'7' is not in [4, 6]")
 
         msg = attributes._validate_values(7, (4, 6))
-        self.assertEquals(msg, "'7' is not in (4, 6)")
+        self.assertEqual(msg, "'7' is not in (4, 6)")
 
     def test_validate_string(self):
         msg = attributes._validate_string(None, None)
-        self.assertEquals(msg, "'None' is not a valid string")
+        self.assertEqual(msg, "'None' is not a valid string")
 
         # 0 == len(data) == max_len
         msg = attributes._validate_string("", 0)
@@ -68,7 +68,7 @@ class TestAttributes(unittest2.TestCase):
 
         # 0 < max_len < len(data)
         msg = attributes._validate_string("1234567890", 9)
-        self.assertEquals(msg, "'1234567890' exceeds maximum length of 9")
+        self.assertEqual(msg, "'1234567890' exceeds maximum length of 9")
 
         msg = attributes._validate_string("123456789", None)
         self.assertIsNone(msg)
@@ -93,10 +93,10 @@ class TestAttributes(unittest2.TestCase):
         self.assertIsNone(msg)
 
         msg = attributes._validate_range(0, [1, 9])
-        self.assertEquals(msg, "'0' is not in range 1 through 9")
+        self.assertEqual(msg, "'0' is not in range 1 through 9")
 
         msg = attributes._validate_range(10, (1, 9))
-        self.assertEquals(msg, "'10' is not in range 1 through 9")
+        self.assertEqual(msg, "'10' is not in range 1 through 9")
 
     def test_validate_mac_address(self):
         mac_addr = "ff:16:3e:4f:00:00"
@@ -105,7 +105,7 @@ class TestAttributes(unittest2.TestCase):
 
         mac_addr = "ffa:16:3e:4f:00:00"
         msg = attributes._validate_mac_address(mac_addr)
-        self.assertEquals(msg, "'%s' is not a valid MAC address" % mac_addr)
+        self.assertEqual(msg, "'%s' is not a valid MAC address" % mac_addr)
 
     def test_validate_ip_address(self):
         ip_addr = '1.1.1.1'
@@ -114,7 +114,7 @@ class TestAttributes(unittest2.TestCase):
 
         ip_addr = '1111.1.1.1'
         msg = attributes._validate_ip_address(ip_addr)
-        self.assertEquals(msg, "'%s' is not a valid IP address" % ip_addr)
+        self.assertEqual(msg, "'%s' is not a valid IP address" % ip_addr)
 
     def test_validate_ip_pools(self):
         pools = [[{'end': '10.0.0.254'}],
@@ -223,7 +223,7 @@ class TestAttributes(unittest2.TestCase):
 
         ip_addr = '1111.1.1.1'
         msg = attributes._validate_ip_address_or_none(ip_addr)
-        self.assertEquals(msg, "'%s' is not a valid IP address" % ip_addr)
+        self.assertEqual(msg, "'%s' is not a valid IP address" % ip_addr)
 
     def test_hostname_pattern(self):
         data = '@openstack'
@@ -322,39 +322,39 @@ class TestAttributes(unittest2.TestCase):
         msg = attributes._validate_subnet(cidr,
                                           None)
         error = "'%s' is not a valid IP subnet" % cidr
-        self.assertEquals(msg, error)
+        self.assertEqual(msg, error)
 
         # Invalid - IPv6 without final octets, missing mask
         cidr = "fe80::"
         msg = attributes._validate_subnet(cidr,
                                           None)
         error = "'%s' is not a valid IP subnet" % cidr
-        self.assertEquals(msg, error)
+        self.assertEqual(msg, error)
 
         # Invalid - IPv6 with final octets, missing mask
         cidr = "fe80::0"
         msg = attributes._validate_subnet(cidr,
                                           None)
         error = "'%s' is not a valid IP subnet" % cidr
-        self.assertEquals(msg, error)
+        self.assertEqual(msg, error)
 
         # Invalid - Address format error
         cidr = 'invalid'
         msg = attributes._validate_subnet(cidr,
                                           None)
         error = "'%s' is not a valid IP subnet" % cidr
-        self.assertEquals(msg, error)
+        self.assertEqual(msg, error)
 
     def test_validate_regex(self):
         pattern = '[hc]at'
 
         data = None
         msg = attributes._validate_regex(data, pattern)
-        self.assertEquals(msg, "'%s' is not a valid input" % data)
+        self.assertEqual(msg, "'%s' is not a valid input" % data)
 
         data = 'bat'
         msg = attributes._validate_regex(data, pattern)
-        self.assertEquals(msg, "'%s' is not a valid input" % data)
+        self.assertEqual(msg, "'%s' is not a valid input" % data)
 
         data = 'hat'
         msg = attributes._validate_regex(data, pattern)
@@ -366,7 +366,7 @@ class TestAttributes(unittest2.TestCase):
 
     def test_validate_uuid(self):
         msg = attributes._validate_uuid('garbage')
-        self.assertEquals(msg, "'garbage' is not a valid UUID")
+        self.assertEqual(msg, "'garbage' is not a valid UUID")
 
         msg = attributes._validate_uuid('00000000-ffff-ffff-ffff-000000000000')
         self.assertIsNone(msg)
@@ -400,13 +400,13 @@ class TestConvertToBoolean(unittest2.TestCase):
 class TestConvertToInt(unittest2.TestCase):
 
     def test_convert_to_int_int(self):
-        self.assertEquals(attributes.convert_to_int(-1), -1)
-        self.assertEquals(attributes.convert_to_int(0), 0)
-        self.assertEquals(attributes.convert_to_int(1), 1)
+        self.assertEqual(attributes.convert_to_int(-1), -1)
+        self.assertEqual(attributes.convert_to_int(0), 0)
+        self.assertEqual(attributes.convert_to_int(1), 1)
 
     def test_convert_to_int_str(self):
-        self.assertEquals(attributes.convert_to_int('4'), 4)
-        self.assertEquals(attributes.convert_to_int('6'), 6)
+        self.assertEqual(attributes.convert_to_int('4'), 4)
+        self.assertEqual(attributes.convert_to_int('6'), 6)
         self.assertRaises(q_exc.InvalidInput,
                           attributes.convert_to_int,
                           'garbage')

diff --git a/quantum/tests/unit/test_db_plugin.py b/quantum/tests/unit/test_db_plugin.py
index 1271b0301d14476e4bf6dc9fb362e692feca97b5..65e0823c69b89624cc2c6efe6a1ec067ab79cb3d 100644 (file)
--- a/quantum/tests/unit/test_db_plugin.py
+++ b/quantum/tests/unit/test_db_plugin.py
@@ -390,7 +390,7 @@ class QuantumDbPluginV2TestCase(unittest2.TestCase):
         self.assertEqual(res.status_int, 400)
         req = self.new_list_request(collection)
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 200)
+        self.assertEqual(res.status_int, 200)
         items = self.deserialize('json', res)
         self.assertEqual(len(items[collection]), 0)
 
@@ -495,20 +495,20 @@ class TestBasicGet(QuantumDbPluginV2TestCase):
 class TestV2HTTPResponse(QuantumDbPluginV2TestCase):
     def test_create_returns_201(self):
         res = self._create_network('json', 'net2', True)
-        self.assertEquals(res.status_int, 201)
+        self.assertEqual(res.status_int, 201)
 
     def test_list_returns_200(self):
         req = self.new_list_request('networks')
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 200)
+        self.assertEqual(res.status_int, 200)
 
     def _check_list_with_fields(self, res, field_name):
-        self.assertEquals(res.status_int, 200)
+        self.assertEqual(res.status_int, 200)
         body = self.deserialize('json', res)
         # further checks: 1 networks
-        self.assertEquals(len(body['networks']), 1)
+        self.assertEqual(len(body['networks']), 1)
         # 1 field in the network record
-        self.assertEquals(len(body['networks'][0]), 1)
+        self.assertEqual(len(body['networks'][0]), 1)
         # field is 'name'
         self.assertIn(field_name, body['networks'][0])
 
@@ -553,14 +553,14 @@ class TestV2HTTPResponse(QuantumDbPluginV2TestCase):
         with self.network() as net:
             req = self.new_show_request('networks', net['network']['id'])
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 200)
+            self.assertEqual(res.status_int, 200)
 
     def test_delete_returns_204(self):
         res = self._create_network('json', 'net1', True)
         net = self.deserialize('json', res)
         req = self.new_delete_request('networks', net['network']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)
 
     def test_update_returns_200(self):
         with self.network() as net:
@@ -568,7 +568,7 @@ class TestV2HTTPResponse(QuantumDbPluginV2TestCase):
                                           {'network': {'name': 'steve'}},
                                           net['network']['id'])
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 200)
+            self.assertEqual(res.status_int, 200)
 
     def test_update_invalid_json_400(self):
         with self.network() as net:
@@ -576,12 +576,12 @@ class TestV2HTTPResponse(QuantumDbPluginV2TestCase):
                                           '{{"name": "aaa"}}',
                                           net['network']['id'])
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_bad_route_404(self):
         req = self.new_list_request('doohickeys')
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 404)
+        self.assertEqual(res.status_int, 404)
 
 
 class TestPortsV2(QuantumDbPluginV2TestCase):
@@ -589,12 +589,12 @@ class TestPortsV2(QuantumDbPluginV2TestCase):
         keys = [('admin_state_up', True), ('status', 'ACTIVE')]
         with self.port(name='myname') as port:
             for k, v in keys:
-                self.assertEquals(port['port'][k], v)
+                self.assertEqual(port['port'][k], v)
             self.assertTrue('mac_address' in port['port'])
             ips = port['port']['fixed_ips']
-            self.assertEquals(len(ips), 1)
-            self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-            self.assertEquals('myname', port['port']['name'])
+            self.assertEqual(len(ips), 1)
+            self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+            self.assertEqual('myname', port['port']['name'])
 
     def test_create_port_bad_tenant(self):
         with self.network() as network:
@@ -607,7 +607,7 @@ class TestPortsV2(QuantumDbPluginV2TestCase):
 
             port_req = self.new_create_request('ports', data)
             res = port_req.get_response(self.api)
-            self.assertEquals(res.status_int, 403)
+            self.assertEqual(res.status_int, 403)
 
     def test_create_port_public_network(self):
         keys = [('admin_state_up', True), ('status', 'ACTIVE')]
@@ -619,7 +619,7 @@ class TestPortsV2(QuantumDbPluginV2TestCase):
                                          set_context=True)
             port = self.deserialize('json', port_res)
             for k, v in keys:
-                self.assertEquals(port['port'][k], v)
+                self.assertEqual(port['port'][k], v)
             self.assertTrue('mac_address' in port['port'])
             self._delete('ports', port['port']['id'])
 
@@ -636,7 +636,7 @@ class TestPortsV2(QuantumDbPluginV2TestCase):
                                              set_context=True)
                 port = self.deserialize('json', port_res)
                 for k, v in keys:
-                    self.assertEquals(port['port'][k], v)
+                    self.assertEqual(port['port'][k], v)
                 self.assertTrue('mac_address' in port['port'])
                 self._delete('ports', port['port']['id'])
 
@@ -677,7 +677,7 @@ class TestPortsV2(QuantumDbPluginV2TestCase):
             self.assertEqual(res.status_int, 400)
             req = self.new_list_request('ports')
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 200)
+            self.assertEqual(res.status_int, 200)
             ports = self.deserialize('json', res)
             self.assertEqual(len(ports['ports']), 0)
 
@@ -770,7 +770,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
         with self.port() as port:
             req = self.new_show_request('ports', port['port']['id'], 'json')
             sport = self.deserialize('json', req.get_response(self.api))
-            self.assertEquals(port['port']['id'], sport['port']['id'])
+            self.assertEqual(port['port']['id'], sport['port']['id'])
 
     def test_delete_port(self):
         port_id = None
@@ -778,7 +778,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             port_id = port['port']['id']
         req = self.new_show_request('port', 'json', port['port']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 404)
+        self.assertEqual(res.status_int, 404)
 
     def test_delete_port_public_network(self):
         with self.network(shared=True) as network:
@@ -807,7 +807,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             data = {'port': {'device_id': None}}
             req = self.new_update_request('ports', data, port['port']['id'])
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_delete_network_if_port_exists(self):
         fmt = 'json'
@@ -815,7 +815,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             req = self.new_delete_request('networks',
                                           port['port']['network_id'])
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 409)
+            self.assertEqual(res.status_int, 409)
 
     def test_delete_network_port_exists_owned_by_network(self):
         gateway_ip = '10.0.0.1'
@@ -830,7 +830,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
         self._create_port(fmt, network_id, device_owner='network:dhcp')
         req = self.new_delete_request('networks', network_id)
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)
 
     def test_update_port_delete_ip(self):
         with self.subnet() as subnet:
@@ -853,9 +853,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
         with self.subnet() as subnet:
             with self.port(subnet=subnet) as port:
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 data = {'port': {'fixed_ips': [{'subnet_id':
                                                 subnet['subnet']['id'],
                                                 'ip_address': "10.0.0.10"}]}}
@@ -863,9 +863,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                                               port['port']['id'])
                 res = self.deserialize('json', req.get_response(self.api))
                 ips = res['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.10')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.10')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
 
     def test_update_port_update_ips(self):
         """Update IP and generate new IP on port.
@@ -884,9 +884,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 self.assertEqual(res['port']['admin_state_up'],
                                  data['port']['admin_state_up'])
                 ips = res['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.3')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.3')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
 
     def test_update_port_add_additional_ip(self):
         """Test update of port with additional IP."""
@@ -903,11 +903,11 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 self.assertEqual(res['port']['admin_state_up'],
                                  data['port']['admin_state_up'])
                 ips = res['port']['fixed_ips']
-                self.assertEquals(len(ips), 2)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.3')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
-                self.assertEquals(ips[1]['ip_address'], '10.0.0.4')
-                self.assertEquals(ips[1]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 2)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.3')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(ips[1]['ip_address'], '10.0.0.4')
+                self.assertEqual(ips[1]['subnet_id'], subnet['subnet']['id'])
 
     def test_requested_duplicate_mac(self):
         fmt = 'json'
@@ -920,7 +920,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             net_id = port['port']['network_id']
             res = self._create_port(fmt, net_id=net_id, **kwargs)
             port2 = self.deserialize(fmt, res)
-            self.assertEquals(res.status_int, 409)
+            self.assertEqual(res.status_int, 409)
 
     def test_mac_generation(self):
         cfg.CONF.set_override('base_mac', "12:34:56:00:00:00")
@@ -961,54 +961,54 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             network = self.deserialize(fmt, res)
             net_id = network['network']['id']
             res = self._create_port(fmt, net_id=net_id)
-            self.assertEquals(res.status_int, 503)
+            self.assertEqual(res.status_int, 503)
 
     def test_requested_duplicate_ip(self):
         fmt = 'json'
         with self.subnet() as subnet:
             with self.port(subnet=subnet) as port:
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 # Check configuring of duplicate IP
                 kwargs = {"fixed_ips": [{'subnet_id': subnet['subnet']['id'],
                                          'ip_address': ips[0]['ip_address']}]}
                 net_id = port['port']['network_id']
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port2 = self.deserialize(fmt, res)
-                self.assertEquals(res.status_int, 409)
+                self.assertEqual(res.status_int, 409)
 
     def test_requested_subnet_delete(self):
         fmt = 'json'
         with self.subnet() as subnet:
             with self.port(subnet=subnet) as port:
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 req = self.new_delete_request('subnet',
                                               subnet['subnet']['id'])
                 res = req.get_response(self.api)
-                self.assertEquals(res.status_int, 404)
+                self.assertEqual(res.status_int, 404)
 
     def test_requested_subnet_id(self):
         fmt = 'json'
         with self.subnet() as subnet:
             with self.port(subnet=subnet) as port:
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 # Request a IP from specific subnet
                 kwargs = {"fixed_ips": [{'subnet_id': subnet['subnet']['id']}]}
                 net_id = port['port']['network_id']
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port2 = self.deserialize(fmt, res)
                 ips = port2['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.3')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.3')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 self._delete('ports', port2['port']['id'])
 
     def test_requested_subnet_id_not_on_network(self):
@@ -1027,7 +1027,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                                          subnet2['subnet']['id']}]}
                 net_id = port['port']['network_id']
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_overlapping_subnets(self):
         fmt = 'json'
@@ -1040,7 +1040,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                                       cidr='10.0.0.225/28',
                                       ip_version=4,
                                       gateway_ip=ATTR_NOT_SPECIFIED)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_requested_subnet_id_v4_and_v6(self):
         fmt = 'json'
@@ -1061,20 +1061,20 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port3 = self.deserialize(fmt, res)
                 ips = port3['port']['fixed_ips']
-                self.assertEquals(len(ips), 2)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
-                self.assertEquals(ips[1]['ip_address'], '2607:f0d0:1002:51::2')
-                self.assertEquals(ips[1]['subnet_id'], subnet2['subnet']['id'])
+                self.assertEqual(len(ips), 2)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(ips[1]['ip_address'], '2607:f0d0:1002:51::2')
+                self.assertEqual(ips[1]['subnet_id'], subnet2['subnet']['id'])
                 res = self._create_port(fmt, net_id=net_id)
                 port4 = self.deserialize(fmt, res)
                 # Check that a v4 and a v6 address are allocated
                 ips = port4['port']['fixed_ips']
-                self.assertEquals(len(ips), 2)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.3')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
-                self.assertEquals(ips[1]['ip_address'], '2607:f0d0:1002:51::3')
-                self.assertEquals(ips[1]['subnet_id'], subnet2['subnet']['id'])
+                self.assertEqual(len(ips), 2)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.3')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(ips[1]['ip_address'], '2607:f0d0:1002:51::3')
+                self.assertEqual(ips[1]['subnet_id'], subnet2['subnet']['id'])
                 self._delete('ports', port3['port']['id'])
                 self._delete('ports', port4['port']['id'])
 
@@ -1092,13 +1092,13 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port = self.deserialize(fmt, res)
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 5)
+                self.assertEqual(len(ips), 5)
                 alloc = ['10.0.0.1', '10.0.0.2', '10.0.0.4', '10.0.0.5',
                          '10.0.0.6']
                 for i in range(len(alloc)):
-                    self.assertEquals(ips[i]['ip_address'], alloc[i])
-                    self.assertEquals(ips[i]['subnet_id'],
-                                      subnet['subnet']['id'])
+                    self.assertEqual(ips[i]['ip_address'], alloc[i])
+                    self.assertEqual(ips[i]['subnet_id'],
+                                     subnet['subnet']['id'])
                 self._delete('ports', port['port']['id'])
 
         with self.subnet(gateway_ip='11.0.0.6',
@@ -1113,13 +1113,13 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port = self.deserialize(fmt, res)
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 5)
+                self.assertEqual(len(ips), 5)
                 alloc = ['11.0.0.1', '11.0.0.2', '11.0.0.3', '11.0.0.4',
                          '11.0.0.5']
                 for i in range(len(alloc)):
-                    self.assertEquals(ips[i]['ip_address'], alloc[i])
-                    self.assertEquals(ips[i]['subnet_id'],
-                                      subnet['subnet']['id'])
+                    self.assertEqual(ips[i]['ip_address'], alloc[i])
+                    self.assertEqual(ips[i]['subnet_id'],
+                                     subnet['subnet']['id'])
                 self._delete('ports', port['port']['id'])
 
     def test_requested_invalid_fixed_ips(self):
@@ -1127,9 +1127,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
         with self.subnet() as subnet:
             with self.port(subnet=subnet) as port:
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 # Test invalid subnet_id
                 kwargs = {"fixed_ips":
                           [{'subnet_id': subnet['subnet']['id']},
@@ -1138,7 +1138,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 net_id = port['port']['network_id']
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port2 = self.deserialize(fmt, res)
-                self.assertEquals(res.status_int, 404)
+                self.assertEqual(res.status_int, 404)
 
                 # Test invalid IP address on specified subnet_id
                 kwargs = {"fixed_ips":
@@ -1147,7 +1147,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 net_id = port['port']['network_id']
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port2 = self.deserialize(fmt, res)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
                 # Test invalid addresses - IP's not on subnet or network
                 # address or broadcast address
@@ -1157,7 +1157,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                     kwargs = {"fixed_ips": [{'ip_address': ip}]}
                     res = self._create_port(fmt, net_id=net_id, **kwargs)
                     port2 = self.deserialize(fmt, res)
-                    self.assertEquals(res.status_int, 400)
+                    self.assertEqual(res.status_int, 400)
 
                 # Enable allocation of gateway address
                 kwargs = {"fixed_ips":
@@ -1167,9 +1167,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 res = self._create_port(fmt, net_id=net_id, **kwargs)
                 port2 = self.deserialize(fmt, res)
                 ips = port2['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.1')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.1')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 self._delete('ports', port2['port']['id'])
 
     def test_invalid_ip(self):
@@ -1181,7 +1181,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             net_id = subnet['subnet']['network_id']
             res = self._create_port(fmt, net_id=net_id, **kwargs)
             port = self.deserialize(fmt, res)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_requested_split(self):
         fmt = 'json'
@@ -1189,9 +1189,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             with self.port(subnet=subnet) as port:
                 ports_to_delete = []
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 # Allocate specific IP
                 kwargs = {"fixed_ips": [{'subnet_id': subnet['subnet']['id'],
                                          'ip_address': '10.0.0.5'}]}
@@ -1200,9 +1200,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 port2 = self.deserialize(fmt, res)
                 ports_to_delete.append(port2)
                 ips = port2['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.5')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.5')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 # Allocate specific IP's
                 allocated = ['10.0.0.3', '10.0.0.4', '10.0.0.6']
 
@@ -1211,10 +1211,10 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                     port2 = self.deserialize(fmt, res)
                     ports_to_delete.append(port2)
                     ips = port2['port']['fixed_ips']
-                    self.assertEquals(len(ips), 1)
-                    self.assertEquals(ips[0]['ip_address'], a)
-                    self.assertEquals(ips[0]['subnet_id'],
-                                      subnet['subnet']['id'])
+                    self.assertEqual(len(ips), 1)
+                    self.assertEqual(ips[0]['ip_address'], a)
+                    self.assertEqual(ips[0]['subnet_id'],
+                                     subnet['subnet']['id'])
 
                 for p in ports_to_delete:
                     self._delete('ports', p['port']['id'])
@@ -1230,7 +1230,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             net_id = subnet['subnet']['network_id']
             res = self._create_port(fmt, net_id=net_id, **kwargs)
             port2 = self.deserialize(fmt, res)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_fixed_ip_invalid_subnet_id(self):
         fmt = 'json'
@@ -1241,7 +1241,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             net_id = subnet['subnet']['network_id']
             res = self._create_port(fmt, net_id=net_id, **kwargs)
             port2 = self.deserialize(fmt, res)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_fixed_ip_invalid_ip(self):
         fmt = 'json'
@@ -1252,16 +1252,16 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             net_id = subnet['subnet']['network_id']
             res = self._create_port(fmt, net_id=net_id, **kwargs)
             port2 = self.deserialize(fmt, res)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_requested_ips_only(self):
         fmt = 'json'
         with self.subnet() as subnet:
             with self.port(subnet=subnet) as port:
                 ips = port['port']['fixed_ips']
-                self.assertEquals(len(ips), 1)
-                self.assertEquals(ips[0]['ip_address'], '10.0.0.2')
-                self.assertEquals(ips[0]['subnet_id'], subnet['subnet']['id'])
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
                 ips_only = ['10.0.0.18', '10.0.0.20', '10.0.0.22', '10.0.0.21',
                             '10.0.0.3', '10.0.0.17', '10.0.0.19']
                 ports_to_delete = []
@@ -1272,10 +1272,10 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                     port = self.deserialize(fmt, res)
                     ports_to_delete.append(port)
                     ips = port['port']['fixed_ips']
-                    self.assertEquals(len(ips), 1)
-                    self.assertEquals(ips[0]['ip_address'], i)
-                    self.assertEquals(ips[0]['subnet_id'],
-                                      subnet['subnet']['id'])
+                    self.assertEqual(len(ips), 1)
+                    self.assertEqual(ips[0]['ip_address'], i)
+                    self.assertEqual(ips[0]['subnet_id'],
+                                     subnet['subnet']['id'])
                 for p in ports_to_delete:
                     self._delete('ports', p['port']['id'])
 
@@ -1290,10 +1290,10 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 with mock.patch.object(timeutils, 'utcnow') as mock_utcnow:
                     mock_utcnow.return_value = reference
                     ips = port['port']['fixed_ips']
-                    self.assertEquals(len(ips), 1)
-                    self.assertEquals(ips[0]['ip_address'], '10.0.1.2')
-                    self.assertEquals(ips[0]['subnet_id'],
-                                      subnet['subnet']['id'])
+                    self.assertEqual(len(ips), 1)
+                    self.assertEqual(ips[0]['ip_address'], '10.0.1.2')
+                    self.assertEqual(ips[0]['subnet_id'],
+                                     subnet['subnet']['id'])
                     net_id = port['port']['network_id']
                     ports = []
                     for i in range(16 - 3):
@@ -1307,10 +1307,10 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                     res = self._create_port(fmt, net_id=net_id)
                     port = self.deserialize(fmt, res)
                     ips = port['port']['fixed_ips']
-                    self.assertEquals(len(ips), 1)
-                    self.assertEquals(ips[0]['ip_address'], '10.0.1.3')
-                    self.assertEquals(ips[0]['subnet_id'],
-                                      subnet['subnet']['id'])
+                    self.assertEqual(len(ips), 1)
+                    self.assertEqual(ips[0]['ip_address'], '10.0.1.3')
+                    self.assertEqual(ips[0]['subnet_id'],
+                                     subnet['subnet']['id'])
                     self._delete('ports', port['port']['id'])
 
     def test_invalid_admin_state(self):
@@ -1321,7 +1321,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                              'fixed_ips': []}}
             port_req = self.new_create_request('ports', data)
             res = port_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_invalid_mac_address(self):
         with self.network() as network:
@@ -1332,7 +1332,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                              'fixed_ips': []}}
             port_req = self.new_create_request('ports', data)
             res = port_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_default_allocation_expiration(self):
         cfg.CONF.set_override('dhcp_lease_duration', 120)
@@ -1377,7 +1377,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 with self.port(subnet=subnet, no_delete=True) as port:
                     req = self.new_delete_request('ports', port['port']['id'])
                     res = req.get_response(self.api)
-                    self.assertEquals(res.status_int, 204)
+                    self.assertEqual(res.status_int, 204)
 
                     hold_ip.assert_called_once_with(
                         mock.ANY,
@@ -1419,7 +1419,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                     q = update_context.session.query(models_v2.IPAllocation)
                     q = q.filter_by(port_id=None, ip_address=ip_address)
 
-                self.assertEquals(len(q.all()), 1)
+                self.assertEqual(len(q.all()), 1)
 
     def test_recycle_held_ip_address(self):
         plugin = QuantumManager.get_plugin()
@@ -1436,9 +1436,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 with mock.patch.object(plugin, '_recycle_ip') as rc:
                     plugin._recycle_expired_ip_allocations(
                         update_context, subnet['subnet']['network_id'])
-                    rc.assertEquals(len(rc.mock_calls), 1)
-                    self.assertEquals(update_context._recycled_networks,
-                                      set([subnet['subnet']['network_id']]))
+                    rc.assertEqual(len(rc.mock_calls), 1)
+                    self.assertEqual(update_context._recycled_networks,
+                                     set([subnet['subnet']['network_id']]))
 
     def test_recycle_expired_previously_run_within_context(self):
         plugin = QuantumManager.get_plugin()
@@ -1459,8 +1459,8 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                     plugin._recycle_expired_ip_allocations(
                         update_context, subnet['subnet']['network_id'])
                     rc.assertFalse(rc.called)
-                    self.assertEquals(update_context._recycled_networks,
-                                      set([subnet['subnet']['network_id']]))
+                    self.assertEqual(update_context._recycled_networks,
+                                     set([subnet['subnet']['network_id']]))
 
 
 class TestNetworksV2(QuantumDbPluginV2TestCase):
@@ -1472,7 +1472,7 @@ class TestNetworksV2(QuantumDbPluginV2TestCase):
                 ('status', 'ACTIVE'), ('shared', False)]
         with self.network(name=name) as net:
             for k, v in keys:
-                self.assertEquals(net['network'][k], v)
+                self.assertEqual(net['network'][k], v)
 
     def test_create_public_network(self):
         name = 'public_net'
@@ -1480,7 +1480,7 @@ class TestNetworksV2(QuantumDbPluginV2TestCase):
                 ('status', 'ACTIVE'), ('shared', True)]
         with self.network(name=name, shared=True) as net:
             for k, v in keys:
-                self.assertEquals(net['network'][k], v)
+                self.assertEqual(net['network'][k], v)
 
     def test_create_public_network_no_admin_tenant(self):
         name = 'public_net'
@@ -1492,7 +1492,7 @@ class TestNetworksV2(QuantumDbPluginV2TestCase):
                               tenant_id="another_tenant",
                               set_context=True):
                 pass
-        self.assertEquals(ctx_manager.exception.code, 403)
+        self.assertEqual(ctx_manager.exception.code, 403)
 
     def test_update_network(self):
         with self.network() as network:
@@ -1642,7 +1642,7 @@ class TestNetworksV2(QuantumDbPluginV2TestCase):
         self.assertEqual(res.status_int, 400)
         req = self.new_list_request('networks')
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 200)
+        self.assertEqual(res.status_int, 200)
         nets = self.deserialize('json', res)
         self.assertEqual(len(nets['networks']), 0)
 
@@ -1708,11 +1708,11 @@ class TestNetworksV2(QuantumDbPluginV2TestCase):
             req = self.new_list_request('networks',
                                         params='fields=name')
             res = self.deserialize('json', req.get_response(self.api))
-            self.assertEquals(1, len(res['networks']))
-            self.assertEquals(res['networks'][0]['name'],
-                              net1['network']['name'])
-            self.assertEquals(None,
-                              res['networks'][0].get('id'))
+            self.assertEqual(1, len(res['networks']))
+            self.assertEqual(res['networks'][0]['name'],
+                             net1['network']['name'])
+            self.assertEqual(None,
+                             res['networks'][0].get('id'))
 
     def test_list_networks_with_parameters_invalid_values(self):
         with contextlib.nested(self.network(name='net1',
@@ -1721,22 +1721,22 @@ class TestNetworksV2(QuantumDbPluginV2TestCase):
             req = self.new_list_request('networks',
                                         params='admin_state_up=fake')
             res = req.get_response(self.api)
-            self.assertEquals(400, res.status_int)
+            self.assertEqual(400, res.status_int)
 
     def test_show_network(self):
         with self.network(name='net1') as net:
             req = self.new_show_request('networks', net['network']['id'])
             res = self.deserialize('json', req.get_response(self.api))
-            self.assertEquals(res['network']['name'],
-                              net['network']['name'])
+            self.assertEqual(res['network']['name'],
+                             net['network']['name'])
 
     def test_show_network_with_subnet(self):
         with self.network(name='net1') as net:
             with self.subnet(net) as subnet:
                 req = self.new_show_request('networks', net['network']['id'])
                 res = self.deserialize('json', req.get_response(self.api))
-                self.assertEquals(res['network']['subnets'][0],
-                                  subnet['subnet']['id'])
+                self.assertEqual(res['network']['subnets'][0],
+                                 subnet['subnet']['id'])
 
     def test_invalid_admin_status(self):
         fmt = 'json'
@@ -1750,10 +1750,10 @@ class TestNetworksV2(QuantumDbPluginV2TestCase):
                                 'tenant_id': self._tenant_id}}
             network_req = self.new_create_request('networks', data)
             req = network_req.get_response(self.api)
-            self.assertEquals(req.status_int, v[2])
+            self.assertEqual(req.status_int, v[2])
             if v[2] == 201:
                 res = self.deserialize(fmt, req)
-                self.assertEquals(res['network']['admin_state_up'], v[1])
+                self.assertEqual(res['network']['admin_state_up'], v[1])
 
 
 class TestSubnetsV2(QuantumDbPluginV2TestCase):
@@ -1767,12 +1767,12 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             # verify the response has each key with the correct value
             for k in keys:
                 self.assertIn(k, subnet['subnet'])
-                self.assertEquals(subnet['subnet'][k], keys[k])
+                self.assertEqual(subnet['subnet'][k], keys[k])
             # verify the configured validations are correct
             if expected:
                 for k in expected:
                     self.assertIn(k, subnet['subnet'])
-                    self.assertEquals(subnet['subnet'][k], expected[k])
+                    self.assertEqual(subnet['subnet'][k], expected[k])
             return subnet
 
     def test_create_subnet(self):
@@ -1819,7 +1819,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                      gateway_ip=gateway_ip_2,
                                      cidr=cidr_2):
                         pass
-                self.assertEquals(ctx_manager.exception.code, 400)
+                self.assertEqual(ctx_manager.exception.code, 400)
 
     def test_create_subnet_bad_V4_cidr(self):
         with self.network() as network:
@@ -1830,7 +1830,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                     'gateway_ip': '10.0.2.1'}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_bad_V6_cidr(self):
         with self.network() as network:
@@ -1841,7 +1841,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                     'gateway_ip': 'fe80::1'}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_2_subnets_overlapping_cidr_allowed_returns_200(self):
         cidr_1 = '10.0.0.0/23'
@@ -1861,7 +1861,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             with contextlib.nested(self.subnet(cidr=cidr_1),
                                    self.subnet(cidr=cidr_2)):
                 pass
-            self.assertEquals(ctx_manager.exception.code, 400)
+            self.assertEqual(ctx_manager.exception.code, 400)
 
     def test_create_subnets_bulk_native(self):
         if self._skip_native_bulk:
@@ -1946,7 +1946,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    cidr, ip_version=4)
         req = self.new_delete_request('subnets', subnet['subnet']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)
 
     def test_delete_subnet_port_exists_owned_by_network(self):
         gateway_ip = '10.0.0.1'
@@ -1964,7 +1964,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                           device_owner='network:dhcp')
         req = self.new_delete_request('subnets', subnet['subnet']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)
 
     def test_delete_subnet_port_exists_owned_by_other(self):
         with self.subnet() as subnet:
@@ -1972,7 +1972,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                 req = self.new_delete_request('subnets',
                                               subnet['subnet']['id'])
                 res = req.get_response(self.api)
-                self.assertEquals(res.status_int, 409)
+                self.assertEqual(res.status_int, 409)
 
     def test_delete_network(self):
         gateway_ip = '10.0.0.1'
@@ -1986,7 +1986,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    cidr, ip_version=4)
         req = self.new_delete_request('networks', network['network']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)
 
     def test_create_subnet_bad_tenant(self):
         with self.network() as network:
@@ -1998,7 +1998,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
 
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 403)
+            self.assertEqual(res.status_int, 403)
 
     def test_create_subnet_bad_ip_version(self):
         with self.network() as network:
@@ -2010,7 +2010,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'gateway_ip': '10.0.2.1'}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_bad_ip_version_null(self):
         with self.network() as network:
@@ -2022,7 +2022,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'gateway_ip': '10.0.2.1'}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_bad_uuid(self):
         with self.network() as network:
@@ -2034,7 +2034,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'gateway_ip': '10.0.2.1'}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_bad_boolean(self):
         with self.network() as network:
@@ -2047,7 +2047,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'gateway_ip': '10.0.2.1'}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_bad_pools(self):
         with self.network() as network:
@@ -2070,7 +2070,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    'allocation_pools': pool}}
                 subnet_req = self.new_create_request('subnets', data)
                 res = subnet_req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_bad_nameserver(self):
         with self.network() as network:
@@ -2088,7 +2088,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    'dns_nameservers': nameservers}}
                 subnet_req = self.new_create_request('subnets', data)
                 res = subnet_req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_bad_hostroutes(self):
         with self.network() as network:
@@ -2109,7 +2109,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    'host_routes': hostroutes}}
                 subnet_req = self.new_create_request('subnets', data)
                 res = subnet_req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_defaults(self):
         gateway = '10.0.0.1'
@@ -2119,11 +2119,11 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
         enable_dhcp = True
         subnet = self._test_create_subnet()
         # verify cidr & gw have been correctly generated
-        self.assertEquals(subnet['subnet']['cidr'], cidr)
-        self.assertEquals(subnet['subnet']['gateway_ip'], gateway)
-        self.assertEquals(subnet['subnet']['enable_dhcp'], enable_dhcp)
-        self.assertEquals(subnet['subnet']['allocation_pools'],
-                          allocation_pools)
+        self.assertEqual(subnet['subnet']['cidr'], cidr)
+        self.assertEqual(subnet['subnet']['gateway_ip'], gateway)
+        self.assertEqual(subnet['subnet']['enable_dhcp'], enable_dhcp)
+        self.assertEqual(subnet['subnet']['allocation_pools'],
+                         allocation_pools)
 
     def test_create_subnet_gw_values(self):
         # Gateway not in subnet
@@ -2196,7 +2196,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             kwargs = {"fixed_ips": [{'subnet_id': subnet['subnet']['id'],
                                      'ip_address': '10.0.0.10'}]}
             res = self._create_port(fmt, net_id=net_id, **kwargs)
-            self.assertEquals(res.status_int, 201)
+            self.assertEqual(res.status_int, 201)
             port = self.deserialize('json', res)
             port_id = port['port']['id']
             # delete the port
@@ -2206,7 +2206,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             kwargs = {"fixed_ips": [{'subnet_id': subnet['subnet']['id'],
                                      'ip_address': '10.0.0.1'}]}
             res = self._create_port(fmt, net_id=net_id, **kwargs)
-            self.assertEquals(res.status_int, 201)
+            self.assertEqual(res.status_int, 201)
             port = self.deserialize('json', res)
             port_id = port['port']['id']
             # delete the port
@@ -2264,7 +2264,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
         with self.assertRaises(webob.exc.HTTPClientError) as ctx_manager:
             self._test_create_subnet(cidr=cidr,
                                      allocation_pools=allocation_pools)
-        self.assertEquals(ctx_manager.exception.code, 409)
+        self.assertEqual(ctx_manager.exception.code, 409)
 
     def test_create_subnet_gateway_in_allocation_pool_returns_409(self):
         gateway_ip = '10.0.0.50'
@@ -2275,7 +2275,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             self._test_create_subnet(gateway_ip=gateway_ip,
                                      cidr=cidr,
                                      allocation_pools=allocation_pools)
-        self.assertEquals(ctx_manager.exception.code, 409)
+        self.assertEqual(ctx_manager.exception.code, 409)
 
     def test_create_subnet_overlapping_allocation_pools_returns_409(self):
         gateway_ip = '10.0.0.1'
@@ -2288,7 +2288,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             self._test_create_subnet(gateway_ip=gateway_ip,
                                      cidr=cidr,
                                      allocation_pools=allocation_pools)
-        self.assertEquals(ctx_manager.exception.code, 409)
+        self.assertEqual(ctx_manager.exception.code, 409)
 
     def test_create_subnet_invalid_allocation_pool_returns_400(self):
         gateway_ip = '10.0.0.1'
@@ -2299,7 +2299,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             self._test_create_subnet(gateway_ip=gateway_ip,
                                      cidr=cidr,
                                      allocation_pools=allocation_pools)
-        self.assertEquals(ctx_manager.exception.code, 400)
+        self.assertEqual(ctx_manager.exception.code, 400)
 
     def test_create_subnet_out_of_range_allocation_pool_returns_400(self):
         gateway_ip = '10.0.0.1'
@@ -2310,14 +2310,14 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             self._test_create_subnet(gateway_ip=gateway_ip,
                                      cidr=cidr,
                                      allocation_pools=allocation_pools)
-        self.assertEquals(ctx_manager.exception.code, 400)
+        self.assertEqual(ctx_manager.exception.code, 400)
 
     def test_create_subnet_shared_returns_400(self):
         cidr = '10.0.0.0/24'
         with self.assertRaises(webob.exc.HTTPClientError) as ctx_manager:
             self._test_create_subnet(cidr=cidr,
                                      shared=True)
-        self.assertEquals(ctx_manager.exception.code, 400)
+        self.assertEqual(ctx_manager.exception.code, 400)
 
     def test_create_subnet_inconsistent_ipv6_cidrv4(self):
         with self.network() as network:
@@ -2327,7 +2327,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'tenant_id': network['network']['tenant_id']}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_inconsistent_ipv4_cidrv6(self):
         with self.network() as network:
@@ -2337,7 +2337,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'tenant_id': network['network']['tenant_id']}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_inconsistent_ipv4_gatewayv6(self):
         with self.network() as network:
@@ -2348,7 +2348,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'tenant_id': network['network']['tenant_id']}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_inconsistent_ipv6_gatewayv4(self):
         with self.network() as network:
@@ -2359,7 +2359,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'tenant_id': network['network']['tenant_id']}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_inconsistent_ipv6_dns_v4(self):
         with self.network() as network:
@@ -2370,7 +2370,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'tenant_id': network['network']['tenant_id']}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_inconsistent_ipv4_hostroute_dst_v6(self):
         host_routes = [{'destination': 'fe80::0/48',
@@ -2383,7 +2383,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'tenant_id': network['network']['tenant_id']}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_inconsistent_ipv4_hostroute_np_v6(self):
         host_routes = [{'destination': '172.16.0.0/24',
@@ -2396,7 +2396,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                'tenant_id': network['network']['tenant_id']}}
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_update_subnet(self):
         with self.subnet() as subnet:
@@ -2423,7 +2423,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                 req = self.new_update_request('subnets', data,
                                               subnet['subnet']['id'])
                 res = req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_update_subnet_inconsistent_ipv6_gatewayv4(self):
         with self.network() as network:
@@ -2433,7 +2433,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                 req = self.new_update_request('subnets', data,
                                               subnet['subnet']['id'])
                 res = req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_update_subnet_inconsistent_ipv4_dns_v6(self):
         dns_nameservers = ['fe80::1']
@@ -2443,7 +2443,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                 req = self.new_update_request('subnets', data,
                                               subnet['subnet']['id'])
                 res = req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_update_subnet_inconsistent_ipv6_hostroute_dst_v4(self):
         host_routes = [{'destination': 'fe80::0/48',
@@ -2455,7 +2455,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                 req = self.new_update_request('subnets', data,
                                               subnet['subnet']['id'])
                 res = req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_update_subnet_inconsistent_ipv6_hostroute_np_v4(self):
         host_routes = [{'destination': '172.16.0.0/24',
@@ -2467,7 +2467,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                 req = self.new_update_request('subnets', data,
                                               subnet['subnet']['id'])
                 res = req.get_response(self.api)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_show_subnet(self):
         with self.network() as network:
@@ -2475,10 +2475,10 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                 req = self.new_show_request('subnets',
                                             subnet['subnet']['id'])
                 res = self.deserialize('json', req.get_response(self.api))
-                self.assertEquals(res['subnet']['id'],
-                                  subnet['subnet']['id'])
-                self.assertEquals(res['subnet']['network_id'],
-                                  network['network']['id'])
+                self.assertEqual(res['subnet']['id'],
+                                 subnet['subnet']['id'])
+                self.assertEqual(res['subnet']['network_id'],
+                                 network['network']['id'])
 
     def test_list_subnets(self):
         with self.network() as network:
@@ -2504,8 +2504,8 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                     res = self.deserialize('json',
                                            req.get_response(self.api))
                     self.assertEqual(len(res['subnets']), 1)
-                    self.assertEquals(res['subnets'][0]['cidr'],
-                                      subnet['subnet']['cidr'])
+                    self.assertEqual(res['subnets'][0]['cidr'],
+                                     subnet['subnet']['cidr'])
                     # admin will see both subnets
                     admin_req = self.new_list_request('subnets')
                     admin_res = self.deserialize(
@@ -2541,7 +2541,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
 
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_invalid_subnet(self):
         with self.network() as network:
@@ -2553,7 +2553,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
 
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_invalid_ip_address(self):
         with self.network() as network:
@@ -2565,7 +2565,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
 
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_invalid_uuid(self):
         with self.network() as network:
@@ -2577,7 +2577,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
 
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_with_one_dns(self):
         gateway_ip = '10.0.0.1'
@@ -2613,7 +2613,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
 
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_create_subnet_with_one_host_route(self):
         gateway_ip = '10.0.0.1'
@@ -2660,7 +2660,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
 
             subnet_req = self.new_create_request('subnets', data)
             res = subnet_req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_update_subnet_dns(self):
         with self.subnet() as subnet:
@@ -2692,7 +2692,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             req = self.new_update_request('subnets', data,
                                           subnet['subnet']['id'])
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_update_subnet_route(self):
         with self.subnet() as subnet:
@@ -2729,7 +2729,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
             req = self.new_update_request('subnets', data,
                                           subnet['subnet']['id'])
             res = req.get_response(self.api)
-            self.assertEquals(res.status_int, 400)
+            self.assertEqual(res.status_int, 400)
 
     def test_delete_subnet_with_dns(self):
         gateway_ip = '10.0.0.1'
@@ -2745,7 +2745,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    dns_nameservers=dns_nameservers)
         req = self.new_delete_request('subnets', subnet['subnet']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)
 
     def test_delete_subnet_with_route(self):
         gateway_ip = '10.0.0.1'
@@ -2762,7 +2762,7 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    host_routes=host_routes)
         req = self.new_delete_request('subnets', subnet['subnet']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)
 
     def test_delete_subnet_with_dns_and_route(self):
         gateway_ip = '10.0.0.1'
@@ -2781,4 +2781,4 @@ class TestSubnetsV2(QuantumDbPluginV2TestCase):
                                    host_routes=host_routes)
         req = self.new_delete_request('subnets', subnet['subnet']['id'])
         res = req.get_response(self.api)
-        self.assertEquals(res.status_int, 204)
+        self.assertEqual(res.status_int, 204)

diff --git a/quantum/tests/unit/test_db_rpc_base.py b/quantum/tests/unit/test_db_rpc_base.py
index 689cbefb1e66b0c53bac429b1d43efd5e220ba17..426f8506048336512669b13d1fe022d0a7ff671d 100644 (file)
--- a/quantum/tests/unit/test_db_rpc_base.py
+++ b/quantum/tests/unit/test_db_rpc_base.py
@@ -59,7 +59,7 @@ class TestDhcpRpcCallackMixin(unittest.TestCase):
         self.plugin.get_ports.return_value = port_retval
 
         retval = self.callbacks.get_network_info(mock.Mock(), network_id='a')
-        self.assertEquals(retval, network_retval)
+        self.assertEqual(retval, network_retval)
         self.assertEqual(retval['subnets'], subnet_retval)
         self.assertEqual(retval['ports'], port_retval)
 

diff --git a/quantum/tests/unit/test_extension_security_group.py b/quantum/tests/unit/test_extension_security_group.py
index aec08503c3c089c56f0c49e82fce8abfeb1815d6..518b093df0d05727c8b343e0167a2b6be91ff228 100644 (file)
--- a/quantum/tests/unit/test_extension_security_group.py
+++ b/quantum/tests/unit/test_extension_security_group.py
@@ -228,7 +228,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
         keys = [('name', name,), ('description', description)]
         with self.security_group(name, description) as security_group:
             for k, v, in keys:
-                self.assertEquals(security_group['security_group'][k], v)
+                self.assertEqual(security_group['security_group'][k], v)
 
     def test_create_security_group_external_id(self):
         cfg.CONF.SECURITYGROUP.proxy_mode = True
@@ -239,13 +239,13 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                 ('external_id', external_id)]
         with self.security_group(name, description, external_id) as sg:
             for k, v, in keys:
-                self.assertEquals(sg['security_group'][k], v)
+                self.assertEqual(sg['security_group'][k], v)
 
     def test_default_security_group(self):
         with self.network():
             res = self.new_list_request('security-groups')
             groups = self.deserialize('json', res.get_response(self.ext_api))
-            self.assertEquals(len(groups['security_groups']), 1)
+            self.assertEqual(len(groups['security_groups']), 1)
 
     def test_create_security_group_proxy_mode_not_admin(self):
         cfg.CONF.SECURITYGROUP.proxy_mode = True
@@ -254,27 +254,27 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                           tenant_id='bad_tenant',
                                           set_context=True)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 500)
+        self.assertEqual(res.status_int, 500)
 
     def test_create_security_group_no_external_id_proxy_mode(self):
         cfg.CONF.SECURITYGROUP.proxy_mode = True
         res = self._create_security_group('json', 'webservers',
                                           'webservers')
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 400)
+        self.assertEqual(res.status_int, 400)
 
     def test_create_security_group_no_external_id_not_proxy_mode(self):
         res = self._create_security_group('json', 'webservers',
                                           'webservers', '1')
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 409)
+        self.assertEqual(res.status_int, 409)
 
     def test_create_default_security_group_fail(self):
         name = 'default'
         description = 'my webservers'
         res = self._create_security_group('json', name, description)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 409)
+        self.assertEqual(res.status_int, 409)
 
     def test_create_security_group_duplicate_external_id(self):
         cfg.CONF.SECURITYGROUP.proxy_mode = True
@@ -285,7 +285,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
             res = self._create_security_group('json', name, description,
                                               external_id)
             self.deserialize('json', res)
-            self.assertEquals(res.status_int, 409)
+            self.assertEqual(res.status_int, 409)
 
     def test_list_security_groups(self):
         name = 'webservers'
@@ -293,7 +293,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
         with self.security_group(name, description):
             res = self.new_list_request('security-groups')
             groups = self.deserialize('json', res.get_response(self.ext_api))
-            self.assertEquals(len(groups['security_groups']), 2)
+            self.assertEqual(len(groups['security_groups']), 2)
 
     def test_get_security_group(self):
         name = 'webservers'
@@ -302,7 +302,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
             source_group_id = sg['security_group']['id']
             res = self.new_show_request('security-groups', source_group_id)
             group = self.deserialize('json', res.get_response(self.ext_api))
-            self.assertEquals(group['security_group']['id'], source_group_id)
+            self.assertEqual(group['security_group']['id'], source_group_id)
 
     def test_delete_security_group(self):
         name = 'webservers'
@@ -322,16 +322,16 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
         with self.network():
             res = self.new_list_request('security-groups')
             groups = self.deserialize('json', res.get_response(self.ext_api))
-            self.assertEquals(len(groups['security_groups']), 1)
+            self.assertEqual(len(groups['security_groups']), 1)
             res = self.new_list_request('security-group-rules')
             rules = self.deserialize('json', res.get_response(self.ext_api))
-            self.assertEquals(len(rules['security_group_rules']), 2)
+            self.assertEqual(len(rules['security_group_rules']), 2)
             # just generic rules to allow default egress and
             # intergroup communicartion
             for rule in rules['security_group_rules']:
-                self.assertEquals(rule['port_range_max'], None)
-                self.assertEquals(rule['port_range_min'], None)
-                self.assertEquals(rule['protocol'], None)
+                self.assertEqual(rule['port_range_max'], None)
+                self.assertEqual(rule['port_range_min'], None)
+                self.assertEqual(rule['protocol'], None)
 
     def test_create_security_group_rule_source_ip_prefix(self):
         name = 'webservers'
@@ -354,7 +354,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                           port_range_max,
                                           source_ip_prefix) as rule:
                 for k, v, in keys:
-                    self.assertEquals(rule['security_group_rule'][k], v)
+                    self.assertEqual(rule['security_group_rule'][k], v)
 
     def test_create_security_group_rule_group_id(self):
         name = 'webservers'
@@ -379,7 +379,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                               source_group_id=source_group_id
                                               ) as rule:
                     for k, v, in keys:
-                        self.assertEquals(rule['security_group_rule'][k], v)
+                        self.assertEqual(rule['security_group_rule'][k], v)
 
     def test_create_security_group_source_group_ip_and_ip_prefix(self):
         security_group_id = "4cd70774-cc67-4a87-9b39-7d1db38eb087"
@@ -396,7 +396,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                source_group_id)
         res = self._create_security_group_rule('json', rule)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 400)
+        self.assertEqual(res.status_int, 400)
 
     def test_create_security_group_rule_bad_security_group_id(self):
         security_group_id = "4cd70774-cc67-4a87-9b39-7d1db38eb087"
@@ -411,7 +411,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                source_ip_prefix)
         res = self._create_security_group_rule('json', rule)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 404)
+        self.assertEqual(res.status_int, 404)
 
     def test_create_security_group_rule_bad_tenant(self):
         with self.security_group() as sg:
@@ -425,7 +425,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
 
         res = self._create_security_group_rule('json', rule)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 404)
+        self.assertEqual(res.status_int, 404)
 
     def test_create_security_group_rule_exteral_id_proxy_mode(self):
         cfg.CONF.SECURITYGROUP.proxy_mode = True
@@ -442,7 +442,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
 
             res = self._create_security_group_rule('json', rule)
             self.deserialize('json', res)
-            self.assertEquals(res.status_int, 201)
+            self.assertEqual(res.status_int, 201)
 
     def test_create_security_group_rule_exteral_id_not_proxy_mode(self):
         with self.security_group() as sg:
@@ -458,7 +458,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
 
             res = self._create_security_group_rule('json', rule)
             self.deserialize('json', res)
-            self.assertEquals(res.status_int, 409)
+            self.assertEqual(res.status_int, 409)
 
     def test_create_security_group_rule_not_admin(self):
         cfg.CONF.SECURITYGROUP.proxy_mode = True
@@ -477,7 +477,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                    tenant_id='bad_tenant',
                                                    set_context=True)
             self.deserialize('json', res)
-            self.assertEquals(res.status_int, 500)
+            self.assertEqual(res.status_int, 500)
 
     def test_create_security_group_rule_bad_tenant_source_group_id(self):
         with self.security_group() as sg:
@@ -498,7 +498,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                    tenant_id='bad_tenant',
                                                    set_context=True)
             self.deserialize('json', res)
-            self.assertEquals(res.status_int, 404)
+            self.assertEqual(res.status_int, 404)
 
     def test_create_security_group_rule_bad_tenant_security_group_rule(self):
         with self.security_group() as sg:
@@ -518,7 +518,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                    tenant_id='bad_tenant',
                                                    set_context=True)
             self.deserialize('json', res)
-            self.assertEquals(res.status_int, 404)
+            self.assertEqual(res.status_int, 404)
 
     def test_create_security_group_rule_bad_source_group_id(self):
         name = 'webservers'
@@ -536,7 +536,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                source_group_id=source_group_id)
         res = self._create_security_group_rule('json', rule)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 404)
+        self.assertEqual(res.status_int, 404)
 
     def test_create_security_group_rule_duplicate_rules(self):
         name = 'webservers'
@@ -549,7 +549,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                 self._create_security_group_rule('json', rule)
                 res = self._create_security_group_rule('json', rule)
                 self.deserialize('json', res)
-                self.assertEquals(res.status_int, 409)
+                self.assertEqual(res.status_int, 409)
 
     def test_create_security_group_rule_min_port_greater_max(self):
         name = 'webservers'
@@ -562,7 +562,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                 self._create_security_group_rule('json', rule)
                 res = self._create_security_group_rule('json', rule)
                 self.deserialize('json', res)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_create_security_group_rule_ports_but_no_protocol(self):
         name = 'webservers'
@@ -575,7 +575,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                 self._create_security_group_rule('json', rule)
                 res = self._create_security_group_rule('json', rule)
                 self.deserialize('json', res)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_update_port_with_security_group(self):
         with self.network() as n:
@@ -592,8 +592,8 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                     req = self.new_update_request('ports', data,
                                                   port['port']['id'])
                     res = self.deserialize('json', req.get_response(self.api))
-                    self.assertEquals(res['port'][ext_sg.SECURITYGROUP][0],
-                                      sg['security_group']['id'])
+                    self.assertEqual(res['port'][ext_sg.SECURITYGROUP][0],
+                                     sg['security_group']['id'])
                     self._delete('ports', port['port']['id'])
 
     def test_update_port_with_multiple_security_groups(self):
@@ -606,7 +606,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                             security_groups=[sg1['security_group']['id'],
                                              sg2['security_group']['id']])
                         port = self.deserialize('json', res)
-                        self.assertEquals(len(
+                        self.assertEqual(len(
                             port['port'][ext_sg.SECURITYGROUP]), 2)
                         self._delete('ports', port['port']['id'])
 
@@ -625,7 +625,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                     req = self.new_update_request('ports', data,
                                                   port['port']['id'])
                     res = self.deserialize('json', req.get_response(self.api))
-                    self.assertEquals(res['port'][ext_sg.SECURITYGROUP], [])
+                    self.assertEqual(res['port'][ext_sg.SECURITYGROUP], [])
                     self._delete('ports', port['port']['id'])
 
     def test_create_port_with_bad_security_group(self):
@@ -635,7 +635,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                         security_groups=['bad_id'])
 
                 self.deserialize('json', res)
-                self.assertEquals(res.status_int, 404)
+                self.assertEqual(res.status_int, 404)
 
     def test_create_delete_security_group_port_in_use(self):
         with self.network() as n:
@@ -645,8 +645,8 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                             security_groups=(
                                             [sg['security_group']['id']]))
                     port = self.deserialize('json', res)
-                    self.assertEquals(port['port'][ext_sg.SECURITYGROUP][0],
-                                      sg['security_group']['id'])
+                    self.assertEqual(port['port'][ext_sg.SECURITYGROUP][0],
+                                     sg['security_group']['id'])
                     # try to delete security group that's in use
                     res = self._delete('security-groups',
                                        sg['security_group']['id'], 409)
@@ -668,7 +668,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                               rule2['security_group_rule']]}
             res = self._create_security_group_rule('json', rules)
             self.deserialize('json', res)
-            self.assertEquals(res.status_int, 201)
+            self.assertEqual(res.status_int, 201)
 
     def test_create_security_group_rule_bulk_emulated(self):
         real_has_attr = hasattr
@@ -693,7 +693,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                          }
                 res = self._create_security_group_rule('json', rules)
                 self.deserialize('json', res)
-                self.assertEquals(res.status_int, 201)
+                self.assertEqual(res.status_int, 201)
 
     def test_create_security_group_rule_duplicate_rule_in_post(self):
         if self._skip_native_bulk:
@@ -707,7 +707,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                               rule['security_group_rule']]}
             res = self._create_security_group_rule('json', rules)
             rule = self.deserialize('json', res)
-            self.assertEquals(res.status_int, 409)
+            self.assertEqual(res.status_int, 409)
 
     def test_create_security_group_rule_duplicate_rule_in_post_emulated(self):
         real_has_attr = hasattr
@@ -729,7 +729,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                   rule['security_group_rule']]}
                 res = self._create_security_group_rule('json', rules)
                 rule = self.deserialize('json', res)
-                self.assertEquals(res.status_int, 409)
+                self.assertEqual(res.status_int, 409)
 
     def test_create_security_group_rule_duplicate_rule_db(self):
         if self._skip_native_bulk:
@@ -743,7 +743,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
             self._create_security_group_rule('json', rules)
             res = self._create_security_group_rule('json', rules)
             rule = self.deserialize('json', res)
-            self.assertEquals(res.status_int, 409)
+            self.assertEqual(res.status_int, 409)
 
     def test_create_security_group_rule_duplicate_rule_db_emulated(self):
         real_has_attr = hasattr
@@ -764,7 +764,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                 self._create_security_group_rule('json', rules)
                 res = self._create_security_group_rule('json', rule)
                 self.deserialize('json', res)
-                self.assertEquals(res.status_int, 409)
+                self.assertEqual(res.status_int, 409)
 
     def test_create_security_group_rule_differnt_security_group_ids(self):
         if self._skip_native_bulk:
@@ -784,7 +784,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                          }
                 res = self._create_security_group_rule('json', rules)
                 self.deserialize('json', res)
-                self.assertEquals(res.status_int, 400)
+                self.assertEqual(res.status_int, 400)
 
     def test_create_security_group_rule_with_invalid_ethertype(self):
         security_group_id = "4cd70774-cc67-4a87-9b39-7d1db38eb087"
@@ -802,7 +802,7 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                ethertype='IPv5')
         res = self._create_security_group_rule('json', rule)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 400)
+        self.assertEqual(res.status_int, 400)
 
     def test_create_security_group_rule_with_invalid_protocol(self):
         security_group_id = "4cd70774-cc67-4a87-9b39-7d1db38eb087"
@@ -819,4 +819,4 @@ class TestSecurityGroups(SecurityGroupDBTestCase):
                                                source_group_id)
         res = self._create_security_group_rule('json', rule)
         self.deserialize('json', res)
-        self.assertEquals(res.status_int, 400)
+        self.assertEqual(res.status_int, 400)

diff --git a/quantum/tests/unit/test_l3_agent.py b/quantum/tests/unit/test_l3_agent.py
index dc474c5bae96e71df187f031333ee0545e08b226..a7356323d7d66ebb772e0d130dade14b7036b870 100644 (file)
--- a/quantum/tests/unit/test_l3_agent.py
+++ b/quantum/tests/unit/test_l3_agent.py
@@ -107,12 +107,12 @@ class TestBasicRouterOperations(unittest2.TestCase):
             self.device_exists.return_value = False
             agent.internal_network_added(ri, ex_gw_port, network_id,
                                          port_id, cidr, mac)
-            self.assertEquals(self.mock_driver.plug.call_count, 1)
-            self.assertEquals(self.mock_driver.init_l3.call_count, 1)
+            self.assertEqual(self.mock_driver.plug.call_count, 1)
+            self.assertEqual(self.mock_driver.init_l3.call_count, 1)
         elif action == 'remove':
             self.device_exists.return_value = True
             agent.internal_network_removed(ri, ex_gw_port, port_id, cidr)
-            self.assertEquals(self.mock_driver.unplug.call_count, 1)
+            self.assertEqual(self.mock_driver.unplug.call_count, 1)
         else:
             raise Exception("Invalid action %s" % action)
 
@@ -140,8 +140,8 @@ class TestBasicRouterOperations(unittest2.TestCase):
         if action == 'add':
             self.device_exists.return_value = False
             agent.external_gateway_added(ri, ex_gw_port, internal_cidrs)
-            self.assertEquals(self.mock_driver.plug.call_count, 1)
-            self.assertEquals(self.mock_driver.init_l3.call_count, 1)
+            self.assertEqual(self.mock_driver.plug.call_count, 1)
+            self.assertEqual(self.mock_driver.init_l3.call_count, 1)
             arping_cmd = ['arping', '-A', '-U',
                           '-I', interface_name,
                           '-c', self.conf.send_arp_for_ha,
@@ -156,7 +156,7 @@ class TestBasicRouterOperations(unittest2.TestCase):
         elif action == 'remove':
             self.device_exists.return_value = True
             agent.external_gateway_removed(ri, ex_gw_port, internal_cidrs)
-            self.assertEquals(self.mock_driver.unplug.call_count, 1)
+            self.assertEqual(self.mock_driver.unplug.call_count, 1)
         else:
             raise Exception("Invalid action %s" % action)
 
@@ -277,7 +277,7 @@ class TestBasicRouterOperations(unittest2.TestCase):
 
         agent.router_deleted(None, routers[0]['id'])
         # verify that remove is called
-        self.assertEquals(self.mock_ip.get_devices.call_count, 1)
+        self.assertEqual(self.mock_ip.get_devices.call_count, 1)
 
         self.device_exists.assert_has_calls(
             [mock.call(self.conf.external_network_bridge)])

diff --git a/quantum/tests/unit/test_l3_plugin.py b/quantum/tests/unit/test_l3_plugin.py
index f628f733a4307fc299f0a15d7d2ec0a92b72a7c9..aba7287fa445c7d7286dae7ce017f382995acdd2 100644 (file)
--- a/quantum/tests/unit/test_l3_plugin.py
+++ b/quantum/tests/unit/test_l3_plugin.py
@@ -363,7 +363,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
             router_req = self.new_create_request('routers', data, 'json')
             res = router_req.get_response(self.ext_api)
             router = self.deserialize('json', res)
-            self.assertEquals(
+            self.assertEqual(
                 s['subnet']['network_id'],
                 router['router']['external_gateway_info']['network_id'])
             self._delete('routers', router['router']['id'])
@@ -394,13 +394,13 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
         rname2 = "nachorouter"
         with self.router(name=rname1) as r:
             body = self._show('routers', r['router']['id'])
-            self.assertEquals(body['router']['name'], rname1)
+            self.assertEqual(body['router']['name'], rname1)
 
             body = self._update('routers', r['router']['id'],
                                 {'router': {'name': rname2}})
 
             body = self._show('routers', r['router']['id'])
-            self.assertEquals(body['router']['name'], rname2)
+            self.assertEqual(body['router']['name'], rname2)
 
     def test_router_update_gateway(self):
         with self.router() as r:
@@ -413,7 +413,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                     body = self._show('routers', r['router']['id'])
                     net_id = (body['router']
                               ['external_gateway_info']['network_id'])
-                    self.assertEquals(net_id, s1['subnet']['network_id'])
+                    self.assertEqual(net_id, s1['subnet']['network_id'])
                     self._set_net_external(s2['subnet']['network_id'])
                     self._add_external_gateway_to_router(
                         r['router']['id'],
@@ -421,7 +421,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                     body = self._show('routers', r['router']['id'])
                     net_id = (body['router']
                               ['external_gateway_info']['network_id'])
-                    self.assertEquals(net_id, s2['subnet']['network_id'])
+                    self.assertEqual(net_id, s2['subnet']['network_id'])
                     self._remove_external_gateway_from_router(
                         r['router']['id'],
                         s2['subnet']['network_id'])
@@ -453,7 +453,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                 # fetch port and confirm device_id
                 r_port_id = body['port_id']
                 body = self._show('ports', r_port_id)
-                self.assertEquals(body['port']['device_id'], r['router']['id'])
+                self.assertEqual(body['port']['device_id'], r['router']['id'])
 
                 body = self._router_interface_action('remove',
                                                      r['router']['id'],
@@ -545,11 +545,11 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                                                      None,
                                                      p['port']['id'])
                 self.assertTrue('port_id' in body)
-                self.assertEquals(body['port_id'], p['port']['id'])
+                self.assertEqual(body['port_id'], p['port']['id'])
 
                 # fetch port and confirm device_id
                 body = self._show('ports', p['port']['id'])
-                self.assertEquals(body['port']['device_id'], r['router']['id'])
+                self.assertEqual(body['port']['device_id'], r['router']['id'])
 
                 # clean-up
                 self._router_interface_action('remove',
@@ -712,13 +712,13 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                     s['subnet']['network_id'])
                 body = self._show('routers', r['router']['id'])
                 net_id = body['router']['external_gateway_info']['network_id']
-                self.assertEquals(net_id, s['subnet']['network_id'])
+                self.assertEqual(net_id, s['subnet']['network_id'])
                 self._remove_external_gateway_from_router(
                     r['router']['id'],
                     s['subnet']['network_id'])
                 body = self._show('routers', r['router']['id'])
                 gw_info = body['router']['external_gateway_info']
-                self.assertEquals(gw_info, None)
+                self.assertEqual(gw_info, None)
 
     def test_router_add_gateway_invalid_network_returns_404(self):
         with self.router() as r:
@@ -919,13 +919,13 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
 
     def _validate_floating_ip(self, fip):
         body = self._list('floatingips')
-        self.assertEquals(len(body['floatingips']), 1)
-        self.assertEquals(body['floatingips'][0]['id'],
-                          fip['floatingip']['id'])
+        self.assertEqual(len(body['floatingips']), 1)
+        self.assertEqual(body['floatingips'][0]['id'],
+                         fip['floatingip']['id'])
 
         body = self._show('floatingips', fip['floatingip']['id'])
-        self.assertEquals(body['floatingip']['id'],
-                          fip['floatingip']['id'])
+        self.assertEqual(body['floatingip']['id'],
+                         fip['floatingip']['id'])
 
     @contextlib.contextmanager
     def floatingip_with_assoc(self, port_id=None, fmt='json'):
@@ -995,7 +995,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
 
         # post-delete, check that it is really gone
         body = self._list('floatingips')
-        self.assertEquals(len(body['floatingips']), 0)
+        self.assertEqual(len(body['floatingips']), 0)
 
         self._show('floatingips', fip['floatingip']['id'],
                    expected_code=exc.HTTPNotFound.code)
@@ -1044,25 +1044,25 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                                       p['port']['fixed_ips'][0]['subnet_id']}}
             with self.floatingip_no_assoc(private_sub) as fip:
                 body = self._show('floatingips', fip['floatingip']['id'])
-                self.assertEquals(body['floatingip']['port_id'], None)
-                self.assertEquals(body['floatingip']['fixed_ip_address'], None)
+                self.assertEqual(body['floatingip']['port_id'], None)
+                self.assertEqual(body['floatingip']['fixed_ip_address'], None)
 
                 port_id = p['port']['id']
                 ip_address = p['port']['fixed_ips'][0]['ip_address']
                 fixed_ip = p['port']['fixed_ips'][0]['ip_address']
                 body = self._update('floatingips', fip['floatingip']['id'],
                                     {'floatingip': {'port_id': port_id}})
-                self.assertEquals(body['floatingip']['port_id'], port_id)
-                self.assertEquals(body['floatingip']['fixed_ip_address'],
-                                  ip_address)
+                self.assertEqual(body['floatingip']['port_id'], port_id)
+                self.assertEqual(body['floatingip']['fixed_ip_address'],
+                                 ip_address)
 
     def test_floatingip_with_assoc(self):
         with self.floatingip_with_assoc() as fip:
             body = self._show('floatingips', fip['floatingip']['id'])
-            self.assertEquals(body['floatingip']['id'],
-                              fip['floatingip']['id'])
-            self.assertEquals(body['floatingip']['port_id'],
-                              fip['floatingip']['port_id'])
+            self.assertEqual(body['floatingip']['id'],
+                             fip['floatingip']['id'])
+            self.assertEqual(body['floatingip']['port_id'],
+                             fip['floatingip']['port_id'])
             self.assertTrue(body['floatingip']['fixed_ip_address'] is not None)
             self.assertTrue(body['floatingip']['router_id'] is not None)
 
@@ -1077,11 +1077,11 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                 # deleted, which is what we want to test. We want to confirm
                 # that the fields are set back to None
                 body = self._show('floatingips', fip['floatingip']['id'])
-                self.assertEquals(body['floatingip']['id'],
-                                  fip['floatingip']['id'])
-                self.assertEquals(body['floatingip']['port_id'], None)
-                self.assertEquals(body['floatingip']['fixed_ip_address'], None)
-                self.assertEquals(body['floatingip']['router_id'], None)
+                self.assertEqual(body['floatingip']['id'],
+                                 fip['floatingip']['id'])
+                self.assertEqual(body['floatingip']['port_id'], None)
+                self.assertEqual(body['floatingip']['fixed_ip_address'], None)
+                self.assertEqual(body['floatingip']['router_id'], None)
 
     def test_two_fips_one_port_invalid_return_409(self):
         with self.floatingip_with_assoc() as fip1:
@@ -1195,15 +1195,15 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
             self._set_net_external(n1['network']['id'])
             with self.network() as n2:
                 body = self._list('networks')
-                self.assertEquals(len(body['networks']), 2)
+                self.assertEqual(len(body['networks']), 2)
 
                 body = self._list('networks',
                                   query_params="%s=True" % l3.EXTERNAL)
-                self.assertEquals(len(body['networks']), 1)
+                self.assertEqual(len(body['networks']), 1)
 
                 body = self._list('networks',
                                   query_params="%s=False" % l3.EXTERNAL)
-                self.assertEquals(len(body['networks']), 1)
+                self.assertEqual(len(body['networks']), 1)
 
     def test_get_network_succeeds_without_filter(self):
         plugin = manager.QuantumManager.get_plugin()
@@ -1237,7 +1237,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                                    set_context='True',
                                    tenant_id='noadmin'):
                         pass
-                    self.assertEquals(ctx_manager.exception.code, 403)
+                    self.assertEqual(ctx_manager.exception.code, 403)
 
     def test_create_port_external_network_admin_suceeds(self):
         with self.network(router__external=True) as ext_net:
@@ -1252,7 +1252,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                               set_context='True',
                               tenant_id='noadmin'):
                 pass
-            self.assertEquals(ctx_manager.exception.code, 403)
+            self.assertEqual(ctx_manager.exception.code, 403)
 
     def test_create_external_network_admin_suceeds(self):
         with self.network(router__external=True) as ext_net:
@@ -1285,7 +1285,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                 self._remove_external_gateway_from_router(
                     r['router']['id'],
                     s['subnet']['network_id'])
-                self.assertEquals(
+                self.assertEqual(
                     2, notifyApi.routers_updated.call_count)
 
     def test_router_gateway_op_agent(self):
@@ -1302,7 +1302,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                                           r['router']['id'],
                                           None,
                                           p['port']['id'])
-        self.assertEquals(2, notifyApi.routers_updated.call_count)
+        self.assertEqual(2, notifyApi.routers_updated.call_count)
 
     def test_interfaces_op_agent(self):
         with self.router() as r:
@@ -1314,7 +1314,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
             pass
         # add gateway, add interface, associate, deletion of floatingip,
         # delete gateway, delete interface
-        self.assertEquals(6, notifyApi.routers_updated.call_count)
+        self.assertEqual(6, notifyApi.routers_updated.call_count)
 
     def test_floatingips_op_agent(self):
         self._test_notify_op_agent(self._test_floatingips_op_agent)
@@ -1382,7 +1382,7 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
                                                [r['router']['id']])
                 self.assertEqual(1, len(routers))
                 gw_port = routers[0]['gw_port']
-                self.assertEquals(s['subnet']['id'], gw_port['subnet']['id'])
+                self.assertEqual(s['subnet']['id'], gw_port['subnet']['id'])
                 self._remove_external_gateway_from_router(
                     r['router']['id'],
                     s['subnet']['network_id'])
@@ -1395,9 +1395,9 @@ class L3NatDBTestCase(test_db_plugin.QuantumDbPluginV2TestCase):
             self.assertEqual(1, len(routers))
             floatingips = routers[0][l3_constants.FLOATINGIP_KEY]
             self.assertEqual(1, len(floatingips))
-            self.assertEquals(floatingips[0]['id'],
-                              fip['floatingip']['id'])
-            self.assertEquals(floatingips[0]['port_id'],
-                              fip['floatingip']['port_id'])
+            self.assertEqual(floatingips[0]['id'],
+                             fip['floatingip']['id'])
+            self.assertEqual(floatingips[0]['port_id'],
+                             fip['floatingip']['port_id'])
             self.assertTrue(floatingips[0]['fixed_ip_address'] is not None)
             self.assertTrue(floatingips[0]['router_id'] is not None)

diff --git a/quantum/tests/unit/test_linux_dhcp.py b/quantum/tests/unit/test_linux_dhcp.py
index 12065b2bbbf5424ab9e5e4edb862a3c9005b176d..5eaf0b971a50b51a544178037db2413b4818bf76 100644 (file)
--- a/quantum/tests/unit/test_linux_dhcp.py
+++ b/quantum/tests/unit/test_linux_dhcp.py
@@ -176,7 +176,7 @@ class TestDhcpBase(unittest.TestCase):
 
         c = SubClass()
         c.restart()
-        self.assertEquals(c.called, ['disable True', 'enable'])
+        self.assertEqual(c.called, ['disable True', 'enable'])
 
 
 class LocalChild(dhcp.DhcpLocalProcess):

diff --git a/quantum/tests/unit/test_linux_interface.py b/quantum/tests/unit/test_linux_interface.py
index 0f6fb0b64048101c1008d1c9263bf95c1129bb1d..50d7c65fa41f70c62ffc5e5fa7bf1fa7083e0579 100644 (file)
--- a/quantum/tests/unit/test_linux_interface.py
+++ b/quantum/tests/unit/test_linux_interface.py
@@ -315,7 +315,7 @@ class TestBridgeInterfaceDriver(TestBase):
                     'tap0',
                     'aa:bb:cc:dd:ee:ff')
             self.ip_dev.assert_has_calls([])
-            self.assertEquals(log.call_count, 1)
+            self.assertEqual(log.call_count, 1)
 
     def test_plug_mtu(self):
         self.device_exists.return_value = False

diff --git a/quantum/tests/unit/test_linux_ip_lib.py b/quantum/tests/unit/test_linux_ip_lib.py
index 502c0ca887a749cd18e997c600f7487ef85e4e83..b3ed926e437f67a8d7bfdcd994e58ca5f94b3076 100644 (file)
--- a/quantum/tests/unit/test_linux_ip_lib.py
+++ b/quantum/tests/unit/test_linux_ip_lib.py
@@ -144,11 +144,11 @@ class TestIpWrapper(unittest.TestCase):
     def test_get_devices(self):
         self.execute.return_value = '\n'.join(LINK_SAMPLE)
         retval = ip_lib.IPWrapper('sudo').get_devices()
-        self.assertEquals(retval,
-                          [ip_lib.IPDevice('lo'),
-                           ip_lib.IPDevice('eth0'),
-                           ip_lib.IPDevice('br-int'),
-                           ip_lib.IPDevice('gw-ddc717df-49')])
+        self.assertEqual(retval,
+                         [ip_lib.IPDevice('lo'),
+                          ip_lib.IPDevice('eth0'),
+                          ip_lib.IPDevice('br-int'),
+                          ip_lib.IPDevice('gw-ddc717df-49')])
 
         self.execute.assert_called_once_with('o', 'link', ('list',),
                                              'sudo', None)
@@ -156,11 +156,11 @@ class TestIpWrapper(unittest.TestCase):
     def test_get_devices_malformed_line(self):
         self.execute.return_value = '\n'.join(LINK_SAMPLE + ['gibberish'])
         retval = ip_lib.IPWrapper('sudo').get_devices()
-        self.assertEquals(retval,
-                          [ip_lib.IPDevice('lo'),
-                           ip_lib.IPDevice('eth0'),
-                           ip_lib.IPDevice('br-int'),
-                           ip_lib.IPDevice('gw-ddc717df-49')])
+        self.assertEqual(retval,
+                         [ip_lib.IPDevice('lo'),
+                          ip_lib.IPDevice('eth0'),
+                          ip_lib.IPDevice('br-int'),
+                          ip_lib.IPDevice('gw-ddc717df-49')])
 
         self.execute.assert_called_once_with('o', 'link', ('list',),
                                              'sudo', None)
@@ -168,10 +168,10 @@ class TestIpWrapper(unittest.TestCase):
     def test_get_namespaces(self):
         self.execute.return_value = '\n'.join(NETNS_SAMPLE)
         retval = ip_lib.IPWrapper.get_namespaces('sudo')
-        self.assertEquals(retval,
-                          ['12345678-1234-5678-abcd-1234567890ab',
-                           'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
-                           'cccccccc-cccc-cccc-cccc-cccccccccccc'])
+        self.assertEqual(retval,
+                         ['12345678-1234-5678-abcd-1234567890ab',
+                          'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
+                          'cccccccc-cccc-cccc-cccc-cccccccccccc'])
 
         self.execute.assert_called_once_with('', 'netns', ('list',),
                                              root_helper='sudo')
@@ -440,7 +440,7 @@ class TestIpLinkCommand(TestIPCmdBase):
                     'brd': 'ff:ff:ff:ff:ff:ff',
                     'link/ether': 'cc:dd:ee:ff:ab:cd'}
         self.parent._execute = mock.Mock(return_value=LINK_SAMPLE[1])
-        self.assertEquals(self.link_cmd.attributes, expected)
+        self.assertEqual(self.link_cmd.attributes, expected)
         self._assert_call('o', ('show', 'eth0'))
 
 
@@ -495,7 +495,7 @@ class TestIpAddrCommand(TestIPCmdBase):
                  broadcast='::')]
 
         self.parent._run = mock.Mock(return_value=ADDR_SAMPLE)
-        self.assertEquals(self.addr_cmd.list(), expected)
+        self.assertEqual(self.addr_cmd.list(), expected)
         self._assert_call([], ('show', 'tap0'))
 
     def test_list_filtered(self):
@@ -506,8 +506,8 @@ class TestIpAddrCommand(TestIPCmdBase):
 
         output = '\n'.join(ADDR_SAMPLE.split('\n')[0:4])
         self.parent._run.return_value = output
-        self.assertEquals(self.addr_cmd.list('global', filters=['permanent']),
-                          expected)
+        self.assertEqual(self.addr_cmd.list('global', filters=['permanent']),
+                         expected)
         self._assert_call([], ('show', 'tap0', 'permanent', 'scope', 'global'))
 
 
@@ -547,8 +547,8 @@ class TestIpRouteCommand(TestIPCmdBase):
                        'expected': {'gateway': '10.35.19.254'}}]
         for test_case in test_cases:
             self.parent._run = mock.Mock(return_value=test_case['sample'])
-            self.assertEquals(self.route_cmd.get_gateway(),
-                              test_case['expected'])
+            self.assertEqual(self.route_cmd.get_gateway(),
+                             test_case['expected'])
 
     def test_pullup_route(self):
         # interface is not the first in the list - requires

diff --git a/quantum/tests/unit/test_quantum_context.py b/quantum/tests/unit/test_quantum_context.py
index 5c6a338eb6354cb0f71359e7bf1a6e2cebbc46cc..da3b7bec846a44a4d4f5ab010f8778cc799e528c 100644 (file)
--- a/quantum/tests/unit/test_quantum_context.py
+++ b/quantum/tests/unit/test_quantum_context.py
@@ -34,14 +34,14 @@ class TestQuantumContext(unittest.TestCase):
 
     def testQuantumContextCreate(self):
         cxt = context.Context('user_id', 'tenant_id')
-        self.assertEquals('user_id', cxt.user_id)
-        self.assertEquals('tenant_id', cxt.project_id)
+        self.assertEqual('user_id', cxt.user_id)
+        self.assertEqual('tenant_id', cxt.project_id)
 
     def testQuantumContextToDict(self):
         cxt = context.Context('user_id', 'tenant_id')
         cxt_dict = cxt.to_dict()
-        self.assertEquals('user_id', cxt_dict['user_id'])
-        self.assertEquals('tenant_id', cxt_dict['project_id'])
+        self.assertEqual('user_id', cxt_dict['user_id'])
+        self.assertEqual('tenant_id', cxt_dict['project_id'])
 
     def testQuantumContextAdminToDict(self):
         self.db_api_session.return_value = 'fakesession'

diff --git a/quantum/tests/unit/test_quota_per_tenant_ext.py b/quantum/tests/unit/test_quota_per_tenant_ext.py
index 1f8ff5c999d140de48873146c10194de37329a38..917b1bbed95212ec8ff171ba8fa625d61058873f 100644 (file)
--- a/quantum/tests/unit/test_quota_per_tenant_ext.py
+++ b/quantum/tests/unit/test_quota_per_tenant_ext.py
@@ -112,17 +112,17 @@ class QuotaExtensionTestCase(unittest.TestCase):
 
     def test_quotas_loaded_right(self):
         res = self.api.get(_get_path('quotas'))
-        self.assertEquals(200, res.status_int)
+        self.assertEqual(200, res.status_int)
 
     def test_quotas_defaul_values(self):
         tenant_id = 'tenant_id1'
         env = {'quantum.context': context.Context('', tenant_id)}
         res = self.api.get(_get_path('quotas', id=tenant_id),
                            extra_environ=env)
-        self.assertEquals(10, res.json['quota']['network'])
-        self.assertEquals(10, res.json['quota']['subnet'])
-        self.assertEquals(50, res.json['quota']['port'])
-        self.assertEquals(-1, res.json['quota']['extra1'])
+        self.assertEqual(10, res.json['quota']['network'])
+        self.assertEqual(10, res.json['quota']['subnet'])
+        self.assertEqual(50, res.json['quota']['port'])
+        self.assertEqual(-1, res.json['quota']['extra1'])
 
     def test_show_quotas_with_admin(self):
         tenant_id = 'tenant_id1'
@@ -130,7 +130,7 @@ class QuotaExtensionTestCase(unittest.TestCase):
                                                   is_admin=True)}
         res = self.api.get(_get_path('quotas', id=tenant_id),
                            extra_environ=env)
-        self.assertEquals(200, res.status_int)
+        self.assertEqual(200, res.status_int)
 
     def test_show_quotas_without_admin_forbidden(self):
         tenant_id = 'tenant_id1'
@@ -138,7 +138,7 @@ class QuotaExtensionTestCase(unittest.TestCase):
                                                   is_admin=False)}
         res = self.api.get(_get_path('quotas', id=tenant_id),
                            extra_environ=env, expect_errors=True)
-        self.assertEquals(403, res.status_int)
+        self.assertEqual(403, res.status_int)
 
     def test_update_quotas_without_admin_forbidden(self):
         tenant_id = 'tenant_id1'
@@ -149,7 +149,7 @@ class QuotaExtensionTestCase(unittest.TestCase):
                                           fmt='json'),
                                 quotas, extra_environ=env,
                                 expect_errors=True)
-        self.assertEquals(403, res.status_int)
+        self.assertEqual(403, res.status_int)
 
     def test_update_quotas_with_admin(self):
         tenant_id = 'tenant_id1'
@@ -158,11 +158,11 @@ class QuotaExtensionTestCase(unittest.TestCase):
         quotas = {'quota': {'network': 100}}
         res = self.api.put_json(_get_path('quotas', id=tenant_id, fmt='json'),
                                 quotas, extra_environ=env)
-        self.assertEquals(200, res.status_int)
+        self.assertEqual(200, res.status_int)
         env2 = {'quantum.context': context.Context('', tenant_id)}
         res = self.api.get(_get_path('quotas', id=tenant_id),
                            extra_environ=env2).json
-        self.assertEquals(100, res['quota']['network'])
+        self.assertEqual(100, res['quota']['network'])
 
     def test_delete_quotas_with_admin(self):
         tenant_id = 'tenant_id1'
@@ -170,7 +170,7 @@ class QuotaExtensionTestCase(unittest.TestCase):
                                                   is_admin=True)}
         res = self.api.delete(_get_path('quotas', id=tenant_id, fmt='json'),
                               extra_environ=env)
-        self.assertEquals(204, res.status_int)
+        self.assertEqual(204, res.status_int)
 
     def test_delete_quotas_without_admin_forbidden(self):
         tenant_id = 'tenant_id1'
@@ -178,13 +178,13 @@ class QuotaExtensionTestCase(unittest.TestCase):
                                                   is_admin=False)}
         res = self.api.delete(_get_path('quotas', id=tenant_id, fmt='json'),
                               extra_environ=env, expect_errors=True)
-        self.assertEquals(403, res.status_int)
+        self.assertEqual(403, res.status_int)
 
     def test_quotas_loaded_bad(self):
         self.testflag = 2
         try:
             res = self.api.get(_get_path('quotas'), expect_errors=True)
-            self.assertEquals(404, res.status_int)
+            self.assertEqual(404, res.status_int)
         except Exception:
             pass
         self.testflag = 1