Bump hacking to 0.7.0

Fixes H202, H602 errors

Change-Id: Ic3045f15116d1d7a28b63bc94a0a341b9304ffdd

25 files changed, 203 insertions, 205 deletions

diff --git a/tests/unit/db/sqlalchemy/test_migrate.py b/tests/unit/db/sqlalchemy/test_migrate.py
index 6724b5c..3e74a88 100644
--- a/tests/unit/db/sqlalchemy/test_migrate.py
+++ b/tests/unit/db/sqlalchemy/test_migrate.py
@@ -28,7 +28,7 @@ def uniques(*constraints):
 
         Convert a sequence of UniqueConstraint instances into a set of
         tuples of form (constraint_name, (constraint_columns)) so that
-        assertEquals() will be able to compare sets of unique constraints
+        assertEqual() will be able to compare sets of unique constraints
 
     """
 
@@ -70,7 +70,7 @@ class TestSqliteUniqueConstraints(test_base.DbTestCase):
             sa.UniqueConstraint(table.c.a, table.c.b, name='unique_a_b'),
             sa.UniqueConstraint(table.c.b, table.c.c, name='unique_b_c'),
         )
-        self.assertEquals(should_be, existing)
+        self.assertEqual(should_be, existing)
 
     def test_add_unique_constraint(self):
         table = self.reflected_table
@@ -82,7 +82,7 @@ class TestSqliteUniqueConstraints(test_base.DbTestCase):
             sa.UniqueConstraint(table.c.b, table.c.c, name='unique_b_c'),
             sa.UniqueConstraint(table.c.a, table.c.c, name='unique_a_c'),
         )
-        self.assertEquals(should_be, existing)
+        self.assertEqual(should_be, existing)
 
     def test_drop_unique_constraint(self):
         table = self.reflected_table
@@ -92,4 +92,4 @@ class TestSqliteUniqueConstraints(test_base.DbTestCase):
         should_be = uniques(
             sa.UniqueConstraint(table.c.b, table.c.c, name='unique_b_c'),
         )
-        self.assertEquals(should_be, existing)
+        self.assertEqual(should_be, existing)
diff --git a/tests/unit/db/sqlalchemy/test_migrations.py b/tests/unit/db/sqlalchemy/test_migrations.py
index 8428b1c..ee2929c 100644
--- a/tests/unit/db/sqlalchemy/test_migrations.py
+++ b/tests/unit/db/sqlalchemy/test_migrations.py
@@ -355,10 +355,10 @@ class TestWalkVersions(test_utils.BaseTestCase, WalkVersionsMixin):
 
         versions = range(self.INIT_VERSION + 1, self.REPOSITORY.latest + 1)
         upgraded = [mock.call(None, v, with_data=True) for v in versions]
-        self.assertEquals(self._migrate_up.call_args_list, upgraded)
+        self.assertEqual(self._migrate_up.call_args_list, upgraded)
 
         downgraded = [mock.call(None, v - 1) for v in reversed(versions)]
-        self.assertEquals(self._migrate_down.call_args_list, downgraded)
+        self.assertEqual(self._migrate_down.call_args_list, downgraded)
 
     @mock.patch.object(WalkVersionsMixin, '_migrate_up')
     @mock.patch.object(WalkVersionsMixin, '_migrate_down')
@@ -376,7 +376,7 @@ class TestWalkVersions(test_utils.BaseTestCase, WalkVersionsMixin):
         upgraded.extend(
             [mock.call(self.engine, v) for v in reversed(versions)]
         )
-        self.assertEquals(upgraded, self._migrate_up.call_args_list)
+        self.assertEqual(upgraded, self._migrate_up.call_args_list)
 
         downgraded_1 = [
             mock.call(self.engine, v - 1, with_data=True) for v in versions
@@ -386,7 +386,7 @@ class TestWalkVersions(test_utils.BaseTestCase, WalkVersionsMixin):
             downgraded_2.append(mock.call(self.engine, v - 1))
             downgraded_2.append(mock.call(self.engine, v - 1))
         downgraded = downgraded_1 + downgraded_2
-        self.assertEquals(self._migrate_down.call_args_list, downgraded)
+        self.assertEqual(self._migrate_down.call_args_list, downgraded)
 
     @mock.patch.object(WalkVersionsMixin, '_migrate_up')
     @mock.patch.object(WalkVersionsMixin, '_migrate_down')
@@ -402,12 +402,12 @@ class TestWalkVersions(test_utils.BaseTestCase, WalkVersionsMixin):
         for v in versions:
             upgraded.append(mock.call(self.engine, v, with_data=True))
             upgraded.append(mock.call(self.engine, v))
-        self.assertEquals(upgraded, self._migrate_up.call_args_list)
+        self.assertEqual(upgraded, self._migrate_up.call_args_list)
 
         downgraded = [
             mock.call(self.engine, v - 1, with_data=True) for v in versions
         ]
-        self.assertEquals(self._migrate_down.call_args_list, downgraded)
+        self.assertEqual(self._migrate_down.call_args_list, downgraded)
 
     @mock.patch.object(WalkVersionsMixin, '_migrate_up')
     @mock.patch.object(WalkVersionsMixin, '_migrate_down')
@@ -422,4 +422,4 @@ class TestWalkVersions(test_utils.BaseTestCase, WalkVersionsMixin):
         upgraded = [
             mock.call(self.engine, v, with_data=True) for v in versions
         ]
-        self.assertEquals(upgraded, self._migrate_up.call_args_list)
+        self.assertEqual(upgraded, self._migrate_up.call_args_list)
diff --git a/tests/unit/db/sqlalchemy/test_sqlalchemy.py b/tests/unit/db/sqlalchemy/test_sqlalchemy.py
index 48d6cf7..01141e3 100644
--- a/tests/unit/db/sqlalchemy/test_sqlalchemy.py
+++ b/tests/unit/db/sqlalchemy/test_sqlalchemy.py
@@ -53,14 +53,14 @@ sql_connection_debug=60
 sql_connection_trace=True
 """)])
         self.conf(['--config-file', paths[0]])
-        self.assertEquals(self.conf.database.connection, 'x://y.z')
-        self.assertEquals(self.conf.database.min_pool_size, 10)
-        self.assertEquals(self.conf.database.max_pool_size, 20)
-        self.assertEquals(self.conf.database.max_retries, 30)
-        self.assertEquals(self.conf.database.retry_interval, 40)
-        self.assertEquals(self.conf.database.max_overflow, 50)
-        self.assertEquals(self.conf.database.connection_debug, 60)
-        self.assertEquals(self.conf.database.connection_trace, True)
+        self.assertEqual(self.conf.database.connection, 'x://y.z')
+        self.assertEqual(self.conf.database.min_pool_size, 10)
+        self.assertEqual(self.conf.database.max_pool_size, 20)
+        self.assertEqual(self.conf.database.max_retries, 30)
+        self.assertEqual(self.conf.database.retry_interval, 40)
+        self.assertEqual(self.conf.database.max_overflow, 50)
+        self.assertEqual(self.conf.database.connection_debug, 60)
+        self.assertEqual(self.conf.database.connection_trace, True)
 
     def test_session_parameters(self):
         paths = self.create_tempfiles([('test', """[database]
@@ -75,15 +75,15 @@ connection_trace=True
 pool_timeout=7
 """)])
         self.conf(['--config-file', paths[0]])
-        self.assertEquals(self.conf.database.connection, 'x://y.z')
-        self.assertEquals(self.conf.database.min_pool_size, 10)
-        self.assertEquals(self.conf.database.max_pool_size, 20)
-        self.assertEquals(self.conf.database.max_retries, 30)
-        self.assertEquals(self.conf.database.retry_interval, 40)
-        self.assertEquals(self.conf.database.max_overflow, 50)
-        self.assertEquals(self.conf.database.connection_debug, 60)
-        self.assertEquals(self.conf.database.connection_trace, True)
-        self.assertEquals(self.conf.database.pool_timeout, 7)
+        self.assertEqual(self.conf.database.connection, 'x://y.z')
+        self.assertEqual(self.conf.database.min_pool_size, 10)
+        self.assertEqual(self.conf.database.max_pool_size, 20)
+        self.assertEqual(self.conf.database.max_retries, 30)
+        self.assertEqual(self.conf.database.retry_interval, 40)
+        self.assertEqual(self.conf.database.max_overflow, 50)
+        self.assertEqual(self.conf.database.connection_debug, 60)
+        self.assertEqual(self.conf.database.connection_trace, True)
+        self.assertEqual(self.conf.database.pool_timeout, 7)
 
     def test_dbapi_database_deprecated_parameters(self):
         paths = self.create_tempfiles([('test',
@@ -98,15 +98,14 @@ pool_timeout=7
                                         'sqlalchemy_pool_timeout=5\n'
                                         )])
         self.conf(['--config-file', paths[0]])
-        self.assertEquals(self.conf.database.connection,
-                          'fake_connection')
-        self.assertEquals(self.conf.database.idle_timeout, 100)
-        self.assertEquals(self.conf.database.min_pool_size, 99)
-        self.assertEquals(self.conf.database.max_pool_size, 199)
-        self.assertEquals(self.conf.database.max_retries, 22)
-        self.assertEquals(self.conf.database.retry_interval, 17)
-        self.assertEquals(self.conf.database.max_overflow, 101)
-        self.assertEquals(self.conf.database.pool_timeout, 5)
+        self.assertEqual(self.conf.database.connection, 'fake_connection')
+        self.assertEqual(self.conf.database.idle_timeout, 100)
+        self.assertEqual(self.conf.database.min_pool_size, 99)
+        self.assertEqual(self.conf.database.max_pool_size, 199)
+        self.assertEqual(self.conf.database.max_retries, 22)
+        self.assertEqual(self.conf.database.retry_interval, 17)
+        self.assertEqual(self.conf.database.max_overflow, 101)
+        self.assertEqual(self.conf.database.pool_timeout, 5)
 
 
 class SessionErrorWrapperTestCase(test_base.DbTestCase):
diff --git a/tests/unit/db/test_api.py b/tests/unit/db/test_api.py
index 2a8db3b..dab2198 100644
--- a/tests/unit/db/test_api.py
+++ b/tests/unit/db/test_api.py
@@ -41,8 +41,8 @@ class DBAPITestCase(test_utils.BaseTestCase):
                                         )])
 
         self.conf(['--config-file', paths[0]])
-        self.assertEquals(self.conf.database.backend, 'test_123')
-        self.assertEquals(self.conf.database.use_tpool, True)
+        self.assertEqual(self.conf.database.backend, 'test_123')
+        self.assertEqual(self.conf.database.use_tpool, True)
 
     def test_dbapi_parameters(self):
         paths = self.create_tempfiles([('test',
@@ -52,8 +52,8 @@ class DBAPITestCase(test_utils.BaseTestCase):
                                         )])
 
         self.conf(['--config-file', paths[0]])
-        self.assertEquals(self.conf.database.backend, 'test_123')
-        self.assertEquals(self.conf.database.use_tpool, True)
+        self.assertEqual(self.conf.database.backend, 'test_123')
+        self.assertEqual(self.conf.database.use_tpool, True)
 
     def test_dbapi_api_class_method_and_tpool_false(self):
         backend_mapping = {'test_known': 'tests.unit.db.test_api'}
diff --git a/tests/unit/deprecated/test_wsgi.py b/tests/unit/deprecated/test_wsgi.py
index abc883d..7e71837 100644
--- a/tests/unit/deprecated/test_wsgi.py
+++ b/tests/unit/deprecated/test_wsgi.py
@@ -522,7 +522,7 @@ class WSGIServerTest(utils.BaseTestCase):
         server.start()
 
         response = urllib2.urlopen('http://127.0.0.1:%d/' % server.port)
-        self.assertEquals(greetings, response.read())
+        self.assertEqual(greetings, response.read())
 
         server.stop()
 
@@ -540,7 +540,7 @@ class WSGIServerTest(utils.BaseTestCase):
         server.start()
 
         response = urllib2.urlopen('http://127.0.0.1:%d/v1.0/' % server.port)
-        self.assertEquals(greetings, response.read())
+        self.assertEqual(greetings, response.read())
 
         server.stop()
 
@@ -594,7 +594,7 @@ class WSGIServerWithSSLTest(utils.BaseTestCase):
         server.start()
 
         response = urllib2.urlopen('https://127.0.0.1:%d/v1.0/' % server.port)
-        self.assertEquals(greetings, response.read())
+        self.assertEqual(greetings, response.read())
 
         server.stop()
 
@@ -617,6 +617,6 @@ class WSGIServerWithSSLTest(utils.BaseTestCase):
         server.start()
 
         response = urllib2.urlopen('https://[::1]:%d/v1.0/' % server.port)
-        self.assertEquals(greetings, response.read())
+        self.assertEqual(greetings, response.read())
 
         server.stop()
diff --git a/tests/unit/fixture/test_config.py b/tests/unit/fixture/test_config.py
index 89582cc..3368272 100644
--- a/tests/unit/fixture/test_config.py
+++ b/tests/unit/fixture/test_config.py
@@ -32,14 +32,14 @@ class ConfigTestCase(BaseTestCase):
             'testing_option', default='initial_value'))
 
     def test_overriden_value(self):
-        self.assertEquals(conf.get('testing_option'), 'initial_value')
+        self.assertEqual(conf.get('testing_option'), 'initial_value')
         self.config(testing_option='changed_value')
-        self.assertEquals(conf.get('testing_option'),
-                          self.config_fixture.conf.get('testing_option'))
+        self.assertEqual(conf.get('testing_option'),
+                         self.config_fixture.conf.get('testing_option'))
 
     def test_cleanup(self):
         self.config(testing_option='changed_value')
-        self.assertEquals(self.config_fixture.conf.get('testing_option'),
-                          'changed_value')
+        self.assertEqual(self.config_fixture.conf.get('testing_option'),
+                         'changed_value')
         self.config_fixture.conf.reset()
-        self.assertEquals(conf.get('testing_option'), 'initial_value')
+        self.assertEqual(conf.get('testing_option'), 'initial_value')
diff --git a/tests/unit/middleware/test_correlation_id.py b/tests/unit/middleware/test_correlation_id.py
index dc83cc7..11939e9 100644
--- a/tests/unit/middleware/test_correlation_id.py
+++ b/tests/unit/middleware/test_correlation_id.py
@@ -36,7 +36,7 @@ class CorrelationIdMiddlewareTest(utils.BaseTestCase):
         middleware = correlation_id.CorrelationIdMiddleware(app)
         middleware(req)
 
-        self.assertEquals(req.headers.get("X_CORRELATION_ID"), "fake_uuid")
+        self.assertEqual(req.headers.get("X_CORRELATION_ID"), "fake_uuid")
 
     def test_process_request_should_not_regenerate_correlation_id(self):
         app = mock.Mock()
@@ -46,5 +46,4 @@ class CorrelationIdMiddlewareTest(utils.BaseTestCase):
         middleware = correlation_id.CorrelationIdMiddleware(app)
         middleware(req)
 
-        self.assertEquals(req.headers.get("X_CORRELATION_ID"),
-                          "correlation_id")
+        self.assertEqual(req.headers.get("X_CORRELATION_ID"), "correlation_id")
diff --git a/tests/unit/middleware/test_sizelimit.py b/tests/unit/middleware/test_sizelimit.py
index 7579659..3666b54 100644
--- a/tests/unit/middleware/test_sizelimit.py
+++ b/tests/unit/middleware/test_sizelimit.py
@@ -32,7 +32,7 @@ class TestLimitingReader(utils.BaseTestCase):
         for chunk in sizelimit.LimitingReader(data, BYTES):
             bytes_read += len(chunk)
 
-        self.assertEquals(bytes_read, BYTES)
+        self.assertEqual(bytes_read, BYTES)
 
         bytes_read = 0
         data = six.StringIO("*" * BYTES)
@@ -42,7 +42,7 @@ class TestLimitingReader(utils.BaseTestCase):
             bytes_read += 1
             byte = reader.read(1)
 
-        self.assertEquals(bytes_read, BYTES)
+        self.assertEqual(bytes_read, BYTES)
 
     def test_limiting_reader_fails(self):
         BYTES = 1024
diff --git a/tests/unit/rpc/test_common.py b/tests/unit/rpc/test_common.py
index a6a2188..f37f4b0 100644
--- a/tests/unit/rpc/test_common.py
+++ b/tests/unit/rpc/test_common.py
@@ -301,8 +301,8 @@ class RpcCommonTestCase(test_utils.BaseTestCase):
 
     def test_safe_log_sanitizes_globals(self):
         def logger_method(msg, data):
-            self.assertEquals('<SANITIZED>', data['_context_auth_token'])
-            self.assertEquals('<SANITIZED>', data['auth_token'])
+            self.assertEqual('<SANITIZED>', data['_context_auth_token'])
+            self.assertEqual('<SANITIZED>', data['auth_token'])
 
         data = {'_context_auth_token': 'banana',
                 'auth_token': 'cheese'}
@@ -310,7 +310,7 @@ class RpcCommonTestCase(test_utils.BaseTestCase):
 
     def test_safe_log_sanitizes_set_admin_password(self):
         def logger_method(msg, data):
-            self.assertEquals('<SANITIZED>', data['args']['new_pass'])
+            self.assertEqual('<SANITIZED>', data['args']['new_pass'])
 
         data = {'_context_auth_token': 'banana',
                 'auth_token': 'cheese',
@@ -320,7 +320,7 @@ class RpcCommonTestCase(test_utils.BaseTestCase):
 
     def test_safe_log_sanitizes_run_instance(self):
         def logger_method(msg, data):
-            self.assertEquals('<SANITIZED>', data['args']['admin_password'])
+            self.assertEqual('<SANITIZED>', data['args']['admin_password'])
 
         data = {'_context_auth_token': 'banana',
                 'auth_token': 'cheese',
@@ -330,8 +330,8 @@ class RpcCommonTestCase(test_utils.BaseTestCase):
 
     def test_safe_log_sanitizes_any_password_in_context(self):
         def logger_method(msg, data):
-            self.assertEquals('<SANITIZED>', data['_context_password'])
-            self.assertEquals('<SANITIZED>', data['password'])
+            self.assertEqual('<SANITIZED>', data['_context_password'])
+            self.assertEqual('<SANITIZED>', data['password'])
 
         data = {'_context_auth_token': 'banana',
                 'auth_token': 'cheese',
@@ -343,7 +343,7 @@ class RpcCommonTestCase(test_utils.BaseTestCase):
     def test_safe_log_sanitizes_cells_route_message(self):
         def logger_method(msg, data):
             vals = data['args']['message']['args']['method_info']
-            self.assertEquals('<SANITIZED>', vals['method_kwargs']['password'])
+            self.assertEqual('<SANITIZED>', vals['method_kwargs']['password'])
 
         meth_info = {'method_args': ['aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'],
                      'method': 'set_admin_password',
diff --git a/tests/unit/rpc/test_qpid.py b/tests/unit/rpc/test_qpid.py
index a4bce1c..910e292 100644
--- a/tests/unit/rpc/test_qpid.py
+++ b/tests/unit/rpc/test_qpid.py
@@ -438,9 +438,9 @@ class RpcQpidTestCase(utils.BaseTestCase):
                          {"method": "test_method", "args": {}})
 
             if multi:
-                self.assertEquals(list(res), ["foo", "bar", "baz"])
+                self.assertEqual(list(res), ["foo", "bar", "baz"])
             else:
-                self.assertEquals(res, "foo")
+                self.assertEqual(res, "foo")
         finally:
             impl_qpid.cleanup()
             self.uuid4 = uuid.uuid4()
@@ -488,7 +488,7 @@ class RpcQpidTestCase(utils.BaseTestCase):
             else:
                 res = method(FLAGS, ctx, "impl_qpid_test",
                              {"method": "test_method", "args": {}}, timeout)
-                self.assertEquals(res, "foo")
+                self.assertEqual(res, "foo")
         finally:
             impl_qpid.cleanup()
             self.uuid4 = uuid.uuid4()
diff --git a/tests/unit/rpc/test_zmq.py b/tests/unit/rpc/test_zmq.py
index 5f6e9b0..11d3fcd 100644
--- a/tests/unit/rpc/test_zmq.py
+++ b/tests/unit/rpc/test_zmq.py
@@ -106,9 +106,7 @@ class _RpcZmqBaseTestCase(common.BaseRpcTestCase):
         for char in badchars:
             self.topic_nested = char.join(('hello', 'world'))
             try:
-                # TODO(ewindisch): Determine which exception is raised.
-                #                  pending bug #1121348
-                self.assertRaises(Exception, self._test_cast,
+                self.assertRaises(AssertionError, self._test_cast,
                                   common.TestReceiver.echo, 42, {"value": 42},
                                   fanout=False)
             finally:
diff --git a/tests/unit/test_cfgfilter.py b/tests/unit/test_cfgfilter.py
index 58b4e2d..1270758 100644
--- a/tests/unit/test_cfgfilter.py
+++ b/tests/unit/test_cfgfilter.py
@@ -30,11 +30,11 @@ class ConfigFilterTestCase(utils.BaseTestCase):
     def test_register_opt_default(self):
         self.fconf.register_opt(cfg.StrOpt('foo', default='bar'))
 
-        self.assertEquals(self.fconf.foo, 'bar')
-        self.assertEquals(self.fconf['foo'], 'bar')
+        self.assertEqual(self.fconf.foo, 'bar')
+        self.assertEqual(self.fconf['foo'], 'bar')
         self.assertTrue('foo' in self.fconf)
-        self.assertEquals(list(self.fconf), ['foo'])
-        self.assertEquals(len(self.fconf), 1)
+        self.assertEqual(list(self.fconf), ['foo'])
+        self.assertEqual(len(self.fconf), 1)
 
     def test_register_opt_none_default(self):
         self.fconf.register_opt(cfg.StrOpt('foo'))
@@ -42,21 +42,21 @@ class ConfigFilterTestCase(utils.BaseTestCase):
         self.assertTrue(self.fconf.foo is None)
         self.assertTrue(self.fconf['foo'] is None)
         self.assertTrue('foo' in self.fconf)
-        self.assertEquals(list(self.fconf), ['foo'])
-        self.assertEquals(len(self.fconf), 1)
+        self.assertEqual(list(self.fconf), ['foo'])
+        self.assertEqual(len(self.fconf), 1)
 
     def test_register_grouped_opt_default(self):
         self.fconf.register_opt(cfg.StrOpt('foo', default='bar'),
                                 group='blaa')
 
-        self.assertEquals(self.fconf.blaa.foo, 'bar')
-        self.assertEquals(self.fconf['blaa']['foo'], 'bar')
+        self.assertEqual(self.fconf.blaa.foo, 'bar')
+        self.assertEqual(self.fconf['blaa']['foo'], 'bar')
         self.assertTrue('blaa' in self.fconf)
         self.assertTrue('foo' in self.fconf.blaa)
-        self.assertEquals(list(self.fconf), ['blaa'])
-        self.assertEquals(list(self.fconf.blaa), ['foo'])
-        self.assertEquals(len(self.fconf), 1)
-        self.assertEquals(len(self.fconf.blaa), 1)
+        self.assertEqual(list(self.fconf), ['blaa'])
+        self.assertEqual(list(self.fconf.blaa), ['foo'])
+        self.assertEqual(len(self.fconf), 1)
+        self.assertEqual(len(self.fconf.blaa), 1)
 
     def test_register_grouped_opt_none_default(self):
         self.fconf.register_opt(cfg.StrOpt('foo'), group='blaa')
@@ -65,10 +65,10 @@ class ConfigFilterTestCase(utils.BaseTestCase):
         self.assertTrue(self.fconf['blaa']['foo'] is None)
         self.assertTrue('blaa' in self.fconf)
         self.assertTrue('foo' in self.fconf.blaa)
-        self.assertEquals(list(self.fconf), ['blaa'])
-        self.assertEquals(list(self.fconf.blaa), ['foo'])
-        self.assertEquals(len(self.fconf), 1)
-        self.assertEquals(len(self.fconf.blaa), 1)
+        self.assertEqual(list(self.fconf), ['blaa'])
+        self.assertEqual(list(self.fconf.blaa), ['foo'])
+        self.assertEqual(len(self.fconf), 1)
+        self.assertEqual(len(self.fconf.blaa), 1)
 
     def test_register_group(self):
         group = cfg.OptGroup('blaa')
@@ -79,24 +79,24 @@ class ConfigFilterTestCase(utils.BaseTestCase):
         self.assertTrue(self.fconf['blaa']['foo'] is None)
         self.assertTrue('blaa' in self.fconf)
         self.assertTrue('foo' in self.fconf.blaa)
-        self.assertEquals(list(self.fconf), ['blaa'])
-        self.assertEquals(list(self.fconf.blaa), ['foo'])
-        self.assertEquals(len(self.fconf), 1)
-        self.assertEquals(len(self.fconf.blaa), 1)
+        self.assertEqual(list(self.fconf), ['blaa'])
+        self.assertEqual(list(self.fconf.blaa), ['foo'])
+        self.assertEqual(len(self.fconf), 1)
+        self.assertEqual(len(self.fconf.blaa), 1)
 
     def test_unknown_opt(self):
         self.assertFalse('foo' in self.fconf)
-        self.assertEquals(len(self.fconf), 0)
+        self.assertEqual(len(self.fconf), 0)
         self.assertRaises(cfg.NoSuchOptError, getattr, self.fconf, 'foo')
 
     def test_blocked_opt(self):
         self.conf.register_opt(cfg.StrOpt('foo'))
 
         self.assertTrue('foo' in self.conf)
-        self.assertEquals(len(self.conf), 1)
+        self.assertEqual(len(self.conf), 1)
         self.assertTrue(self.conf.foo is None)
         self.assertFalse('foo' in self.fconf)
-        self.assertEquals(len(self.fconf), 0)
+        self.assertEqual(len(self.fconf), 0)
         self.assertRaises(cfg.NoSuchOptError, getattr, self.fconf, 'foo')
 
     def test_import_opt(self):
diff --git a/tests/unit/test_compat.py b/tests/unit/test_compat.py
index 5c3d9e5..f71e130 100644
--- a/tests/unit/test_compat.py
+++ b/tests/unit/test_compat.py
@@ -24,30 +24,30 @@ class CompatTestCase(utils.BaseTestCase):
     def test_urlencode(self):
         fake = 'fake'
         result = urlutils.urlencode({'Fake': fake})
-        self.assertEquals(result, 'Fake=fake')
+        self.assertEqual(result, 'Fake=fake')
 
     def test_urljoin(self):
         root_url = "http://yahoo.com/"
         url2 = "faq.html"
         result = urlutils.urljoin(root_url, url2)
-        self.assertEquals(result, "http://yahoo.com/faq.html")
+        self.assertEqual(result, "http://yahoo.com/faq.html")
 
     def test_urlquote(self):
         url = "/~fake"
         result = urlutils.quote(url)
-        self.assertEquals(result, '/%7Efake')
+        self.assertEqual(result, '/%7Efake')
 
     def test_urlparse(self):
         url = 'http://www.yahoo.com'
         result = urlutils.urlparse(url)
-        self.assertEquals(result.scheme, 'http')
+        self.assertEqual(result.scheme, 'http')
 
     def test_urlsplit(self):
         url = 'http://www.yahoo.com'
         result = urlutils.urlsplit(url)
-        self.assertEquals(result.scheme, 'http')
+        self.assertEqual(result.scheme, 'http')
 
     def test_urlunsplit(self):
         url = "http://www.yahoo.com"
         result = urlutils.urlunsplit(urlutils.urlsplit(url))
-        self.assertEquals(result, 'http://www.yahoo.com')
+        self.assertEqual(result, 'http://www.yahoo.com')
diff --git a/tests/unit/test_fileutils.py b/tests/unit/test_fileutils.py
index 706ae71..139d478 100644
--- a/tests/unit/test_fileutils.py
+++ b/tests/unit/test_fileutils.py
@@ -142,6 +142,6 @@ class UtilsTestCase(test.BaseTestCase):
             with open(dst_path, 'w') as f:
                 f.write('hello')
             with fileutils.file_open(dst_path, 'r') as fp:
-                self.assertEquals(fp.read(), 'hello')
+                self.assertEqual(fp.read(), 'hello')
         finally:
             os.unlink(dst_path)
diff --git a/tests/unit/test_gettext.py b/tests/unit/test_gettext.py
index ef16ac3..ddd8b84 100644
--- a/tests/unit/test_gettext.py
+++ b/tests/unit/test_gettext.py
@@ -111,18 +111,18 @@ class GettextTest(utils.BaseTestCase):
         self.stubs.Set(gettextutils.Message,
                        '__unicode__', _mock_translation_and_unicode)
 
-        self.assertEquals(es_translation,
-                          gettextutils.get_localized_message(message, 'es'))
-        self.assertEquals(zh_translation,
-                          gettextutils.get_localized_message(message, 'zh'))
-        self.assertEquals(en_message,
-                          gettextutils.get_localized_message(message, 'en'))
-        self.assertEquals(en_message,
-                          gettextutils.get_localized_message(message, 'XX'))
-        self.assertEquals(en_message,
-                          gettextutils.get_localized_message(message, None))
-        self.assertEquals(non_message,
-                          gettextutils.get_localized_message(non_message, 'A'))
+        self.assertEqual(es_translation,
+                         gettextutils.get_localized_message(message, 'es'))
+        self.assertEqual(zh_translation,
+                         gettextutils.get_localized_message(message, 'zh'))
+        self.assertEqual(en_message,
+                         gettextutils.get_localized_message(message, 'en'))
+        self.assertEqual(en_message,
+                         gettextutils.get_localized_message(message, 'XX'))
+        self.assertEqual(en_message,
+                         gettextutils.get_localized_message(message, None))
+        self.assertEqual(non_message,
+                         gettextutils.get_localized_message(non_message, 'A'))
 
     def test_get_available_languages(self):
         # All the available languages for which locale data is available
@@ -147,15 +147,15 @@ class GettextTest(utils.BaseTestCase):
         # en_US should also always be the first element since order matters
         # finally only the domain languages should be included after en_US
         self.assertTrue('en_US', domain_languages)
-        self.assertEquals(3, len(domain_languages))
-        self.assertEquals('en_US', domain_languages[0])
+        self.assertEqual(3, len(domain_languages))
+        self.assertEqual('en_US', domain_languages[0])
         self.assertTrue('zh' in domain_languages)
         self.assertTrue('es' in domain_languages)
 
         # Clear languages to test an unknown domain
         gettextutils._AVAILABLE_LANGUAGES = []
         unknown_domain_languages = gettextutils.get_available_languages('huh')
-        self.assertEquals(1, len(unknown_domain_languages))
+        self.assertEqual(1, len(unknown_domain_languages))
         self.assertTrue('en_US' in unknown_domain_languages)
 
 
diff --git a/tests/unit/test_jsonutils.py b/tests/unit/test_jsonutils.py
index 41bbcf5..0d22e7e 100644
--- a/tests/unit/test_jsonutils.py
+++ b/tests/unit/test_jsonutils.py
@@ -40,35 +40,35 @@ class JSONUtilsTestCase(test.BaseTestCase):
 
 class ToPrimitiveTestCase(test.BaseTestCase):
     def test_list(self):
-        self.assertEquals(jsonutils.to_primitive([1, 2, 3]), [1, 2, 3])
+        self.assertEqual(jsonutils.to_primitive([1, 2, 3]), [1, 2, 3])
 
     def test_empty_list(self):
-        self.assertEquals(jsonutils.to_primitive([]), [])
+        self.assertEqual(jsonutils.to_primitive([]), [])
 
     def test_tuple(self):
-        self.assertEquals(jsonutils.to_primitive((1, 2, 3)), [1, 2, 3])
+        self.assertEqual(jsonutils.to_primitive((1, 2, 3)), [1, 2, 3])
 
     def test_dict(self):
-        self.assertEquals(jsonutils.to_primitive(dict(a=1, b=2, c=3)),
-                          dict(a=1, b=2, c=3))
+        self.assertEqual(jsonutils.to_primitive(dict(a=1, b=2, c=3)),
+                         dict(a=1, b=2, c=3))
 
     def test_empty_dict(self):
-        self.assertEquals(jsonutils.to_primitive({}), {})
+        self.assertEqual(jsonutils.to_primitive({}), {})
 
     def test_datetime(self):
         x = datetime.datetime(1920, 2, 3, 4, 5, 6, 7)
-        self.assertEquals(jsonutils.to_primitive(x),
-                          '1920-02-03T04:05:06.000007')
+        self.assertEqual(jsonutils.to_primitive(x),
+                         '1920-02-03T04:05:06.000007')
 
     def test_datetime_preserve(self):
         x = datetime.datetime(1920, 2, 3, 4, 5, 6, 7)
-        self.assertEquals(jsonutils.to_primitive(x, convert_datetime=False), x)
+        self.assertEqual(jsonutils.to_primitive(x, convert_datetime=False), x)
 
     def test_DateTime(self):
         x = xmlrpclib.DateTime()
         x.decode("19710203T04:05:06")
-        self.assertEquals(jsonutils.to_primitive(x),
-                          '1971-02-03T04:05:06.000000')
+        self.assertEqual(jsonutils.to_primitive(x),
+                         '1971-02-03T04:05:06.000000')
 
     def test_iter(self):
         class IterClass(object):
@@ -86,7 +86,7 @@ class ToPrimitiveTestCase(test.BaseTestCase):
                 return self.data[self.index - 1]
 
         x = IterClass()
-        self.assertEquals(jsonutils.to_primitive(x), [1, 2, 3, 4, 5])
+        self.assertEqual(jsonutils.to_primitive(x), [1, 2, 3, 4, 5])
 
     def test_iteritems(self):
         class IterItemsClass(object):
@@ -99,7 +99,7 @@ class ToPrimitiveTestCase(test.BaseTestCase):
 
         x = IterItemsClass()
         p = jsonutils.to_primitive(x)
-        self.assertEquals(p, {'a': 1, 'b': 2, 'c': 3})
+        self.assertEqual(p, {'a': 1, 'b': 2, 'c': 3})
 
     def test_iteritems_with_cycle(self):
         class IterItemsClass(object):
@@ -127,24 +127,24 @@ class ToPrimitiveTestCase(test.BaseTestCase):
                 self.b = 1
 
         x = MysteryClass()
-        self.assertEquals(jsonutils.to_primitive(x, convert_instances=True),
-                          dict(b=1))
+        self.assertEqual(jsonutils.to_primitive(x, convert_instances=True),
+                         dict(b=1))
 
-        self.assertEquals(jsonutils.to_primitive(x), x)
+        self.assertEqual(jsonutils.to_primitive(x), x)
 
     def test_typeerror(self):
         x = bytearray  # Class, not instance
-        self.assertEquals(jsonutils.to_primitive(x), u"<type 'bytearray'>")
+        self.assertEqual(jsonutils.to_primitive(x), u"<type 'bytearray'>")
 
     def test_nasties(self):
         def foo():
             pass
         x = [datetime, foo, dir]
         ret = jsonutils.to_primitive(x)
-        self.assertEquals(len(ret), 3)
+        self.assertEqual(len(ret), 3)
         self.assertTrue(ret[0].startswith(u"<module 'datetime' from "))
         self.assertTrue(ret[1].startswith('<function foo at 0x'))
-        self.assertEquals(ret[2], '<built-in function dir>')
+        self.assertEqual(ret[2], '<built-in function dir>')
 
     def test_depth(self):
         class LevelsGenerator(object):
@@ -164,15 +164,15 @@ class ToPrimitiveTestCase(test.BaseTestCase):
         json_l4 = {0: {0: {0: {0: '?'}}}}
 
         ret = jsonutils.to_primitive(l4_obj, max_depth=2)
-        self.assertEquals(ret, json_l2)
+        self.assertEqual(ret, json_l2)
 
         ret = jsonutils.to_primitive(l4_obj, max_depth=3)
-        self.assertEquals(ret, json_l3)
+        self.assertEqual(ret, json_l3)
 
         ret = jsonutils.to_primitive(l4_obj, max_depth=4)
-        self.assertEquals(ret, json_l4)
+        self.assertEqual(ret, json_l4)
 
     def test_ipaddr(self):
         thing = {'ip_addr': netaddr.IPAddress('1.2.3.4')}
         ret = jsonutils.to_primitive(thing)
-        self.assertEquals({'ip_addr': '1.2.3.4'}, ret)
+        self.assertEqual({'ip_addr': '1.2.3.4'}, ret)
diff --git a/tests/unit/test_lockutils.py b/tests/unit/test_lockutils.py
index b5783b8..670d289 100644
--- a/tests/unit/test_lockutils.py
+++ b/tests/unit/test_lockutils.py
@@ -73,10 +73,10 @@ class LockTestCase(utils.BaseTestCase):
             """Bar"""
             pass
 
-        self.assertEquals(foo.__doc__, 'Bar', "Wrapped function's docstring "
-                                              "got lost")
-        self.assertEquals(foo.__name__, 'foo', "Wrapped function's name "
-                                               "got mangled")
+        self.assertEqual(foo.__doc__, 'Bar', "Wrapped function's docstring "
+                                             "got lost")
+        self.assertEqual(foo.__name__, 'foo', "Wrapped function's name "
+                                              "got mangled")
 
     def test_lock_internally(self):
         """We can lock across multiple green threads."""
@@ -97,13 +97,13 @@ class LockTestCase(utils.BaseTestCase):
         for thread in threads:
             thread.wait()
 
-        self.assertEquals(len(seen_threads), 100)
+        self.assertEqual(len(seen_threads), 100)
         # Looking at the seen threads, split it into chunks of 10, and verify
         # that the last 9 match the first in each chunk.
         for i in range(10):
             for j in range(9):
-                self.assertEquals(seen_threads[i * 10],
-                                  seen_threads[i * 10 + 1 + j])
+                self.assertEqual(seen_threads[i * 10],
+                                 seen_threads[i * 10 + 1 + j])
 
         self.assertEqual(saved_sem_num, len(lockutils._semaphores),
                          "Semaphore leak detected")
diff --git a/tests/unit/test_log.py b/tests/unit/test_log.py
index 8f40f75..39a0cce 100644
--- a/tests/unit/test_log.py
+++ b/tests/unit/test_log.py
@@ -108,13 +108,13 @@ class LazyLoggerTestCase(CommonLoggerTestsMixIn, test_utils.BaseTestCase):
 class LogHandlerTestCase(test_utils.BaseTestCase):
     def test_log_path_logdir(self):
         self.config(log_dir='/some/path', log_file=None)
-        self.assertEquals(log._get_log_file_path(binary='foo-bar'),
-                          '/some/path/foo-bar.log')
+        self.assertEqual(log._get_log_file_path(binary='foo-bar'),
+                         '/some/path/foo-bar.log')
 
     def test_log_path_logfile(self):
         self.config(log_file='/some/path/foo-bar.log')
-        self.assertEquals(log._get_log_file_path(binary='foo-bar'),
-                          '/some/path/foo-bar.log')
+        self.assertEqual(log._get_log_file_path(binary='foo-bar'),
+                         '/some/path/foo-bar.log')
 
     def test_log_path_none(self):
         self.config(log_dir=None, log_file=None)
@@ -123,8 +123,8 @@ class LogHandlerTestCase(test_utils.BaseTestCase):
     def test_log_path_logfile_overrides_logdir(self):
         self.config(log_dir='/some/other/path',
                     log_file='/some/path/foo-bar.log')
-        self.assertEquals(log._get_log_file_path(binary='foo-bar'),
-                          '/some/path/foo-bar.log')
+        self.assertEqual(log._get_log_file_path(binary='foo-bar'),
+                         '/some/path/foo-bar.log')
 
 
 class PublishErrorsHandlerTestCase(test_utils.BaseTestCase):
@@ -354,7 +354,7 @@ class SetDefaultsTestCase(test_utils.BaseTestCase):
     def test_default_to_none(self):
         log.set_defaults(logging_context_format_string=None)
         self.conf([])
-        self.assertEquals(self.conf.logging_context_format_string, None)
+        self.assertEqual(self.conf.logging_context_format_string, None)
 
     def test_change_default(self):
         my_default = '%(asctime)s %(levelname)s %(name)s [%(request_id)s '\
@@ -362,7 +362,7 @@ class SetDefaultsTestCase(test_utils.BaseTestCase):
                      '%(message)s'
         log.set_defaults(logging_context_format_string=my_default)
         self.conf([])
-        self.assertEquals(self.conf.logging_context_format_string, my_default)
+        self.assertEqual(self.conf.logging_context_format_string, my_default)
 
 
 class LogConfigOptsTestCase(test_utils.BaseTestCase):
@@ -379,8 +379,8 @@ class LogConfigOptsTestCase(test_utils.BaseTestCase):
     def test_debug_verbose(self):
         CONF(['--debug', '--verbose'])
 
-        self.assertEquals(CONF.debug, True)
-        self.assertEquals(CONF.verbose, True)
+        self.assertEqual(CONF.debug, True)
+        self.assertEqual(CONF.verbose, True)
 
     def test_logging_opts(self):
         CONF([])
@@ -390,29 +390,29 @@ class LogConfigOptsTestCase(test_utils.BaseTestCase):
         self.assertTrue(CONF.log_dir is None)
         self.assertTrue(CONF.log_format is None)
 
-        self.assertEquals(CONF.log_date_format, log._DEFAULT_LOG_DATE_FORMAT)
+        self.assertEqual(CONF.log_date_format, log._DEFAULT_LOG_DATE_FORMAT)
 
-        self.assertEquals(CONF.use_syslog, False)
+        self.assertEqual(CONF.use_syslog, False)
 
     def test_log_file(self):
         log_file = '/some/path/foo-bar.log'
         CONF(['--log-file', log_file])
-        self.assertEquals(CONF.log_file, log_file)
+        self.assertEqual(CONF.log_file, log_file)
 
     def test_logfile_deprecated(self):
         logfile = '/some/other/path/foo-bar.log'
         CONF(['--logfile', logfile])
-        self.assertEquals(CONF.log_file, logfile)
+        self.assertEqual(CONF.log_file, logfile)
 
     def test_log_dir(self):
         log_dir = '/some/path/'
         CONF(['--log-dir', log_dir])
-        self.assertEquals(CONF.log_dir, log_dir)
+        self.assertEqual(CONF.log_dir, log_dir)
 
     def test_logdir_deprecated(self):
         logdir = '/some/other/path/'
         CONF(['--logdir', logdir])
-        self.assertEquals(CONF.log_dir, logdir)
+        self.assertEqual(CONF.log_dir, logdir)
 
     def test_log_format_overrides_formatter(self):
         CONF(['--log-format', '[Any format]'])
diff --git a/tests/unit/test_pastedeploy.py b/tests/unit/test_pastedeploy.py
index 9b64c1c..f8a2c57 100644
--- a/tests/unit/test_pastedeploy.py
+++ b/tests/unit/test_pastedeploy.py
@@ -67,7 +67,7 @@ openstack.app_factory = tests.unit.test_pastedeploy:App
 """)
 
         app = pastedeploy.paste_deploy_app(paste_conf, 'myfoo', data)
-        self.assertEquals(app.data, data)
+        self.assertEqual(app.data, data)
 
     def test_app_factory_with_local_conf(self):
         data = 'test_app_factory_with_local_conf'
@@ -80,8 +80,8 @@ foo = bar
 """)
 
         app = pastedeploy.paste_deploy_app(paste_conf, 'myfoo', data)
-        self.assertEquals(app.data, data)
-        self.assertEquals(app.foo, 'bar')
+        self.assertEqual(app.data, data)
+        self.assertEqual(app.foo, 'bar')
 
     def test_filter_factory(self):
         data = 'test_filter_factory'
@@ -100,5 +100,5 @@ openstack.app_factory = tests.unit.test_pastedeploy:App
 """)
 
         app = pastedeploy.paste_deploy_app(paste_conf, 'myfoo', data)
-        self.assertEquals(app.data, data)
-        self.assertEquals(app.app.data, data)
+        self.assertEqual(app.data, data)
+        self.assertEqual(app.app.data, data)
diff --git a/tests/unit/test_periodic.py b/tests/unit/test_periodic.py
index d663f8b..500e8f4 100644
--- a/tests/unit/test_periodic.py
+++ b/tests/unit/test_periodic.py
@@ -28,6 +28,10 @@ from tests import utils
 from testtools import matchers
 
 
+class AnException(Exception):
+    pass
+
+
 class AService(periodic_task.PeriodicTasks):
 
     def __init__(self):
@@ -40,7 +44,7 @@ class AService(periodic_task.PeriodicTasks):
     @periodic_task.periodic_task
     def crashit(self, context):
         self.called['urg'] = True
-        raise Exception('urg')
+        raise AnException('urg')
 
     @periodic_task.periodic_task(spacing=10)
     def doit_with_kwargs_odd(self, context):
@@ -66,7 +70,7 @@ class PeriodicTasksTestCase(utils.BaseTestCase):
 
     def test_raises(self):
         serv = AService()
-        self.assertRaises(Exception,
+        self.assertRaises(AnException,
                           serv.run_periodic_tasks,
                           None, raise_on_error=True)
 
diff --git a/tests/unit/test_policy.py b/tests/unit/test_policy.py
index cc2afe7..143f56c 100644
--- a/tests/unit/test_policy.py
+++ b/tests/unit/test_policy.py
@@ -200,13 +200,13 @@ class EnforcerTest(PolicyBaseTestCase):
     def test_enforcer_overwrite_rules(self):
         self.enforcer.set_rules({'test': 'test'})
         self.enforcer.set_rules({'test': 'test1'}, overwrite=True)
-        self.assertEquals(self.enforcer.rules, {'test': 'test1'})
+        self.assertEqual(self.enforcer.rules, {'test': 'test1'})
 
     def test_enforcer_update_rules(self):
         self.enforcer.set_rules({'test': 'test'})
         self.enforcer.set_rules({'test1': 'test1'}, overwrite=False)
-        self.assertEquals(self.enforcer.rules, {'test': 'test',
-                                                'test1': 'test1'})
+        self.assertEqual(self.enforcer.rules, {'test': 'test',
+                                               'test1': 'test1'})
 
     def test_get_policy_path_raises_exc(self):
         enforcer = policy.Enforcer(policy_file='raise_error.json')
diff --git a/tests/unit/test_processutils.py b/tests/unit/test_processutils.py
index 032c7f6..0f9289c 100644
--- a/tests/unit/test_processutils.py
+++ b/tests/unit/test_processutils.py
@@ -127,8 +127,7 @@ exit 1
                                                           'always get passed '
                                                           'correctly')
             runs = int(runs.strip())
-            self.assertEquals(runs, 10,
-                              'Ran %d times instead of 10.' % (runs,))
+            self.assertEqual(runs, 10, 'Ran %d times instead of 10.' % (runs,))
         finally:
             os.unlink(tmpfilename)
             os.unlink(tmpfilename2)
diff --git a/tests/unit/test_sslutils.py b/tests/unit/test_sslutils.py
index ce9176f..2095d3c 100644
--- a/tests/unit/test_sslutils.py
+++ b/tests/unit/test_sslutils.py
@@ -22,34 +22,33 @@ from openstack.common import test
 
 class SSLUtilsTest(test.BaseTestCase):
     def test_valid_versions(self):
-        self.assertEquals(sslutils.validate_ssl_version("SSLv3"),
-                          ssl.PROTOCOL_SSLv3)
-        self.assertEquals(sslutils.validate_ssl_version("SSLv23"),
-                          ssl.PROTOCOL_SSLv23)
-        self.assertEquals(sslutils.validate_ssl_version("TLSv1"),
-                          ssl.PROTOCOL_TLSv1)
+        self.assertEqual(sslutils.validate_ssl_version("SSLv3"),
+                         ssl.PROTOCOL_SSLv3)
+        self.assertEqual(sslutils.validate_ssl_version("SSLv23"),
+                         ssl.PROTOCOL_SSLv23)
+        self.assertEqual(sslutils.validate_ssl_version("TLSv1"),
+                         ssl.PROTOCOL_TLSv1)
         try:
             protocol = ssl.PROTOCOL_SSLv2
         except AttributeError:
             pass
         else:
-            self.assertEquals(sslutils.validate_ssl_version("SSLv2"),
-                              protocol)
+            self.assertEqual(sslutils.validate_ssl_version("SSLv2"), protocol)
 
     def test_lowercase_valid_versions(self):
-        self.assertEquals(sslutils.validate_ssl_version("sslv3"),
-                          ssl.PROTOCOL_SSLv3)
-        self.assertEquals(sslutils.validate_ssl_version("sslv23"),
-                          ssl.PROTOCOL_SSLv23)
-        self.assertEquals(sslutils.validate_ssl_version("tlsv1"),
-                          ssl.PROTOCOL_TLSv1)
+        self.assertEqual(sslutils.validate_ssl_version("sslv3"),
+                         ssl.PROTOCOL_SSLv3)
+        self.assertEqual(sslutils.validate_ssl_version("sslv23"),
+                         ssl.PROTOCOL_SSLv23)
+        self.assertEqual(sslutils.validate_ssl_version("tlsv1"),
+                         ssl.PROTOCOL_TLSv1)
         try:
             protocol = ssl.PROTOCOL_SSLv2
         except AttributeError:
             pass
         else:
-            self.assertEquals(sslutils.validate_ssl_version("sslv2"),
-                              protocol)
+            self.assertEqual(sslutils.validate_ssl_version("sslv2"),
+                             protocol)
 
     def test_invalid_version(self):
         self.assertRaises(RuntimeError,
diff --git a/tests/unit/test_strutils.py b/tests/unit/test_strutils.py
index 8c5b618..22aafd9 100644
--- a/tests/unit/test_strutils.py
+++ b/tests/unit/test_strutils.py
@@ -188,11 +188,11 @@ class StrUtilsTest(test.BaseTestCase):
         }
         for (in_value, expected_value) in working_examples.items():
             b_value = strutils.to_bytes(in_value)
-            self.assertEquals(expected_value, b_value)
+            self.assertEqual(expected_value, b_value)
             if in_value:
                 in_value = "-" + in_value
                 b_value = strutils.to_bytes(in_value)
-                self.assertEquals(expected_value * -1, b_value)
+                self.assertEqual(expected_value * -1, b_value)
         breaking_examples = [
             'junk1KB', '1023BBBB',
         ]
diff --git a/tests/unit/test_timeutils.py b/tests/unit/test_timeutils.py
index cd6188b..792c0aa 100644
--- a/tests/unit/test_timeutils.py
+++ b/tests/unit/test_timeutils.py
@@ -184,13 +184,13 @@ class TimeUtilsTest(test.BaseTestCase):
 class TestIso8601Time(test.BaseTestCase):
 
     def _instaneous(self, timestamp, yr, mon, day, hr, min, sec, micro):
-        self.assertEquals(timestamp.year, yr)
-        self.assertEquals(timestamp.month, mon)
-        self.assertEquals(timestamp.day, day)
-        self.assertEquals(timestamp.hour, hr)
-        self.assertEquals(timestamp.minute, min)
-        self.assertEquals(timestamp.second, sec)
-        self.assertEquals(timestamp.microsecond, micro)
+        self.assertEqual(timestamp.year, yr)
+        self.assertEqual(timestamp.month, mon)
+        self.assertEqual(timestamp.day, day)
+        self.assertEqual(timestamp.hour, hr)
+        self.assertEqual(timestamp.minute, min)
+        self.assertEqual(timestamp.second, sec)
+        self.assertEqual(timestamp.microsecond, micro)
 
     def _do_test(self, str, yr, mon, day, hr, min, sec, micro, shift):
         DAY_SECONDS = 24 * 60 * 60
@@ -246,26 +246,26 @@ class TestIso8601Time(test.BaseTestCase):
     def test_zulu_roundtrip(self):
         str = '2012-02-14T20:53:07Z'
         zulu = timeutils.parse_isotime(str)
-        self.assertEquals(zulu.tzinfo, iso8601.iso8601.UTC)
-        self.assertEquals(timeutils.isotime(zulu), str)
+        self.assertEqual(zulu.tzinfo, iso8601.iso8601.UTC)
+        self.assertEqual(timeutils.isotime(zulu), str)
 
     def test_east_roundtrip(self):
         str = '2012-02-14T20:53:07-07:00'
         east = timeutils.parse_isotime(str)
-        self.assertEquals(east.tzinfo.tzname(None), '-07:00')
-        self.assertEquals(timeutils.isotime(east), str)
+        self.assertEqual(east.tzinfo.tzname(None), '-07:00')
+        self.assertEqual(timeutils.isotime(east), str)
 
     def test_west_roundtrip(self):
         str = '2012-02-14T20:53:07+11:30'
         west = timeutils.parse_isotime(str)
-        self.assertEquals(west.tzinfo.tzname(None), '+11:30')
-        self.assertEquals(timeutils.isotime(west), str)
+        self.assertEqual(west.tzinfo.tzname(None), '+11:30')
+        self.assertEqual(timeutils.isotime(west), str)
 
     def test_now_roundtrip(self):
         str = timeutils.isotime()
         now = timeutils.parse_isotime(str)
-        self.assertEquals(now.tzinfo, iso8601.iso8601.UTC)
-        self.assertEquals(timeutils.isotime(now), str)
+        self.assertEqual(now.tzinfo, iso8601.iso8601.UTC)
+        self.assertEqual(timeutils.isotime(now), str)
 
     def test_zulu_normalize(self):
         str = '2012-02-14T20:53:07Z'