openstack
/
nova
Code Issues Proposed changes

Utilizes assertIn - tests/etc 

Using assertTrue and the 'in' operator to test
if an element is in a sequence is too python2.4.
Our unit testing framework supports assertIn,
which was created for these types of tests.
Adapting assertIn will enhance the readability
of the test scripts.

Change-Id: Ib44d57e75238691234c5290d13c54c526a6ae64b
This commit is contained in:
Zhongyue Luo 2013-10-12 11:34:55 +08:00
parent 8d8798efff
commit 184dfaaaa8
24 changed files with 151 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
nova/tests/compute/test_compute.py
View File

@ -1731,13 +1731,13 @@ class ComputeTestCase(BaseTestCase):
self.assertEquals(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id']
self.assertEquals(str(payload['instance_type_id']), str(type_id))
self.assertTrue('display_name' in payload)
self.assertTrue('created_at' in payload)
self.assertTrue('launched_at' in payload)
self.assertIn('display_name', payload)
self.assertIn('created_at', payload)
self.assertIn('launched_at', payload)
image_ref_url = glance.generate_image_url(FAKE_IMAGE_REF)
self.assertEquals(payload['image_ref_url'], image_ref_url)
msg = fake_notifier.NOTIFICATIONS[1]
self.assertTrue('rescue_image_name' in msg.payload)
self.assertIn('rescue_image_name', msg.payload)
self.compute.terminate_instance(self.context, instance=instance)
@ -1771,9 +1771,9 @@ class ComputeTestCase(BaseTestCase):
self.assertEquals(payload['instance_type'], 'm1.tiny')
type_id = flavors.get_flavor_by_name('m1.tiny')['id']
self.assertEquals(str(payload['instance_type_id']), str(type_id))
self.assertTrue('display_name' in payload)
self.assertTrue('created_at' in payload)
self.assertTrue('launched_at' in payload)
self.assertIn('display_name', payload)
self.assertIn('created_at', payload)
self.assertIn('launched_at', payload)
image_ref_url = glance.generate_image_url(FAKE_IMAGE_REF)
self.assertEquals(payload['image_ref_url'], image_ref_url)
@ -2812,10 +2812,10 @@ class ComputeTestCase(BaseTestCase):
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid']
self.assertEquals(str(payload['instance_flavor_id']), str(flavor_id))
self.assertEquals(payload['state'], 'active')
self.assertTrue('display_name' in payload)
self.assertTrue('created_at' in payload)
self.assertTrue('launched_at' in payload)
self.assertTrue('fixed_ips' in payload)
self.assertIn('display_name', payload)
self.assertIn('created_at', payload)
self.assertIn('launched_at', payload)
self.assertIn('fixed_ips', payload)
self.assertTrue(payload['launched_at'])
image_ref_url = glance.generate_image_url(FAKE_IMAGE_REF)
self.assertEquals(payload['image_ref_url'], image_ref_url)
@ -2925,11 +2925,11 @@ class ComputeTestCase(BaseTestCase):
self.assertEquals(str(payload['instance_type_id']), str(type_id))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid']
self.assertEquals(str(payload['instance_flavor_id']), str(flavor_id))
self.assertTrue('display_name' in payload)
self.assertTrue('created_at' in payload)
self.assertTrue('launched_at' in payload)
self.assertTrue('terminated_at' in payload)
self.assertTrue('deleted_at' in payload)
self.assertIn('display_name', payload)
self.assertIn('created_at', payload)
self.assertIn('launched_at', payload)
self.assertIn('terminated_at', payload)
self.assertIn('deleted_at', payload)
self.assertEqual(payload['terminated_at'], timeutils.strtime(cur_time))
image_ref_url = glance.generate_image_url(FAKE_IMAGE_REF)
self.assertEquals(payload['image_ref_url'], image_ref_url)
@ -3424,7 +3424,7 @@ class ComputeTestCase(BaseTestCase):
# NOTE(mriedem): make sure prep_resize set old_vm_state correctly
sys_meta = instance.system_metadata
self.assertTrue('old_vm_state' in sys_meta)
self.assertIn('old_vm_state', sys_meta)
if power_on:
self.assertEqual(vm_states.ACTIVE, sys_meta['old_vm_state'])
else:
@ -3775,9 +3775,9 @@ class ComputeTestCase(BaseTestCase):
self.assertEquals(str(payload['instance_type_id']), str(type_id))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid']
self.assertEquals(str(payload['instance_flavor_id']), str(flavor_id))
self.assertTrue('display_name' in payload)
self.assertTrue('created_at' in payload)
self.assertTrue('launched_at' in payload)
self.assertIn('display_name', payload)
self.assertIn('created_at', payload)
self.assertIn('launched_at', payload)
self.assertEqual(payload['launched_at'], timeutils.strtime(cur_time))
self.assertEquals(payload['image_ref_url'], new_image_ref_url)
self.compute.terminate_instance(self.context,
@ -3832,9 +3832,9 @@ class ComputeTestCase(BaseTestCase):
self.assertEquals(payload['instance_type'], 'm1.small')
self.assertEquals(str(payload['instance_type_id']), str(new_type_id))
self.assertEquals(str(payload['instance_flavor_id']), str(flavor_id))
self.assertTrue('display_name' in payload)
self.assertTrue('created_at' in payload)
self.assertTrue('launched_at' in payload)
self.assertIn('display_name', payload)
self.assertIn('created_at', payload)
self.assertIn('launched_at', payload)
self.assertEqual(payload['launched_at'], timeutils.strtime(cur_time))
image_ref_url = glance.generate_image_url(FAKE_IMAGE_REF)
self.assertEquals(payload['image_ref_url'], image_ref_url)
@ -3882,9 +3882,9 @@ class ComputeTestCase(BaseTestCase):
self.assertEquals(str(payload['instance_type_id']), str(type_id))
flavor_id = flavors.get_flavor_by_name('m1.tiny')['flavorid']
self.assertEquals(str(payload['instance_flavor_id']), str(flavor_id))
self.assertTrue('display_name' in payload)
self.assertTrue('created_at' in payload)
self.assertTrue('launched_at' in payload)
self.assertIn('display_name', payload)
self.assertIn('created_at', payload)
self.assertIn('launched_at', payload)
image_ref_url = glance.generate_image_url(FAKE_IMAGE_REF)
self.assertEquals(payload['image_ref_url'], image_ref_url)
self.compute.terminate_instance(self.context, instance=instance)
@ -4571,7 +4571,7 @@ class ComputeTestCase(BaseTestCase):
migrate_data = {'is_shared_storage': False}
self.compute._post_live_migration(c, inst_ref, dest,
migrate_data=migrate_data)
self.assertTrue('destroyed' in result)
self.assertIn('destroyed', result)
self.assertTrue(result['destroyed'] == True)
def test_post_live_migration_working_correctly(self):
@ -4759,7 +4759,7 @@ class ComputeTestCase(BaseTestCase):
exc_info = None
def fake_db_fault_create(ctxt, values):
self.assertTrue('raise NotImplementedError' in values['details'])
self.assertIn('raise NotImplementedError', values['details'])
del values['details']
expected = {
@ -5995,7 +5995,7 @@ class ComputeAPITestCase(BaseTestCase):
'image_ramdisk_id': 'fake_ramdisk_id',
'image_something_else': 'meow', }
for key, value in image_props.iteritems():
self.assertTrue(key in sys_metadata)
self.assertIn(key, sys_metadata)
self.assertEqual(value, sys_metadata[key])
finally:
@ -6016,7 +6016,7 @@ class ComputeAPITestCase(BaseTestCase):
'rxtx_factor', 'vcpu_weight']
for key in instance_type_props:
sys_meta_key = "instance_type_%s" % key
self.assertTrue(sys_meta_key in sys_metadata)
self.assertIn(sys_meta_key, sys_metadata)
self.assertEqual(str(instance_type[key]),
str(sys_metadata[sys_meta_key]))
@ -6591,27 +6591,27 @@ class ComputeAPITestCase(BaseTestCase):
search_opts={'name': '^woo.*'})
self.assertEqual(len(instances), 2)
instance_uuids = [instance['uuid'] for instance in instances]
self.assertTrue(instance1['uuid'] in instance_uuids)
self.assertTrue(instance2['uuid'] in instance_uuids)
self.assertIn(instance1['uuid'], instance_uuids)
self.assertIn(instance2['uuid'], instance_uuids)
instances = self.compute_api.get_all(c,
search_opts={'name': '^woot.*'})
instance_uuids = [instance['uuid'] for instance in instances]
self.assertEqual(len(instances), 1)
self.assertTrue(instance1['uuid'] in instance_uuids)
self.assertIn(instance1['uuid'], instance_uuids)
instances = self.compute_api.get_all(c,
search_opts={'name': '.*oot.*'})
self.assertEqual(len(instances), 2)
instance_uuids = [instance['uuid'] for instance in instances]
self.assertTrue(instance1['uuid'] in instance_uuids)
self.assertTrue(instance3['uuid'] in instance_uuids)
self.assertIn(instance1['uuid'], instance_uuids)
self.assertIn(instance3['uuid'], instance_uuids)
instances = self.compute_api.get_all(c,
search_opts={'name': '^n.*'})
self.assertEqual(len(instances), 1)
instance_uuids = [instance['uuid'] for instance in instances]
self.assertTrue(instance3['uuid'] in instance_uuids)
self.assertIn(instance3['uuid'], instance_uuids)
instances = self.compute_api.get_all(c,
search_opts={'name': 'noth.*'})
@ -6693,8 +6693,8 @@ class ComputeAPITestCase(BaseTestCase):
instances = self.compute_api.get_all(c, search_opts={'image': '4567'})
self.assertEqual(len(instances), 2)
instance_uuids = [instance['uuid'] for instance in instances]
self.assertTrue(instance2['uuid'] in instance_uuids)
self.assertTrue(instance3['uuid'] in instance_uuids)
self.assertIn(instance2['uuid'], instance_uuids)
self.assertIn(instance3['uuid'], instance_uuids)
# Test passing a list as search arg
instances = self.compute_api.get_all(c,
@ -6738,8 +6738,8 @@ class ComputeAPITestCase(BaseTestCase):
instances = self.compute_api.get_all(c, search_opts={'flavor': 1})
self.assertEqual(len(instances), 2)
instance_uuids = [instance['uuid'] for instance in instances]
self.assertTrue(instance2['uuid'] in instance_uuids)
self.assertTrue(instance3['uuid'] in instance_uuids)
self.assertIn(instance2['uuid'], instance_uuids)
self.assertIn(instance3['uuid'], instance_uuids)
db.instance_destroy(c, instance1['uuid'])
db.instance_destroy(c, instance2['uuid'])
@ -6772,8 +6772,8 @@ class ComputeAPITestCase(BaseTestCase):
search_opts={'power_state': power_state.RUNNING})
self.assertEqual(len(instances), 2)
instance_uuids = [instance['uuid'] for instance in instances]
self.assertTrue(instance2['uuid'] in instance_uuids)
self.assertTrue(instance3['uuid'] in instance_uuids)
self.assertIn(instance2['uuid'], instance_uuids)
self.assertIn(instance3['uuid'], instance_uuids)
# Test passing a list as search arg
instances = self.compute_api.get_all(c,
@ -6825,8 +6825,8 @@ class ComputeAPITestCase(BaseTestCase):
search_opts={'metadata': {'key3': 'value3'}})
self.assertEqual(len(instances), 2)
instance_uuids = [instance['uuid'] for instance in instances]
self.assertTrue(instance3['uuid'] in instance_uuids)
self.assertTrue(instance4['uuid'] in instance_uuids)
self.assertIn(instance3['uuid'], instance_uuids)
self.assertIn(instance4['uuid'], instance_uuids)
# multiple criteria as a dict
instances = self.compute_api.get_all(c,
@ -6903,7 +6903,7 @@ class ComputeAPITestCase(BaseTestCase):
self.assertEquals(len(fake_notifier.NOTIFICATIONS), 1)
msg = fake_notifier.NOTIFICATIONS[0]
payload = msg.payload
self.assertTrue('metadata' in payload)
self.assertIn('metadata', payload)
self.assertEquals(payload['metadata'], metadata)
new_metadata = {'key2': 'bah', 'key3': 'value3'}
@ -6920,7 +6920,7 @@ class ComputeAPITestCase(BaseTestCase):
self.assertEquals(len(fake_notifier.NOTIFICATIONS), 2)
msg = fake_notifier.NOTIFICATIONS[1]
payload = msg.payload
self.assertTrue('metadata' in payload)
self.assertIn('metadata', payload)
self.assertEquals(payload['metadata'], metadata)
self.compute_api.delete_instance_metadata(_context, instance, 'key2')
@ -6931,7 +6931,7 @@ class ComputeAPITestCase(BaseTestCase):
self.assertEquals(len(fake_notifier.NOTIFICATIONS), 3)
msg = fake_notifier.NOTIFICATIONS[2]
payload = msg.payload
self.assertTrue('metadata' in payload)
self.assertIn('metadata', payload)
self.assertEquals(payload['metadata'], {})
db.instance_destroy(_context, instance['uuid'])
@ -8295,7 +8295,7 @@ class ComputeAPIAggrTestCase(BaseTestCase):
def fake_add_aggregate_host(*args, **kwargs):
hosts = kwargs["aggregate"]["hosts"]
self.assertTrue(fake_host in hosts)
self.assertIn(fake_host, hosts)
self.stubs.Set(self.api.compute_rpcapi, 'add_aggregate_host',
fake_add_aggregate_host)

2
nova/tests/compute/test_rpcapi.py
View File

@ -40,7 +40,7 @@ class ComputeRpcAPITestCase(test.TestCase):
self.fake_instance = jsonutils.to_primitive(inst)
def test_serialized_instance_has_name(self):
self.assertTrue('name' in self.fake_instance)
self.assertIn('name', self.fake_instance)
def _test_compute_api(self, method, rpc_method, **kwargs):
ctxt = context.RequestContext('fake_user', 'fake_project')

2
nova/tests/conductor/test_conductor.py
View File

@ -1191,7 +1191,7 @@ class ConductorAPITestCase(_BaseTestCase, test.TestCase):
self.conductor.wait_until_ready(self.context)
self.assertEqual(timeouts.count(10), 10)
self.assertTrue(None in timeouts)
self.assertIn(None, timeouts)
def test_security_groups_trigger_handler(self):
self.mox.StubOutWithMock(self.conductor_manager.security_group_api,

2
nova/tests/console/test_console.py
View File

@ -100,7 +100,7 @@ class ConsoleTestCase(test.TestCase):
self.console.driver.console_type)
console_instances = [con['instance_uuid'] for con in pool['consoles']]
self.assertTrue(instance['uuid'] in console_instances)
self.assertIn(instance['uuid'], console_instances)
db.instance_destroy(self.context, instance['uuid'])
def test_add_console_does_not_duplicate(self):

8
nova/tests/db/test_db_api.py
View File

@ -370,7 +370,7 @@ class AggregateDBApiTestCase(test.TestCase):
r1 = db.aggregate_metadata_get_by_metadata_key(ctxt, aggr['id'],
'availability_zone')
self.assertEqual(r1['availability_zone'], set(['az1']))
self.assertTrue('availability_zone' in r1)
self.assertIn('availability_zone', r1)
self.assertNotIn('name', r1)
def test_aggregate_metadata_get_by_host_with_key(self):
@ -1441,7 +1441,7 @@ class InstanceTestCase(test.TestCase, ModelsObjectComparatorMixin):
uuids = [self.create_instance_with_args()['uuid'] for i in range(3)]
meta = sqlalchemy_api._instance_metadata_get_multi(self.ctxt, uuids)
for row in meta:
self.assertTrue(row['instance_uuid'] in uuids)
self.assertIn(row['instance_uuid'], uuids)
def test_instance_metadata_get_multi_no_uuids(self):
self.mox.StubOutWithMock(query.Query, 'filter')
@ -1453,7 +1453,7 @@ class InstanceTestCase(test.TestCase, ModelsObjectComparatorMixin):
sys_meta = sqlalchemy_api._instance_system_metadata_get_multi(
self.ctxt, uuids)
for row in sys_meta:
self.assertTrue(row['instance_uuid'] in uuids)
self.assertIn(row['instance_uuid'], uuids)
def test_instance_system_metadata_get_multi_no_uuids(self):
self.mox.StubOutWithMock(query.Query, 'filter')
@ -5977,7 +5977,7 @@ class Ec2TestCase(test.TestCase):
try:
method(self.ctxt, value)
except exception.NotFound as exc:
self.assertTrue(unicode(value) in unicode(exc))
self.assertIn(unicode(value), unicode(exc))
check_exc_format(db.get_ec2_volume_id_by_uuid, 'fake')
check_exc_format(db.get_volume_uuid_by_ec2_id, 123456)

6
nova/tests/db/test_migration_utils.py
View File

@ -194,7 +194,7 @@ class TestMigrationUtils(test_migrations.BaseMigrationTestCase):
self.assertEqual(len(real_ids), len(expected_ids))
for id_ in expected_ids:
self.assertTrue(id_ in real_ids)
self.assertIn(id_, real_ids)
def test_drop_old_duplicate_entries_from_table_soft_delete(self):
table_name = "__test_tmp_table__"
@ -227,7 +227,7 @@ class TestMigrationUtils(test_migrations.BaseMigrationTestCase):
engine.execute(rows_select).fetchall()]
self.assertEqual(len(row_ids), len(expected_values))
for value in expected_values:
self.assertTrue(value['id'] in row_ids)
self.assertIn(value['id'], row_ids)
deleted_rows_select = base_select.\
where(table.c.deleted == table.c.id)
@ -236,7 +236,7 @@ class TestMigrationUtils(test_migrations.BaseMigrationTestCase):
self.assertEqual(len(deleted_rows_ids),
len(values) - len(row_ids))
for value in soft_deleted_values:
self.assertTrue(value['id'] in deleted_rows_ids)
self.assertIn(value['id'], deleted_rows_ids)
def test_check_shadow_table(self):
table_name = 'abc'

8
nova/tests/image/test_s3.py
View File

@ -109,9 +109,9 @@ class TestS3ImageService(test.TestCase):
key = keys[0]
for x in list0:
self.assertEqual(len(x), len(keys))
self.assertTrue(key in x)
self.assertIn(key, x)
for y in list1:
self.assertTrue(key in y)
self.assertIn(key, y)
if x[key] == y[key]:
for k in keys:
self.assertEqual(x[k], y[k])
@ -172,10 +172,10 @@ class TestS3ImageService(test.TestCase):
self.context, metadata, ami_manifest_xml)
ret_image = self.image_service.show(self.context, image['id'])
self.assertTrue('properties' in ret_image)
self.assertIn('properties', ret_image)
properties = ret_image['properties']
self.assertTrue('mappings' in properties)
self.assertIn('mappings', properties)
mappings = properties['mappings']
expected_mappings = [
{"device": "sda1", "virtual": "ami"},

6
nova/tests/integrated/test_servers.py
View File

@ -141,7 +141,7 @@ class ServersTest(integrated_helpers._IntegratedTestBase):
# It should also be in the all-servers list
servers = self.api.get_servers()
server_ids = [s['id'] for s in servers]
self.assertTrue(created_server_id in server_ids)
self.assertIn(created_server_id, server_ids)
found_server = self._wait_for_state_change(found_server, 'BUILD')
# It should be available...
@ -149,8 +149,8 @@ class ServersTest(integrated_helpers._IntegratedTestBase):
self.assertEqual('ACTIVE', found_server['status'])
servers = self.api.get_servers(detail=True)
for server in servers:
self.assertTrue("image" in server)
self.assertTrue("flavor" in server)
self.assertIn("image", server)
self.assertIn("flavor", server)
self._delete_server(created_server_id)

4
nova/tests/network/test_linux_net.py
View File

@ -636,7 +636,7 @@ class LinuxNetworkTestCase(test.NoDBTestCase):
'-s 192.168.1.1 -j DROP' % iface,
]
for inp in expected_inputs:
self.assertTrue(inp in inputs[0])
self.assertIn(inp, inputs[0])
executes = []
inputs = []
@ -727,7 +727,7 @@ class LinuxNetworkTestCase(test.NoDBTestCase):
'-s 192.168.1.1 -j LOGDROP' % iface),
]
for inp in expected_inputs:
self.assertTrue(inp in inputs[0])
self.assertIn(inp, inputs[0])
executes = []
inputs = []

20
nova/tests/network/test_manager.py
View File

@ -1433,7 +1433,7 @@ class CommonNetworkTestCase(test.TestCase):
None, None)
self.assertEqual(1, len(nets))
cidrs = [str(net['cidr']) for net in nets]
self.assertTrue('192.168.0.0/24' in cidrs)
self.assertIn('192.168.0.0/24', cidrs)
def test_validate_cidrs_split_exact_in_half(self):
manager = fake_network.FakeNetworkManager()
@ -1442,8 +1442,8 @@ class CommonNetworkTestCase(test.TestCase):
None, None)
self.assertEqual(2, len(nets))
cidrs = [str(net['cidr']) for net in nets]
self.assertTrue('192.168.0.0/25' in cidrs)
self.assertTrue('192.168.0.128/25' in cidrs)
self.assertIn('192.168.0.0/25', cidrs)
self.assertIn('192.168.0.128/25', cidrs)
def test_validate_cidrs_split_cidr_in_use_middle_of_range(self):
manager = fake_network.FakeNetworkManager()
@ -1460,7 +1460,7 @@ class CommonNetworkTestCase(test.TestCase):
exp_cidrs = ['192.168.0.0/24', '192.168.1.0/24', '192.168.3.0/24',
'192.168.4.0/24']
for exp_cidr in exp_cidrs:
self.assertTrue(exp_cidr in cidrs)
self.assertIn(exp_cidr, cidrs)
self.assertNotIn('192.168.2.0/24', cidrs)
def test_validate_cidrs_smaller_subnet_in_use(self):
@ -1492,7 +1492,7 @@ class CommonNetworkTestCase(test.TestCase):
exp_cidrs = ['192.168.0.0/24', '192.168.1.0/24', '192.168.3.0/24',
'192.168.4.0/24']
for exp_cidr in exp_cidrs:
self.assertTrue(exp_cidr in cidrs)
self.assertIn(exp_cidr, cidrs)
self.assertNotIn('192.168.2.0/24', cidrs)
def test_validate_cidrs_split_smaller_cidr_in_use2(self):
@ -1509,7 +1509,7 @@ class CommonNetworkTestCase(test.TestCase):
cidrs = [str(net['cidr']) for net in nets]
exp_cidrs = ['192.168.2.32/27', '192.168.2.64/27', '192.168.2.96/27']
for exp_cidr in exp_cidrs:
self.assertTrue(exp_cidr in cidrs)
self.assertIn(exp_cidr, cidrs)
self.assertNotIn('192.168.2.0/27', cidrs)
def test_validate_cidrs_split_all_in_use(self):
@ -1563,8 +1563,8 @@ class CommonNetworkTestCase(test.TestCase):
False, 2, 256, None, None, None, None,
None)
returned_cidrs = [str(net['cidr']) for net in nets]
self.assertTrue('192.168.0.0/24' in returned_cidrs)
self.assertTrue('192.168.1.0/24' in returned_cidrs)
self.assertIn('192.168.0.0/24', returned_cidrs)
self.assertIn('192.168.1.0/24', returned_cidrs)
def test_validate_cidrs_conflict_existing_supernet(self):
manager = fake_network.FakeNetworkManager()
@ -1856,7 +1856,7 @@ class CommonNetworkTestCase(test.TestCase):
# Compare the expected rules against the actual ones
for line in expected_lines:
self.assertTrue(line in new_lines)
self.assertIn(line, new_lines)
# Add an additional network and ensure the rules get configured
new_network = {'id': 2,
@ -1910,7 +1910,7 @@ class CommonNetworkTestCase(test.TestCase):
# Compare the expected rules (with new network) against the actual ones
for line in expected_lines:
self.assertTrue(line in new_lines)
self.assertIn(line, new_lines)
def test_flatdhcpmanager_dynamic_fixed_range(self):
"""Test FlatDHCPManager NAT rules for fixed_range."""

22
nova/tests/network/test_network_info.py
View File

@ -422,22 +422,22 @@ class NetworkInfoTests(test.NoDBTestCase):
self.assertTrue(template is None)
else:
if use_ipv4:
self.assertTrue('auto eth0' in template)
self.assertTrue('iface eth0 inet static' in template)
self.assertTrue('address 10.10.0.2' in template)
self.assertTrue('netmask 255.255.255.0' in template)
self.assertTrue('broadcast 10.10.0.255' in template)
self.assertIn('auto eth0', template)
self.assertIn('iface eth0 inet static', template)
self.assertIn('address 10.10.0.2', template)
self.assertIn('netmask 255.255.255.0', template)
self.assertIn('broadcast 10.10.0.255', template)
if gateway:
self.assertTrue('gateway 10.10.0.1' in template)
self.assertIn('gateway 10.10.0.1', template)
else:
self.assertNotIn('gateway', template)
self.assertTrue('dns-nameservers 1.2.3.4 2.3.4.5' in template)
self.assertIn('dns-nameservers 1.2.3.4 2.3.4.5', template)
if use_ipv6:
self.assertTrue('iface eth0 inet6 static' in template)
self.assertTrue('address 1234:567::2' in template)
self.assertTrue('netmask 48' in template)
self.assertIn('iface eth0 inet6 static', template)
self.assertIn('address 1234:567::2', template)
self.assertIn('netmask 48', template)
if gateway:
self.assertTrue('gateway 1234:567::1' in template)
self.assertIn('gateway 1234:567::1', template)
if not use_ipv4 and not use_ipv6:
self.assertTrue(template is None)

4
nova/tests/network/test_neutronv2.py
View File

@ -907,7 +907,7 @@ class TestNeutronv2(TestNeutronv2Base):
try:
api.validate_networks(self.context, requested_networks)
except exception.NetworkNotFound as ex:
self.assertTrue("my_netid2" in str(ex))
self.assertIn("my_netid2", str(ex))
def test_validate_networks_ex_2(self):
requested_networks = [('my_netid1', 'test', None),
@ -922,7 +922,7 @@ class TestNeutronv2(TestNeutronv2Base):
try:
api.validate_networks(self.context, requested_networks)
except exception.NetworkNotFound as ex:
self.assertTrue("my_netid2, my_netid3" in str(ex))
self.assertIn("my_netid2, my_netid3", str(ex))
def test_validate_networks_duplicate(self):
"""Verify that the correct exception is thrown when duplicate

8
nova/tests/objects/test_objects.py
View File

@ -452,7 +452,7 @@ class _TestObject(object):
except NotImplementedError as ex:
raised = True
self.assertTrue(raised)
self.assertTrue('foobar' in str(ex))
self.assertIn('foobar', str(ex))
def test_loaded_in_primitive(self):
obj = MyObj()
@ -472,7 +472,7 @@ class _TestObject(object):
obj.foo = 123
self.assertEqual(obj.obj_what_changed(), set(['foo']))
primitive = obj.obj_to_primitive()
self.assertTrue('nova_object.changes' in primitive)
self.assertIn('nova_object.changes', primitive)
obj2 = MyObj.obj_from_primitive(primitive)
self.assertEqual(obj2.obj_what_changed(), set(['foo']))
obj2.obj_reset_changes()
@ -574,7 +574,7 @@ class _TestObject(object):
obj = MyObj()
self.assertNotIn('foo', obj)
obj.foo = 1
self.assertTrue('foo' in obj)
self.assertIn('foo', obj)
self.assertNotIn('does_not_exist', obj)
def test_obj_attr_is_set(self):
@ -711,7 +711,7 @@ class TestObjectSerializer(_BaseTestCase):
ser = base.NovaObjectSerializer()
obj = MyObj()
primitive = ser.serialize_entity(self.context, obj)
self.assertTrue('nova_object.name' in primitive)
self.assertIn('nova_object.name', primitive)
obj2 = ser.deserialize_entity(self.context, primitive)
self.assertIsInstance(obj2, MyObj)
self.assertEqual(self.context, obj2._context)

6
nova/tests/servicegroup/test_db_servicegroup.py
View File

@ -103,11 +103,11 @@ class DBServiceGroupTestCase(test.TestCase):
services = self.servicegroup_api.get_all(self._topic)
self.assertTrue(service_ref1['host'] in services)
self.assertTrue(service_ref2['host'] in services)
self.assertIn(service_ref1['host'], services)
self.assertIn(service_ref2['host'], services)
service_id = self.servicegroup_api.get_one(self._topic)
self.assertTrue(service_id in services)
self.assertIn(service_id, services)
def test_service_is_up(self):
fts_func = datetime.datetime.fromtimestamp

6
nova/tests/servicegroup/test_mc_servicegroup.py
View File

@ -123,12 +123,12 @@ class MemcachedServiceGroupTestCase(test.TestCase):
services = self.servicegroup_api.get_all(self._topic)
self.assertTrue(host1 in services)
self.assertTrue(host2 in services)
self.assertIn(host1, services)
self.assertIn(host2, services)
self.assertNotIn(host3, services)
service_id = self.servicegroup_api.get_one(self._topic)
self.assertTrue(service_id in services)
self.assertIn(service_id, services)
def test_service_is_up(self):
serv = self.useFixture(

12
nova/tests/test_block_device.py
View File

@ -264,15 +264,15 @@ class TestBlockDeviceDict(test.NoDBTestCase):
dev_dict = block_device.BlockDeviceDict({'field1': 'foo',
'field2': 'bar',
'db_field1': 'baz'})
self.assertTrue('field1' in dev_dict)
self.assertTrue('field2' in dev_dict)
self.assertTrue('db_field1' in dev_dict)
self.assertIn('field1', dev_dict)
self.assertIn('field2', dev_dict)
self.assertIn('db_field1', dev_dict)
self.assertFalse('db_field2'in dev_dict)
# Make sure all expected fields are defaulted
dev_dict = block_device.BlockDeviceDict({'field1': 'foo'})
self.assertTrue('field1' in dev_dict)
self.assertTrue('field2' in dev_dict)
self.assertIn('field1', dev_dict)
self.assertIn('field2', dev_dict)
self.assertTrue(dev_dict['field2'] is None)
self.assertNotIn('db_field1', dev_dict)
self.assertFalse('db_field2'in dev_dict)
@ -280,7 +280,7 @@ class TestBlockDeviceDict(test.NoDBTestCase):
# Unless they are not meant to be
dev_dict = block_device.BlockDeviceDict({'field1': 'foo'},
do_not_default=set(['field2']))
self.assertTrue('field1' in dev_dict)
self.assertIn('field1', dev_dict)
self.assertNotIn('field2', dev_dict)
self.assertNotIn('db_field1', dev_dict)
self.assertFalse('db_field2'in dev_dict)

2
nova/tests/test_cinder.py
View File

@ -176,7 +176,7 @@ class CinderTestCase(test.NoDBTestCase):
def test_volume_with_image_metadata(self):
volume = self.api.get(self.context, '5678')
self.assert_called('GET', '/volumes/5678')
self.assertTrue('volume_image_metadata' in volume)
self.assertIn('volume_image_metadata', volume)
self.assertEqual(volume['volume_image_metadata'], _image_metadata)
def test_cinder_api_insecure(self):

2
nova/tests/test_exception.py
View File

@ -61,7 +61,7 @@ class WrapExceptionTestCase(test.NoDBTestCase):
self.assertEquals(notifier.provided_context, ctxt)
self.assertEquals(notifier.provided_payload['args']['extra'], 3)
for key in ['exception', 'args']:
self.assertTrue(key in notifier.provided_payload.keys())
self.assertIn(key, notifier.provided_payload.keys())
class NovaExceptionTestCase(test.NoDBTestCase):

2
nova/tests/test_manager.py
View File

@ -32,4 +32,4 @@ class ManagerTestCase(test.NoDBTestCase):
dispatch = m.create_rpc_dispatcher(additional_apis=[api])
self.assertEqual(len(dispatch.callbacks), 3)
self.assertTrue(api in dispatch.callbacks)
self.assertIn(api, dispatch.callbacks)

18
nova/tests/test_metadata.py
View File

@ -329,8 +329,8 @@ class OpenStackMetadataTestCase(test.TestCase):
# the 'content' should not show up in directory listing
self.assertNotIn(base.CONTENT_DIR, result)
self.assertTrue('2012-08-10' in result)
self.assertTrue('latest' in result)
self.assertIn('2012-08-10', result)
self.assertIn('latest', result)
def test_version_content_listing(self):
# request for /openstack/<version>/ should show metadata.json
@ -338,7 +338,7 @@ class OpenStackMetadataTestCase(test.TestCase):
mdinst = fake_InstanceMetadata(self.stubs, inst)
listing = mdinst.lookup("/openstack/2012-08-10")
self.assertTrue("meta_data.json" in listing)
self.assertIn("meta_data.json", listing)
def test_metadata_json(self):
inst = copy.copy(self.instance)
@ -355,13 +355,13 @@ class OpenStackMetadataTestCase(test.TestCase):
mddict = json.loads(mdjson)
self.assertEqual(mddict['uuid'], self.instance['uuid'])
self.assertTrue('files' in mddict)
self.assertIn('files', mddict)
self.assertTrue('public_keys' in mddict)
self.assertIn('public_keys', mddict)
self.assertEqual(mddict['public_keys'][self.instance['key_name']],
self.instance['key_data'])
self.assertTrue('launch_index' in mddict)
self.assertIn('launch_index', mddict)
self.assertEqual(mddict['launch_index'], self.instance['launch_index'])
# verify that each of the things we put in content
@ -403,7 +403,7 @@ class OpenStackMetadataTestCase(test.TestCase):
self.assertEqual(USER_DATA_STRING, userdata_found)
# since we had user-data in this instance, it should be in listing
self.assertTrue('user_data' in mdinst.lookup("/openstack/2012-08-10"))
self.assertIn('user_data', mdinst.lookup("/openstack/2012-08-10"))
del inst['user_data']
mdinst = fake_InstanceMetadata(self.stubs, inst)
@ -422,7 +422,7 @@ class OpenStackMetadataTestCase(test.TestCase):
mdjson = mdinst.lookup("/openstack/2013-04-04/meta_data.json")
mddict = json.loads(mdjson)
self.assertTrue("random_seed" in mddict)
self.assertIn("random_seed", mddict)
self.assertEqual(len(base64.b64decode(mddict["random_seed"])), 512)
# verify that older version do not have it
@ -443,7 +443,7 @@ class OpenStackMetadataTestCase(test.TestCase):
# verify that 2013-10-17 has the vendor_data.json file
result = mdinst.lookup("/openstack/2013-10-17")
self.assertTrue('vendor_data.json' in result)
self.assertIn('vendor_data.json', result)
# verify that older version do not have it
result = mdinst.lookup("/openstack/2013-04-04")

2
nova/tests/test_notifications.py
View File

@ -277,7 +277,7 @@ class NotificationsTestCase(test.TestCase):
def test_payload_has_fixed_ip_labels(self):
info = notifications.info_from_instance(self.context, self.instance,
self.net_info, None)
self.assertTrue("fixed_ips" in info)
self.assertIn("fixed_ips", info)
self.assertEquals(info["fixed_ips"][0]["label"], "test1")
def test_send_access_ip_update(self):

2
nova/tests/test_nova_manage.py
View File

@ -80,7 +80,7 @@ class FloatingIpCommandsTestCase(test.TestCase):
def test_address_to_hosts(self):
def assert_loop(result, expected):
for ip in result:
self.assertTrue(str(ip) in expected)
self.assertIn(str(ip), expected)
address_to_hosts = self.commands.address_to_hosts
# /32 and /31

36
nova/tests/test_safeutils.py
View File

@ -28,11 +28,11 @@ class GetCallArgsTestCase(test.NoDBTestCase):
callargs = safe_utils.getcallargs(self._test_func, *args, **kwargs)
#implicit self counts as an arg
self.assertEqual(4, len(callargs))
self.assertTrue('instance' in callargs)
self.assertIn('instance', callargs)
self.assertEqual({'uuid': 1}, callargs['instance'])
self.assertTrue('red' in callargs)
self.assertIn('red', callargs)
self.assertEqual(3, callargs['red'])
self.assertTrue('blue' in callargs)
self.assertIn('blue', callargs)
self.assertEqual(4, callargs['blue'])
def test_all_args(self):
@ -41,11 +41,11 @@ class GetCallArgsTestCase(test.NoDBTestCase):
callargs = safe_utils.getcallargs(self._test_func, *args, **kwargs)
#implicit self counts as an arg
self.assertEqual(4, len(callargs))
self.assertTrue('instance' in callargs)
self.assertIn('instance', callargs)
self.assertEqual({'uuid': 1}, callargs['instance'])
self.assertTrue('red' in callargs)
self.assertIn('red', callargs)
self.assertEqual(3, callargs['red'])
self.assertTrue('blue' in callargs)
self.assertIn('blue', callargs)
self.assertEqual(4, callargs['blue'])
def test_mixed_args(self):
@ -54,11 +54,11 @@ class GetCallArgsTestCase(test.NoDBTestCase):
callargs = safe_utils.getcallargs(self._test_func, *args, **kwargs)
#implicit self counts as an arg
self.assertEqual(4, len(callargs))
self.assertTrue('instance' in callargs)
self.assertIn('instance', callargs)
self.assertEqual({'uuid': 1}, callargs['instance'])
self.assertTrue('red' in callargs)
self.assertIn('red', callargs)
self.assertEqual(3, callargs['red'])
self.assertTrue('blue' in callargs)
self.assertIn('blue', callargs)
self.assertEqual(4, callargs['blue'])
def test_partial_kwargs(self):
@ -67,11 +67,11 @@ class GetCallArgsTestCase(test.NoDBTestCase):
callargs = safe_utils.getcallargs(self._test_func, *args, **kwargs)
#implicit self counts as an arg
self.assertEqual(4, len(callargs))
self.assertTrue('instance' in callargs)
self.assertIn('instance', callargs)
self.assertEqual({'uuid': 1}, callargs['instance'])
self.assertTrue('red' in callargs)
self.assertIn('red', callargs)
self.assertEqual(3, callargs['red'])
self.assertTrue('blue' in callargs)
self.assertIn('blue', callargs)
self.assertEqual(None, callargs['blue'])
def test_partial_args(self):
@ -80,11 +80,11 @@ class GetCallArgsTestCase(test.NoDBTestCase):
callargs = safe_utils.getcallargs(self._test_func, *args, **kwargs)
#implicit self counts as an arg
self.assertEqual(4, len(callargs))
self.assertTrue('instance' in callargs)
self.assertIn('instance', callargs)
self.assertEqual({'uuid': 1}, callargs['instance'])
self.assertTrue('red' in callargs)
self.assertIn('red', callargs)
self.assertEqual(3, callargs['red'])
self.assertTrue('blue' in callargs)
self.assertIn('blue', callargs)
self.assertEqual(None, callargs['blue'])
def test_partial_mixed_args(self):
@ -92,9 +92,9 @@ class GetCallArgsTestCase(test.NoDBTestCase):
kwargs = {'instance': {'uuid': 1}}
callargs = safe_utils.getcallargs(self._test_func, *args, **kwargs)
self.assertEqual(4, len(callargs))
self.assertTrue('instance' in callargs)
self.assertIn('instance', callargs)
self.assertEqual({'uuid': 1}, callargs['instance'])
self.assertTrue('red' in callargs)
self.assertIn('red', callargs)
self.assertEqual(3, callargs['red'])
self.assertTrue('blue' in callargs)
self.assertIn('blue', callargs)
self.assertEqual(None, callargs['blue'])

26
nova/tests/test_utils.py
View File

@ -689,10 +689,10 @@ class WrappedCodeTestCase(test.NoDBTestCase):
func = utils.get_wrapped_function(wrapped)
func_code = func.func_code
self.assertEqual(4, len(func_code.co_varnames))
self.assertTrue('self' in func_code.co_varnames)
self.assertTrue('instance' in func_code.co_varnames)
self.assertTrue('red' in func_code.co_varnames)
self.assertTrue('blue' in func_code.co_varnames)
self.assertIn('self', func_code.co_varnames)
self.assertIn('instance', func_code.co_varnames)
self.assertIn('red', func_code.co_varnames)
self.assertIn('blue', func_code.co_varnames)
def test_double_wrapped(self):
@self._wrapper
@ -703,10 +703,10 @@ class WrappedCodeTestCase(test.NoDBTestCase):
func = utils.get_wrapped_function(wrapped)
func_code = func.func_code
self.assertEqual(4, len(func_code.co_varnames))
self.assertTrue('self' in func_code.co_varnames)
self.assertTrue('instance' in func_code.co_varnames)
self.assertTrue('red' in func_code.co_varnames)
self.assertTrue('blue' in func_code.co_varnames)
self.assertIn('self', func_code.co_varnames)
self.assertIn('instance', func_code.co_varnames)
self.assertIn('red', func_code.co_varnames)
self.assertIn('blue', func_code.co_varnames)
def test_triple_wrapped(self):
@self._wrapper
@ -718,10 +718,10 @@ class WrappedCodeTestCase(test.NoDBTestCase):
func = utils.get_wrapped_function(wrapped)
func_code = func.func_code
self.assertEqual(4, len(func_code.co_varnames))
self.assertTrue('self' in func_code.co_varnames)
self.assertTrue('instance' in func_code.co_varnames)
self.assertTrue('red' in func_code.co_varnames)
self.assertTrue('blue' in func_code.co_varnames)
self.assertIn('self', func_code.co_varnames)
self.assertIn('instance', func_code.co_varnames)
self.assertIn('red', func_code.co_varnames)
self.assertIn('blue', func_code.co_varnames)
class StringLengthTestCase(test.NoDBTestCase):
@ -899,7 +899,7 @@ class GetImageFromSystemMetadataTestCase(test.NoDBTestCase):
self.assertEqual(image[key], sys_meta.get(sys_key))
# Verify that we inherit the rest of metadata as properties
self.assertTrue("properties" in image)
self.assertIn("properties", image)
for key, value in image["properties"].iteritems():
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, key)