diff --git a/nova/tests/cells/test_cells_messaging.py b/nova/tests/cells/test_cells_messaging.py index cd880d3c60d7..f80850af6c83 100644 --- a/nova/tests/cells/test_cells_messaging.py +++ b/nova/tests/cells/test_cells_messaging.py @@ -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]) diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py index 3029347ba8a1..ba57a10f61b3 100644 --- a/nova/tests/image/test_glance.py +++ b/nova/tests/image/test_glance.py @@ -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): diff --git a/nova/tests/keymgr/test_key.py b/nova/tests/keymgr/test_key.py index a2fb01527f12..9b95832ab4f8 100644 --- a/nova/tests/keymgr/test_key.py +++ b/nova/tests/keymgr/test_key.py @@ -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) diff --git a/nova/tests/test_availability_zones.py b/nova/tests/test_availability_zones.py index 4bdeb870669d..d0a66b5f1e9f 100644 --- a/nova/tests/test_availability_zones.py +++ b/nova/tests/test_availability_zones.py @@ -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.""" diff --git a/nova/tests/test_block_device.py b/nova/tests/test_block_device.py index 83114d53deb3..77ecbfe2c8c0 100644 --- a/nova/tests/test_block_device.py +++ b/nova/tests/test_block_device.py @@ -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): diff --git a/nova/tests/test_cinder.py b/nova/tests/test_cinder.py index ae1382c69e9b..6e66ccf6cc8d 100644 --- a/nova/tests/test_cinder.py +++ b/nova/tests/test_cinder.py @@ -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) diff --git a/nova/tests/test_context.py b/nova/tests/test_context.py index 5f2d72a63404..df2b41af8d41 100644 --- a/nova/tests/test_context.py +++ b/nova/tests/test_context.py @@ -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 = [] diff --git a/nova/tests/test_exception.py b/nova/tests/test_exception.py index b3d418ae761f..e112efd937b3 100644 --- a/nova/tests/test_exception.py +++ b/nova/tests/test_exception.py @@ -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): diff --git a/nova/tests/test_instance_types_extra_specs.py b/nova/tests/test_instance_types_extra_specs.py index c0f3976beb78..14ab309b4133 100644 --- a/nova/tests/test_instance_types_extra_specs.py +++ b/nova/tests/test_instance_types_extra_specs.py @@ -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'], {}) diff --git a/nova/tests/test_ipv6.py b/nova/tests/test_ipv6.py index 53b7c81ff897..b307fe0caf41 100644 --- a/nova/tests/test_ipv6.py +++ b/nova/tests/test_ipv6.py @@ -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' diff --git a/nova/tests/test_notifications.py b/nova/tests/test_notifications.py index 44562b9177b7..ad4481f62d8d 100644 --- a/nova/tests/test_notifications.py +++ b/nova/tests/test_notifications.py @@ -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)) diff --git a/nova/tests/test_nova_manage.py b/nova/tests/test_nova_manage.py index a7f9b2c099b6..555fb932c076 100644 --- a/nova/tests/test_nova_manage.py +++ b/nova/tests/test_nova_manage.py @@ -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')) diff --git a/nova/tests/test_objectstore.py b/nova/tests/test_objectstore.py index bd204004dd28..5e01247b4e7c 100644 --- a/nova/tests/test_objectstore.py +++ b/nova/tests/test_objectstore.py @@ -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() diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py index 4112a53be76f..08c3d945560c 100644 --- a/nova/tests/test_utils.py +++ b/nova/tests/test_utils.py @@ -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) diff --git a/nova/tests/test_wsgi.py b/nova/tests/test_wsgi.py index c1f313e30d0c..ddda074b0f5a 100644 --- a/nova/tests/test_wsgi.py +++ b/nova/tests/test_wsgi.py @@ -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() diff --git a/nova/tests/virt/test_virt_disk.py b/nova/tests/virt/test_virt_disk.py index 28887a8dcf0c..0edf37787573 100644 --- a/nova/tests/virt/test_virt_disk.py +++ b/nova/tests/virt/test_virt_disk.py @@ -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,