openstack
/
nova
Code Issues Proposed changes

Replace assertEquals with assertEqual - tests/etc 

The method assertEquals has been deprecated since python 2.7.
http://docs.python.org/2/library/unittest.html#deprecated-aliases

Also in Python 3, a deprecated warning is raised when using assertEquals
therefore we should use assertEqual instead.

This is part of blueprint assertequal

Change-Id: I5ecb36332b9353b7010a4f977813ff0295738014
This commit is contained in:
Zhongyue Luo 2013-09-05 11:13:42 +08:00
parent d9692ec5ce
commit d815bbd4df
16 changed files with 188 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
nova/tests/cells/test_cells_messaging.py
View File

@ -2025,7 +2025,7 @@ class CellsBroadcastMethodsTestCase(test.TestCase):
responses = self.src_msg_runner.get_migrations( responses = self.src_msg_runner.get_migrations(
self.ctxt, self.ctxt,
None, False, filters) None, False, filters)
self.assertEquals(2, len(responses)) self.assertEqual(2, len(responses))
for response in responses: for response in responses:
self.assertIn(response.value_or_raise(), [migrations_from_cell1, self.assertIn(response.value_or_raise(), [migrations_from_cell1,
migrations_from_cell2]) migrations_from_cell2])

3
nova/tests/image/test_glance.py
View File

@ -757,8 +757,7 @@ class TestGlanceImageService(test.NoDBTestCase):
(service, same_id) = glance.get_remote_image_service( (service, same_id) = glance.get_remote_image_service(
self.context, image_url) self.context, image_url)
self.assertEqual(same_id, image_id) self.assertEqual(same_id, image_id)
self.assertEqual(service._client.host, self.assertEqual(service._client.host, 'something-less-likely')
'something-less-likely')
def _create_failing_glance_client(info): def _create_failing_glance_client(info):

6
nova/tests/keymgr/test_key.py
View File

@ -48,13 +48,13 @@ class SymmetricKeyTestCase(KeyTestCase):
super(SymmetricKeyTestCase, self).setUp() super(SymmetricKeyTestCase, self).setUp()
def test_get_algorithm(self): def test_get_algorithm(self):
self.assertEquals(self.key.get_algorithm(), self.algorithm) self.assertEqual(self.key.get_algorithm(), self.algorithm)
def test_get_format(self): def test_get_format(self):
self.assertEquals(self.key.get_format(), 'RAW') self.assertEqual(self.key.get_format(), 'RAW')
def test_get_encoded(self): def test_get_encoded(self):
self.assertEquals(self.key.get_encoded(), self.encoded) self.assertEqual(self.key.get_encoded(), self.encoded)
def test___eq__(self): def test___eq__(self):
self.assertTrue(self.key == self.key) self.assertTrue(self.key == self.key)

34
nova/tests/test_availability_zones.py
View File

@ -95,15 +95,15 @@ class AvailabilityZoneTestCases(test.TestCase):
# The service is not add into aggregate, so confirm it is default # The service is not add into aggregate, so confirm it is default
# availability zone. # availability zone.
new_service = az.set_availability_zones(self.context, services)[0] new_service = az.set_availability_zones(self.context, services)[0]
self.assertEquals(new_service['availability_zone'], self.assertEqual(new_service['availability_zone'],
self.default_az) self.default_az)
# The service is added into aggregate, confirm return the aggregate # The service is added into aggregate, confirm return the aggregate
# availability zone. # availability zone.
self._add_to_aggregate(service, self.agg) self._add_to_aggregate(service, self.agg)
new_service = az.set_availability_zones(self.context, services)[0] new_service = az.set_availability_zones(self.context, services)[0]
self.assertEquals(new_service['availability_zone'], self.assertEqual(new_service['availability_zone'],
self.availability_zone) self.availability_zone)
self._destroy_service(service) self._destroy_service(service)
@ -112,9 +112,9 @@ class AvailabilityZoneTestCases(test.TestCase):
service = self._create_service_with_topic('network', self.host) service = self._create_service_with_topic('network', self.host)
services = db.service_get_all(self.context) services = db.service_get_all(self.context)
new_service = az.set_availability_zones(self.context, services)[0] new_service = az.set_availability_zones(self.context, services)[0]
self.assertEquals(type(services[0]['host']), unicode) self.assertEqual(type(services[0]['host']), unicode)
cached_key = az._make_cache_key(services[0]['host']) cached_key = az._make_cache_key(services[0]['host'])
self.assertEquals(type(cached_key), str) self.assertEqual(type(cached_key), str)
self._destroy_service(service) self._destroy_service(service)
def test_set_availability_zone_not_compute_service(self): def test_set_availability_zone_not_compute_service(self):
@ -122,19 +122,19 @@ class AvailabilityZoneTestCases(test.TestCase):
service = self._create_service_with_topic('network', self.host) service = self._create_service_with_topic('network', self.host)
services = db.service_get_all(self.context) services = db.service_get_all(self.context)
new_service = az.set_availability_zones(self.context, services)[0] new_service = az.set_availability_zones(self.context, services)[0]
self.assertEquals(new_service['availability_zone'], self.assertEqual(new_service['availability_zone'],
self.default_in_az) self.default_in_az)
self._destroy_service(service) self._destroy_service(service)
def test_get_host_availability_zone(self): def test_get_host_availability_zone(self):
"""Test get right availability zone by given host.""" """Test get right availability zone by given host."""
self.assertEquals(self.default_az, self.assertEqual(self.default_az,
az.get_host_availability_zone(self.context, self.host)) az.get_host_availability_zone(self.context, self.host))
service = self._create_service_with_topic('compute', self.host) service = self._create_service_with_topic('compute', self.host)
self._add_to_aggregate(service, self.agg) self._add_to_aggregate(service, self.agg)
self.assertEquals(self.availability_zone, self.assertEqual(self.availability_zone,
az.get_host_availability_zone(self.context, self.host)) az.get_host_availability_zone(self.context, self.host))
def test_update_host_availability_zone(self): def test_update_host_availability_zone(self):
@ -145,12 +145,12 @@ class AvailabilityZoneTestCases(test.TestCase):
az_name = 'az1' az_name = 'az1'
agg_az1 = self._create_az('agg-az1', az_name) agg_az1 = self._create_az('agg-az1', az_name)
self._add_to_aggregate(service, agg_az1) self._add_to_aggregate(service, agg_az1)
self.assertEquals(az_name, self.assertEqual(az_name,
az.get_host_availability_zone(self.context, self.host)) az.get_host_availability_zone(self.context, self.host))
# Update AZ # Update AZ
new_az_name = 'az2' new_az_name = 'az2'
self._update_az(agg_az1, new_az_name) self._update_az(agg_az1, new_az_name)
self.assertEquals(new_az_name, self.assertEqual(new_az_name,
az.get_host_availability_zone(self.context, self.host)) az.get_host_availability_zone(self.context, self.host))
def test_delete_host_availability_zone(self): def test_delete_host_availability_zone(self):
@ -161,11 +161,11 @@ class AvailabilityZoneTestCases(test.TestCase):
az_name = 'az1' az_name = 'az1'
agg_az1 = self._create_az('agg-az1', az_name) agg_az1 = self._create_az('agg-az1', az_name)
self._add_to_aggregate(service, agg_az1) self._add_to_aggregate(service, agg_az1)
self.assertEquals(az_name, self.assertEqual(az_name,
az.get_host_availability_zone(self.context, self.host)) az.get_host_availability_zone(self.context, self.host))
# Delete the AZ via deleting the aggregate # Delete the AZ via deleting the aggregate
self._delete_from_aggregate(service, agg_az1) self._delete_from_aggregate(service, agg_az1)
self.assertEquals(self.default_az, self.assertEqual(self.default_az,
az.get_host_availability_zone(self.context, self.host)) az.get_host_availability_zone(self.context, self.host))
def test_get_availability_zones(self): def test_get_availability_zones(self):
@ -206,12 +206,12 @@ class AvailabilityZoneTestCases(test.TestCase):
zones, not_zones = az.get_availability_zones(self.context) zones, not_zones = az.get_availability_zones(self.context)
self.assertEquals(zones, ['nova-test', 'nova-test2']) self.assertEqual(zones, ['nova-test', 'nova-test2'])
self.assertEquals(not_zones, ['nova-test3', 'nova']) self.assertEqual(not_zones, ['nova-test3', 'nova'])
zones = az.get_availability_zones(self.context, True) zones = az.get_availability_zones(self.context, True)
self.assertEquals(zones, ['nova-test', 'nova-test2']) self.assertEqual(zones, ['nova-test', 'nova-test2'])
def test_get_instance_availability_zone_default_value(self): def test_get_instance_availability_zone_default_value(self):
"""Test get right availability zone by given an instance.""" """Test get right availability zone by given an instance."""

24
nova/tests/test_block_device.py
View File

@ -118,7 +118,7 @@ class BlockDeviceTestCase(test.NoDBTestCase):
def _assert_volume_in_mapping(device_name, true_or_false): def _assert_volume_in_mapping(device_name, true_or_false):
in_mapping = block_device.volume_in_mapping( in_mapping = block_device.volume_in_mapping(
device_name, block_device_info) device_name, block_device_info)
self.assertEquals(in_mapping, true_or_false) self.assertEqual(in_mapping, true_or_false)
_assert_volume_in_mapping('sda', False) _assert_volume_in_mapping('sda', False)
_assert_volume_in_mapping('sdb', True) _assert_volume_in_mapping('sdb', True)
@ -327,7 +327,7 @@ class TestBlockDeviceDict(test.NoDBTestCase):
cool_volume_size_bdm['volume_size'] = '42' cool_volume_size_bdm['volume_size'] = '42'
cool_volume_size_bdm = block_device.BlockDeviceDict( cool_volume_size_bdm = block_device.BlockDeviceDict(
cool_volume_size_bdm) cool_volume_size_bdm)
self.assertEquals(cool_volume_size_bdm['volume_size'], 42) self.assertEqual(cool_volume_size_bdm['volume_size'], 42)
lame_volume_size_bdm = dict(self.new_mapping[2]) lame_volume_size_bdm = dict(self.new_mapping[2])
lame_volume_size_bdm['volume_size'] = 'some_non_int_string' lame_volume_size_bdm['volume_size'] = 'some_non_int_string'
@ -338,7 +338,7 @@ class TestBlockDeviceDict(test.NoDBTestCase):
truthy_bdm = dict(self.new_mapping[2]) truthy_bdm = dict(self.new_mapping[2])
truthy_bdm['delete_on_termination'] = '1' truthy_bdm['delete_on_termination'] = '1'
truthy_bdm = block_device.BlockDeviceDict(truthy_bdm) truthy_bdm = block_device.BlockDeviceDict(truthy_bdm)
self.assertEquals(truthy_bdm['delete_on_termination'], True) self.assertEqual(truthy_bdm['delete_on_termination'], True)
verbose_bdm = dict(self.new_mapping[2]) verbose_bdm = dict(self.new_mapping[2])
verbose_bdm['boot_index'] = 'first' verbose_bdm['boot_index'] = 'first'
@ -360,7 +360,7 @@ class TestBlockDeviceDict(test.NoDBTestCase):
return [bdm for bdm in bdms if bdm['boot_index'] >= 0] return [bdm for bdm in bdms if bdm['boot_index'] >= 0]
new_no_img = block_device.from_legacy_mapping(self.legacy_mapping) new_no_img = block_device.from_legacy_mapping(self.legacy_mapping)
self.assertEquals(len(_get_image_bdms(new_no_img)), 0) self.assertEqual(len(_get_image_bdms(new_no_img)), 0)
for new, expected in zip(new_no_img, self.new_mapping): for new, expected in zip(new_no_img, self.new_mapping):
self.assertThat(new, matchers.IsSubDictOf(expected)) self.assertThat(new, matchers.IsSubDictOf(expected))
@ -369,19 +369,19 @@ class TestBlockDeviceDict(test.NoDBTestCase):
self.legacy_mapping, 'fake_image_ref') self.legacy_mapping, 'fake_image_ref')
image_bdms = _get_image_bdms(new_with_img) image_bdms = _get_image_bdms(new_with_img)
boot_bdms = _get_bootable_bdms(new_with_img) boot_bdms = _get_bootable_bdms(new_with_img)
self.assertEquals(len(image_bdms), 1) self.assertEqual(len(image_bdms), 1)
self.assertEquals(len(boot_bdms), 1) self.assertEqual(len(boot_bdms), 1)
self.assertEquals(image_bdms[0]['boot_index'], 0) self.assertEqual(image_bdms[0]['boot_index'], 0)
self.assertEquals(boot_bdms[0]['source_type'], 'image') self.assertEqual(boot_bdms[0]['source_type'], 'image')
new_with_img_and_root = block_device.from_legacy_mapping( new_with_img_and_root = block_device.from_legacy_mapping(
self.legacy_mapping, 'fake_image_ref', 'sda1') self.legacy_mapping, 'fake_image_ref', 'sda1')
image_bdms = _get_image_bdms(new_with_img_and_root) image_bdms = _get_image_bdms(new_with_img_and_root)
boot_bdms = _get_bootable_bdms(new_with_img_and_root) boot_bdms = _get_bootable_bdms(new_with_img_and_root)
self.assertEquals(len(image_bdms), 0) self.assertEqual(len(image_bdms), 0)
self.assertEquals(len(boot_bdms), 1) self.assertEqual(len(boot_bdms), 1)
self.assertEquals(boot_bdms[0]['boot_index'], 0) self.assertEqual(boot_bdms[0]['boot_index'], 0)
self.assertEquals(boot_bdms[0]['source_type'], 'volume') self.assertEqual(boot_bdms[0]['source_type'], 'volume')
def test_from_api(self): def test_from_api(self):
for api, new in zip(self.api_mapping, self.new_mapping): for api, new in zip(self.api_mapping, self.new_mapping):

10
nova/tests/test_cinder.py
View File

@ -155,7 +155,7 @@ class CinderTestCase(test.NoDBTestCase):
def test_context_with_catalog(self): def test_context_with_catalog(self):
self.api.get(self.context, '1234') self.api.get(self.context, '1234')
self.assert_called('GET', '/volumes/1234') self.assert_called('GET', '/volumes/1234')
self.assertEquals( self.assertEqual(
self.fake_client_factory.client.client.management_url, self.fake_client_factory.client.client.management_url,
'http://localhost:8776/v1/project_id') 'http://localhost:8776/v1/project_id')
@ -165,7 +165,7 @@ class CinderTestCase(test.NoDBTestCase):
) )
self.api.get(self.context, '1234') self.api.get(self.context, '1234')
self.assert_called('GET', '/volumes/1234') self.assert_called('GET', '/volumes/1234')
self.assertEquals( self.assertEqual(
self.fake_client_factory.client.client.management_url, self.fake_client_factory.client.client.management_url,
'http://other_host:8776/v1/project_id') 'http://other_host:8776/v1/project_id')
@ -185,7 +185,7 @@ class CinderTestCase(test.NoDBTestCase):
self.flags(cinder_api_insecure=True) self.flags(cinder_api_insecure=True)
self.api.get(self.context, '1234') self.api.get(self.context, '1234')
self.assert_called('GET', '/volumes/1234') self.assert_called('GET', '/volumes/1234')
self.assertEquals( self.assertEqual(
self.fake_client_factory.client.client.verify_cert, False) self.fake_client_factory.client.client.verify_cert, False)
def test_cinder_api_cacert_file(self): def test_cinder_api_cacert_file(self):
@ -193,7 +193,7 @@ class CinderTestCase(test.NoDBTestCase):
self.flags(cinder_ca_certificates_file=cacert) self.flags(cinder_ca_certificates_file=cacert)
self.api.get(self.context, '1234') self.api.get(self.context, '1234')
self.assert_called('GET', '/volumes/1234') self.assert_called('GET', '/volumes/1234')
self.assertEquals( self.assertEqual(
self.fake_client_factory.client.client.verify_cert, cacert) self.fake_client_factory.client.client.verify_cert, cacert)
def test_cinder_http_retries(self): def test_cinder_http_retries(self):
@ -201,5 +201,5 @@ class CinderTestCase(test.NoDBTestCase):
self.flags(cinder_http_retries=retries) self.flags(cinder_http_retries=retries)
self.api.get(self.context, '1234') self.api.get(self.context, '1234')
self.assert_called('GET', '/volumes/1234') self.assert_called('GET', '/volumes/1234')
self.assertEquals( self.assertEqual(
self.fake_client_factory.client.client.retries, retries) self.fake_client_factory.client.client.retries, retries)

18
nova/tests/test_context.py
View File

@ -24,28 +24,28 @@ class ContextTestCase(test.NoDBTestCase):
ctxt = context.RequestContext('111', ctxt = context.RequestContext('111',
'222', '222',
roles=['admin', 'weasel']) roles=['admin', 'weasel'])
self.assertEquals(ctxt.is_admin, True) self.assertEqual(ctxt.is_admin, True)
def test_request_context_sets_is_admin_by_role(self): def test_request_context_sets_is_admin_by_role(self):
ctxt = context.RequestContext('111', ctxt = context.RequestContext('111',
'222', '222',
roles=['administrator']) roles=['administrator'])
self.assertEquals(ctxt.is_admin, True) self.assertEqual(ctxt.is_admin, True)
def test_request_context_sets_is_admin_upcase(self): def test_request_context_sets_is_admin_upcase(self):
ctxt = context.RequestContext('111', ctxt = context.RequestContext('111',
'222', '222',
roles=['Admin', 'weasel']) roles=['Admin', 'weasel'])
self.assertEquals(ctxt.is_admin, True) self.assertEqual(ctxt.is_admin, True)
def test_request_context_read_deleted(self): def test_request_context_read_deleted(self):
ctxt = context.RequestContext('111', ctxt = context.RequestContext('111',
'222', '222',
read_deleted='yes') read_deleted='yes')
self.assertEquals(ctxt.read_deleted, 'yes') self.assertEqual(ctxt.read_deleted, 'yes')
ctxt.read_deleted = 'no' ctxt.read_deleted = 'no'
self.assertEquals(ctxt.read_deleted, 'no') self.assertEqual(ctxt.read_deleted, 'no')
def test_request_context_read_deleted_invalid(self): def test_request_context_read_deleted_invalid(self):
self.assertRaises(ValueError, self.assertRaises(ValueError,
@ -77,15 +77,15 @@ class ContextTestCase(test.NoDBTestCase):
def test_service_catalog_default(self): def test_service_catalog_default(self):
ctxt = context.RequestContext('111', '222') ctxt = context.RequestContext('111', '222')
self.assertEquals(ctxt.service_catalog, []) self.assertEqual(ctxt.service_catalog, [])
ctxt = context.RequestContext('111', '222', ctxt = context.RequestContext('111', '222',
service_catalog=[]) service_catalog=[])
self.assertEquals(ctxt.service_catalog, []) self.assertEqual(ctxt.service_catalog, [])
ctxt = context.RequestContext('111', '222', ctxt = context.RequestContext('111', '222',
service_catalog=None) service_catalog=None)
self.assertEquals(ctxt.service_catalog, []) self.assertEqual(ctxt.service_catalog, [])
def test_service_catalog_cinder_only(self): def test_service_catalog_cinder_only(self):
service_catalog = [ service_catalog = [
@ -100,7 +100,7 @@ class ContextTestCase(test.NoDBTestCase):
volume_catalog = [{u'type': u'volume', u'name': u'cinder'}] volume_catalog = [{u'type': u'volume', u'name': u'cinder'}]
ctxt = context.RequestContext('111', '222', ctxt = context.RequestContext('111', '222',
service_catalog=service_catalog) service_catalog=service_catalog)
self.assertEquals(ctxt.service_catalog, volume_catalog) self.assertEqual(ctxt.service_catalog, volume_catalog)
def test_to_dict_from_dict_no_log(self): def test_to_dict_from_dict_no_log(self):
warns = [] warns = []

38
nova/tests/test_exception.py
View File

@ -49,7 +49,7 @@ def bad_function_exception(self, context, extra, blah="a", boo="b", zoo=None):
class WrapExceptionTestCase(test.NoDBTestCase): class WrapExceptionTestCase(test.NoDBTestCase):
def test_wrap_exception_good_return(self): def test_wrap_exception_good_return(self):
wrapped = exception.wrap_exception('foo') wrapped = exception.wrap_exception('foo')
self.assertEquals(99, wrapped(good_function)(1, 2)) self.assertEqual(99, wrapped(good_function)(1, 2))
def test_wrap_exception_with_notifier(self): def test_wrap_exception_with_notifier(self):
notifier = FakeNotifier() notifier = FakeNotifier()
@ -57,9 +57,9 @@ class WrapExceptionTestCase(test.NoDBTestCase):
ctxt = context.get_admin_context() ctxt = context.get_admin_context()
self.assertRaises(test.TestingException, self.assertRaises(test.TestingException,
wrapped(bad_function_exception), 1, ctxt, 3, zoo=3) wrapped(bad_function_exception), 1, ctxt, 3, zoo=3)
self.assertEquals(notifier.provided_event, "bad_function_exception") self.assertEqual(notifier.provided_event, "bad_function_exception")
self.assertEquals(notifier.provided_context, ctxt) self.assertEqual(notifier.provided_context, ctxt)
self.assertEquals(notifier.provided_payload['args']['extra'], 3) self.assertEqual(notifier.provided_payload['args']['extra'], 3)
for key in ['exception', 'args']: for key in ['exception', 'args']:
self.assertIn(key, notifier.provided_payload.keys()) self.assertIn(key, notifier.provided_payload.keys())
@ -70,55 +70,55 @@ class NovaExceptionTestCase(test.NoDBTestCase):
msg_fmt = "default message" msg_fmt = "default message"
exc = FakeNovaException() exc = FakeNovaException()
self.assertEquals(unicode(exc), 'default message') self.assertEqual(unicode(exc), 'default message')
def test_error_msg(self): def test_error_msg(self):
self.assertEquals(unicode(exception.NovaException('test')), self.assertEqual(unicode(exception.NovaException('test')),
'test') 'test')
def test_default_error_msg_with_kwargs(self): def test_default_error_msg_with_kwargs(self):
class FakeNovaException(exception.NovaException): class FakeNovaException(exception.NovaException):
msg_fmt = "default message: %(code)s" msg_fmt = "default message: %(code)s"
exc = FakeNovaException(code=500) exc = FakeNovaException(code=500)
self.assertEquals(unicode(exc), 'default message: 500') self.assertEqual(unicode(exc), 'default message: 500')
self.assertEquals(exc.message, 'default message: 500') self.assertEqual(exc.message, 'default message: 500')
def test_error_msg_exception_with_kwargs(self): def test_error_msg_exception_with_kwargs(self):
class FakeNovaException(exception.NovaException): class FakeNovaException(exception.NovaException):
msg_fmt = "default message: %(mispelled_code)s" msg_fmt = "default message: %(mispelled_code)s"
exc = FakeNovaException(code=500, mispelled_code='blah') exc = FakeNovaException(code=500, mispelled_code='blah')
self.assertEquals(unicode(exc), 'default message: blah') self.assertEqual(unicode(exc), 'default message: blah')
self.assertEquals(exc.message, 'default message: blah') self.assertEqual(exc.message, 'default message: blah')
def test_default_error_code(self): def test_default_error_code(self):
class FakeNovaException(exception.NovaException): class FakeNovaException(exception.NovaException):
code = 404 code = 404
exc = FakeNovaException() exc = FakeNovaException()
self.assertEquals(exc.kwargs['code'], 404) self.assertEqual(exc.kwargs['code'], 404)
def test_error_code_from_kwarg(self): def test_error_code_from_kwarg(self):
class FakeNovaException(exception.NovaException): class FakeNovaException(exception.NovaException):
code = 500 code = 500
exc = FakeNovaException(code=404) exc = FakeNovaException(code=404)
self.assertEquals(exc.kwargs['code'], 404) self.assertEqual(exc.kwargs['code'], 404)
def test_cleanse_dict(self): def test_cleanse_dict(self):
kwargs = {'foo': 1, 'blah_pass': 2, 'zoo_password': 3, '_pass': 4} kwargs = {'foo': 1, 'blah_pass': 2, 'zoo_password': 3, '_pass': 4}
self.assertEquals(exception._cleanse_dict(kwargs), {'foo': 1}) self.assertEqual(exception._cleanse_dict(kwargs), {'foo': 1})
kwargs = {} kwargs = {}
self.assertEquals(exception._cleanse_dict(kwargs), {}) self.assertEqual(exception._cleanse_dict(kwargs), {})
def test_format_message_local(self): def test_format_message_local(self):
class FakeNovaException(exception.NovaException): class FakeNovaException(exception.NovaException):
msg_fmt = "some message" msg_fmt = "some message"
exc = FakeNovaException() exc = FakeNovaException()
self.assertEquals(unicode(exc), exc.format_message()) self.assertEqual(unicode(exc), exc.format_message())
def test_format_message_remote(self): def test_format_message_remote(self):
class FakeNovaException_Remote(exception.NovaException): class FakeNovaException_Remote(exception.NovaException):
@ -128,8 +128,8 @@ class NovaExceptionTestCase(test.NoDBTestCase):
return u"print the whole trace" return u"print the whole trace"
exc = FakeNovaException_Remote() exc = FakeNovaException_Remote()
self.assertEquals(unicode(exc), u"print the whole trace") self.assertEqual(unicode(exc), u"print the whole trace")
self.assertEquals(exc.format_message(), "some message") self.assertEqual(exc.format_message(), "some message")
def test_format_message_remote_error(self): def test_format_message_remote_error(self):
class FakeNovaException_Remote(exception.NovaException): class FakeNovaException_Remote(exception.NovaException):
@ -140,7 +140,7 @@ class NovaExceptionTestCase(test.NoDBTestCase):
self.flags(fatal_exception_format_errors=False) self.flags(fatal_exception_format_errors=False)
exc = FakeNovaException_Remote(lame_arg='lame') exc = FakeNovaException_Remote(lame_arg='lame')
self.assertEquals(exc.format_message(), "some message %(somearg)s") self.assertEqual(exc.format_message(), "some message %(somearg)s")
def test_format_message_gettext_msg_returned(self): def test_format_message_gettext_msg_returned(self):
class FakeNovaException(exception.NovaException): class FakeNovaException(exception.NovaException):

30
nova/tests/test_instance_types_extra_specs.py
View File

@ -53,7 +53,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
self.context, self.context,
self.flavorid) self.flavorid)
self.assertEquals(self.specs, actual_specs) self.assertEqual(self.specs, actual_specs)
def test_flavor_extra_specs_delete(self): def test_flavor_extra_specs_delete(self):
del self.specs["xpu_model"] del self.specs["xpu_model"]
@ -63,7 +63,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
self.context, self.context,
self.flavorid) self.flavorid)
self.assertEquals(self.specs, actual_specs) self.assertEqual(self.specs, actual_specs)
def test_instance_type_extra_specs_update(self): def test_instance_type_extra_specs_update(self):
self.specs["cpu_model"] = "Sandy Bridge" self.specs["cpu_model"] = "Sandy Bridge"
@ -74,7 +74,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
self.context, self.context,
self.flavorid) self.flavorid)
self.assertEquals(self.specs, actual_specs) self.assertEqual(self.specs, actual_specs)
def test_instance_type_extra_specs_update_with_nonexisting_flavor(self): def test_instance_type_extra_specs_update_with_nonexisting_flavor(self):
extra_specs = dict(cpu_arch="x86_64") extra_specs = dict(cpu_arch="x86_64")
@ -96,40 +96,40 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
self.context, self.context,
self.flavorid) self.flavorid)
self.assertEquals(self.specs, actual_specs) self.assertEqual(self.specs, actual_specs)
def test_instance_type_get_with_extra_specs(self): def test_instance_type_get_with_extra_specs(self):
instance_type = db.flavor_get( instance_type = db.flavor_get(
self.context, self.context,
self.instance_type_id) self.instance_type_id)
self.assertEquals(instance_type['extra_specs'], self.assertEqual(instance_type['extra_specs'],
self.specs) self.specs)
instance_type = db.flavor_get( instance_type = db.flavor_get(
self.context, self.context,
5) 5)
self.assertEquals(instance_type['extra_specs'], {}) self.assertEqual(instance_type['extra_specs'], {})
def test_instance_type_get_by_name_with_extra_specs(self): def test_instance_type_get_by_name_with_extra_specs(self):
instance_type = db.flavor_get_by_name( instance_type = db.flavor_get_by_name(
self.context, self.context,
"cg1.4xlarge") "cg1.4xlarge")
self.assertEquals(instance_type['extra_specs'], self.assertEqual(instance_type['extra_specs'],
self.specs) self.specs)
instance_type = db.flavor_get_by_name( instance_type = db.flavor_get_by_name(
self.context, self.context,
"m1.small") "m1.small")
self.assertEquals(instance_type['extra_specs'], {}) self.assertEqual(instance_type['extra_specs'], {})
def test_instance_type_get_by_flavor_id_with_extra_specs(self): def test_instance_type_get_by_flavor_id_with_extra_specs(self):
instance_type = db.flavor_get_by_flavor_id( instance_type = db.flavor_get_by_flavor_id(
self.context, self.context,
105) 105)
self.assertEquals(instance_type['extra_specs'], self.assertEqual(instance_type['extra_specs'],
self.specs) self.specs)
instance_type = db.flavor_get_by_flavor_id( instance_type = db.flavor_get_by_flavor_id(
self.context, self.context,
2) 2)
self.assertEquals(instance_type['extra_specs'], {}) self.assertEqual(instance_type['extra_specs'], {})
def test_instance_type_get_all(self): def test_instance_type_get_all(self):
types = db.flavor_get_all(self.context) types = db.flavor_get_all(self.context)
@ -139,5 +139,5 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
name = instance_type['name'] name = instance_type['name']
name2specs[name] = instance_type['extra_specs'] name2specs[name] = instance_type['extra_specs']
self.assertEquals(name2specs['cg1.4xlarge'], self.specs) self.assertEqual(name2specs['cg1.4xlarge'], self.specs)
self.assertEquals(name2specs['m1.small'], {}) self.assertEqual(name2specs['m1.small'], {})

8
nova/tests/test_ipv6.py
View File

@ -29,11 +29,11 @@ class IPv6RFC2462TestCase(test.NoDBTestCase):
def test_to_global(self): def test_to_global(self):
addr = ipv6.to_global('2001:db8::', '02:16:3e:33:44:55', 'test') addr = ipv6.to_global('2001:db8::', '02:16:3e:33:44:55', 'test')
self.assertEquals(addr, '2001:db8::16:3eff:fe33:4455') self.assertEqual(addr, '2001:db8::16:3eff:fe33:4455')
def test_to_mac(self): def test_to_mac(self):
mac = ipv6.to_mac('2001:db8::216:3eff:fe33:4455') mac = ipv6.to_mac('2001:db8::216:3eff:fe33:4455')
self.assertEquals(mac, '00:16:3e:33:44:55') self.assertEqual(mac, '00:16:3e:33:44:55')
def test_to_global_with_bad_mac(self): def test_to_global_with_bad_mac(self):
bad_mac = '02:16:3e:33:44:5Z' bad_mac = '02:16:3e:33:44:5Z'
@ -64,11 +64,11 @@ class IPv6AccountIdentiferTestCase(test.NoDBTestCase):
def test_to_global(self): def test_to_global(self):
addr = ipv6.to_global('2001:db8::', '02:16:3e:33:44:55', 'test') addr = ipv6.to_global('2001:db8::', '02:16:3e:33:44:55', 'test')
self.assertEquals(addr, '2001:db8::a94a:8fe5:ff33:4455') self.assertEqual(addr, '2001:db8::a94a:8fe5:ff33:4455')
def test_to_mac(self): def test_to_mac(self):
mac = ipv6.to_mac('2001:db8::a94a:8fe5:ff33:4455') mac = ipv6.to_mac('2001:db8::a94a:8fe5:ff33:4455')
self.assertEquals(mac, '02:16:3e:33:44:55') self.assertEqual(mac, '02:16:3e:33:44:55')
def test_to_global_with_bad_mac(self): def test_to_global_with_bad_mac(self):
bad_mac = '02:16:3e:33:44:5X' bad_mac = '02:16:3e:33:44:5X'

90
nova/tests/test_notifications.py
View File

@ -89,7 +89,7 @@ class NotificationsTestCase(test.TestCase):
def test_send_api_fault_disabled(self): def test_send_api_fault_disabled(self):
self.flags(notify_api_faults=False) self.flags(notify_api_faults=False)
notifications.send_api_fault("http://example.com/foo", 500, None) notifications.send_api_fault("http://example.com/foo", 500, None)
self.assertEquals(0, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
def test_send_api_fault(self): def test_send_api_fault(self):
self.flags(notify_api_faults=True) self.flags(notify_api_faults=True)
@ -102,12 +102,12 @@ class NotificationsTestCase(test.TestCase):
notifications.send_api_fault("http://example.com/foo", 500, exception) notifications.send_api_fault("http://example.com/foo", 500, exception)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
n = fake_notifier.NOTIFICATIONS[0] n = fake_notifier.NOTIFICATIONS[0]
self.assertEquals(n.priority, 'ERROR') self.assertEqual(n.priority, 'ERROR')
self.assertEquals(n.event_type, 'api.fault') self.assertEqual(n.event_type, 'api.fault')
self.assertEquals(n.payload['url'], 'http://example.com/foo') self.assertEqual(n.payload['url'], 'http://example.com/foo')
self.assertEquals(n.payload['status'], 500) self.assertEqual(n.payload['status'], 500)
self.assertIsNotNone(n.payload['exception']) self.assertIsNotNone(n.payload['exception'])
def test_notif_disabled(self): def test_notif_disabled(self):
@ -128,7 +128,7 @@ class NotificationsTestCase(test.TestCase):
verify_states=True) verify_states=True)
notifications.send_update(self.context, old, self.instance) notifications.send_update(self.context, old, self.instance)
self.assertEquals(0, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
def test_task_notif(self): def test_task_notif(self):
@ -148,13 +148,13 @@ class NotificationsTestCase(test.TestCase):
old_vm_state, new_vm_state, old_task_state, new_task_state, old_vm_state, new_vm_state, old_task_state, new_task_state,
verify_states=True) verify_states=True)
self.assertEquals(0, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
# ok now enable task state notifcations and re-try # ok now enable task state notifcations and re-try
self.flags(notify_on_state_change="vm_and_task_state") self.flags(notify_on_state_change="vm_and_task_state")
notifications.send_update(self.context, old, self.instance) notifications.send_update(self.context, old, self.instance)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
def test_send_no_notif(self): def test_send_no_notif(self):
@ -168,7 +168,7 @@ class NotificationsTestCase(test.TestCase):
old_vm_state, new_vm_state, old_task_state, new_task_state, old_vm_state, new_vm_state, old_task_state, new_task_state,
service="compute", host=None, verify_states=True) service="compute", host=None, verify_states=True)
self.assertEquals(0, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
def test_send_on_vm_change(self): def test_send_on_vm_change(self):
@ -178,7 +178,7 @@ class NotificationsTestCase(test.TestCase):
self.instance['uuid'], params) self.instance['uuid'], params)
notifications.send_update(self.context, old_ref, new_ref) notifications.send_update(self.context, old_ref, new_ref)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
def test_send_on_task_change(self): def test_send_on_task_change(self):
@ -188,21 +188,21 @@ class NotificationsTestCase(test.TestCase):
self.instance['uuid'], params) self.instance['uuid'], params)
notifications.send_update(self.context, old_ref, new_ref) notifications.send_update(self.context, old_ref, new_ref)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
def test_no_update_with_states(self): def test_no_update_with_states(self):
notifications.send_update_with_states(self.context, self.instance, notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING, vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
task_states.SPAWNING, verify_states=True) task_states.SPAWNING, verify_states=True)
self.assertEquals(0, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
def test_vm_update_with_states(self): def test_vm_update_with_states(self):
notifications.send_update_with_states(self.context, self.instance, notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.ACTIVE, task_states.SPAWNING, vm_states.BUILDING, vm_states.ACTIVE, task_states.SPAWNING,
task_states.SPAWNING, verify_states=True) task_states.SPAWNING, verify_states=True)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
notif = fake_notifier.NOTIFICATIONS[0] notif = fake_notifier.NOTIFICATIONS[0]
payload = notif.payload payload = notif.payload
access_ip_v4 = self.instance["access_ip_v4"] access_ip_v4 = self.instance["access_ip_v4"]
@ -211,15 +211,15 @@ class NotificationsTestCase(test.TestCase):
hostname = self.instance["hostname"] hostname = self.instance["hostname"]
node = self.instance["node"] node = self.instance["node"]
self.assertEquals(vm_states.BUILDING, payload["old_state"]) self.assertEqual(vm_states.BUILDING, payload["old_state"])
self.assertEquals(vm_states.ACTIVE, payload["state"]) self.assertEqual(vm_states.ACTIVE, payload["state"])
self.assertEquals(task_states.SPAWNING, payload["old_task_state"]) self.assertEqual(task_states.SPAWNING, payload["old_task_state"])
self.assertEquals(task_states.SPAWNING, payload["new_task_state"]) self.assertEqual(task_states.SPAWNING, payload["new_task_state"])
self.assertEquals(payload["access_ip_v4"], access_ip_v4) self.assertEqual(payload["access_ip_v4"], access_ip_v4)
self.assertEquals(payload["access_ip_v6"], access_ip_v6) self.assertEqual(payload["access_ip_v6"], access_ip_v6)
self.assertEquals(payload["display_name"], display_name) self.assertEqual(payload["display_name"], display_name)
self.assertEquals(payload["hostname"], hostname) self.assertEqual(payload["hostname"], hostname)
self.assertEquals(payload["node"], node) self.assertEqual(payload["node"], node)
def test_task_update_with_states(self): def test_task_update_with_states(self):
self.flags(notify_on_state_change="vm_and_task_state") self.flags(notify_on_state_change="vm_and_task_state")
@ -227,7 +227,7 @@ class NotificationsTestCase(test.TestCase):
notifications.send_update_with_states(self.context, self.instance, notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING, vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
None, verify_states=True) None, verify_states=True)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
notif = fake_notifier.NOTIFICATIONS[0] notif = fake_notifier.NOTIFICATIONS[0]
payload = notif.payload payload = notif.payload
access_ip_v4 = self.instance["access_ip_v4"] access_ip_v4 = self.instance["access_ip_v4"]
@ -235,74 +235,74 @@ class NotificationsTestCase(test.TestCase):
display_name = self.instance["display_name"] display_name = self.instance["display_name"]
hostname = self.instance["hostname"] hostname = self.instance["hostname"]
self.assertEquals(vm_states.BUILDING, payload["old_state"]) self.assertEqual(vm_states.BUILDING, payload["old_state"])
self.assertEquals(vm_states.BUILDING, payload["state"]) self.assertEqual(vm_states.BUILDING, payload["state"])
self.assertEquals(task_states.SPAWNING, payload["old_task_state"]) self.assertEqual(task_states.SPAWNING, payload["old_task_state"])
self.assertIsNone(payload["new_task_state"]) self.assertIsNone(payload["new_task_state"])
self.assertEquals(payload["access_ip_v4"], access_ip_v4) self.assertEqual(payload["access_ip_v4"], access_ip_v4)
self.assertEquals(payload["access_ip_v6"], access_ip_v6) self.assertEqual(payload["access_ip_v6"], access_ip_v6)
self.assertEquals(payload["display_name"], display_name) self.assertEqual(payload["display_name"], display_name)
self.assertEquals(payload["hostname"], hostname) self.assertEqual(payload["hostname"], hostname)
def test_update_no_service_name(self): def test_update_no_service_name(self):
notifications.send_update_with_states(self.context, self.instance, notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING, vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
None) None)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
# service name should default to 'compute' # service name should default to 'compute'
notif = fake_notifier.NOTIFICATIONS[0] notif = fake_notifier.NOTIFICATIONS[0]
self.assertEquals('compute.testhost', notif.publisher_id) self.assertEqual('compute.testhost', notif.publisher_id)
def test_update_with_service_name(self): def test_update_with_service_name(self):
notifications.send_update_with_states(self.context, self.instance, notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING, vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
None, service="testservice") None, service="testservice")
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
# service name should default to 'compute' # service name should default to 'compute'
notif = fake_notifier.NOTIFICATIONS[0] notif = fake_notifier.NOTIFICATIONS[0]
self.assertEquals('testservice.testhost', notif.publisher_id) self.assertEqual('testservice.testhost', notif.publisher_id)
def test_update_with_host_name(self): def test_update_with_host_name(self):
notifications.send_update_with_states(self.context, self.instance, notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING, vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
None, host="someotherhost") None, host="someotherhost")
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
# service name should default to 'compute' # service name should default to 'compute'
notif = fake_notifier.NOTIFICATIONS[0] notif = fake_notifier.NOTIFICATIONS[0]
self.assertEquals('compute.someotherhost', notif.publisher_id) self.assertEqual('compute.someotherhost', notif.publisher_id)
def test_payload_has_fixed_ip_labels(self): def test_payload_has_fixed_ip_labels(self):
info = notifications.info_from_instance(self.context, self.instance, info = notifications.info_from_instance(self.context, self.instance,
self.net_info, None) self.net_info, None)
self.assertIn("fixed_ips", info) self.assertIn("fixed_ips", info)
self.assertEquals(info["fixed_ips"][0]["label"], "test1") self.assertEqual(info["fixed_ips"][0]["label"], "test1")
def test_send_access_ip_update(self): def test_send_access_ip_update(self):
notifications.send_update(self.context, self.instance, self.instance) notifications.send_update(self.context, self.instance, self.instance)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
notif = fake_notifier.NOTIFICATIONS[0] notif = fake_notifier.NOTIFICATIONS[0]
payload = notif.payload payload = notif.payload
access_ip_v4 = self.instance["access_ip_v4"] access_ip_v4 = self.instance["access_ip_v4"]
access_ip_v6 = self.instance["access_ip_v6"] access_ip_v6 = self.instance["access_ip_v6"]
self.assertEquals(payload["access_ip_v4"], access_ip_v4) self.assertEqual(payload["access_ip_v4"], access_ip_v4)
self.assertEquals(payload["access_ip_v6"], access_ip_v6) self.assertEqual(payload["access_ip_v6"], access_ip_v6)
def test_send_name_update(self): def test_send_name_update(self):
param = {"display_name": "new_display_name"} param = {"display_name": "new_display_name"}
new_name_inst = self._wrapped_create(params=param) new_name_inst = self._wrapped_create(params=param)
notifications.send_update(self.context, self.instance, new_name_inst) notifications.send_update(self.context, self.instance, new_name_inst)
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
notif = fake_notifier.NOTIFICATIONS[0] notif = fake_notifier.NOTIFICATIONS[0]
payload = notif.payload payload = notif.payload
old_display_name = self.instance["display_name"] old_display_name = self.instance["display_name"]
new_display_name = new_name_inst["display_name"] new_display_name = new_name_inst["display_name"]
self.assertEquals(payload["old_display_name"], old_display_name) self.assertEqual(payload["old_display_name"], old_display_name)
self.assertEquals(payload["display_name"], new_display_name) self.assertEqual(payload["display_name"], new_display_name)
def test_send_no_state_change(self): def test_send_no_state_change(self):
called = [False] called = [False]
@ -321,4 +321,4 @@ class NotificationsTestCase(test.TestCase):
fail_sending) fail_sending)
notifications.send_update(self.context, self.instance, self.instance) notifications.send_update(self.context, self.instance, self.instance)
self.assertEquals(0, len(fake_notifier.NOTIFICATIONS)) self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))

12
nova/tests/test_nova_manage.py
View File

@ -309,7 +309,7 @@ class FlavorCommandsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(), context.get_admin_context(),
self.instance_type_id) self.instance_type_id)
self.assertEquals(empty_specs, actual_specs) self.assertEqual(empty_specs, actual_specs)
def test_extra_specs_set_unset(self): def test_extra_specs_set_unset(self):
expected_specs = {'k1': 'v1'} expected_specs = {'k1': 'v1'}
@ -320,7 +320,7 @@ class FlavorCommandsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(), context.get_admin_context(),
self.instance_type_flavorid) self.instance_type_flavorid)
self.assertEquals(expected_specs, actual_specs) self.assertEqual(expected_specs, actual_specs)
self.unset_key(self.instance_type_name, "k1") self.unset_key(self.instance_type_name, "k1")
self._test_extra_specs_empty() self._test_extra_specs_empty()
@ -335,13 +335,13 @@ class FlavorCommandsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(), context.get_admin_context(),
self.instance_type_flavorid) self.instance_type_flavorid)
self.assertEquals(expected_specs, actual_specs) self.assertEqual(expected_specs, actual_specs)
self.set_key(self.instance_type_name, "k1", "v2") self.set_key(self.instance_type_name, "k1", "v2")
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(), context.get_admin_context(),
self.instance_type_flavorid) self.instance_type_flavorid)
self.assertEquals(updated_specs, actual_specs) self.assertEqual(updated_specs, actual_specs)
self.unset_key(self.instance_type_name, "k1") self.unset_key(self.instance_type_name, "k1")
@ -356,7 +356,7 @@ class FlavorCommandsTestCase(test.TestCase):
actual_specs = db.flavor_extra_specs_get( actual_specs = db.flavor_extra_specs_get(
context.get_admin_context(), context.get_admin_context(),
self.instance_type_flavorid) self.instance_type_flavorid)
self.assertEquals(two_items_extra_specs, actual_specs) self.assertEqual(two_items_extra_specs, actual_specs)
self.unset_key(self.instance_type_name, "k1") self.unset_key(self.instance_type_name, "k1")
self.unset_key(self.instance_type_name, "k3") self.unset_key(self.instance_type_name, "k3")
@ -378,7 +378,7 @@ class ProjectCommandsTestCase(test.TestCase):
sys.stdout = sys.__stdout__ sys.stdout = sys.__stdout__
result = output.getvalue() result = output.getvalue()
print_format = "%-36s %-10s" % ('instances', 'unlimited') print_format = "%-36s %-10s" % ('instances', 'unlimited')
self.assertEquals((print_format in result), True) self.assertEqual((print_format in result), True)
def test_quota_update_invalid_key(self): def test_quota_update_invalid_key(self):
self.assertEqual(2, self.commands.quota('admin', 'volumes1', '10')) self.assertEqual(2, self.commands.quota('admin', 'volumes1', '10'))

12
nova/tests/test_objectstore.py
View File

@ -84,13 +84,13 @@ class S3APITestCase(test.NoDBTestCase):
self.conn.get_http_connection = get_http_connection self.conn.get_http_connection = get_http_connection
def _ensure_no_buckets(self, buckets): # pylint: disable=C0111 def _ensure_no_buckets(self, buckets): # pylint: disable=C0111
self.assertEquals(len(buckets), 0, "Bucket list was not empty") self.assertEqual(len(buckets), 0, "Bucket list was not empty")
return True return True
def _ensure_one_bucket(self, buckets, name): # pylint: disable=C0111 def _ensure_one_bucket(self, buckets, name): # pylint: disable=C0111
self.assertEquals(len(buckets), 1, self.assertEqual(len(buckets), 1,
"Bucket list didn't have exactly one element in it") "Bucket list didn't have exactly one element in it")
self.assertEquals(buckets[0].name, name, "Wrong name") self.assertEqual(buckets[0].name, name, "Wrong name")
return True return True
def test_list_buckets(self): def test_list_buckets(self):
@ -120,8 +120,8 @@ class S3APITestCase(test.NoDBTestCase):
# make sure the contents are correct # make sure the contents are correct
key = bucket.get_key(key_name) key = bucket.get_key(key_name)
self.assertEquals(key.get_contents_as_string(), key_contents, self.assertEqual(key.get_contents_as_string(), key_contents,
"Bad contents") "Bad contents")
# delete the key # delete the key
key.delete() key.delete()

74
nova/tests/test_utils.py
View File

@ -278,13 +278,13 @@ class GenericUtilsTestCase(test.NoDBTestCase):
self.assertFalse(utils.is_valid_ipv6_cidr("127.0.0.1")) self.assertFalse(utils.is_valid_ipv6_cidr("127.0.0.1"))
def test_get_shortened_ipv6(self): def test_get_shortened_ipv6(self):
self.assertEquals("abcd:ef01:2345:6789:abcd:ef01:c0a8:fefe", self.assertEqual("abcd:ef01:2345:6789:abcd:ef01:c0a8:fefe",
utils.get_shortened_ipv6( utils.get_shortened_ipv6(
"abcd:ef01:2345:6789:abcd:ef01:192.168.254.254")) "abcd:ef01:2345:6789:abcd:ef01:192.168.254.254"))
self.assertEquals("::1", utils.get_shortened_ipv6( self.assertEqual("::1", utils.get_shortened_ipv6(
"0000:0000:0000:0000:0000:0000:0000:0001")) "0000:0000:0000:0000:0000:0000:0000:0001"))
self.assertEquals("caca::caca:0:babe:201:102", self.assertEqual("caca::caca:0:babe:201:102",
utils.get_shortened_ipv6( utils.get_shortened_ipv6(
"caca:0000:0000:caca:0000:babe:0201:0102")) "caca:0000:0000:caca:0000:babe:0201:0102"))
self.assertRaises(netaddr.AddrFormatError, utils.get_shortened_ipv6, self.assertRaises(netaddr.AddrFormatError, utils.get_shortened_ipv6,
"127.0.0.1") "127.0.0.1")
@ -292,9 +292,9 @@ class GenericUtilsTestCase(test.NoDBTestCase):
"failure") "failure")
def test_get_shortened_ipv6_cidr(self): def test_get_shortened_ipv6_cidr(self):
self.assertEquals("2600::/64", utils.get_shortened_ipv6_cidr( self.assertEqual("2600::/64", utils.get_shortened_ipv6_cidr(
"2600:0000:0000:0000:0000:0000:0000:0000/64")) "2600:0000:0000:0000:0000:0000:0000:0000/64"))
self.assertEquals("2600::/64", utils.get_shortened_ipv6_cidr( self.assertEqual("2600::/64", utils.get_shortened_ipv6_cidr(
"2600::1/64")) "2600::1/64"))
self.assertRaises(netaddr.AddrFormatError, self.assertRaises(netaddr.AddrFormatError,
utils.get_shortened_ipv6_cidr, utils.get_shortened_ipv6_cidr,
@ -391,12 +391,12 @@ class AuditPeriodTest(test.NoDBTestCase):
def test_hour(self): def test_hour(self):
begin, end = utils.last_completed_audit_period(unit='hour') begin, end = utils.last_completed_audit_period(unit='hour')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
hour=7, hour=7,
day=5, day=5,
month=3, month=3,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
hour=8, hour=8,
day=5, day=5,
month=3, month=3,
@ -404,13 +404,13 @@ class AuditPeriodTest(test.NoDBTestCase):
def test_hour_with_offset_before_current(self): def test_hour_with_offset_before_current(self):
begin, end = utils.last_completed_audit_period(unit='hour@10') begin, end = utils.last_completed_audit_period(unit='hour@10')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
minute=10, minute=10,
hour=7, hour=7,
day=5, day=5,
month=3, month=3,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
minute=10, minute=10,
hour=8, hour=8,
day=5, day=5,
@ -419,13 +419,13 @@ class AuditPeriodTest(test.NoDBTestCase):
def test_hour_with_offset_after_current(self): def test_hour_with_offset_after_current(self):
begin, end = utils.last_completed_audit_period(unit='hour@30') begin, end = utils.last_completed_audit_period(unit='hour@30')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
minute=30, minute=30,
hour=6, hour=6,
day=5, day=5,
month=3, month=3,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
minute=30, minute=30,
hour=7, hour=7,
day=5, day=5,
@ -434,23 +434,23 @@ class AuditPeriodTest(test.NoDBTestCase):
def test_day(self): def test_day(self):
begin, end = utils.last_completed_audit_period(unit='day') begin, end = utils.last_completed_audit_period(unit='day')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
day=4, day=4,
month=3, month=3,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
day=5, day=5,
month=3, month=3,
year=2012)) year=2012))
def test_day_with_offset_before_current(self): def test_day_with_offset_before_current(self):
begin, end = utils.last_completed_audit_period(unit='day@6') begin, end = utils.last_completed_audit_period(unit='day@6')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
hour=6, hour=6,
day=4, day=4,
month=3, month=3,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
hour=6, hour=6,
day=5, day=5,
month=3, month=3,
@ -458,12 +458,12 @@ class AuditPeriodTest(test.NoDBTestCase):
def test_day_with_offset_after_current(self): def test_day_with_offset_after_current(self):
begin, end = utils.last_completed_audit_period(unit='day@10') begin, end = utils.last_completed_audit_period(unit='day@10')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
hour=10, hour=10,
day=3, day=3,
month=3, month=3,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
hour=10, hour=10,
day=4, day=4,
month=3, month=3,
@ -471,66 +471,66 @@ class AuditPeriodTest(test.NoDBTestCase):
def test_month(self): def test_month(self):
begin, end = utils.last_completed_audit_period(unit='month') begin, end = utils.last_completed_audit_period(unit='month')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
day=1, day=1,
month=2, month=2,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
day=1, day=1,
month=3, month=3,
year=2012)) year=2012))
def test_month_with_offset_before_current(self): def test_month_with_offset_before_current(self):
begin, end = utils.last_completed_audit_period(unit='month@2') begin, end = utils.last_completed_audit_period(unit='month@2')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
day=2, day=2,
month=2, month=2,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
day=2, day=2,
month=3, month=3,
year=2012)) year=2012))
def test_month_with_offset_after_current(self): def test_month_with_offset_after_current(self):
begin, end = utils.last_completed_audit_period(unit='month@15') begin, end = utils.last_completed_audit_period(unit='month@15')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
day=15, day=15,
month=1, month=1,
year=2012)) year=2012))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
day=15, day=15,
month=2, month=2,
year=2012)) year=2012))
def test_year(self): def test_year(self):
begin, end = utils.last_completed_audit_period(unit='year') begin, end = utils.last_completed_audit_period(unit='year')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
day=1, day=1,
month=1, month=1,
year=2011)) year=2011))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
day=1, day=1,
month=1, month=1,
year=2012)) year=2012))
def test_year_with_offset_before_current(self): def test_year_with_offset_before_current(self):
begin, end = utils.last_completed_audit_period(unit='year@2') begin, end = utils.last_completed_audit_period(unit='year@2')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
day=1, day=1,
month=2, month=2,
year=2011)) year=2011))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
day=1, day=1,
month=2, month=2,
year=2012)) year=2012))
def test_year_with_offset_after_current(self): def test_year_with_offset_after_current(self):
begin, end = utils.last_completed_audit_period(unit='year@6') begin, end = utils.last_completed_audit_period(unit='year@6')
self.assertEquals(begin, datetime.datetime( self.assertEqual(begin, datetime.datetime(
day=1, day=1,
month=6, month=6,
year=2010)) year=2010))
self.assertEquals(end, datetime.datetime( self.assertEqual(end, datetime.datetime(
day=1, day=1,
month=6, month=6,
year=2011)) year=2011))
@ -706,20 +706,20 @@ class StringLengthTestCase(test.NoDBTestCase):
class ValidateIntegerTestCase(test.NoDBTestCase): class ValidateIntegerTestCase(test.NoDBTestCase):
def test_valid_inputs(self): def test_valid_inputs(self):
self.assertEquals( self.assertEqual(
utils.validate_integer(42, "answer"), 42) utils.validate_integer(42, "answer"), 42)
self.assertEquals( self.assertEqual(
utils.validate_integer("42", "answer"), 42) utils.validate_integer("42", "answer"), 42)
self.assertEquals( self.assertEqual(
utils.validate_integer( utils.validate_integer(
"7", "lucky", min_value=7, max_value=8), 7) "7", "lucky", min_value=7, max_value=8), 7)
self.assertEquals( self.assertEqual(
utils.validate_integer( utils.validate_integer(
7, "lucky", min_value=6, max_value=7), 7) 7, "lucky", min_value=6, max_value=7), 7)
self.assertEquals( self.assertEqual(
utils.validate_integer( utils.validate_integer(
300, "Spartaaa!!!", min_value=300), 300) 300, "Spartaaa!!!", min_value=300), 300)
self.assertEquals( self.assertEqual(
utils.validate_integer( utils.validate_integer(
"300", "Spartaaa!!!", max_value=300), 300) "300", "Spartaaa!!!", max_value=300), 300)

14
nova/tests/test_wsgi.py
View File

@ -69,7 +69,7 @@ document_root = /tmp
self.loader = nova.wsgi.Loader(self.config.name) self.loader = nova.wsgi.Loader(self.config.name)
def test_config_found(self): def test_config_found(self):
self.assertEquals(self.config.name, self.loader.config_path) self.assertEqual(self.config.name, self.loader.config_path)
def test_app_not_found(self): def test_app_not_found(self):
self.assertRaises( self.assertRaises(
@ -80,7 +80,7 @@ document_root = /tmp
def test_app_found(self): def test_app_found(self):
url_parser = self.loader.load_app("test_app") url_parser = self.loader.load_app("test_app")
self.assertEquals("/tmp", url_parser.directory) self.assertEqual("/tmp", url_parser.directory)
def tearDown(self): def tearDown(self):
self.config.close() self.config.close()
@ -92,7 +92,7 @@ class TestWSGIServer(test.NoDBTestCase):
def test_no_app(self): def test_no_app(self):
server = nova.wsgi.Server("test_app", None) server = nova.wsgi.Server("test_app", None)
self.assertEquals("test_app", server.name) self.assertEqual("test_app", server.name)
def test_start_random_port(self): def test_start_random_port(self):
server = nova.wsgi.Server("test_random_port", None, server = nova.wsgi.Server("test_random_port", None,
@ -160,7 +160,7 @@ class TestWSGIServerWithSSL(test.NoDBTestCase):
cli.write('POST / HTTP/1.1\r\nHost: localhost\r\n' cli.write('POST / HTTP/1.1\r\nHost: localhost\r\n'
'Connection: close\r\nContent-length:4\r\n\r\nPING') 'Connection: close\r\nContent-length:4\r\n\r\nPING')
response = cli.read(8192) response = cli.read(8192)
self.assertEquals(response[-4:], "PONG") self.assertEqual(response[-4:], "PONG")
fake_ssl_server.stop() fake_ssl_server.stop()
fake_ssl_server.wait() fake_ssl_server.wait()
@ -188,14 +188,14 @@ class TestWSGIServerWithSSL(test.NoDBTestCase):
cli.write('POST / HTTP/1.1\r\nHost: localhost\r\n' cli.write('POST / HTTP/1.1\r\nHost: localhost\r\n'
'Connection: close\r\nContent-length:4\r\n\r\nPING') 'Connection: close\r\nContent-length:4\r\n\r\nPING')
response = cli.read(8192) response = cli.read(8192)
self.assertEquals(response[-4:], "PONG") self.assertEqual(response[-4:], "PONG")
cli = eventlet.connect(("localhost", fake_server.port)) cli = eventlet.connect(("localhost", fake_server.port))
cli.sendall('POST / HTTP/1.1\r\nHost: localhost\r\n' cli.sendall('POST / HTTP/1.1\r\nHost: localhost\r\n'
'Connection: close\r\nContent-length:4\r\n\r\nPING') 'Connection: close\r\nContent-length:4\r\n\r\nPING')
response = cli.recv(8192) response = cli.recv(8192)
self.assertEquals(response[-4:], "PONG") self.assertEqual(response[-4:], "PONG")
fake_ssl_server.stop() fake_ssl_server.stop()
fake_ssl_server.wait() fake_ssl_server.wait()
@ -217,7 +217,7 @@ class TestWSGIServerWithSSL(test.NoDBTestCase):
server.start() server.start()
response = urllib2.urlopen('https://[::1]:%d/' % server.port) response = urllib2.urlopen('https://[::1]:%d/' % server.port)
self.assertEquals(greetings, response.read()) self.assertEqual(greetings, response.read())
server.stop() server.stop()
server.wait() server.wait()

2
nova/tests/virt/test_virt_disk.py
View File

@ -77,7 +77,7 @@ class VirtDiskTest(test.NoDBTestCase):
self.assertIn("/root/.ssh", vfs.handle.files) self.assertIn("/root/.ssh", vfs.handle.files)
self.assertEqual(vfs.handle.files["/root/.ssh"], self.assertEqual(vfs.handle.files["/root/.ssh"],
{'isdir': True, 'gid': 0, 'uid': 0, 'mode': 0o700}) {'isdir': True, 'gid': 0, 'uid': 0, 'mode': 0o700})
self.assertIn("/root/.ssh/authorized_keys", vfs.handle.files) self.assertIn("/root/.ssh/authorized_keys", vfs.handle.files)
self.assertEqual(vfs.handle.files["/root/.ssh/authorized_keys"], self.assertEqual(vfs.handle.files["/root/.ssh/authorized_keys"],
{'isdir': False, {'isdir': False,