openstack
/
heat
Code Issues Proposed changes

Change assertTrue(A in B) to assertIn(A, B) 

The code in tests was using assertTrue(A in B) and similar
instead of assertIn / assertNotIn.

assertIn / assertNotIn assertions are provided by `testtools` package,
so this change is not breaking backward compatibility with Python 2.6.

Closes-Bug: #1259295

Change-Id: Ibf3b0c7f27895699db8a13bf6e1640d196f1a953
This commit is contained in:
Pavlo Shchelokovskyy 2013-12-12 12:07:11 +02:00
parent 582cf8f047
commit 6c7173ebd4
16 changed files with 155 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/rackspace/heat/tests/test_clouddatabase.py
View File

@ -196,5 +196,5 @@ class CloudDBInstanceTest(HeatTestCase):
inject_property_error=True)
self.m.ReplayAll()
ret = instance.validate()
self.assertTrue('Error' in ret)
self.assertIn('Error', ret)
self.m.VerifyAll()

6
contrib/rackspace/heat/tests/test_rackspace_cloud_server.py
View File

@ -251,7 +251,7 @@ class RackspaceCloudServerTest(HeatTestCase):
self.m.ReplayAll()
create = scheduler.TaskRunner(cs.create)
exc = self.assertRaises(exception.ResourceFailure, create)
self.assertTrue("The heat-script.sh script exited" in str(exc))
self.assertIn("The heat-script.sh script exited", str(exc))
self.m.VerifyAll()
def test_cs_create_cfnuserdata_nonzero_exit_status(self):
@ -261,7 +261,7 @@ class RackspaceCloudServerTest(HeatTestCase):
self.m.ReplayAll()
create = scheduler.TaskRunner(cs.create)
exc = self.assertRaises(exception.ResourceFailure, create)
self.assertTrue("The cfn-userdata script exited" in str(exc))
self.assertIn("The cfn-userdata script exited", str(exc))
self.m.VerifyAll()
def test_cs_update_cfnuserdata_nonzero_exit_status(self):
@ -277,7 +277,7 @@ class RackspaceCloudServerTest(HeatTestCase):
update_template['Metadata'] = {'test': 123}
update = scheduler.TaskRunner(cs.update, update_template)
exc = self.assertRaises(exception.ResourceFailure, update)
self.assertTrue("The cfn-userdata script exited" in str(exc))
self.assertIn("The cfn-userdata script exited", str(exc))
def test_cs_create_flavor_err(self):
"""validate() should throw an if the flavor is invalid."""

32
heat/tests/test_api_aws.py
View File

@ -36,9 +36,9 @@ class AWSCommonTest(HeatTestCase):
keyname='ParameterKey',
valuename='ParameterValue')
self.assertEqual(len(params), 2)
self.assertTrue('foo' in params)
self.assertIn('foo', params)
self.assertEqual(params['foo'], 'bar')
self.assertTrue('blarg' in params)
self.assertIn('blarg', params)
self.assertEqual(params['blarg'], 'wibble')
def test_params_extract_dots(self):
@ -60,7 +60,7 @@ class AWSCommonTest(HeatTestCase):
keyname='ParameterKey',
valuename='ParameterValue')
self.assertEqual(len(params), 1)
self.assertTrue('foo' in params)
self.assertIn('foo', params)
self.assertEqual(params['foo'], 'bar')
def test_params_extract_garbage_prefix(self):
@ -85,9 +85,9 @@ class AWSCommonTest(HeatTestCase):
'MetricData.member.1.Value': 234333}
params = api_utils.extract_param_list(p, prefix='MetricData')
self.assertEqual(len(params), 1)
self.assertTrue('MetricName' in params[0])
self.assertTrue('Unit' in params[0])
self.assertTrue('Value' in params[0])
self.assertIn('MetricName', params[0])
self.assertIn('Unit', params[0])
self.assertIn('Value', params[0])
self.assertEqual(params[0]['MetricName'], 'foo')
self.assertEqual(params[0]['Unit'], 'Bytes')
self.assertEqual(params[0]['Value'], 234333)
@ -98,9 +98,9 @@ class AWSCommonTest(HeatTestCase):
'MetricData.member.1.Value': 234333}
params = api_utils.extract_param_list(p, prefix='MetricData')
self.assertEqual(len(params), 1)
self.assertTrue('MetricName' not in params[0])
self.assertTrue('Unit' in params[0])
self.assertTrue('Value' in params[0])
self.assertNotIn('MetricName', params[0])
self.assertIn('Unit', params[0])
self.assertIn('Value', params[0])
self.assertEqual(params[0]['Unit'], 'Bytes')
self.assertEqual(params[0]['Value'], 234333)
@ -117,9 +117,9 @@ class AWSCommonTest(HeatTestCase):
'MetricData.member.1.Value': 234333}
params = api_utils.extract_param_list(p, prefix='MetricData')
self.assertEqual(len(params), 1)
self.assertTrue('MetricName' not in params[0])
self.assertTrue('Unit' in params[0])
self.assertTrue('Value' in params[0])
self.assertNotIn('MetricName', params[0])
self.assertIn('Unit', params[0])
self.assertIn('Value', params[0])
self.assertEqual(params[0]['Unit'], 'Bytes')
self.assertEqual(params[0]['Value'], 234333)
@ -132,8 +132,8 @@ class AWSCommonTest(HeatTestCase):
'MetricData.member.2.Value': 12345}
params = api_utils.extract_param_list(p, prefix='MetricData')
self.assertEqual(len(params), 2)
self.assertTrue('MetricName' in params[0])
self.assertTrue('MetricName' in params[1])
self.assertIn('MetricName', params[0])
self.assertIn('MetricName', params[1])
self.assertEqual(params[0]['MetricName'], 'foo')
self.assertEqual(params[0]['Unit'], 'Bytes')
self.assertEqual(params[0]['Value'], 234333)
@ -151,8 +151,8 @@ class AWSCommonTest(HeatTestCase):
'MetricData.member.3.Value': 12345}
params = api_utils.extract_param_list(p, prefix='MetricData')
self.assertEqual(len(params), 2)
self.assertTrue('MetricName' in params[0])
self.assertTrue('MetricName' in params[1])
self.assertIn('MetricName', params[0])
self.assertIn('MetricName', params[1])
self.assertEqual(params[0]['MetricName'], 'foo')
self.assertEqual(params[0]['Unit'], 'Bytes')
self.assertEqual(params[0]['Value'], 234333)

13
heat/tests/test_autoscaling_update_policy.py
View File

@ -338,7 +338,7 @@ class AutoScalingGroupTest(HeatTestCase):
grp = stack['WebServerGroup']
self.assertTrue(grp.update_policy)
self.assertTrue(len(grp.update_policy) == 1)
self.assertTrue('AutoScalingRollingUpdate' in grp.update_policy)
self.assertIn('AutoScalingRollingUpdate', grp.update_policy)
policy = grp.update_policy['AutoScalingRollingUpdate']
self.assertTrue(policy and len(policy) > 0)
self.assertEqual(int(policy['MinInstancesInService']), 1)
@ -352,7 +352,7 @@ class AutoScalingGroupTest(HeatTestCase):
grp = stack['WebServerGroup']
self.assertTrue(grp.update_policy)
self.assertTrue(len(grp.update_policy) == 1)
self.assertTrue('AutoScalingRollingUpdate' in grp.update_policy)
self.assertIn('AutoScalingRollingUpdate', grp.update_policy)
policy = grp.update_policy['AutoScalingRollingUpdate']
self.assertTrue(policy and len(policy) > 0)
self.assertEqual(int(policy['MinInstancesInService']), 0)
@ -688,8 +688,7 @@ class AutoScalingGroupTest(HeatTestCase):
# test that update policy is loaded
current_grp = stack['WebServerGroup']
self.assertTrue('AutoScalingRollingUpdate'
in current_grp.update_policy)
self.assertIn('AutoScalingRollingUpdate', current_grp.update_policy)
current_policy = current_grp.update_policy['AutoScalingRollingUpdate']
self.assertTrue(current_policy)
self.assertTrue(len(current_policy) > 0)
@ -741,8 +740,7 @@ class AutoScalingGroupTest(HeatTestCase):
# test that update policy is loaded
current_grp = stack['WebServerGroup']
self.assertTrue('AutoScalingRollingUpdate'
in current_grp.update_policy)
self.assertIn('AutoScalingRollingUpdate', current_grp.update_policy)
current_policy = current_grp.update_policy['AutoScalingRollingUpdate']
self.assertTrue(current_policy)
self.assertTrue(len(current_policy) > 0)
@ -778,8 +776,7 @@ class AutoScalingGroupTest(HeatTestCase):
# test that the update policy is updated
updated_grp = stack['WebServerGroup']
self.assertTrue('AutoScalingRollingUpdate'
in updated_grp.update_policy)
self.assertIn('AutoScalingRollingUpdate', updated_grp.update_policy)
updated_policy = updated_grp.update_policy['AutoScalingRollingUpdate']
self.assertTrue(updated_policy)
self.assertTrue(len(updated_policy) > 0)

4
heat/tests/test_dependencies.py
View File

@ -68,8 +68,8 @@ class dependenciesTest(testtools.TestCase):
d = Dependencies([('1', None), ('2', None)])
l = list(iter(d))
self.assertEqual(len(l), 2)
self.assertTrue('1' in l)
self.assertTrue('2' in l)
self.assertIn('1', l)
self.assertIn('2', l)
def test_single_fwd(self):
self._dep_test_fwd(('second', 'first'))

20
heat/tests/test_engine_api_utils.py
View File

@ -35,46 +35,46 @@ class EngineApiTest(HeatTestCase):
def test_timeout_extract_zero(self):
p = {'timeout_mins': '0'}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_garbage(self):
p = {'timeout_mins': 'wibble'}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_none(self):
p = {'timeout_mins': None}
args = api.extract_args(p)
self.assertTrue('timeout_mins' not in args)
self.assertNotIn('timeout_mins', args)
def test_timeout_extract_not_present(self):
args = api.extract_args({})
self.assertTrue('timeout_mins' not in args)
self.assertNotIn('timeout_mins', args)
def test_disable_rollback_extract_true(self):
args = api.extract_args({'disable_rollback': True})
self.assertTrue('disable_rollback' in args)
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'True'})
self.assertTrue('disable_rollback' in args)
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'true'})
self.assertTrue('disable_rollback' in args)
self.assertIn('disable_rollback', args)
self.assertTrue(args.get('disable_rollback'))
def test_disable_rollback_extract_false(self):
args = api.extract_args({'disable_rollback': False})
self.assertTrue('disable_rollback' in args)
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'False'})
self.assertTrue('disable_rollback' in args)
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
args = api.extract_args({'disable_rollback': 'false'})
self.assertTrue('disable_rollback' in args)
self.assertIn('disable_rollback', args)
self.assertFalse(args.get('disable_rollback'))
def test_disable_rollback_extract_bad(self):

147
heat/tests/test_engine_service.py
View File

@ -982,41 +982,40 @@ class StackServiceTest(HeatTestCase):
self.assertEqual(2, len(events))
for ev in events:
self.assertTrue('event_identity' in ev)
self.assertIn('event_identity', ev)
self.assertEqual(dict, type(ev['event_identity']))
self.assertTrue(ev['event_identity']['path'].rsplit('/', 1)[1])
self.assertTrue('resource_name' in ev)
self.assertIn('resource_name', ev)
self.assertEqual('WebServer', ev['resource_name'])
self.assertTrue('physical_resource_id' in ev)
self.assertIn('physical_resource_id', ev)
self.assertTrue('resource_properties' in ev)
self.assertIn('resource_properties', ev)
# Big long user data field.. it mentions 'wordpress'
# a few times so this should work.
user_data = ev['resource_properties']['UserData']
self.assertNotEqual(user_data.find('wordpress'), -1)
self.assertIn('wordpress', user_data)
self.assertEqual('F17-x86_64-gold',
ev['resource_properties']['ImageId'])
self.assertEqual('m1.large',
ev['resource_properties']['InstanceType'])
self.assertEqual('CREATE', ev['resource_action'])
self.assertTrue(ev['resource_status'] in ('IN_PROGRESS',
'COMPLETE'))
self.assertIn(ev['resource_status'], ('IN_PROGRESS', 'COMPLETE'))
self.assertTrue('resource_status_reason' in ev)
self.assertIn('resource_status_reason', ev)
self.assertEqual('state changed', ev['resource_status_reason'])
self.assertTrue('resource_type' in ev)
self.assertIn('resource_type', ev)
self.assertEqual('AWS::EC2::Instance', ev['resource_type'])
self.assertTrue('stack_identity' in ev)
self.assertIn('stack_identity', ev)
self.assertTrue('stack_name' in ev)
self.assertIn('stack_name', ev)
self.assertEqual(self.stack.name, ev['stack_name'])
self.assertTrue('event_time' in ev)
self.assertIn('event_time', ev)
self.m.VerifyAll()
@ -1088,12 +1087,12 @@ class StackServiceTest(HeatTestCase):
self.assertThat(ev['event_identity'], matchers.IsInstance(dict))
self.assertTrue(ev['event_identity']['path'].rsplit('/', 1)[1])
self.assertTrue('resource_name' in ev)
self.assertIn('resource_name', ev)
self.assertEqual('WebServer', ev['resource_name'])
self.assertTrue('physical_resource_id' in ev)
self.assertIn('physical_resource_id', ev)
self.assertTrue('resource_properties' in ev)
self.assertIn('resource_properties', ev)
# Big long user data field.. it mentions 'wordpress'
# a few times so this should work.
user_data = ev['resource_properties']['UserData']
@ -1132,16 +1131,16 @@ class StackServiceTest(HeatTestCase):
self.assertEqual(1, len(sl))
for s in sl:
self.assertTrue('creation_time' in s)
self.assertTrue('updated_time' in s)
self.assertTrue('stack_identity' in s)
self.assertIn('creation_time', s)
self.assertIn('updated_time', s)
self.assertIn('stack_identity', s)
self.assertNotEqual(s['stack_identity'], None)
self.assertTrue('stack_name' in s)
self.assertIn('stack_name', s)
self.assertEqual(self.stack.name, s['stack_name'])
self.assertTrue('stack_status' in s)
self.assertTrue('stack_status_reason' in s)
self.assertTrue('description' in s)
self.assertNotEqual(s['description'].find('WordPress'), -1)
self.assertIn('stack_status', s)
self.assertIn('stack_status_reason', s)
self.assertIn('description', s)
self.assertIn('WordPress', s['description'])
self.m.VerifyAll()
@ -1178,7 +1177,7 @@ class StackServiceTest(HeatTestCase):
self.assertEqual('CREATE', ret['action'])
self.assertEqual('COMPLETE', ret['status'])
self.assertEqual('service_abandon_stack', ret['name'])
self.assertTrue('id' in ret)
self.assertIn('id', ret)
self.assertEqual(expected_res, ret['resources'])
self.assertEqual(self.stack.t.t, ret['template'])
self.m.VerifyAll()
@ -1233,17 +1232,17 @@ class StackServiceTest(HeatTestCase):
self.assertEqual(1, len(sl))
s = sl[0]
self.assertTrue('creation_time' in s)
self.assertTrue('updated_time' in s)
self.assertTrue('stack_identity' in s)
self.assertIn('creation_time', s)
self.assertIn('updated_time', s)
self.assertIn('stack_identity', s)
self.assertNotEqual(s['stack_identity'], None)
self.assertTrue('stack_name' in s)
self.assertIn('stack_name', s)
self.assertEqual(self.stack.name, s['stack_name'])
self.assertTrue('stack_status' in s)
self.assertTrue('stack_status_reason' in s)
self.assertTrue('description' in s)
self.assertNotEqual(s['description'].find('WordPress'), -1)
self.assertTrue('parameters' in s)
self.assertIn('stack_status', s)
self.assertIn('stack_status_reason', s)
self.assertIn('description', s)
self.assertIn('WordPress', s['description'])
self.assertIn('parameters', s)
self.m.VerifyAll()
@ -1254,22 +1253,22 @@ class StackServiceTest(HeatTestCase):
self.assertEqual(1, len(sl))
s = sl[0]
self.assertTrue('creation_time' in s)
self.assertTrue('updated_time' in s)
self.assertTrue('stack_identity' in s)
self.assertIn('creation_time', s)
self.assertIn('updated_time', s)
self.assertIn('stack_identity', s)
self.assertNotEqual(s['stack_identity'], None)
self.assertTrue('stack_name' in s)
self.assertIn('stack_name', s)
self.assertEqual(self.stack.name, s['stack_name'])
self.assertTrue('stack_status' in s)
self.assertTrue('stack_status_reason' in s)
self.assertTrue('description' in s)
self.assertNotEqual(s['description'].find('WordPress'), -1)
self.assertTrue('parameters' in s)
self.assertIn('stack_status', s)
self.assertIn('stack_status_reason', s)
self.assertIn('description', s)
self.assertIn('WordPress', s['description'])
self.assertIn('parameters', s)
def test_list_resource_types(self):
resources = self.eng.list_resource_types(self.ctx)
self.assertTrue(isinstance(resources, list))
self.assertTrue('AWS::EC2::Instance' in resources)
self.assertIn('AWS::EC2::Instance', resources)
def test_resource_schema(self):
type_name = 'ResourceWithPropsType'
@ -1306,19 +1305,19 @@ class StackServiceTest(HeatTestCase):
r = self.eng.describe_stack_resource(self.ctx, self.stack.identifier(),
'WebServer')
self.assertTrue('resource_identity' in r)
self.assertTrue('description' in r)
self.assertTrue('updated_time' in r)
self.assertTrue('stack_identity' in r)
self.assertIn('resource_identity', r)
self.assertIn('description', r)
self.assertIn('updated_time', r)
self.assertIn('stack_identity', r)
self.assertNotEqual(r['stack_identity'], None)
self.assertTrue('stack_name' in r)
self.assertIn('stack_name', r)
self.assertEqual(self.stack.name, r['stack_name'])
self.assertTrue('metadata' in r)
self.assertTrue('resource_status' in r)
self.assertTrue('resource_status_reason' in r)
self.assertTrue('resource_type' in r)
self.assertTrue('physical_resource_id' in r)
self.assertTrue('resource_name' in r)
self.assertIn('metadata', r)
self.assertIn('resource_status', r)
self.assertIn('resource_status_reason', r)
self.assertIn('resource_type', r)
self.assertIn('physical_resource_id', r)
self.assertIn('resource_name', r)
self.assertEqual('WebServer', r['resource_name'])
self.m.VerifyAll()
@ -1409,18 +1408,18 @@ class StackServiceTest(HeatTestCase):
self.assertEqual(1, len(resources))
r = resources[0]
self.assertTrue('resource_identity' in r)
self.assertTrue('description' in r)
self.assertTrue('updated_time' in r)
self.assertTrue('stack_identity' in r)
self.assertIn('resource_identity', r)
self.assertIn('description', r)
self.assertIn('updated_time', r)
self.assertIn('stack_identity', r)
self.assertNotEqual(r['stack_identity'], None)
self.assertTrue('stack_name' in r)
self.assertIn('stack_name', r)
self.assertEqual(self.stack.name, r['stack_name'])
self.assertTrue('resource_status' in r)
self.assertTrue('resource_status_reason' in r)
self.assertTrue('resource_type' in r)
self.assertTrue('physical_resource_id' in r)
self.assertTrue('resource_name' in r)
self.assertIn('resource_status', r)
self.assertIn('resource_status_reason', r)
self.assertIn('resource_type', r)
self.assertIn('physical_resource_id', r)
self.assertIn('resource_name', r)
self.assertEqual('WebServer', r['resource_name'])
self.m.VerifyAll()
@ -1438,7 +1437,7 @@ class StackServiceTest(HeatTestCase):
self.assertEqual(1, len(resources))
r = resources[0]
self.assertTrue('resource_name' in r)
self.assertIn('resource_name', r)
self.assertEqual('WebServer', r['resource_name'])
self.m.VerifyAll()
@ -1493,14 +1492,14 @@ class StackServiceTest(HeatTestCase):
self.assertEqual(1, len(resources))
r = resources[0]
self.assertTrue('resource_identity' in r)
self.assertTrue('updated_time' in r)
self.assertTrue('physical_resource_id' in r)
self.assertTrue('resource_name' in r)
self.assertIn('resource_identity', r)
self.assertIn('updated_time', r)
self.assertIn('physical_resource_id', r)
self.assertIn('resource_name', r)
self.assertEqual('WebServer', r['resource_name'])
self.assertTrue('resource_status' in r)
self.assertTrue('resource_status_reason' in r)
self.assertTrue('resource_type' in r)
self.assertIn('resource_status', r)
self.assertIn('resource_status_reason', r)
self.assertIn('resource_type', r)
self.m.VerifyAll()
@ -1731,7 +1730,7 @@ class StackServiceTest(HeatTestCase):
# Check the response has all keys defined in the engine API
for key in engine_api.WATCH_KEYS:
self.assertTrue(key in result[0])
self.assertIn(key, result[0])
@stack_context('service_show_watch_metric_test_stack', False)
@utils.wr_delete_after
@ -1778,7 +1777,7 @@ class StackServiceTest(HeatTestCase):
# Check the response has all keys defined in the engine API
for key in engine_api.WATCH_DATA_KEYS:
self.assertTrue(key in result[0])
self.assertIn(key, result[0])
@stack_context('service_show_watch_state_test_stack')
@utils.wr_delete_after

2
heat/tests/test_event.py
View File

@ -144,4 +144,4 @@ class EventTest(HeatTestCase):
res = generic_rsrc.ResourceWithRequiredProps(rname, tmpl, self.stack)
e = event.Event(self.ctx, self.stack, 'TEST', 'IN_PROGRESS', 'Testing',
'wibble', res.properties, res.name, res.type())
self.assertTrue('Error' in e.resource_properties)
self.assertIn('Error', e.resource_properties)

14
heat/tests/test_instance_group_update_policy.py
View File

@ -245,7 +245,7 @@ class InstanceGroupTest(HeatTestCase):
grp = stack['JobServerGroup']
self.assertTrue(grp.update_policy)
self.assertTrue(len(grp.update_policy) == 1)
self.assertTrue('RollingUpdate' in grp.update_policy)
self.assertIn('RollingUpdate', grp.update_policy)
policy = grp.update_policy['RollingUpdate']
self.assertTrue(policy and len(policy) > 0)
self.assertEqual(int(policy['MinInstancesInService']), 1)
@ -259,7 +259,7 @@ class InstanceGroupTest(HeatTestCase):
grp = stack['JobServerGroup']
self.assertTrue(grp.update_policy)
self.assertTrue(len(grp.update_policy) == 1)
self.assertTrue('RollingUpdate' in grp.update_policy)
self.assertIn('RollingUpdate', grp.update_policy)
policy = grp.update_policy['RollingUpdate']
self.assertTrue(policy and len(policy) > 0)
self.assertEqual(int(policy['MinInstancesInService']), 0)
@ -354,7 +354,7 @@ class InstanceGroupTest(HeatTestCase):
# test that update policy is loaded
current_grp = stack['JobServerGroup']
self.assertTrue('RollingUpdate' in current_grp.update_policy)
self.assertIn('RollingUpdate', current_grp.update_policy)
current_policy = current_grp.update_policy['RollingUpdate']
self.assertTrue(current_policy)
self.assertTrue(len(current_policy) > 0)
@ -406,7 +406,7 @@ class InstanceGroupTest(HeatTestCase):
# test that the update policy is updated
updated_grp = stack['JobServerGroup']
self.assertTrue('RollingUpdate' in updated_grp.update_policy)
self.assertIn('RollingUpdate', updated_grp.update_policy)
updated_policy = updated_grp.update_policy['RollingUpdate']
self.assertTrue(updated_policy)
self.assertTrue(len(updated_policy) > 0)
@ -589,7 +589,7 @@ class InstanceGroupTest(HeatTestCase):
# test that update policy is loaded
current_grp = stack['JobServerGroup']
self.assertTrue('RollingUpdate' in current_grp.update_policy)
self.assertIn('RollingUpdate', current_grp.update_policy)
current_policy = current_grp.update_policy['RollingUpdate']
self.assertTrue(current_policy)
self.assertTrue(len(current_policy) > 0)
@ -633,7 +633,7 @@ class InstanceGroupTest(HeatTestCase):
# test that update policy is loaded
current_grp = stack['JobServerGroup']
self.assertTrue('RollingUpdate' in current_grp.update_policy)
self.assertIn('RollingUpdate', current_grp.update_policy)
current_policy = current_grp.update_policy['RollingUpdate']
self.assertTrue(current_policy)
self.assertTrue(len(current_policy) > 0)
@ -664,7 +664,7 @@ class InstanceGroupTest(HeatTestCase):
# test that the update policy is updated
updated_grp = stack['JobServerGroup']
self.assertTrue('RollingUpdate' in updated_grp.update_policy)
self.assertIn('RollingUpdate', updated_grp.update_policy)
updated_policy = updated_grp.update_policy['RollingUpdate']
self.assertTrue(updated_policy)
self.assertTrue(len(updated_policy) > 0)

18
heat/tests/test_nova_utils.py
View File

@ -119,13 +119,13 @@ class NovaUtilsUserdataTests(HeatTestCase):
self.m.ReplayAll()
data = nova_utils.build_userdata(resource,
instance_user=self.instance_user)
self.assertTrue("Content-Type: text/cloud-config;" in data)
self.assertTrue("Content-Type: text/cloud-boothook;" in data)
self.assertTrue("Content-Type: text/part-handler;" in data)
self.assertTrue("Content-Type: text/x-cfninitdata;" in data)
self.assertTrue("Content-Type: text/x-shellscript;" in data)
self.assertTrue("http://server.test:345" in data)
self.assertTrue("http://server.test:123" in data)
self.assertTrue("[Boto]" in data)
self.assertTrue(self.expect in data)
self.assertIn("Content-Type: text/cloud-config;", data)
self.assertIn("Content-Type: text/cloud-boothook;", data)
self.assertIn("Content-Type: text/part-handler;", data)
self.assertIn("Content-Type: text/x-cfninitdata;", data)
self.assertIn("Content-Type: text/x-shellscript;", data)
self.assertIn("http://server.test:345", data)
self.assertIn("http://server.test:123", data)
self.assertIn("[Boto]", data)
self.assertIn(self.expect, data)
self.m.VerifyAll()

4
heat/tests/test_parameters.py
View File

@ -341,7 +341,7 @@ class ParametersTest(testtools.TestCase):
self.assertEqual(params['AWS::StackName'], 'test_stack')
self.assertEqual(params['AWS::StackId'], 'None')
self.assertTrue('AWS::Region' in params)
self.assertIn('AWS::Region', params)
def test_pseudo_param_stackid(self):
params = self.new_parameters('test_stack', {'Parameters': {}},
@ -369,7 +369,7 @@ class ParametersTest(testtools.TestCase):
self.assertEqual(as_dict['Foo'], 'foo')
self.assertEqual(as_dict['Bar'], 42)
self.assertEqual(as_dict['AWS::StackName'], 'test_params')
self.assertTrue('AWS::Region' in as_dict)
self.assertIn('AWS::Region', as_dict)
def test_map(self):
template = {'Parameters': {'Foo': {'Type': 'String'},

18
heat/tests/test_parser.py
View File

@ -886,7 +886,7 @@ class StackTest(HeatTestCase):
self.stack.store()
info = self.stack.get_abandon_data()
self.assertEqual(None, info['action'])
self.assertTrue('id' in info)
self.assertIn('id', info)
self.assertEqual('stack_details_test', info['name'])
self.assertTrue(resources, info['resources'])
self.assertEqual(None, info['status'])
@ -1239,7 +1239,7 @@ class StackTest(HeatTestCase):
self.stack.create()
self.assertEqual(self.stack.state,
(parser.Stack.CREATE, parser.Stack.COMPLETE))
self.assertTrue('AResource' in self.stack)
self.assertIn('AResource', self.stack)
rsrc = self.stack['AResource']
rsrc.resource_id_set('aaaa')
self.assertNotEqual(None, resource)
@ -1280,7 +1280,7 @@ class StackTest(HeatTestCase):
self.stack.update(updated_stack)
self.assertEqual(self.stack.state,
(parser.Stack.UPDATE, parser.Stack.COMPLETE))
self.assertTrue('BResource' in self.stack)
self.assertIn('BResource', self.stack)
@utils.stack_delete_after
def test_update_remove(self):
@ -1302,7 +1302,7 @@ class StackTest(HeatTestCase):
self.stack.update(updated_stack)
self.assertEqual(self.stack.state,
(parser.Stack.UPDATE, parser.Stack.COMPLETE))
self.assertFalse('BResource' in self.stack)
self.assertNotIn('BResource', self.stack)
@utils.stack_delete_after
def test_update_description(self):
@ -1485,12 +1485,12 @@ class StackTest(HeatTestCase):
self.stack.update(updated_stack)
self.assertEqual(self.stack.state,
(parser.Stack.UPDATE, parser.Stack.FAILED))
self.assertTrue('BResource' in self.stack)
self.assertIn('BResource', self.stack)
# Reload the stack from the DB and prove that it contains the failed
# resource (to ensure it will be deleted on stack delete)
re_stack = parser.Stack.load(self.ctx, stack_id=self.stack.id)
self.assertTrue('BResource' in re_stack)
self.assertIn('BResource', re_stack)
self.m.VerifyAll()
@utils.stack_delete_after
@ -1592,7 +1592,7 @@ class StackTest(HeatTestCase):
self.stack.update(updated_stack)
self.assertEqual(self.stack.state,
(parser.Stack.ROLLBACK, parser.Stack.COMPLETE))
self.assertFalse('BResource' in self.stack)
self.assertNotIn('BResource', self.stack)
self.m.VerifyAll()
@utils.stack_delete_after
@ -1622,7 +1622,7 @@ class StackTest(HeatTestCase):
self.stack.update(updated_stack)
self.assertEqual(self.stack.state,
(parser.Stack.ROLLBACK, parser.Stack.COMPLETE))
self.assertTrue('BResource' in self.stack)
self.assertIn('BResource', self.stack)
self.m.VerifyAll()
# Unset here so delete() is not stubbed for stack.delete cleanup
self.m.UnsetStubs()
@ -2013,7 +2013,7 @@ class StackTest(HeatTestCase):
self.stack.create()
self.assertEqual(self.stack.state,
(parser.Stack.CREATE, parser.Stack.COMPLETE))
self.assertTrue('AResource' in self.stack)
self.assertIn('AResource', self.stack)
rsrc = self.stack['AResource']
rsrc.resource_id_set('aaaa')
self.assertEqual('AResource', rsrc.FnGetAtt('Foo'))

10
heat/tests/test_plugin_loader.py
View File

@ -28,11 +28,11 @@ class PluginLoaderTest(testtools.TestCase):
def test_create_subpackage_single_path(self):
pkg_name = 'heat.engine.test_single_path'
self.assertFalse(pkg_name in sys.modules)
self.assertNotIn(pkg_name, sys.modules)
pkg = plugin_loader.create_subpackage('/tmp',
'heat.engine',
'test_single_path')
self.assertTrue(pkg_name in sys.modules)
self.assertIn(pkg_name, sys.modules)
self.assertEqual(sys.modules[pkg_name], pkg)
self.assertEqual(pkg.__path__, ['/tmp'])
self.assertEqual(pkg.__name__, pkg_name)
@ -40,14 +40,14 @@ class PluginLoaderTest(testtools.TestCase):
def test_create_subpackage_path_list(self):
path_list = ['/tmp']
pkg_name = 'heat.engine.test_path_list'
self.assertFalse(pkg_name in sys.modules)
self.assertNotIn(pkg_name, sys.modules)
pkg = plugin_loader.create_subpackage('/tmp',
'heat.engine',
'test_path_list')
self.assertTrue(pkg_name in sys.modules)
self.assertIn(pkg_name, sys.modules)
self.assertEqual(sys.modules[pkg_name], pkg)
self.assertEqual(pkg.__path__, path_list)
self.assertFalse(pkg.__path__ is path_list)
self.assertNotIn(pkg.__path__, path_list)
self.assertEqual(pkg.__name__, pkg_name)
def test_import_module_existing(self):

6
heat/tests/test_stack_resource.py
View File

@ -132,9 +132,9 @@ class StackResourceTest(HeatTestCase):
# randomly generated uuids)
self.assertEqual(6, len(ret))
self.assertEqual('CREATE', ret['action'])
self.assertTrue('name' in ret)
self.assertTrue('id' in ret)
self.assertTrue('resources' in ret)
self.assertIn('name', ret)
self.assertIn('id', ret)
self.assertIn('resources', ret)
self.assertEqual(template_format.parse(param_template),
ret['template'])

2
heat/tests/test_urlfetch.py
View File

@ -128,5 +128,5 @@ class UrlFetchTest(HeatTestCase):
requests.get(url, stream=True).AndReturn(response)
self.m.ReplayAll()
exception = self.assertRaises(IOError, urlfetch.get, url)
self.assertTrue("Template exceeds" in str(exception))
self.assertIn("Template exceeds", str(exception))
self.m.VerifyAll()

16
heat/tests/test_wsgi.py
View File

@ -280,14 +280,14 @@ class JSONRequestDeserializerTest(HeatTestCase):
request = wsgi.Request.blank('/')
request.method = 'POST'
request.body = '{"key": "value"}'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request))
def test_has_body_has_content_length_plain_content_type(self):
request = wsgi.Request.blank('/')
request.method = 'POST'
request.body = '{"key": "value"}'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
request.headers['Content-Type'] = 'text/plain'
self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request))
@ -295,7 +295,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request = wsgi.Request.blank('/')
request.method = 'POST'
request.body = 'asdf'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
request.headers['Content-Type'] = 'application/json'
self.assertFalse(wsgi.JSONRequestDeserializer().has_body(request))
@ -303,7 +303,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request = wsgi.Request.blank('/')
request.method = 'POST'
request.body = '{"key": "value"}'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
request.headers['Content-Type'] = 'application/json'
self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request))
@ -311,7 +311,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request = wsgi.Request.blank('/')
request.method = 'POST'
request.body = '{"key": "value"}'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
request.headers['Content-Type'] = 'application/xml'
self.assertFalse(wsgi.JSONRequestDeserializer().has_body(request))
@ -319,14 +319,14 @@ class JSONRequestDeserializerTest(HeatTestCase):
request = wsgi.Request.blank('/?ContentType=JSON')
request.method = 'GET'
request.body = '{"key": "value"}'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request))
def test_has_body_respect_aws_content_type(self):
request = wsgi.Request.blank('/?ContentType=JSON')
request.method = 'GET'
request.body = '{"key": "value"}'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
request.headers['Content-Type'] = 'application/xml'
self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request))
@ -334,7 +334,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request = wsgi.Request.blank('/')
request.method = 'GET'
request.body = '{"key": "value"}'
self.assertTrue('Content-Length' in request.headers)
self.assertIn('Content-Length', request.headers)
self.assertTrue(wsgi.JSONRequestDeserializer().has_body(request))
def test_no_body_no_content_length(self):