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
parent
d9692ec5ce
commit
d815bbd4df
|
|
@ -2025,7 +2025,7 @@ class CellsBroadcastMethodsTestCase(test.TestCase):
|
|||
responses = self.src_msg_runner.get_migrations(
|
||||
self.ctxt,
|
||||
None, False, filters)
|
||||
self.assertEquals(2, len(responses))
|
||||
self.assertEqual(2, len(responses))
|
||||
for response in responses:
|
||||
self.assertIn(response.value_or_raise(), [migrations_from_cell1,
|
||||
migrations_from_cell2])
|
||||
|
|
|
|||
|
|
@ -757,8 +757,7 @@ class TestGlanceImageService(test.NoDBTestCase):
|
|||
(service, same_id) = glance.get_remote_image_service(
|
||||
self.context, image_url)
|
||||
self.assertEqual(same_id, image_id)
|
||||
self.assertEqual(service._client.host,
|
||||
'something-less-likely')
|
||||
self.assertEqual(service._client.host, 'something-less-likely')
|
||||
|
||||
|
||||
def _create_failing_glance_client(info):
|
||||
|
|
|
|||
|
|
@ -48,13 +48,13 @@ class SymmetricKeyTestCase(KeyTestCase):
|
|||
super(SymmetricKeyTestCase, self).setUp()
|
||||
|
||||
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):
|
||||
self.assertEquals(self.key.get_format(), 'RAW')
|
||||
self.assertEqual(self.key.get_format(), 'RAW')
|
||||
|
||||
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):
|
||||
self.assertTrue(self.key == self.key)
|
||||
|
|
|
|||
|
|
@ -95,15 +95,15 @@ class AvailabilityZoneTestCases(test.TestCase):
|
|||
# The service is not add into aggregate, so confirm it is default
|
||||
# availability zone.
|
||||
new_service = az.set_availability_zones(self.context, services)[0]
|
||||
self.assertEquals(new_service['availability_zone'],
|
||||
self.default_az)
|
||||
self.assertEqual(new_service['availability_zone'],
|
||||
self.default_az)
|
||||
|
||||
# The service is added into aggregate, confirm return the aggregate
|
||||
# availability zone.
|
||||
self._add_to_aggregate(service, self.agg)
|
||||
new_service = az.set_availability_zones(self.context, services)[0]
|
||||
self.assertEquals(new_service['availability_zone'],
|
||||
self.availability_zone)
|
||||
self.assertEqual(new_service['availability_zone'],
|
||||
self.availability_zone)
|
||||
|
||||
self._destroy_service(service)
|
||||
|
||||
|
|
@ -112,9 +112,9 @@ class AvailabilityZoneTestCases(test.TestCase):
|
|||
service = self._create_service_with_topic('network', self.host)
|
||||
services = db.service_get_all(self.context)
|
||||
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'])
|
||||
self.assertEquals(type(cached_key), str)
|
||||
self.assertEqual(type(cached_key), str)
|
||||
self._destroy_service(service)
|
||||
|
||||
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)
|
||||
services = db.service_get_all(self.context)
|
||||
new_service = az.set_availability_zones(self.context, services)[0]
|
||||
self.assertEquals(new_service['availability_zone'],
|
||||
self.default_in_az)
|
||||
self.assertEqual(new_service['availability_zone'],
|
||||
self.default_in_az)
|
||||
self._destroy_service(service)
|
||||
|
||||
def test_get_host_availability_zone(self):
|
||||
"""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))
|
||||
|
||||
service = self._create_service_with_topic('compute', self.host)
|
||||
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))
|
||||
|
||||
def test_update_host_availability_zone(self):
|
||||
|
|
@ -145,12 +145,12 @@ class AvailabilityZoneTestCases(test.TestCase):
|
|||
az_name = 'az1'
|
||||
agg_az1 = self._create_az('agg-az1', az_name)
|
||||
self._add_to_aggregate(service, agg_az1)
|
||||
self.assertEquals(az_name,
|
||||
self.assertEqual(az_name,
|
||||
az.get_host_availability_zone(self.context, self.host))
|
||||
# Update AZ
|
||||
new_az_name = 'az2'
|
||||
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))
|
||||
|
||||
def test_delete_host_availability_zone(self):
|
||||
|
|
@ -161,11 +161,11 @@ class AvailabilityZoneTestCases(test.TestCase):
|
|||
az_name = 'az1'
|
||||
agg_az1 = self._create_az('agg-az1', az_name)
|
||||
self._add_to_aggregate(service, agg_az1)
|
||||
self.assertEquals(az_name,
|
||||
self.assertEqual(az_name,
|
||||
az.get_host_availability_zone(self.context, self.host))
|
||||
# Delete the AZ via deleting the aggregate
|
||||
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))
|
||||
|
||||
def test_get_availability_zones(self):
|
||||
|
|
@ -206,12 +206,12 @@ class AvailabilityZoneTestCases(test.TestCase):
|
|||
|
||||
zones, not_zones = az.get_availability_zones(self.context)
|
||||
|
||||
self.assertEquals(zones, ['nova-test', 'nova-test2'])
|
||||
self.assertEquals(not_zones, ['nova-test3', 'nova'])
|
||||
self.assertEqual(zones, ['nova-test', 'nova-test2'])
|
||||
self.assertEqual(not_zones, ['nova-test3', 'nova'])
|
||||
|
||||
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):
|
||||
"""Test get right availability zone by given an instance."""
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ class BlockDeviceTestCase(test.NoDBTestCase):
|
|||
def _assert_volume_in_mapping(device_name, true_or_false):
|
||||
in_mapping = block_device.volume_in_mapping(
|
||||
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('sdb', True)
|
||||
|
|
@ -327,7 +327,7 @@ class TestBlockDeviceDict(test.NoDBTestCase):
|
|||
cool_volume_size_bdm['volume_size'] = '42'
|
||||
cool_volume_size_bdm = block_device.BlockDeviceDict(
|
||||
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['volume_size'] = 'some_non_int_string'
|
||||
|
|
@ -338,7 +338,7 @@ class TestBlockDeviceDict(test.NoDBTestCase):
|
|||
truthy_bdm = dict(self.new_mapping[2])
|
||||
truthy_bdm['delete_on_termination'] = '1'
|
||||
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['boot_index'] = 'first'
|
||||
|
|
@ -360,7 +360,7 @@ class TestBlockDeviceDict(test.NoDBTestCase):
|
|||
return [bdm for bdm in bdms if bdm['boot_index'] >= 0]
|
||||
|
||||
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):
|
||||
self.assertThat(new, matchers.IsSubDictOf(expected))
|
||||
|
|
@ -369,19 +369,19 @@ class TestBlockDeviceDict(test.NoDBTestCase):
|
|||
self.legacy_mapping, 'fake_image_ref')
|
||||
image_bdms = _get_image_bdms(new_with_img)
|
||||
boot_bdms = _get_bootable_bdms(new_with_img)
|
||||
self.assertEquals(len(image_bdms), 1)
|
||||
self.assertEquals(len(boot_bdms), 1)
|
||||
self.assertEquals(image_bdms[0]['boot_index'], 0)
|
||||
self.assertEquals(boot_bdms[0]['source_type'], 'image')
|
||||
self.assertEqual(len(image_bdms), 1)
|
||||
self.assertEqual(len(boot_bdms), 1)
|
||||
self.assertEqual(image_bdms[0]['boot_index'], 0)
|
||||
self.assertEqual(boot_bdms[0]['source_type'], 'image')
|
||||
|
||||
new_with_img_and_root = block_device.from_legacy_mapping(
|
||||
self.legacy_mapping, 'fake_image_ref', 'sda1')
|
||||
image_bdms = _get_image_bdms(new_with_img_and_root)
|
||||
boot_bdms = _get_bootable_bdms(new_with_img_and_root)
|
||||
self.assertEquals(len(image_bdms), 0)
|
||||
self.assertEquals(len(boot_bdms), 1)
|
||||
self.assertEquals(boot_bdms[0]['boot_index'], 0)
|
||||
self.assertEquals(boot_bdms[0]['source_type'], 'volume')
|
||||
self.assertEqual(len(image_bdms), 0)
|
||||
self.assertEqual(len(boot_bdms), 1)
|
||||
self.assertEqual(boot_bdms[0]['boot_index'], 0)
|
||||
self.assertEqual(boot_bdms[0]['source_type'], 'volume')
|
||||
|
||||
def test_from_api(self):
|
||||
for api, new in zip(self.api_mapping, self.new_mapping):
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ class CinderTestCase(test.NoDBTestCase):
|
|||
def test_context_with_catalog(self):
|
||||
self.api.get(self.context, '1234')
|
||||
self.assert_called('GET', '/volumes/1234')
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
self.fake_client_factory.client.client.management_url,
|
||||
'http://localhost:8776/v1/project_id')
|
||||
|
||||
|
|
@ -165,7 +165,7 @@ class CinderTestCase(test.NoDBTestCase):
|
|||
)
|
||||
self.api.get(self.context, '1234')
|
||||
self.assert_called('GET', '/volumes/1234')
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
self.fake_client_factory.client.client.management_url,
|
||||
'http://other_host:8776/v1/project_id')
|
||||
|
||||
|
|
@ -185,7 +185,7 @@ class CinderTestCase(test.NoDBTestCase):
|
|||
self.flags(cinder_api_insecure=True)
|
||||
self.api.get(self.context, '1234')
|
||||
self.assert_called('GET', '/volumes/1234')
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
self.fake_client_factory.client.client.verify_cert, False)
|
||||
|
||||
def test_cinder_api_cacert_file(self):
|
||||
|
|
@ -193,7 +193,7 @@ class CinderTestCase(test.NoDBTestCase):
|
|||
self.flags(cinder_ca_certificates_file=cacert)
|
||||
self.api.get(self.context, '1234')
|
||||
self.assert_called('GET', '/volumes/1234')
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
self.fake_client_factory.client.client.verify_cert, cacert)
|
||||
|
||||
def test_cinder_http_retries(self):
|
||||
|
|
@ -201,5 +201,5 @@ class CinderTestCase(test.NoDBTestCase):
|
|||
self.flags(cinder_http_retries=retries)
|
||||
self.api.get(self.context, '1234')
|
||||
self.assert_called('GET', '/volumes/1234')
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
self.fake_client_factory.client.client.retries, retries)
|
||||
|
|
|
|||
|
|
@ -24,28 +24,28 @@ class ContextTestCase(test.NoDBTestCase):
|
|||
ctxt = context.RequestContext('111',
|
||||
'222',
|
||||
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):
|
||||
ctxt = context.RequestContext('111',
|
||||
'222',
|
||||
roles=['administrator'])
|
||||
self.assertEquals(ctxt.is_admin, True)
|
||||
self.assertEqual(ctxt.is_admin, True)
|
||||
|
||||
def test_request_context_sets_is_admin_upcase(self):
|
||||
ctxt = context.RequestContext('111',
|
||||
'222',
|
||||
roles=['Admin', 'weasel'])
|
||||
self.assertEquals(ctxt.is_admin, True)
|
||||
self.assertEqual(ctxt.is_admin, True)
|
||||
|
||||
def test_request_context_read_deleted(self):
|
||||
ctxt = context.RequestContext('111',
|
||||
'222',
|
||||
read_deleted='yes')
|
||||
self.assertEquals(ctxt.read_deleted, 'yes')
|
||||
self.assertEqual(ctxt.read_deleted, 'yes')
|
||||
|
||||
ctxt.read_deleted = 'no'
|
||||
self.assertEquals(ctxt.read_deleted, 'no')
|
||||
self.assertEqual(ctxt.read_deleted, 'no')
|
||||
|
||||
def test_request_context_read_deleted_invalid(self):
|
||||
self.assertRaises(ValueError,
|
||||
|
|
@ -77,15 +77,15 @@ class ContextTestCase(test.NoDBTestCase):
|
|||
|
||||
def test_service_catalog_default(self):
|
||||
ctxt = context.RequestContext('111', '222')
|
||||
self.assertEquals(ctxt.service_catalog, [])
|
||||
self.assertEqual(ctxt.service_catalog, [])
|
||||
|
||||
ctxt = context.RequestContext('111', '222',
|
||||
service_catalog=[])
|
||||
self.assertEquals(ctxt.service_catalog, [])
|
||||
self.assertEqual(ctxt.service_catalog, [])
|
||||
|
||||
ctxt = context.RequestContext('111', '222',
|
||||
service_catalog=None)
|
||||
self.assertEquals(ctxt.service_catalog, [])
|
||||
self.assertEqual(ctxt.service_catalog, [])
|
||||
|
||||
def test_service_catalog_cinder_only(self):
|
||||
service_catalog = [
|
||||
|
|
@ -100,7 +100,7 @@ class ContextTestCase(test.NoDBTestCase):
|
|||
volume_catalog = [{u'type': u'volume', u'name': u'cinder'}]
|
||||
ctxt = context.RequestContext('111', '222',
|
||||
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):
|
||||
warns = []
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ def bad_function_exception(self, context, extra, blah="a", boo="b", zoo=None):
|
|||
class WrapExceptionTestCase(test.NoDBTestCase):
|
||||
def test_wrap_exception_good_return(self):
|
||||
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):
|
||||
notifier = FakeNotifier()
|
||||
|
|
@ -57,9 +57,9 @@ class WrapExceptionTestCase(test.NoDBTestCase):
|
|||
ctxt = context.get_admin_context()
|
||||
self.assertRaises(test.TestingException,
|
||||
wrapped(bad_function_exception), 1, ctxt, 3, zoo=3)
|
||||
self.assertEquals(notifier.provided_event, "bad_function_exception")
|
||||
self.assertEquals(notifier.provided_context, ctxt)
|
||||
self.assertEquals(notifier.provided_payload['args']['extra'], 3)
|
||||
self.assertEqual(notifier.provided_event, "bad_function_exception")
|
||||
self.assertEqual(notifier.provided_context, ctxt)
|
||||
self.assertEqual(notifier.provided_payload['args']['extra'], 3)
|
||||
for key in ['exception', 'args']:
|
||||
self.assertIn(key, notifier.provided_payload.keys())
|
||||
|
||||
|
|
@ -70,55 +70,55 @@ class NovaExceptionTestCase(test.NoDBTestCase):
|
|||
msg_fmt = "default message"
|
||||
|
||||
exc = FakeNovaException()
|
||||
self.assertEquals(unicode(exc), 'default message')
|
||||
self.assertEqual(unicode(exc), 'default message')
|
||||
|
||||
def test_error_msg(self):
|
||||
self.assertEquals(unicode(exception.NovaException('test')),
|
||||
'test')
|
||||
self.assertEqual(unicode(exception.NovaException('test')),
|
||||
'test')
|
||||
|
||||
def test_default_error_msg_with_kwargs(self):
|
||||
class FakeNovaException(exception.NovaException):
|
||||
msg_fmt = "default message: %(code)s"
|
||||
|
||||
exc = FakeNovaException(code=500)
|
||||
self.assertEquals(unicode(exc), 'default message: 500')
|
||||
self.assertEquals(exc.message, 'default message: 500')
|
||||
self.assertEqual(unicode(exc), 'default message: 500')
|
||||
self.assertEqual(exc.message, 'default message: 500')
|
||||
|
||||
def test_error_msg_exception_with_kwargs(self):
|
||||
class FakeNovaException(exception.NovaException):
|
||||
msg_fmt = "default message: %(mispelled_code)s"
|
||||
|
||||
exc = FakeNovaException(code=500, mispelled_code='blah')
|
||||
self.assertEquals(unicode(exc), 'default message: blah')
|
||||
self.assertEquals(exc.message, 'default message: blah')
|
||||
self.assertEqual(unicode(exc), 'default message: blah')
|
||||
self.assertEqual(exc.message, 'default message: blah')
|
||||
|
||||
def test_default_error_code(self):
|
||||
class FakeNovaException(exception.NovaException):
|
||||
code = 404
|
||||
|
||||
exc = FakeNovaException()
|
||||
self.assertEquals(exc.kwargs['code'], 404)
|
||||
self.assertEqual(exc.kwargs['code'], 404)
|
||||
|
||||
def test_error_code_from_kwarg(self):
|
||||
class FakeNovaException(exception.NovaException):
|
||||
code = 500
|
||||
|
||||
exc = FakeNovaException(code=404)
|
||||
self.assertEquals(exc.kwargs['code'], 404)
|
||||
self.assertEqual(exc.kwargs['code'], 404)
|
||||
|
||||
def test_cleanse_dict(self):
|
||||
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 = {}
|
||||
self.assertEquals(exception._cleanse_dict(kwargs), {})
|
||||
self.assertEqual(exception._cleanse_dict(kwargs), {})
|
||||
|
||||
def test_format_message_local(self):
|
||||
class FakeNovaException(exception.NovaException):
|
||||
msg_fmt = "some message"
|
||||
|
||||
exc = FakeNovaException()
|
||||
self.assertEquals(unicode(exc), exc.format_message())
|
||||
self.assertEqual(unicode(exc), exc.format_message())
|
||||
|
||||
def test_format_message_remote(self):
|
||||
class FakeNovaException_Remote(exception.NovaException):
|
||||
|
|
@ -128,8 +128,8 @@ class NovaExceptionTestCase(test.NoDBTestCase):
|
|||
return u"print the whole trace"
|
||||
|
||||
exc = FakeNovaException_Remote()
|
||||
self.assertEquals(unicode(exc), u"print the whole trace")
|
||||
self.assertEquals(exc.format_message(), "some message")
|
||||
self.assertEqual(unicode(exc), u"print the whole trace")
|
||||
self.assertEqual(exc.format_message(), "some message")
|
||||
|
||||
def test_format_message_remote_error(self):
|
||||
class FakeNovaException_Remote(exception.NovaException):
|
||||
|
|
@ -140,7 +140,7 @@ class NovaExceptionTestCase(test.NoDBTestCase):
|
|||
|
||||
self.flags(fatal_exception_format_errors=False)
|
||||
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):
|
||||
class FakeNovaException(exception.NovaException):
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
self.context,
|
||||
self.flavorid)
|
||||
self.assertEquals(self.specs, actual_specs)
|
||||
self.assertEqual(self.specs, actual_specs)
|
||||
|
||||
def test_flavor_extra_specs_delete(self):
|
||||
del self.specs["xpu_model"]
|
||||
|
|
@ -63,7 +63,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
self.context,
|
||||
self.flavorid)
|
||||
self.assertEquals(self.specs, actual_specs)
|
||||
self.assertEqual(self.specs, actual_specs)
|
||||
|
||||
def test_instance_type_extra_specs_update(self):
|
||||
self.specs["cpu_model"] = "Sandy Bridge"
|
||||
|
|
@ -74,7 +74,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
self.context,
|
||||
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):
|
||||
extra_specs = dict(cpu_arch="x86_64")
|
||||
|
|
@ -96,40 +96,40 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
self.context,
|
||||
self.flavorid)
|
||||
self.assertEquals(self.specs, actual_specs)
|
||||
self.assertEqual(self.specs, actual_specs)
|
||||
|
||||
def test_instance_type_get_with_extra_specs(self):
|
||||
instance_type = db.flavor_get(
|
||||
self.context,
|
||||
self.instance_type_id)
|
||||
self.assertEquals(instance_type['extra_specs'],
|
||||
self.specs)
|
||||
self.assertEqual(instance_type['extra_specs'],
|
||||
self.specs)
|
||||
instance_type = db.flavor_get(
|
||||
self.context,
|
||||
5)
|
||||
self.assertEquals(instance_type['extra_specs'], {})
|
||||
self.assertEqual(instance_type['extra_specs'], {})
|
||||
|
||||
def test_instance_type_get_by_name_with_extra_specs(self):
|
||||
instance_type = db.flavor_get_by_name(
|
||||
self.context,
|
||||
"cg1.4xlarge")
|
||||
self.assertEquals(instance_type['extra_specs'],
|
||||
self.specs)
|
||||
self.assertEqual(instance_type['extra_specs'],
|
||||
self.specs)
|
||||
instance_type = db.flavor_get_by_name(
|
||||
self.context,
|
||||
"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):
|
||||
instance_type = db.flavor_get_by_flavor_id(
|
||||
self.context,
|
||||
105)
|
||||
self.assertEquals(instance_type['extra_specs'],
|
||||
self.specs)
|
||||
self.assertEqual(instance_type['extra_specs'],
|
||||
self.specs)
|
||||
instance_type = db.flavor_get_by_flavor_id(
|
||||
self.context,
|
||||
2)
|
||||
self.assertEquals(instance_type['extra_specs'], {})
|
||||
self.assertEqual(instance_type['extra_specs'], {})
|
||||
|
||||
def test_instance_type_get_all(self):
|
||||
types = db.flavor_get_all(self.context)
|
||||
|
|
@ -139,5 +139,5 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
|
|||
name = instance_type['name']
|
||||
name2specs[name] = instance_type['extra_specs']
|
||||
|
||||
self.assertEquals(name2specs['cg1.4xlarge'], self.specs)
|
||||
self.assertEquals(name2specs['m1.small'], {})
|
||||
self.assertEqual(name2specs['cg1.4xlarge'], self.specs)
|
||||
self.assertEqual(name2specs['m1.small'], {})
|
||||
|
|
|
|||
|
|
@ -29,11 +29,11 @@ class IPv6RFC2462TestCase(test.NoDBTestCase):
|
|||
|
||||
def test_to_global(self):
|
||||
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):
|
||||
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):
|
||||
bad_mac = '02:16:3e:33:44:5Z'
|
||||
|
|
@ -64,11 +64,11 @@ class IPv6AccountIdentiferTestCase(test.NoDBTestCase):
|
|||
|
||||
def test_to_global(self):
|
||||
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):
|
||||
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):
|
||||
bad_mac = '02:16:3e:33:44:5X'
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ class NotificationsTestCase(test.TestCase):
|
|||
def test_send_api_fault_disabled(self):
|
||||
self.flags(notify_api_faults=False)
|
||||
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):
|
||||
self.flags(notify_api_faults=True)
|
||||
|
|
@ -102,12 +102,12 @@ class NotificationsTestCase(test.TestCase):
|
|||
|
||||
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]
|
||||
self.assertEquals(n.priority, 'ERROR')
|
||||
self.assertEquals(n.event_type, 'api.fault')
|
||||
self.assertEquals(n.payload['url'], 'http://example.com/foo')
|
||||
self.assertEquals(n.payload['status'], 500)
|
||||
self.assertEqual(n.priority, 'ERROR')
|
||||
self.assertEqual(n.event_type, 'api.fault')
|
||||
self.assertEqual(n.payload['url'], 'http://example.com/foo')
|
||||
self.assertEqual(n.payload['status'], 500)
|
||||
self.assertIsNotNone(n.payload['exception'])
|
||||
|
||||
def test_notif_disabled(self):
|
||||
|
|
@ -128,7 +128,7 @@ class NotificationsTestCase(test.TestCase):
|
|||
verify_states=True)
|
||||
|
||||
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):
|
||||
|
||||
|
|
@ -148,13 +148,13 @@ class NotificationsTestCase(test.TestCase):
|
|||
old_vm_state, new_vm_state, old_task_state, new_task_state,
|
||||
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
|
||||
self.flags(notify_on_state_change="vm_and_task_state")
|
||||
|
||||
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):
|
||||
|
||||
|
|
@ -168,7 +168,7 @@ class NotificationsTestCase(test.TestCase):
|
|||
old_vm_state, new_vm_state, old_task_state, new_task_state,
|
||||
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):
|
||||
|
||||
|
|
@ -178,7 +178,7 @@ class NotificationsTestCase(test.TestCase):
|
|||
self.instance['uuid'], params)
|
||||
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):
|
||||
|
||||
|
|
@ -188,21 +188,21 @@ class NotificationsTestCase(test.TestCase):
|
|||
self.instance['uuid'], params)
|
||||
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):
|
||||
|
||||
notifications.send_update_with_states(self.context, self.instance,
|
||||
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
|
||||
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):
|
||||
|
||||
notifications.send_update_with_states(self.context, self.instance,
|
||||
vm_states.BUILDING, vm_states.ACTIVE, task_states.SPAWNING,
|
||||
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]
|
||||
payload = notif.payload
|
||||
access_ip_v4 = self.instance["access_ip_v4"]
|
||||
|
|
@ -211,15 +211,15 @@ class NotificationsTestCase(test.TestCase):
|
|||
hostname = self.instance["hostname"]
|
||||
node = self.instance["node"]
|
||||
|
||||
self.assertEquals(vm_states.BUILDING, payload["old_state"])
|
||||
self.assertEquals(vm_states.ACTIVE, payload["state"])
|
||||
self.assertEquals(task_states.SPAWNING, payload["old_task_state"])
|
||||
self.assertEquals(task_states.SPAWNING, payload["new_task_state"])
|
||||
self.assertEquals(payload["access_ip_v4"], access_ip_v4)
|
||||
self.assertEquals(payload["access_ip_v6"], access_ip_v6)
|
||||
self.assertEquals(payload["display_name"], display_name)
|
||||
self.assertEquals(payload["hostname"], hostname)
|
||||
self.assertEquals(payload["node"], node)
|
||||
self.assertEqual(vm_states.BUILDING, payload["old_state"])
|
||||
self.assertEqual(vm_states.ACTIVE, payload["state"])
|
||||
self.assertEqual(task_states.SPAWNING, payload["old_task_state"])
|
||||
self.assertEqual(task_states.SPAWNING, payload["new_task_state"])
|
||||
self.assertEqual(payload["access_ip_v4"], access_ip_v4)
|
||||
self.assertEqual(payload["access_ip_v6"], access_ip_v6)
|
||||
self.assertEqual(payload["display_name"], display_name)
|
||||
self.assertEqual(payload["hostname"], hostname)
|
||||
self.assertEqual(payload["node"], node)
|
||||
|
||||
def test_task_update_with_states(self):
|
||||
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,
|
||||
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
|
||||
None, verify_states=True)
|
||||
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS))
|
||||
self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
|
||||
notif = fake_notifier.NOTIFICATIONS[0]
|
||||
payload = notif.payload
|
||||
access_ip_v4 = self.instance["access_ip_v4"]
|
||||
|
|
@ -235,74 +235,74 @@ class NotificationsTestCase(test.TestCase):
|
|||
display_name = self.instance["display_name"]
|
||||
hostname = self.instance["hostname"]
|
||||
|
||||
self.assertEquals(vm_states.BUILDING, payload["old_state"])
|
||||
self.assertEquals(vm_states.BUILDING, payload["state"])
|
||||
self.assertEquals(task_states.SPAWNING, payload["old_task_state"])
|
||||
self.assertEqual(vm_states.BUILDING, payload["old_state"])
|
||||
self.assertEqual(vm_states.BUILDING, payload["state"])
|
||||
self.assertEqual(task_states.SPAWNING, payload["old_task_state"])
|
||||
self.assertIsNone(payload["new_task_state"])
|
||||
self.assertEquals(payload["access_ip_v4"], access_ip_v4)
|
||||
self.assertEquals(payload["access_ip_v6"], access_ip_v6)
|
||||
self.assertEquals(payload["display_name"], display_name)
|
||||
self.assertEquals(payload["hostname"], hostname)
|
||||
self.assertEqual(payload["access_ip_v4"], access_ip_v4)
|
||||
self.assertEqual(payload["access_ip_v6"], access_ip_v6)
|
||||
self.assertEqual(payload["display_name"], display_name)
|
||||
self.assertEqual(payload["hostname"], hostname)
|
||||
|
||||
def test_update_no_service_name(self):
|
||||
notifications.send_update_with_states(self.context, self.instance,
|
||||
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
|
||||
None)
|
||||
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS))
|
||||
self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
|
||||
|
||||
# service name should default to 'compute'
|
||||
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):
|
||||
notifications.send_update_with_states(self.context, self.instance,
|
||||
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
|
||||
None, service="testservice")
|
||||
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS))
|
||||
self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
|
||||
|
||||
# service name should default to 'compute'
|
||||
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):
|
||||
notifications.send_update_with_states(self.context, self.instance,
|
||||
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
|
||||
None, host="someotherhost")
|
||||
self.assertEquals(1, len(fake_notifier.NOTIFICATIONS))
|
||||
self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
|
||||
|
||||
# service name should default to 'compute'
|
||||
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):
|
||||
info = notifications.info_from_instance(self.context, self.instance,
|
||||
self.net_info, None)
|
||||
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):
|
||||
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]
|
||||
payload = notif.payload
|
||||
access_ip_v4 = self.instance["access_ip_v4"]
|
||||
access_ip_v6 = self.instance["access_ip_v6"]
|
||||
|
||||
self.assertEquals(payload["access_ip_v4"], access_ip_v4)
|
||||
self.assertEquals(payload["access_ip_v6"], access_ip_v6)
|
||||
self.assertEqual(payload["access_ip_v4"], access_ip_v4)
|
||||
self.assertEqual(payload["access_ip_v6"], access_ip_v6)
|
||||
|
||||
def test_send_name_update(self):
|
||||
param = {"display_name": "new_display_name"}
|
||||
new_name_inst = self._wrapped_create(params=param)
|
||||
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]
|
||||
payload = notif.payload
|
||||
old_display_name = self.instance["display_name"]
|
||||
new_display_name = new_name_inst["display_name"]
|
||||
|
||||
self.assertEquals(payload["old_display_name"], old_display_name)
|
||||
self.assertEquals(payload["display_name"], new_display_name)
|
||||
self.assertEqual(payload["old_display_name"], old_display_name)
|
||||
self.assertEqual(payload["display_name"], new_display_name)
|
||||
|
||||
def test_send_no_state_change(self):
|
||||
called = [False]
|
||||
|
|
@ -321,4 +321,4 @@ class NotificationsTestCase(test.TestCase):
|
|||
fail_sending)
|
||||
|
||||
notifications.send_update(self.context, self.instance, self.instance)
|
||||
self.assertEquals(0, len(fake_notifier.NOTIFICATIONS))
|
||||
self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
|
||||
|
|
|
|||
|
|
@ -309,7 +309,7 @@ class FlavorCommandsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
context.get_admin_context(),
|
||||
self.instance_type_id)
|
||||
self.assertEquals(empty_specs, actual_specs)
|
||||
self.assertEqual(empty_specs, actual_specs)
|
||||
|
||||
def test_extra_specs_set_unset(self):
|
||||
expected_specs = {'k1': 'v1'}
|
||||
|
|
@ -320,7 +320,7 @@ class FlavorCommandsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
context.get_admin_context(),
|
||||
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._test_extra_specs_empty()
|
||||
|
|
@ -335,13 +335,13 @@ class FlavorCommandsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
context.get_admin_context(),
|
||||
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")
|
||||
actual_specs = db.flavor_extra_specs_get(
|
||||
context.get_admin_context(),
|
||||
self.instance_type_flavorid)
|
||||
self.assertEquals(updated_specs, actual_specs)
|
||||
self.assertEqual(updated_specs, actual_specs)
|
||||
|
||||
self.unset_key(self.instance_type_name, "k1")
|
||||
|
||||
|
|
@ -356,7 +356,7 @@ class FlavorCommandsTestCase(test.TestCase):
|
|||
actual_specs = db.flavor_extra_specs_get(
|
||||
context.get_admin_context(),
|
||||
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, "k3")
|
||||
|
|
@ -378,7 +378,7 @@ class ProjectCommandsTestCase(test.TestCase):
|
|||
sys.stdout = sys.__stdout__
|
||||
result = output.getvalue()
|
||||
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):
|
||||
self.assertEqual(2, self.commands.quota('admin', 'volumes1', '10'))
|
||||
|
|
|
|||
|
|
@ -84,13 +84,13 @@ class S3APITestCase(test.NoDBTestCase):
|
|||
self.conn.get_http_connection = get_http_connection
|
||||
|
||||
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
|
||||
|
||||
def _ensure_one_bucket(self, buckets, name): # pylint: disable=C0111
|
||||
self.assertEquals(len(buckets), 1,
|
||||
"Bucket list didn't have exactly one element in it")
|
||||
self.assertEquals(buckets[0].name, name, "Wrong name")
|
||||
self.assertEqual(len(buckets), 1,
|
||||
"Bucket list didn't have exactly one element in it")
|
||||
self.assertEqual(buckets[0].name, name, "Wrong name")
|
||||
return True
|
||||
|
||||
def test_list_buckets(self):
|
||||
|
|
@ -120,8 +120,8 @@ class S3APITestCase(test.NoDBTestCase):
|
|||
|
||||
# make sure the contents are correct
|
||||
key = bucket.get_key(key_name)
|
||||
self.assertEquals(key.get_contents_as_string(), key_contents,
|
||||
"Bad contents")
|
||||
self.assertEqual(key.get_contents_as_string(), key_contents,
|
||||
"Bad contents")
|
||||
|
||||
# delete the key
|
||||
key.delete()
|
||||
|
|
|
|||
|
|
@ -278,13 +278,13 @@ class GenericUtilsTestCase(test.NoDBTestCase):
|
|||
self.assertFalse(utils.is_valid_ipv6_cidr("127.0.0.1"))
|
||||
|
||||
def test_get_shortened_ipv6(self):
|
||||
self.assertEquals("abcd:ef01:2345:6789:abcd:ef01:c0a8:fefe",
|
||||
utils.get_shortened_ipv6(
|
||||
self.assertEqual("abcd:ef01:2345:6789:abcd:ef01:c0a8:fefe",
|
||||
utils.get_shortened_ipv6(
|
||||
"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"))
|
||||
self.assertEquals("caca::caca:0:babe:201:102",
|
||||
utils.get_shortened_ipv6(
|
||||
self.assertEqual("caca::caca:0:babe:201:102",
|
||||
utils.get_shortened_ipv6(
|
||||
"caca:0000:0000:caca:0000:babe:0201:0102"))
|
||||
self.assertRaises(netaddr.AddrFormatError, utils.get_shortened_ipv6,
|
||||
"127.0.0.1")
|
||||
|
|
@ -292,9 +292,9 @@ class GenericUtilsTestCase(test.NoDBTestCase):
|
|||
"failure")
|
||||
|
||||
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"))
|
||||
self.assertEquals("2600::/64", utils.get_shortened_ipv6_cidr(
|
||||
self.assertEqual("2600::/64", utils.get_shortened_ipv6_cidr(
|
||||
"2600::1/64"))
|
||||
self.assertRaises(netaddr.AddrFormatError,
|
||||
utils.get_shortened_ipv6_cidr,
|
||||
|
|
@ -391,12 +391,12 @@ class AuditPeriodTest(test.NoDBTestCase):
|
|||
|
||||
def test_hour(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='hour')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
hour=7,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
hour=8,
|
||||
day=5,
|
||||
month=3,
|
||||
|
|
@ -404,13 +404,13 @@ class AuditPeriodTest(test.NoDBTestCase):
|
|||
|
||||
def test_hour_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='hour@10')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
minute=10,
|
||||
hour=7,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
minute=10,
|
||||
hour=8,
|
||||
day=5,
|
||||
|
|
@ -419,13 +419,13 @@ class AuditPeriodTest(test.NoDBTestCase):
|
|||
|
||||
def test_hour_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='hour@30')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
minute=30,
|
||||
hour=6,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
minute=30,
|
||||
hour=7,
|
||||
day=5,
|
||||
|
|
@ -434,23 +434,23 @@ class AuditPeriodTest(test.NoDBTestCase):
|
|||
|
||||
def test_day(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='day')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=4,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_day_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='day@6')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
hour=6,
|
||||
day=4,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
hour=6,
|
||||
day=5,
|
||||
month=3,
|
||||
|
|
@ -458,12 +458,12 @@ class AuditPeriodTest(test.NoDBTestCase):
|
|||
|
||||
def test_day_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='day@10')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
hour=10,
|
||||
day=3,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
hour=10,
|
||||
day=4,
|
||||
month=3,
|
||||
|
|
@ -471,66 +471,66 @@ class AuditPeriodTest(test.NoDBTestCase):
|
|||
|
||||
def test_month(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='month')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=2,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_month_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='month@2')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=2,
|
||||
month=2,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=2,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_month_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='month@15')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=15,
|
||||
month=1,
|
||||
year=2012))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=15,
|
||||
month=2,
|
||||
year=2012))
|
||||
|
||||
def test_year(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='year')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=1,
|
||||
year=2011))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=1,
|
||||
year=2012))
|
||||
|
||||
def test_year_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='year@2')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=2,
|
||||
year=2011))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=2,
|
||||
year=2012))
|
||||
|
||||
def test_year_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='year@6')
|
||||
self.assertEquals(begin, datetime.datetime(
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=6,
|
||||
year=2010))
|
||||
self.assertEquals(end, datetime.datetime(
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=6,
|
||||
year=2011))
|
||||
|
|
@ -706,20 +706,20 @@ class StringLengthTestCase(test.NoDBTestCase):
|
|||
|
||||
class ValidateIntegerTestCase(test.NoDBTestCase):
|
||||
def test_valid_inputs(self):
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
utils.validate_integer(42, "answer"), 42)
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
utils.validate_integer("42", "answer"), 42)
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
"7", "lucky", min_value=7, max_value=8), 7)
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
7, "lucky", min_value=6, max_value=7), 7)
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
300, "Spartaaa!!!", min_value=300), 300)
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
"300", "Spartaaa!!!", max_value=300), 300)
|
||||
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ document_root = /tmp
|
|||
self.loader = nova.wsgi.Loader(self.config.name)
|
||||
|
||||
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):
|
||||
self.assertRaises(
|
||||
|
|
@ -80,7 +80,7 @@ document_root = /tmp
|
|||
|
||||
def test_app_found(self):
|
||||
url_parser = self.loader.load_app("test_app")
|
||||
self.assertEquals("/tmp", url_parser.directory)
|
||||
self.assertEqual("/tmp", url_parser.directory)
|
||||
|
||||
def tearDown(self):
|
||||
self.config.close()
|
||||
|
|
@ -92,7 +92,7 @@ class TestWSGIServer(test.NoDBTestCase):
|
|||
|
||||
def test_no_app(self):
|
||||
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):
|
||||
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'
|
||||
'Connection: close\r\nContent-length:4\r\n\r\nPING')
|
||||
response = cli.read(8192)
|
||||
self.assertEquals(response[-4:], "PONG")
|
||||
self.assertEqual(response[-4:], "PONG")
|
||||
|
||||
fake_ssl_server.stop()
|
||||
fake_ssl_server.wait()
|
||||
|
|
@ -188,14 +188,14 @@ class TestWSGIServerWithSSL(test.NoDBTestCase):
|
|||
cli.write('POST / HTTP/1.1\r\nHost: localhost\r\n'
|
||||
'Connection: close\r\nContent-length:4\r\n\r\nPING')
|
||||
response = cli.read(8192)
|
||||
self.assertEquals(response[-4:], "PONG")
|
||||
self.assertEqual(response[-4:], "PONG")
|
||||
|
||||
cli = eventlet.connect(("localhost", fake_server.port))
|
||||
|
||||
cli.sendall('POST / HTTP/1.1\r\nHost: localhost\r\n'
|
||||
'Connection: close\r\nContent-length:4\r\n\r\nPING')
|
||||
response = cli.recv(8192)
|
||||
self.assertEquals(response[-4:], "PONG")
|
||||
self.assertEqual(response[-4:], "PONG")
|
||||
|
||||
fake_ssl_server.stop()
|
||||
fake_ssl_server.wait()
|
||||
|
|
@ -217,7 +217,7 @@ class TestWSGIServerWithSSL(test.NoDBTestCase):
|
|||
server.start()
|
||||
|
||||
response = urllib2.urlopen('https://[::1]:%d/' % server.port)
|
||||
self.assertEquals(greetings, response.read())
|
||||
self.assertEqual(greetings, response.read())
|
||||
|
||||
server.stop()
|
||||
server.wait()
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ class VirtDiskTest(test.NoDBTestCase):
|
|||
|
||||
self.assertIn("/root/.ssh", vfs.handle.files)
|
||||
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.assertEqual(vfs.handle.files["/root/.ssh/authorized_keys"],
|
||||
{'isdir': False,
|
||||
|
|
|
|||
Loading…
Reference in New Issue