openstack
/
heat
Code Issues Proposed changes

Fix order of arguments in assertEqual (patch 2/2) 

Some tests used incorrect order assertEqual(observed, expected).

The correct order expected by testtools is
assertEqual(expected, observed).

This patch includes the other half of the files touched by these changes
(starting from test_n* plus contrib code) to ease the review.

Change-Id: I870386871581980abd796304dd91be0c662cb73e
Partial-Bug: #1259292
This commit is contained in:
Pavlo Shchelokovskyy 2013-12-30 11:15:54 +02:00
parent 834eb42e2e
commit 240fec9eef
31 changed files with 687 additions and 682 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
contrib/docker-plugin/tests/test_docker_container.py
View File

@ -64,8 +64,8 @@ class DockerContainerTest(HeatTestCase):
self.assertIsNone(resource.validate())
self.m.ReplayAll()
scheduler.TaskRunner(resource.create)()
self.assertEqual(resource.state, (resource.CREATE,
resource.COMPLETE))
self.assertEqual((resource.CREATE, resource.COMPLETE),
resource.state)
return resource
def get_container_state(self, resource):
@ -96,8 +96,8 @@ class DockerContainerTest(HeatTestCase):
def test_resource_delete(self):
container = self.create_container('Blog')
scheduler.TaskRunner(container.delete)()
self.assertEqual(container.state, (container.DELETE,
container.COMPLETE))
self.assertEqual((container.DELETE, container.COMPLETE),
container.state)
running = self.get_container_state(container)['Running']
self.assertIs(False, running)
self.m.VerifyAll()
@ -106,14 +106,14 @@ class DockerContainerTest(HeatTestCase):
container = self.create_container('Blog')
# Test suspend
scheduler.TaskRunner(container.suspend)()
self.assertEqual(container.state, (container.SUSPEND,
container.COMPLETE))
self.assertEqual((container.SUSPEND, container.COMPLETE),
container.state)
running = self.get_container_state(container)['Running']
self.assertIs(False, running)
# Test resume
scheduler.TaskRunner(container.resume)()
self.assertEqual(container.state, (container.RESUME,
container.COMPLETE))
self.assertEqual((container.RESUME, container.COMPLETE),
container.state)
running = self.get_container_state(container)['Running']
self.assertIs(True, running)
self.m.VerifyAll()

73
contrib/rackspace/heat/tests/test_auto_scale.py
View File

@ -207,7 +207,7 @@ class ScalingGroupTest(HeatTestCase):
self.stack = utils.parse_stack(self.group_template)
self.stack.create()
self.assertEqual(
self.stack.state, ('CREATE', 'COMPLETE'),
('CREATE', 'COMPLETE'), self.stack.state,
self.stack.status_reason)
def test_group_create(self):
@ -216,9 +216,8 @@ class ScalingGroupTest(HeatTestCase):
the group ID as the resource ID.
"""
self._setup_test_stack()
self.assertEqual(len(self.fake_auto_scale.groups), 1)
self.assertEqual(1, len(self.fake_auto_scale.groups))
self.assertEqual(
self.fake_auto_scale.groups['0'].kwargs,
{
'cooldown': 60,
'disk_config': None,
@ -234,9 +233,11 @@ class ScalingGroupTest(HeatTestCase):
'name': 'My Group',
'networks': None,
'personality': None,
'server_name': u'autoscaled-server'})
'server_name': u'autoscaled-server'},
self.fake_auto_scale.groups['0'].kwargs)
resource = self.stack['my_group']
self.assertEqual(resource.FnGetRefId(), '0')
self.assertEqual('0', resource.FnGetRefId())
def test_update_group_config(self):
"""
@ -250,9 +251,9 @@ class ScalingGroupTest(HeatTestCase):
new_template['Properties']['groupConfiguration']['minEntities'] = 5
scheduler.TaskRunner(resource.update, new_template)()
self.assertEqual(len(self.fake_auto_scale.groups), 1)
self.assertEqual(1, len(self.fake_auto_scale.groups))
self.assertEqual(
self.fake_auto_scale.groups['0'].kwargs['min_entities'], 5)
5, self.fake_auto_scale.groups['0'].kwargs['min_entities'])
def test_update_launch_config(self):
"""
@ -267,10 +268,10 @@ class ScalingGroupTest(HeatTestCase):
lcargs['loadBalancers'] = [{'loadBalancerId': '1', 'port': 80}]
scheduler.TaskRunner(resource.update, new_template)()
self.assertEqual(len(self.fake_auto_scale.groups), 1)
self.assertEqual(1, len(self.fake_auto_scale.groups))
self.assertEqual(
self.fake_auto_scale.groups['0'].kwargs['load_balancers'],
[{'loadBalancerId': 1, 'port': 80}])
[{'loadBalancerId': 1, 'port': 80}],
self.fake_auto_scale.groups['0'].kwargs['load_balancers'])
def test_delete(self):
"""
@ -279,7 +280,7 @@ class ScalingGroupTest(HeatTestCase):
self._setup_test_stack()
resource = self.stack['my_group']
scheduler.TaskRunner(resource.delete)()
self.assertEqual(self.fake_auto_scale.groups, {})
self.assertEqual({}, self.fake_auto_scale.groups)
def test_delete_without_backing_group(self):
"""
@ -290,7 +291,7 @@ class ScalingGroupTest(HeatTestCase):
resource = self.stack['my_group']
del self.fake_auto_scale.groups['0']
scheduler.TaskRunner(resource.delete)()
self.assertEqual(self.fake_auto_scale.groups, {})
self.assertEqual({}, self.fake_auto_scale.groups)
def test_delete_waits_for_server_deletion(self):
"""
@ -309,7 +310,7 @@ class ScalingGroupTest(HeatTestCase):
resource = self.stack['my_group']
scheduler.TaskRunner(resource.delete)()
# It really called delete until it succeeded:
self.assertEqual(delete_counter.next(), 4)
self.assertEqual(4, delete_counter.next())
def test_delete_blows_up_on_other_errors(self):
"""
@ -356,7 +357,7 @@ class PolicyTest(HeatTestCase):
self.stack = utils.parse_stack(template)
self.stack.create()
self.assertEqual(
self.stack.state, ('CREATE', 'COMPLETE'),
('CREATE', 'COMPLETE'), self.stack.state,
self.stack.status_reason)
def test_create_webhook_change(self):
@ -366,15 +367,15 @@ class PolicyTest(HeatTestCase):
"""
self._setup_test_stack(self.policy_template)
resource = self.stack['my_policy']
self.assertEqual(resource.FnGetRefId(), 'my-group-id:0')
self.assertEqual('my-group-id:0', resource.FnGetRefId())
self.assertEqual(
self.fake_auto_scale.policies['0'].kwargs,
{
'name': '+10 on webhook',
'scaling_group': 'my-group-id',
'change': 10,
'cooldown': 0,
'policy_type': 'webhook'})
'policy_type': 'webhook'},
self.fake_auto_scale.policies['0'].kwargs)
def test_webhook_change_percent(self):
"""
@ -386,14 +387,14 @@ class PolicyTest(HeatTestCase):
del template['Resources']['my_policy']['Properties']['change']
self._setup_test_stack(template)
self.assertEqual(
self.fake_auto_scale.policies['0'].kwargs,
{
'name': '+10 on webhook',
'scaling_group': 'my-group-id',
'change': 10,
'is_percent': True,
'cooldown': 0,
'policy_type': 'webhook'})
'policy_type': 'webhook'},
self.fake_auto_scale.policies['0'].kwargs)
def test_webhook_desired_capacity(self):
"""
@ -405,13 +406,13 @@ class PolicyTest(HeatTestCase):
del template['Resources']['my_policy']['Properties']['change']
self._setup_test_stack(template)
self.assertEqual(
self.fake_auto_scale.policies['0'].kwargs,
{
'name': '+10 on webhook',
'scaling_group': 'my-group-id',
'desired_capacity': 1,
'cooldown': 0,
'policy_type': 'webhook'})
'policy_type': 'webhook'},
self.fake_auto_scale.policies['0'].kwargs)
def test_schedule(self):
"""We can specify schedule-type policies with args."""
@ -421,14 +422,14 @@ class PolicyTest(HeatTestCase):
props['args'] = {'cron': '0 0 0 * *'}
self._setup_test_stack(template)
self.assertEqual(
self.fake_auto_scale.policies['0'].kwargs,
{
'name': '+10 on webhook',
'scaling_group': 'my-group-id',
'change': 10,
'cooldown': 0,
'policy_type': 'schedule',
'args': {'cron': '0 0 0 * *'}})
'args': {'cron': '0 0 0 * *'}},
self.fake_auto_scale.policies['0'].kwargs)
def test_update(self):
"""
@ -442,21 +443,21 @@ class PolicyTest(HeatTestCase):
scheduler.TaskRunner(resource.update, template)()
self.assertEqual(
self.fake_auto_scale.policies['0'].kwargs,
{
'name': '+10 on webhook',
'scaling_group': 'my-group-id',
'change': 50,
'is_percent': True,
'cooldown': 0,
'policy_type': 'webhook'})
'policy_type': 'webhook'},
self.fake_auto_scale.policies['0'].kwargs)
def test_delete(self):
"""Deleting the resource deletes the policy with pyrax."""
self._setup_test_stack(self.policy_template)
resource = self.stack['my_policy']
scheduler.TaskRunner(resource.delete)()
self.assertEqual(self.fake_auto_scale.policies, {})
self.assertEqual({}, self.fake_auto_scale.policies)
def test_delete_policy_non_existent(self):
"""
@ -467,7 +468,7 @@ class PolicyTest(HeatTestCase):
resource = self.stack['my_policy']
del self.fake_auto_scale.policies['0']
scheduler.TaskRunner(resource.delete)()
self.assertEqual(self.fake_auto_scale.policies, {})
self.assertEqual({}, self.fake_auto_scale.policies)
class WebHookTest(HeatTestCase):
@ -497,7 +498,7 @@ class WebHookTest(HeatTestCase):
self.stack = utils.parse_stack(template)
self.stack.create()
self.assertEqual(
self.stack.state, ('CREATE', 'COMPLETE'),
('CREATE', 'COMPLETE'), self.stack.state,
self.stack.status_reason)
def test_create(self):
@ -505,14 +506,14 @@ class WebHookTest(HeatTestCase):
self._setup_test_stack(self.webhook_template)
resource = self.stack['my_webhook']
self.assertEqual(
self.fake_auto_scale.webhooks['0'].kwargs,
{
'name': 'exec my policy',
'scaling_group': 'my-group-id',
'policy': 'my-policy-id',
'metadata': {'a': 'b'}})
self.assertEqual(resource.FnGetAtt("executeUrl"), "self-url")
self.assertEqual(resource.FnGetAtt("capabilityUrl"), "capability-url")
'metadata': {'a': 'b'}},
self.fake_auto_scale.webhooks['0'].kwargs)
self.assertEqual("self-url", resource.FnGetAtt("executeUrl"))
self.assertEqual("capability-url", resource.FnGetAtt("capabilityUrl"))
def test_failed_create(self):
"""When a create fails, getting the attributes returns None."""
@ -532,19 +533,19 @@ class WebHookTest(HeatTestCase):
scheduler.TaskRunner(resource.update, template)()
self.assertEqual(
self.fake_auto_scale.webhooks['0'].kwargs,
{
'name': 'newhook',
'scaling_group': 'my-group-id',
'policy': 'my-policy-id',
'metadata': {'a': 'different!'}})
'metadata': {'a': 'different!'}},
self.fake_auto_scale.webhooks['0'].kwargs)
def test_delete(self):
"""Deleting the resource deletes the webhook with pyrax."""
self._setup_test_stack(self.webhook_template)
resource = self.stack['my_webhook']
scheduler.TaskRunner(resource.delete)()
self.assertEqual(self.fake_auto_scale.webhooks, {})
self.assertEqual({}, self.fake_auto_scale.webhooks)
def test_delete_without_backing_webhook(self):
"""
@ -555,4 +556,4 @@ class WebHookTest(HeatTestCase):
resource = self.stack['my_webhook']
del self.fake_auto_scale.webhooks['0']
scheduler.TaskRunner(resource.delete)()
self.assertEqual(self.fake_auto_scale.webhooks, {})
self.assertEqual({}, self.fake_auto_scale.webhooks)

15
contrib/rackspace/heat/tests/test_cloud_loadbalancer.py
View File

@ -298,10 +298,11 @@ class LoadBalancerTest(HeatTestCase):
rsrc, fake_loadbalancer = self._mock_loadbalancer(template,
self.lb_name,
expected)
self.assertEqual(rsrc.validate(), {
'Error':
'The halfClosed property is only available for the '
'TCP or TCP_CLIENT_FIRST protocols'})
self.assertEqual(
{'Error':
'The halfClosed property is only available for the '
'TCP or TCP_CLIENT_FIRST protocols'},
rsrc.validate())
#test TCP protocol
template = self._set_template(template, protocol='TCP')
@ -349,8 +350,8 @@ class LoadBalancerTest(HeatTestCase):
rsrc, fake_loadbalancer = self._mock_loadbalancer(template,
self.lb_name,
expected)
self.assertEqual(rsrc.validate(),
{'Error': 'Unknown Property bodyRegex'})
self.assertEqual({'Error': 'Unknown Property bodyRegex'},
rsrc.validate())
#test http fields
health_monitor['type'] = 'HTTP'
@ -425,7 +426,7 @@ class LoadBalancerTest(HeatTestCase):
scheduler.TaskRunner(rsrc.create)()
self.m.VerifyAll()
self.assertEqual(rsrc.FnGetRefId(), rsrc.resource_id)
self.assertEqual(rsrc.resource_id, rsrc.FnGetRefId())
def test_post_creation_error_page(self):
error_page = "REALLY BIG ERROR"

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

@ -137,9 +137,9 @@ class CloudDBInstanceTest(HeatTestCase):
instance.handle_create()
expected_hostname = fakedbinstance.hostname
expected_href = fakedbinstance.links[0]['href']
self.assertEqual(instance._resolve_attribute('hostname'),
expected_hostname)
self.assertEqual(instance._resolve_attribute('href'), expected_href)
self.assertEqual(expected_hostname,
instance._resolve_attribute('hostname'))
self.assertEqual(expected_href, instance._resolve_attribute('href'))
self.m.VerifyAll()
def test_clouddbinstance_delete_resource_notfound(self):

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

@ -181,10 +181,10 @@ class RackspaceCloudServerTest(HeatTestCase):
expected_public = return_server.networks['public'][0]
expected_private = return_server.networks['private'][0]
self.assertEqual(cs.FnGetAtt('PublicIp'), expected_public)
self.assertEqual(cs.FnGetAtt('PrivateIp'), expected_private)
self.assertEqual(cs.FnGetAtt('PublicDnsName'), expected_public)
self.assertEqual(cs.FnGetAtt('PrivateDnsName'), expected_public)
self.assertEqual(expected_public, cs.FnGetAtt('PublicIp'))
self.assertEqual(expected_private, cs.FnGetAtt('PrivateIp'))
self.assertEqual(expected_public, cs.FnGetAtt('PublicDnsName'))
self.assertEqual(expected_public, cs.FnGetAtt('PrivateDnsName'))
self.m.VerifyAll()
@ -200,10 +200,10 @@ class RackspaceCloudServerTest(HeatTestCase):
expected_public = return_server.networks['public'][0]
expected_private = return_server.networks['private'][0]
self.assertEqual(cs.FnGetAtt('PublicIp'), expected_public)
self.assertEqual(cs.FnGetAtt('PrivateIp'), expected_private)
self.assertEqual(cs.FnGetAtt('PublicDnsName'), expected_public)
self.assertEqual(cs.FnGetAtt('PrivateDnsName'), expected_public)
self.assertEqual(expected_public, cs.FnGetAtt('PublicIp'))
self.assertEqual(expected_private, cs.FnGetAtt('PrivateIp'))
self.assertEqual(expected_public, cs.FnGetAtt('PublicDnsName'))
self.assertEqual(expected_public, cs.FnGetAtt('PrivateDnsName'))
self.assertRaises(exception.InvalidTemplateAttribute,
cs.FnGetAtt, 'foo')
self.m.VerifyAll()
@ -317,7 +317,7 @@ class RackspaceCloudServerTest(HeatTestCase):
scheduler.TaskRunner(cs.delete)()
self.assertIsNone(cs.resource_id)
self.assertEqual(cs.state, (cs.DELETE, cs.COMPLETE))
self.assertEqual((cs.DELETE, cs.COMPLETE), cs.state)
self.m.VerifyAll()
def test_cs_update_metadata(self):
@ -329,7 +329,7 @@ class RackspaceCloudServerTest(HeatTestCase):
update_template = copy.deepcopy(cs.t)
update_template['Metadata'] = {'test': 123}
scheduler.TaskRunner(cs.update, update_template)()
self.assertEqual(cs.metadata, {'test': 123})
self.assertEqual({'test': 123}, cs.metadata)
def test_cs_update_replace(self):
return_server = self.fc.servers.list()[1]
@ -361,7 +361,7 @@ class RackspaceCloudServerTest(HeatTestCase):
self.m.ReplayAll()
scheduler.TaskRunner(cs.create)()
self.assertEqual(cs.state, (cs.CREATE, cs.COMPLETE))
self.assertEqual((cs.CREATE, cs.COMPLETE), cs.state)
def test_cs_status_hard_reboot(self):
self._test_cs_status_not_build_active('HARD_REBOOT')
@ -409,7 +409,7 @@ class RackspaceCloudServerTest(HeatTestCase):
self.m.ReplayAll()
scheduler.TaskRunner(cs.create)()
self.assertEqual(cs.state, (cs.CREATE, cs.COMPLETE))
self.assertEqual((cs.CREATE, cs.COMPLETE), cs.state)
self.m.VerifyAll()
@ -429,9 +429,9 @@ class RackspaceCloudServerTest(HeatTestCase):
{'version': 6, 'addr': 'fake:ip::6'}],
'private': [{'version': 4, 'addr': '10.13.12.13'}]}
self.mock_get_ip(cs)
self.assertEqual(cs.public_ip, '4.5.6.7')
self.assertEqual('4.5.6.7', cs.public_ip)
self.mock_get_ip(cs)
self.assertEqual(cs.private_ip, '10.13.12.13')
self.assertEqual('10.13.12.13', cs.private_ip)
cs.addresses = {'public': [],
'private': []}
@ -455,8 +455,8 @@ class RackspaceCloudServerTest(HeatTestCase):
stack.id)
encrypted_key = rs.data[0]['value']
self.assertNotEqual(encrypted_key, "fake private key")
decrypted_key = cs.private_key
self.assertEqual(decrypted_key, "fake private key")
# Test private_key property returns decrypted value
self.assertEqual("fake private key", cs.private_key)
def test_rackconnect_deployed(self):
return_server = self.fc.servers.list()[1]
@ -467,8 +467,8 @@ class RackspaceCloudServerTest(HeatTestCase):
cs.context.roles = ['rack_connect']
self.m.ReplayAll()
scheduler.TaskRunner(cs.create)()
self.assertEqual(cs.action, 'CREATE')
self.assertEqual(cs.status, 'COMPLETE')
self.assertEqual('CREATE', cs.action)
self.assertEqual('COMPLETE', cs.status)
self.m.VerifyAll()
def test_rackconnect_failed(self):
@ -496,8 +496,8 @@ class RackspaceCloudServerTest(HeatTestCase):
cs.context.roles = ['rack_connect']
self.m.ReplayAll()
scheduler.TaskRunner(cs.create)()
self.assertEqual(cs.action, 'CREATE')
self.assertEqual(cs.status, 'COMPLETE')
self.assertEqual('CREATE', cs.action)
self.assertEqual('COMPLETE', cs.status)
self.m.VerifyAll()
def test_rackconnect_unknown(self):
@ -522,8 +522,8 @@ class RackspaceCloudServerTest(HeatTestCase):
cs.context.roles = ['rax_managed']
self.m.ReplayAll()
scheduler.TaskRunner(cs.create)()
self.assertEqual(cs.action, 'CREATE')
self.assertEqual(cs.status, 'COMPLETE')
self.assertEqual('CREATE', cs.action)
self.assertEqual('COMPLETE', cs.status)
self.m.VerifyAll()
def test_managed_cloud_build_error(self):

18
heat/tests/test_nested_stack.py
View File

@ -73,7 +73,7 @@ Outputs:
t = template_format.parse(template)
stack = self.parse_stack(t)
stack.create()
self.assertEqual(stack.state, (stack.CREATE, stack.COMPLETE))
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
return stack
def parse_stack(self, t):
@ -92,7 +92,7 @@ Outputs:
stack = self.create_stack(self.test_template)
rsrc = stack['the_nested']
nested_name = utils.PhysName(stack.name, 'the_nested')
self.assertEqual(nested_name, rsrc.physical_resource_name())
self.assertEqual(rsrc.physical_resource_name(), nested_name)
arn_prefix = ('arn:openstack:heat::aaaa:stacks/%s/' %
rsrc.physical_resource_name())
self.assertTrue(rsrc.FnGetRefId().startswith(arn_prefix))
@ -121,7 +121,7 @@ Outputs:
props['TimeoutInMinutes'] = '50'
stack = self.create_stack(json.dumps(timeout_template))
self.assertEqual(stack.state, (stack.CREATE, stack.COMPLETE))
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
self.m.VerifyAll()
def test_nested_stack_create_exceeds_resource_limit(self):
@ -146,7 +146,7 @@ Outputs:
t = template_format.parse(self.test_template)
stack = self.parse_stack(t)
stack.create()
self.assertEqual(stack.state, (stack.CREATE, stack.FAILED))
self.assertEqual((stack.CREATE, stack.FAILED), stack.state)
self.assertIn('Maximum resources per stack exceeded',
stack.status_reason)
@ -174,7 +174,7 @@ Outputs:
t = template_format.parse(self.test_template)
stack = self.parse_stack(t)
stack.create()
self.assertEqual(stack.state, (stack.CREATE, stack.COMPLETE))
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
self.assertIn('NestedResource',
stack['the_nested'].nested())
@ -310,10 +310,10 @@ Outputs:
rsrc = stack['the_nested']
scheduler.TaskRunner(rsrc.suspend)()
self.assertEqual(rsrc.state, (rsrc.SUSPEND, rsrc.COMPLETE))
self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state)
scheduler.TaskRunner(rsrc.resume)()
self.assertEqual(rsrc.state, (rsrc.RESUME, rsrc.COMPLETE))
self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state)
rsrc.delete()
self.m.VerifyAll()
@ -474,7 +474,7 @@ Resources:
t = template_format.parse(template)
stack = self.parse_stack(t)
stack.create()
self.assertEqual(stack.state, (stack.CREATE, stack.FAILED))
self.assertEqual((stack.CREATE, stack.FAILED), stack.state)
self.assertIn('Recursion depth exceeds', stack.status_reason)
self.m.VerifyAll()
@ -545,6 +545,6 @@ Outputs:
stack = self.create_stack(self.test_template)
res = stack['the_nested'].nested()['nested_res']
stack.delete()
self.assertEqual(stack.state, (stack.DELETE, stack.COMPLETE))
self.assertEqual((stack.DELETE, stack.COMPLETE), stack.state)
self.assertRaises(exception.NotFound, db_api.resource_data_get, res,
'test')

8
heat/tests/test_neutron_autoscaling.py
View File

@ -357,8 +357,8 @@ class AutoScalingTest(HeatTestCase):
stack.store()
stack.create()
self.assertEqual(stack.state,
(parser.Stack.CREATE, parser.Stack.COMPLETE))
self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE),
stack.state)
# Start of stack update
stack2 = parser.Stack.load(self.ctx, stack_id=stack.id)
@ -370,8 +370,8 @@ class AutoScalingTest(HeatTestCase):
template.Template(tmpl2),
environment.Environment(env))
stack2.update(update_stack)
self.assertEqual(stack2.state,
(parser.Stack.UPDATE, parser.Stack.COMPLETE))
self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE),
stack2.state)
members = db_api.resource_data_get_all(stack['ElasticLoadBalancer'])
self.assertEqual(3, len(members.keys()))

29
heat/tests/test_notifications.py
View File

@ -102,8 +102,8 @@ class NotificationTest(common.HeatTestCase):
with mock.patch('heat.openstack.common.notifier.api.notify') \
as mock_notify:
self.create_test_stack()
self.assertEqual(self.stack.state, (self.stack.CREATE,
self.stack.COMPLETE))
self.assertEqual((self.stack.CREATE, self.stack.COMPLETE),
self.stack.state)
self.assertEqual(self.expected['create'],
mock_notify.call_args_list)
@ -113,33 +113,32 @@ class NotificationTest(common.HeatTestCase):
with mock.patch('heat.openstack.common.notifier.api.notify') \
as mock_notify:
self.create_test_stack()
self.assertEqual(self.stack.state, (self.stack.CREATE,
self.stack.COMPLETE))
self.assertEqual((self.stack.CREATE, self.stack.COMPLETE),
self.stack.state)
self.assertEqual(self.expected['create'],
mock_notify.call_args_list)
self.stack.suspend()
self.assertEqual(self.stack.state, (self.stack.SUSPEND,
self.stack.COMPLETE))
expected = self.expected['create'] + self.expected['suspend']
self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE),
self.stack.state)
self.assertEqual(expected,
mock_notify.call_args_list)
expected = self.expected['create'] + self.expected['suspend']
self.assertEqual(expected, mock_notify.call_args_list)
@utils.stack_delete_after
def test_create_and_delete_stack(self):
with mock.patch('heat.openstack.common.notifier.api.notify') \
as mock_notify:
self.create_test_stack()
self.assertEqual(self.stack.state, (self.stack.CREATE,
self.stack.COMPLETE))
self.assertEqual((self.stack.CREATE, self.stack.COMPLETE),
self.stack.state)
self.assertEqual(self.expected['create'],
mock_notify.call_args_list)
self.stack.delete()
self.assertEqual(self.stack.state, (self.stack.DELETE,
self.stack.COMPLETE))
self.assertEqual((self.stack.DELETE, self.stack.COMPLETE),
self.stack.state)
expected = self.expected['create'] + self.expected['delete']
self.assertEqual(expected,
mock_notify.call_args_list)
expected = self.expected['create'] + self.expected['delete']
self.assertEqual(expected, mock_notify.call_args_list)

6
heat/tests/test_nova_keypair.py
View File

@ -89,7 +89,7 @@ class NovaKeyPairTest(HeatTestCase):
self.assertEqual("generated test public key",
tp_test.FnGetAtt('public_key'))
self.assertEqual((tp_test.CREATE, tp_test.COMPLETE), tp_test.state)
self.assertEqual(created_key.name, tp_test.resource_id)
self.assertEqual(tp_test.resource_id, created_key.name)
self.m.VerifyAll()
def test_delete_key(self):
@ -127,7 +127,7 @@ class NovaKeyPairTest(HeatTestCase):
self.assertEqual("test_create_pub",
tp_test.FnGetAtt('public_key'))
self.assertEqual((tp_test.CREATE, tp_test.COMPLETE), tp_test.state)
self.assertEqual(created_key.name, tp_test.resource_id)
self.assertEqual(tp_test.resource_id, created_key.name)
self.m.VerifyAll()
def test_save_priv_key(self):
@ -143,5 +143,5 @@ class NovaKeyPairTest(HeatTestCase):
self.assertEqual("generated test public key",
tp_test.FnGetAtt('public_key'))
self.assertEqual((tp_test.CREATE, tp_test.COMPLETE), tp_test.state)
self.assertEqual(created_key.name, tp_test.resource_id)
self.assertEqual(tp_test.resource_id, created_key.name)
self.m.VerifyAll()

54
heat/tests/test_parameters.py
View File

@ -60,8 +60,8 @@ class ParameterTest(testtools.TestCase):
p = self.new_parameter('defaulted', {'Type': 'String',
'Default': 'blarg'})
self.assertTrue(p.has_default())
self.assertEqual(p.default(), 'blarg')
self.assertEqual(p.value(), 'blarg')
self.assertEqual('blarg', p.default())
self.assertEqual('blarg', p.value())
def test_default_override(self):
p = self.new_parameter('defaulted',
@ -69,8 +69,8 @@ class ParameterTest(testtools.TestCase):
'Default': 'blarg'},
'wibble')
self.assertTrue(p.has_default())
self.assertEqual(p.default(), 'blarg')
self.assertEqual(p.value(), 'wibble')
self.assertEqual('blarg', p.default())
self.assertEqual('wibble', p.value())
def test_default_invalid(self):
schema = {'Type': 'String',
@ -103,25 +103,25 @@ class ParameterTest(testtools.TestCase):
'NoEcho': 'false'},
'wibble')
self.assertFalse(p.no_echo())
self.assertEqual(str(p), 'wibble')
self.assertEqual('wibble', str(p))
def test_description(self):
description = 'Description of the parameter'
p = self.new_parameter('p', {'Type': 'String',
'Description': description},
validate_value=False)
self.assertEqual(p.description(), description)
self.assertEqual(description, p.description())
def test_no_description(self):
p = self.new_parameter('p', {'Type': 'String'}, validate_value=False)
self.assertEqual(p.description(), '')
self.assertEqual('', p.description())
def test_string_len_good(self):
schema = {'Type': 'String',
'MinLength': '3',
'MaxLength': '3'}
p = self.new_parameter('p', schema, 'foo')
self.assertEqual(p.value(), 'foo')
self.assertEqual('foo', p.value())
def test_string_underflow(self):
schema = {'Type': 'String',
@ -143,7 +143,7 @@ class ParameterTest(testtools.TestCase):
schema = {'Type': 'String',
'AllowedPattern': '[a-z]*'}
p = self.new_parameter('p', schema, 'foo')
self.assertEqual(p.value(), 'foo')
self.assertEqual('foo', p.value())
def test_string_pattern_bad_prefix(self):
schema = {'Type': 'String',
@ -165,7 +165,7 @@ class ParameterTest(testtools.TestCase):
schema = {'Type': 'String',
'AllowedValues': ['foo', 'bar', 'baz']}
p = self.new_parameter('p', schema, 'bar')
self.assertEqual(p.value(), 'bar')
self.assertEqual('bar', p.value())
def test_string_value_list_bad(self):
schema = {'Type': 'String',
@ -180,14 +180,14 @@ class ParameterTest(testtools.TestCase):
'MinValue': '3',
'MaxValue': '3'}
p = self.new_parameter('p', schema, '3')
self.assertEqual(p.value(), 3)
self.assertEqual(3, p.value())
def test_number_float_good(self):
schema = {'Type': 'Number',
'MinValue': '3.0',
'MaxValue': '4.0'}
p = self.new_parameter('p', schema, '3.5')
self.assertEqual(p.value(), 3.5)
self.assertEqual(3.5, p.value())
def test_number_low(self):
schema = {'Type': 'Number',
@ -209,7 +209,7 @@ class ParameterTest(testtools.TestCase):
schema = {'Type': 'Number',
'AllowedValues': ['1', '3', '5']}
p = self.new_parameter('p', schema, '5')
self.assertEqual(p.value(), 5)
self.assertEqual(5, p.value())
def test_number_value_list_bad(self):
schema = {'Type': 'Number',
@ -223,13 +223,13 @@ class ParameterTest(testtools.TestCase):
schema = {'Type': 'CommaDelimitedList',
'AllowedValues': ['foo', 'bar', 'baz']}
p = self.new_parameter('p', schema, 'baz,foo,bar')
self.assertEqual(p.value(), 'baz,foo,bar'.split(','))
self.assertEqual('baz,foo,bar'.split(','), p.value())
schema['Default'] = []
p = self.new_parameter('p', schema)
self.assertEqual(p.value(), [])
self.assertEqual([], p.value())
schema['Default'] = 'baz,foo,bar'
p = self.new_parameter('p', schema)
self.assertEqual(p.value(), 'baz,foo,bar'.split(','))
self.assertEqual('baz,foo,bar'.split(','), p.value())
def test_list_value_list_bad(self):
schema = {'Type': 'CommaDelimitedList',
@ -339,26 +339,26 @@ class ParametersTest(testtools.TestCase):
def test_pseudo_params(self):
params = self.new_parameters('test_stack', {"Parameters": {}})
self.assertEqual(params['AWS::StackName'], 'test_stack')
self.assertEqual(params['AWS::StackId'], 'None')
self.assertEqual('test_stack', params['AWS::StackName'])
self.assertEqual('None', params['AWS::StackId'])
self.assertIn('AWS::Region', params)
def test_pseudo_param_stackid(self):
params = self.new_parameters('test_stack', {'Parameters': {}},
stack_id='123::foo')
self.assertEqual(params['AWS::StackId'], '123::foo')
self.assertEqual('123::foo', params['AWS::StackId'])
params.set_stack_id('456::bar')
self.assertEqual(params['AWS::StackId'], '456::bar')
self.assertEqual('456::bar', params['AWS::StackId'])
def test_schema_invariance(self):
params1 = self.new_parameters('test', params_schema,
{'User': 'foo',
'Defaulted': 'wibble'})
self.assertEqual(params1['Defaulted'], 'wibble')
self.assertEqual('wibble', params1['Defaulted'])
params2 = self.new_parameters('test', params_schema, {'User': 'foo'})
self.assertEqual(params2['Defaulted'], 'foobar')
self.assertEqual('foobar', params2['Defaulted'])
def test_to_dict(self):
template = {'Parameters': {'Foo': {'Type': 'String'},
@ -366,9 +366,9 @@ class ParametersTest(testtools.TestCase):
params = self.new_parameters('test_params', template, {'Foo': 'foo'})
as_dict = dict(params)
self.assertEqual(as_dict['Foo'], 'foo')
self.assertEqual(as_dict['Bar'], 42)
self.assertEqual(as_dict['AWS::StackName'], 'test_params')
self.assertEqual('foo', as_dict['Foo'])
self.assertEqual(42, as_dict['Bar'])
self.assertEqual('test_params', as_dict['AWS::StackName'])
self.assertIn('AWS::Region', as_dict)
def test_map(self):
@ -382,7 +382,7 @@ class ParametersTest(testtools.TestCase):
'AWS::StackId': True,
'AWS::StackName': True}
self.assertEqual(params.map(lambda p: p.has_default()), expected)
self.assertEqual(expected, params.map(lambda p: p.has_default()))
def test_map_str(self):
template = {'Parameters': {'Foo': {'Type': 'String'},
@ -396,7 +396,7 @@ class ParametersTest(testtools.TestCase):
'AWS::StackId': 'None',
'AWS::StackName': 'test_params'}
self.assertEqual(params.map(str), expected)
self.assertEqual(expected, params.map(str))
def test_unknown_params(self):
user_params = {'Foo': 'wibble'}

498
heat/tests/test_parser.py
View File

File diff suppressed because it is too large Load Diff

12
heat/tests/test_plugin_loader.py
View File

@ -23,8 +23,8 @@ from heat.common import plugin_loader
class PluginLoaderTest(testtools.TestCase):
def test_module_name(self):
self.assertEqual(plugin_loader._module_name('foo.bar', 'blarg.wibble'),
'foo.bar.blarg.wibble')
self.assertEqual('foo.bar.blarg.wibble',
plugin_loader._module_name('foo.bar', 'blarg.wibble'))
def test_create_subpackage_single_path(self):
pkg_name = 'heat.engine.test_single_path'
@ -34,8 +34,8 @@ class PluginLoaderTest(testtools.TestCase):
'test_single_path')
self.assertIn(pkg_name, sys.modules)
self.assertEqual(sys.modules[pkg_name], pkg)
self.assertEqual(pkg.__path__, ['/tmp'])
self.assertEqual(pkg.__name__, pkg_name)
self.assertEqual(['/tmp'], pkg.__path__)
self.assertEqual(pkg_name, pkg.__name__)
def test_create_subpackage_path_list(self):
path_list = ['/tmp']
@ -46,9 +46,9 @@ class PluginLoaderTest(testtools.TestCase):
'test_path_list')
self.assertIn(pkg_name, sys.modules)
self.assertEqual(sys.modules[pkg_name], pkg)
self.assertEqual(pkg.__path__, path_list)
self.assertEqual(path_list, pkg.__path__)
self.assertNotIn(pkg.__path__, path_list)
self.assertEqual(pkg.__name__, pkg_name)
self.assertEqual(pkg_name, pkg.__name__)
def test_import_module_existing(self):
import heat.engine.service

55
heat/tests/test_properties.py
View File

@ -597,11 +597,11 @@ class PropertyTest(testtools.TestCase):
def test_default(self):
p = properties.Property({'Type': 'String', 'Default': 'wibble'})
self.assertEqual(p.default(), 'wibble')
self.assertEqual('wibble', p.default())
def test_type(self):
p = properties.Property({'Type': 'String'})
self.assertEqual(p.type(), 'String')
self.assertEqual('String', p.type())
def test_bad_type(self):
self.assertRaises(constraints.InvalidSchemaError,
@ -616,7 +616,7 @@ class PropertyTest(testtools.TestCase):
schema = {'Type': 'String',
'AllowedPattern': '[a-z]*'}
p = properties.Property(schema)
self.assertEqual(p.validate_data('foo'), 'foo')
self.assertEqual('foo', p.validate_data('foo'))
def test_string_pattern_bad_prefix(self):
schema = {'Type': 'String',
@ -634,7 +634,7 @@ class PropertyTest(testtools.TestCase):
schema = {'Type': 'String',
'AllowedValues': ['foo', 'bar', 'baz']}
p = properties.Property(schema)
self.assertEqual(p.validate_data('bar'), 'bar')
self.assertEqual('bar', p.validate_data('bar'))
def test_string_value_list_bad(self):
schema = {'Type': 'String',
@ -646,7 +646,7 @@ class PropertyTest(testtools.TestCase):
schema = {'Type': 'String',
'MaxLength': '5'}
p = properties.Property(schema)
self.assertEqual(p.validate_data('abcd'), 'abcd')
self.assertEqual('abcd', p.validate_data('abcd'))
def test_string_exceeded_maxlength(self):
schema = {'Type': 'String',
@ -659,13 +659,13 @@ class PropertyTest(testtools.TestCase):
'MinLength': '5',
'MaxLength': '10'}
p = properties.Property(schema)
self.assertEqual(p.validate_data('abcdef'), 'abcdef')
self.assertEqual('abcdef', p.validate_data('abcdef'))
def test_string_minlength_good(self):
schema = {'Type': 'String',
'MinLength': '5'}
p = properties.Property(schema)
self.assertEqual(p.validate_data('abcde'), 'abcde')
self.assertEqual('abcde', p.validate_data('abcde'))
def test_string_smaller_than_minlength(self):
schema = {'Type': 'String',
@ -678,7 +678,7 @@ class PropertyTest(testtools.TestCase):
'MinValue': 3,
'MaxValue': 3}
p = properties.Property(schema)
self.assertEqual(p.validate_data(3), 3)
self.assertEqual(3, p.validate_data(3))
def test_int_bad(self):
schema = {'Type': 'Integer'}
@ -714,7 +714,7 @@ class PropertyTest(testtools.TestCase):
schema = {'Type': 'Integer',
'AllowedValues': [1, 3, 5]}
p = properties.Property(schema)
self.assertEqual(p.validate_data(5), 5)
self.assertEqual(5, p.validate_data(5))
def test_integer_value_list_bad(self):
schema = {'Type': 'Integer',
@ -727,7 +727,7 @@ class PropertyTest(testtools.TestCase):
'MinValue': '3',
'MaxValue': '3'}
p = properties.Property(schema)
self.assertEqual(p.validate_data(3), 3)
self.assertEqual(3, p.validate_data(3))
def test_numbers_from_strings(self):
"""Numbers can be converted from strings."""
@ -735,13 +735,13 @@ class PropertyTest(testtools.TestCase):
'MinValue': '3',
'MaxValue': '3'}
p = properties.Property(schema)
self.assertEqual(p.validate_data('3'), 3)
self.assertEqual(3, p.validate_data('3'))
def test_number_value_list_good(self):
schema = {'Type': 'Number',
'AllowedValues': [1, 3, 5]}
p = properties.Property(schema)
self.assertEqual(p.validate_data('5'), 5)
self.assertEqual(5, p.validate_data('5'))
def test_number_value_list_bad(self):
schema = {'Type': 'Number',
@ -783,7 +783,7 @@ class PropertyTest(testtools.TestCase):
def test_list_good(self):
p = properties.Property({'Type': 'List'})
self.assertEqual(p.validate_data(['foo', 'bar']), ['foo', 'bar'])
self.assertEqual(['foo', 'bar'], p.validate_data(['foo', 'bar']))
def test_list_dict(self):
p = properties.Property({'Type': 'List'})
@ -793,7 +793,7 @@ class PropertyTest(testtools.TestCase):
schema = {'Type': 'List',
'MaxLength': '3'}
p = properties.Property(schema)
self.assertEqual(p.validate_data(['1', '2']), ['1', '2'])
self.assertEqual(['1', '2'], p.validate_data(['1', '2']))
def test_list_exceeded_maxlength(self):
schema = {'Type': 'List',
@ -806,13 +806,13 @@ class PropertyTest(testtools.TestCase):
'MinLength': '2',
'MaxLength': '4'}
p = properties.Property(schema)
self.assertEqual(p.validate_data(['1', '2', '3']), ['1', '2', '3'])
self.assertEqual(['1', '2', '3'], p.validate_data(['1', '2', '3']))
def test_list_minlength_good(self):
schema = {'Type': 'List',
'MinLength': '3'}
p = properties.Property(schema)
self.assertEqual(p.validate_data(['1', '2', '3']), ['1', '2', '3'])
self.assertEqual(['1', '2', '3'], p.validate_data(['1', '2', '3']))
def test_list_smaller_than_minlength(self):
schema = {'Type': 'List',
@ -831,7 +831,7 @@ class PropertyTest(testtools.TestCase):
def test_map_schema_good(self):
map_schema = {'valid': {'Type': 'Boolean'}}
p = properties.Property({'Type': 'Map', 'Schema': map_schema})
self.assertEqual(p.validate_data({'valid': 'TRUE'}), {'valid': True})
self.assertEqual({'valid': True}, p.validate_data({'valid': 'TRUE'}))
def test_map_schema_bad_data(self):
map_schema = {'valid': {'Type': 'Boolean'}}
@ -841,7 +841,7 @@ class PropertyTest(testtools.TestCase):
def test_map_schema_missing_data(self):
map_schema = {'valid': {'Type': 'Boolean'}}
p = properties.Property({'Type': 'Map', 'Schema': map_schema})
self.assertEqual(p.validate_data({}), {'valid': None})
self.assertEqual({'valid': None}, p.validate_data({}))
def test_map_schema_missing_required_data(self):
map_schema = {'valid': {'Type': 'Boolean', 'Required': True}}
@ -852,9 +852,10 @@ class PropertyTest(testtools.TestCase):
map_schema = {'valid': {'Type': 'Boolean'}}
list_schema = {'Type': 'Map', 'Schema': map_schema}
p = properties.Property({'Type': 'List', 'Schema': list_schema})
self.assertEqual(p.validate_data(
[{'valid': 'TRUE'}, {'valid': 'False'}]),
[{'valid': True}, {'valid': False}])
self.assertEqual([{'valid': True},
{'valid': False}],
p.validate_data([{'valid': 'TRUE'},
{'valid': 'False'}]))
def test_list_schema_bad_data(self):
map_schema = {'valid': {'Type': 'Boolean'}}
@ -866,7 +867,7 @@ class PropertyTest(testtools.TestCase):
def test_list_schema_int_good(self):
list_schema = {'Type': 'Integer'}
p = properties.Property({'Type': 'List', 'Schema': list_schema})
self.assertEqual(p.validate_data([1, 2, 3]), [1, 2, 3])
self.assertEqual([1, 2, 3], p.validate_data([1, 2, 3]))
def test_list_schema_int_bad_data(self):
list_schema = {'Type': 'Integer'}
@ -896,10 +897,10 @@ class PropertiesTest(testtools.TestCase):
self.props = properties.Properties(schema, data, double, 'wibble')
def test_integer_good(self):
self.assertEqual(self.props['int'], 42)
self.assertEqual(42, self.props['int'])
def test_string_good(self):
self.assertEqual(self.props['string'], 'foofoo')
self.assertEqual('foofoo', self.props['string'])
def test_missing_required(self):
self.assertRaises(ValueError, self.props.get, 'required_int')
@ -911,13 +912,13 @@ class PropertiesTest(testtools.TestCase):
self.assertIsNone(self.props['missing'])
def test_default(self):
self.assertEqual(self.props['defaulted'], 1)
self.assertEqual(1, self.props['defaulted'])
def test_default_override(self):
self.assertEqual(self.props['default_override'], 42)
self.assertEqual(42, self.props['default_override'])
def test_bad_key(self):
self.assertEqual(self.props.get('foo', 'wibble'), 'wibble')
self.assertEqual('wibble', self.props.get('foo', 'wibble'))
def test_none_string(self):
schema = {'foo': {'Type': 'String'}}

6
heat/tests/test_provider_template.py
View File

@ -356,7 +356,7 @@ class ProviderTemplateTest(HeatTestCase):
"OS::ResourceType": "some_magic.yaml"}}}}
env = environment.Environment(env_str)
cls = env.get_class('OS::ResourceType', 'fred')
self.assertEqual(cls, template_resource.TemplateResource)
self.assertEqual(template_resource.TemplateResource, cls)
def test_template_as_resource(self):
"""
@ -648,7 +648,7 @@ Outputs:
stack = parser.Stack(self.ctx, utils.random_name(), tmpl)
stack.store()
stack.create()
self.assertEqual(stack.state, (stack.CREATE, stack.COMPLETE))
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
return stack
@utils.stack_delete_after
@ -661,7 +661,7 @@ Outputs:
files={'the.yaml': self.provider})
updated_stack = parser.Stack(self.ctx, stack.name, tmpl)
stack.update(updated_stack)
self.assertEqual(stack.state, ('UPDATE', 'COMPLETE'))
self.assertEqual(('UPDATE', 'COMPLETE'), stack.state)
if self.expect == self.REPLACE:
self.assertNotEqual(initial_id,
stack.output('identifier'))

68
heat/tests/test_resource.py
View File

@ -50,7 +50,7 @@ class ResourceTest(HeatTestCase):
def test_get_class_ok(self):
cls = resource.get_class('GenericResourceType')
self.assertEqual(cls, generic_rsrc.GenericResource)
self.assertEqual(generic_rsrc.GenericResource, cls)
def test_get_class_noexist(self):
self.assertRaises(exception.StackValidationFailed, resource.get_class,
@ -96,8 +96,8 @@ class ResourceTest(HeatTestCase):
def test_state_defaults(self):
tmpl = {'Type': 'Foo'}
res = generic_rsrc.GenericResource('test_res_def', tmpl, self.stack)
self.assertEqual(res.state, (res.INIT, res.COMPLETE))
self.assertEqual(res.status_reason, '')
self.assertEqual((res.INIT, res.COMPLETE), res.state)
self.assertEqual('', res.status_reason)
def test_resource_str_repr_stack_id_resource_id(self):
tmpl = {'Type': 'Foo'}
@ -134,10 +134,10 @@ class ResourceTest(HeatTestCase):
tmpl = {'Type': 'Foo'}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.state_set(res.CREATE, res.COMPLETE, 'wibble')
self.assertEqual(res.action, res.CREATE)
self.assertEqual(res.status, res.COMPLETE)
self.assertEqual(res.state, (res.CREATE, res.COMPLETE))
self.assertEqual(res.status_reason, 'wibble')
self.assertEqual(res.CREATE, res.action)
self.assertEqual(res.COMPLETE, res.status)
self.assertEqual((res.CREATE, res.COMPLETE), res.state)
self.assertEqual('wibble', res.status_reason)
def test_set_deletion_policy(self):
tmpl = {'Type': 'Foo'}
@ -180,7 +180,7 @@ class ResourceTest(HeatTestCase):
def test_type(self):
tmpl = {'Type': 'Foo'}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual(res.type(), 'Foo')
self.assertEqual('Foo', res.type())
def test_has_interface_direct_match(self):
tmpl = {'Type': 'GenericResourceType'}
@ -223,17 +223,17 @@ class ResourceTest(HeatTestCase):
self.assertEqual('test_store', res.status_reason)
db_res = db_api.resource_get(res.context, res.id)
self.assertEqual(db_res.action, res.CREATE)
self.assertEqual(db_res.status, res.IN_PROGRESS)
self.assertEqual(db_res.status_reason, 'test_store')
self.assertEqual(res.CREATE, db_res.action)
self.assertEqual(res.IN_PROGRESS, db_res.status)
self.assertEqual('test_store', db_res.status_reason)
res._store_or_update(res.CREATE, res.COMPLETE, 'test_update')
self.assertEqual(res.action, res.CREATE)
self.assertEqual(res.status, res.COMPLETE)
self.assertEqual(res.status_reason, 'test_update')
self.assertEqual(db_res.action, res.CREATE)
self.assertEqual(db_res.status, res.COMPLETE)
self.assertEqual(db_res.status_reason, 'test_update')
self.assertEqual(res.CREATE, res.action)
self.assertEqual(res.COMPLETE, res.status)
self.assertEqual('test_update', res.status_reason)
self.assertEqual(res.CREATE, db_res.action)
self.assertEqual(res.COMPLETE, db_res.status)
self.assertEqual('test_update', db_res.status_reason)
def test_parsed_template(self):
tmpl = {
@ -243,22 +243,22 @@ class ResourceTest(HeatTestCase):
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
parsed_tmpl = res.parsed_template()
self.assertEqual(parsed_tmpl['Type'], 'Foo')
self.assertEqual(parsed_tmpl['foo'], 'bar baz quux')
self.assertEqual('Foo', parsed_tmpl['Type'])
self.assertEqual('bar baz quux', parsed_tmpl['foo'])
self.assertEqual(res.parsed_template('foo'), 'bar baz quux')
self.assertEqual(res.parsed_template('foo', 'bar'), 'bar baz quux')
self.assertEqual('bar baz quux', res.parsed_template('foo'))
self.assertEqual('bar baz quux', res.parsed_template('foo', 'bar'))
def test_parsed_template_default(self):
tmpl = {'Type': 'Foo'}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual(res.parsed_template('foo'), {})
self.assertEqual(res.parsed_template('foo', 'bar'), 'bar')
self.assertEqual({}, res.parsed_template('foo'))
self.assertEqual('bar', res.parsed_template('foo', 'bar'))
def test_metadata_default(self):
tmpl = {'Type': 'Foo'}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual(res.metadata, {})
self.assertEqual({}, res.metadata)
def test_equals_different_stacks(self):
tmpl1 = {'Type': 'Foo'}
@ -303,7 +303,7 @@ class ResourceTest(HeatTestCase):
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.update_allowed_keys = ('Metadata',)
diff = res.update_template_diff(update_snippet, tmpl)
self.assertEqual(diff, {'Metadata': {'foo': 456}})
self.assertEqual({'Metadata': {'foo': 456}}, diff)
def test_update_template_diff_changed_add(self):
tmpl = {'Type': 'Foo'}
@ -311,7 +311,7 @@ class ResourceTest(HeatTestCase):
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.update_allowed_keys = ('Metadata',)
diff = res.update_template_diff(update_snippet, tmpl)
self.assertEqual(diff, {'Metadata': {'foo': 123}})
self.assertEqual({'Metadata': {'foo': 123}}, diff)
def test_update_template_diff_changed_remove(self):
tmpl = {'Type': 'Foo', 'Metadata': {'foo': 123}}
@ -319,14 +319,14 @@ class ResourceTest(HeatTestCase):
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.update_allowed_keys = ('Metadata',)
diff = res.update_template_diff(update_snippet, tmpl)
self.assertEqual(diff, {'Metadata': None})
self.assertEqual({'Metadata': None}, diff)
def test_update_template_diff_properties_none(self):
tmpl = {'Type': 'Foo'}
update_snippet = {'Type': 'Foo'}
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
diff = res.update_template_diff_properties(update_snippet, tmpl)
self.assertEqual(diff, {})
self.assertEqual({}, diff)
def test_update_template_diff_properties_added(self):
tmpl = {'Type': 'Foo'}
@ -334,7 +334,7 @@ class ResourceTest(HeatTestCase):
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Bar',)
diff = res.update_template_diff_properties(update_snippet, tmpl)
self.assertEqual(diff, {'Bar': 123})
self.assertEqual({'Bar': 123}, diff)
def test_update_template_diff_properties_removed(self):
tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}}
@ -342,7 +342,7 @@ class ResourceTest(HeatTestCase):
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Bar',)
diff = res.update_template_diff_properties(update_snippet, tmpl)
self.assertEqual(diff, {'Bar': None})
self.assertEqual({'Bar': None}, diff)
def test_update_template_diff_properties_changed(self):
tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}}
@ -350,7 +350,7 @@ class ResourceTest(HeatTestCase):
res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
res.update_allowed_properties = ('Bar',)
diff = res.update_template_diff_properties(update_snippet, tmpl)
self.assertEqual(diff, {'Bar': 456})
self.assertEqual({'Bar': 456}, diff)
def test_update_template_diff_properties_notallowed(self):
tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}}
@ -1115,12 +1115,12 @@ class MetadataTest(HeatTestCase):
self.addCleanup(self.stack.delete)
def test_read_initial(self):
self.assertEqual(self.res.metadata, {'Test': 'Initial metadata'})
self.assertEqual({'Test': 'Initial metadata'}, self.res.metadata)
def test_write(self):
test_data = {'Test': 'Newly-written data'}
self.res.metadata = test_data
self.assertEqual(self.res.metadata, test_data)
self.assertEqual(test_data, self.res.metadata)
class ReducePhysicalResourceNameTest(HeatTestCase):
@ -1184,7 +1184,7 @@ class ReducePhysicalResourceNameTest(HeatTestCase):
self.assertEqual(self.reduced, reduced)
if self.will_reduce:
# check it has been truncated to exactly the limit
self.assertEqual(len(reduced), self.limit)
self.assertEqual(self.limit, len(reduced))
else:
# check that nothing has changed
self.assertEqual(self.original, reduced)

2
heat/tests/test_rpc_client.py
View File

@ -71,7 +71,7 @@ class EngineRpcAPITestCase(testtools.TestCase):
retval = getattr(rpcapi, method)(ctxt, **kwargs)
self.assertEqual(retval, expected_retval)
self.assertEqual(expected_retval, retval)
expected_args = [ctxt, expected_topic, expected_msg,
mock.ANY]
actual_args, _ = mock_rpc_method.call_args

20
heat/tests/test_scheduler.py
View File

@ -72,7 +72,7 @@ class PollingTaskGroupTest(HeatTestCase):
{'i': 1, 'i2': 1},
{'i': 2, 'i2': 4}]
self.assertEqual(list(output_kwargs), expected_kwargs)
self.assertEqual(expected_kwargs, list(output_kwargs))
def test_kwargs_short(self):
input_kwargs = {'i': [0, 1, 2],
@ -82,11 +82,11 @@ class PollingTaskGroupTest(HeatTestCase):
expected_kwargs = [{'i': 0, 'i2': 0}]
self.assertEqual(list(output_kwargs), expected_kwargs)
self.assertEqual(expected_kwargs, list(output_kwargs))
def test_no_kwargs(self):
output_kwargs = scheduler.PollingTaskGroup._kwargs({})
self.assertEqual(list(output_kwargs), [])
self.assertEqual([], list(output_kwargs))
def test_args(self):
input_args = ([0, 1, 2],
@ -96,7 +96,7 @@ class PollingTaskGroupTest(HeatTestCase):
expected_args = [(0, 0), (1, 1), (2, 4)]
self.assertEqual(list(output_args), expected_args)
self.assertEqual(expected_args, list(output_args))
def test_args_short(self):
input_args = ([0, 1, 2],
@ -106,11 +106,11 @@ class PollingTaskGroupTest(HeatTestCase):
expected_args = [(0, 0)]
self.assertEqual(list(output_args), expected_args)
self.assertEqual(expected_args, list(output_args))
def test_no_args(self):
output_args = scheduler.PollingTaskGroup._args([])
self.assertEqual(list(output_args), [])
self.assertEqual([], list(output_args))
@contextlib.contextmanager
def _args_test(self, *arg_lists, **kwarg_lists):
@ -680,12 +680,12 @@ class DescriptionTest(HeatTestCase):
def f():
pass
self.assertEqual(scheduler.task_description(f), 'f')
self.assertEqual('f', scheduler.task_description(f))
def test_lambda(self):
l = lambda: None
self.assertEqual(scheduler.task_description(l), '<lambda>')
self.assertEqual('<lambda>', scheduler.task_description(l))
def test_method(self):
class C(object):
@ -698,7 +698,7 @@ class DescriptionTest(HeatTestCase):
def m(self):
pass
self.assertEqual(scheduler.task_description(C().m), 'm from C "o"')
self.assertEqual('m from C "o"', scheduler.task_description(C().m))
def test_object(self):
class C(object):
@ -711,7 +711,7 @@ class DescriptionTest(HeatTestCase):
def __call__(self):
pass
self.assertEqual(scheduler.task_description(C()), 'o')
self.assertEqual('o', scheduler.task_description(C()))
class WrapperTaskTest(HeatTestCase):

68
heat/tests/test_server.py
View File

@ -125,16 +125,16 @@ class ServersTest(HeatTestCase):
self.assertTrue(server.id > 0)
public_ip = return_server.networks['public'][0]
self.assertEqual(
server.FnGetAtt('addresses')['public'][0]['addr'], public_ip)
self.assertEqual(
server.FnGetAtt('networks')['public'][0], public_ip)
self.assertEqual(public_ip,
server.FnGetAtt('addresses')['public'][0]['addr'])
self.assertEqual(public_ip,
server.FnGetAtt('networks')['public'][0])
private_ip = return_server.networks['private'][0]
self.assertEqual(
server.FnGetAtt('addresses')['private'][0]['addr'], private_ip)
self.assertEqual(
server.FnGetAtt('networks')['private'][0], private_ip)
self.assertEqual(private_ip,
server.FnGetAtt('addresses')['private'][0]['addr'])
self.assertEqual(private_ip,
server.FnGetAtt('networks')['private'][0])
self.assertIn(
server.FnGetAtt('first_address'), (private_ip, public_ip))
@ -442,7 +442,7 @@ class ServersTest(HeatTestCase):
scheduler.TaskRunner(server.delete)()
self.assertIsNone(server.resource_id)
self.assertEqual(server.state, (server.DELETE, server.COMPLETE))
self.assertEqual((server.DELETE, server.COMPLETE), server.state)
self.m.VerifyAll()
def test_server_delete_notfound(self):
@ -461,12 +461,12 @@ class ServersTest(HeatTestCase):
scheduler.TaskRunner(server.delete)()
self.assertIsNone(server.resource_id)
self.assertEqual(server.state, (server.DELETE, server.COMPLETE))
self.assertEqual((server.DELETE, server.COMPLETE), server.state)
self.m.VerifyAll()
server.state_set(server.CREATE, server.COMPLETE, 'to delete again')
scheduler.TaskRunner(server.delete)()
self.assertEqual(server.state, (server.DELETE, server.COMPLETE))
self.assertEqual((server.DELETE, server.COMPLETE), server.state)
self.m.VerifyAll()
def test_server_update_metadata(self):
@ -477,11 +477,11 @@ class ServersTest(HeatTestCase):
update_template = copy.deepcopy(server.t)
update_template['Metadata'] = {'test': 123}
scheduler.TaskRunner(server.update, update_template)()
self.assertEqual(server.metadata, {'test': 123})
self.assertEqual({'test': 123}, server.metadata)
server.t['Metadata'] = {'test': 456}
server.metadata_update()
self.assertEqual(server.metadata, {'test': 456})
self.assertEqual({'test': 456}, server.metadata)
def test_server_update_nova_metadata(self):
return_server = self.fc.servers.list()[1]
@ -496,7 +496,7 @@ class ServersTest(HeatTestCase):
update_template = copy.deepcopy(server.t)
update_template['Properties']['metadata'] = new_meta
scheduler.TaskRunner(server.update, update_template)()
self.assertEqual(server.state, (server.UPDATE, server.COMPLETE))
self.assertEqual((server.UPDATE, server.COMPLETE), server.state)
self.m.VerifyAll()
def test_server_update_nova_metadata_with_delete(self):
@ -513,7 +513,7 @@ class ServersTest(HeatTestCase):
update_template = copy.deepcopy(server.t)
update_template['Properties']['metadata'] = new_meta
scheduler.TaskRunner(server.update, update_template)()
self.assertEqual(server.state, (server.UPDATE, server.COMPLETE))
self.assertEqual((server.UPDATE, server.COMPLETE), server.state)
self.m.VerifyAll()
self.m.UnsetStubs()
@ -538,7 +538,7 @@ class ServersTest(HeatTestCase):
server.resource_id = '56789'
scheduler.TaskRunner(server.update, update_template)()
self.assertEqual(server.state, (server.UPDATE, server.COMPLETE))
self.assertEqual((server.UPDATE, server.COMPLETE), server.state)
self.m.VerifyAll()
def test_server_update_server_flavor(self):
@ -569,7 +569,7 @@ class ServersTest(HeatTestCase):
self.m.ReplayAll()
scheduler.TaskRunner(server.update, update_template)()
self.assertEqual(server.state, (server.UPDATE, server.COMPLETE))
self.assertEqual((server.UPDATE, server.COMPLETE), server.state)
self.m.VerifyAll()
def test_server_update_server_flavor_failed(self):
@ -602,7 +602,7 @@ class ServersTest(HeatTestCase):
self.assertEqual(
"Error: Resizing to 'm1.small' failed, status 'ACTIVE'",
str(error))
self.assertEqual(server.state, (server.UPDATE, server.FAILED))
self.assertEqual((server.UPDATE, server.FAILED), server.state)
self.m.VerifyAll()
def test_server_update_server_flavor_replace(self):
@ -679,7 +679,7 @@ class ServersTest(HeatTestCase):
self.m.ReplayAll()
scheduler.TaskRunner(server.update, update_template)()
self.assertEqual(server.state, (server.UPDATE, server.COMPLETE))
self.assertEqual((server.UPDATE, server.COMPLETE), server.state)
self.m.VerifyAll()
def test_server_update_image_rebuild_status_rebuild(self):
@ -733,7 +733,7 @@ class ServersTest(HeatTestCase):
self.assertEqual(
"Error: Rebuilding server failed, status 'ERROR'",
str(error))
self.assertEqual(server.state, (server.UPDATE, server.FAILED))
self.assertEqual((server.UPDATE, server.FAILED), server.state)
self.m.VerifyAll()
def test_server_update_attr_replace(self):
@ -769,7 +769,7 @@ class ServersTest(HeatTestCase):
self.m.ReplayAll()
scheduler.TaskRunner(server.create)()
self.assertEqual(server.state, (server.CREATE, server.COMPLETE))
self.assertEqual((server.CREATE, server.COMPLETE), server.state)
def test_server_status_suspend_no_resource_id(self):
return_server = self.fc.servers.list()[1]
@ -784,7 +784,7 @@ class ServersTest(HeatTestCase):
self.assertEqual('Error: Cannot suspend srv_sus1, '
'resource_id not set',
str(ex))
self.assertEqual(server.state, (server.SUSPEND, server.FAILED))
self.assertEqual((server.SUSPEND, server.FAILED), server.state)
self.m.VerifyAll()
@ -804,7 +804,7 @@ class ServersTest(HeatTestCase):
scheduler.TaskRunner(server.suspend))
self.assertEqual('NotFound: Failed to find server 1234',
str(ex))
self.assertEqual(server.state, (server.SUSPEND, server.FAILED))
self.assertEqual((server.SUSPEND, server.FAILED), server.state)
self.m.VerifyAll()
@ -825,7 +825,7 @@ class ServersTest(HeatTestCase):
mox.Replay(get)
scheduler.TaskRunner(server.suspend)()
self.assertEqual(server.state, (server.SUSPEND, server.COMPLETE))
self.assertEqual((server.SUSPEND, server.COMPLETE), server.state)
self.m.VerifyAll()
@ -847,7 +847,7 @@ class ServersTest(HeatTestCase):
server.state_set(server.SUSPEND, server.COMPLETE)
scheduler.TaskRunner(server.resume)()
self.assertEqual(server.state, (server.RESUME, server.COMPLETE))
self.assertEqual((server.RESUME, server.COMPLETE), server.state)
self.m.VerifyAll()
@ -873,7 +873,7 @@ class ServersTest(HeatTestCase):
self.m.ReplayAll()
scheduler.TaskRunner(server.suspend)()
self.assertEqual(server.state, (server.SUSPEND, server.COMPLETE))
self.assertEqual((server.SUSPEND, server.COMPLETE), server.state)
self.m.VerifyAll()
@ -903,7 +903,7 @@ class ServersTest(HeatTestCase):
self.assertEqual('Error: Suspend of server sample-server failed '
'with unknown status: TRANSMOGRIFIED',
str(ex))
self.assertEqual(server.state, (server.SUSPEND, server.FAILED))
self.assertEqual((server.SUSPEND, server.FAILED), server.state)
self.m.VerifyAll()
@ -931,7 +931,7 @@ class ServersTest(HeatTestCase):
server.state_set(server.SUSPEND, server.COMPLETE)
scheduler.TaskRunner(server.resume)()
self.assertEqual(server.state, (server.RESUME, server.COMPLETE))
self.assertEqual((server.RESUME, server.COMPLETE), server.state)
self.m.VerifyAll()
@ -949,7 +949,7 @@ class ServersTest(HeatTestCase):
self.assertEqual('Error: Cannot resume srv_susp_norid, '
'resource_id not set',
str(ex))
self.assertEqual(server.state, (server.RESUME, server.FAILED))
self.assertEqual((server.RESUME, server.FAILED), server.state)
self.m.VerifyAll()
@ -974,7 +974,7 @@ class ServersTest(HeatTestCase):
scheduler.TaskRunner(server.resume))
self.assertEqual('NotFound: Failed to find server 1234',
str(ex))
self.assertEqual(server.state, (server.RESUME, server.FAILED))
self.assertEqual((server.RESUME, server.FAILED), server.state)
self.m.VerifyAll()
@ -1027,7 +1027,7 @@ class ServersTest(HeatTestCase):
self.m.ReplayAll()
scheduler.TaskRunner(server.create)()
self.assertEqual(server.state, (server.CREATE, server.COMPLETE))
self.assertEqual((server.CREATE, server.COMPLETE), server.state)
self.m.VerifyAll()
@ -1065,9 +1065,9 @@ class ServersTest(HeatTestCase):
server = self._create_test_server(return_server,
'wo_ipaddr')
self.assertEqual(server.FnGetAtt('addresses'), {'empty_net': []})
self.assertEqual(server.FnGetAtt('networks'), {'empty_net': []})
self.assertEqual(server.FnGetAtt('first_address'), '')
self.assertEqual({'empty_net': []}, server.FnGetAtt('addresses'))
self.assertEqual({'empty_net': []}, server.FnGetAtt('networks'))
self.assertEqual('', server.FnGetAtt('first_address'))
def test_build_block_device_mapping(self):
self.assertIsNone(servers.Server._build_block_device_mapping([]))

4
heat/tests/test_server_tags.py
View File

@ -184,7 +184,7 @@ class ServerTagsTest(HeatTestCase):
instance = self._setup_test_instance(intags=tags, nova_tags=metadata)
self.m.ReplayAll()
scheduler.TaskRunner(instance.create)()
self.assertEqual(instance.state, (instance.CREATE, instance.COMPLETE))
self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
# we are just using mock to verify that the tags get through to the
# nova call.
self.m.VerifyAll()
@ -202,7 +202,7 @@ class ServerTagsTest(HeatTestCase):
update_template = copy.deepcopy(instance.t)
update_template['Properties']['Tags'] = new_tags
scheduler.TaskRunner(instance.update, update_template)()
self.assertEqual(instance.state, (instance.UPDATE, instance.COMPLETE))
self.assertEqual((instance.UPDATE, instance.COMPLETE), instance.state)
self.m.VerifyAll()
def _setup_test_group(self, intags=None, nova_tags=None):

30
heat/tests/test_short_id.py
View File

@ -22,42 +22,42 @@ import uuid
class ShortIdTest(testtools.TestCase):
def test_byte_string_8(self):
self.assertEqual(short_id._to_byte_string(0xab, 8), '\xab')
self.assertEqual(short_id._to_byte_string(0x05, 8), '\x05')
self.assertEqual('\xab', short_id._to_byte_string(0xab, 8))
self.assertEqual('\x05', short_id._to_byte_string(0x05, 8))
def test_byte_string_16(self):
self.assertEqual(short_id._to_byte_string(0xabcd, 16), '\xab\xcd')
self.assertEqual(short_id._to_byte_string(0xabc, 16), '\x0a\xbc')
self.assertEqual('\xab\xcd', short_id._to_byte_string(0xabcd, 16))
self.assertEqual('\x0a\xbc', short_id._to_byte_string(0xabc, 16))
def test_byte_string_12(self):
self.assertEqual(short_id._to_byte_string(0xabc, 12), '\xab\xc0')
self.assertEqual(short_id._to_byte_string(0x0ab, 12), '\x0a\xb0')
self.assertEqual('\xab\xc0', short_id._to_byte_string(0xabc, 12))
self.assertEqual('\x0a\xb0', short_id._to_byte_string(0x0ab, 12))
def test_byte_string_60(self):
val = 0x111111111111111
byte_string = short_id._to_byte_string(val, 60)
self.assertEqual(byte_string, '\x11\x11\x11\x11\x11\x11\x11\x10')
self.assertEqual('\x11\x11\x11\x11\x11\x11\x11\x10', byte_string)
def test_get_id_string(self):
id = short_id.get_id('11111111-1111-4111-bfff-ffffffffffff')
self.assertEqual(id, 'ceirceirceir')
self.assertEqual('ceirceirceir', id)
def test_get_id_uuid_1(self):
source = uuid.UUID('11111111-1111-4111-bfff-ffffffffffff')
self.assertEqual(source.time, 0x111111111111111)
self.assertEqual(short_id.get_id(source), 'ceirceirceir')
self.assertEqual(0x111111111111111, source.time)
self.assertEqual('ceirceirceir', short_id.get_id(source))
def test_get_id_uuid_f(self):
source = uuid.UUID('ffffffff-ffff-4fff-8000-000000000000')
self.assertEqual(short_id.get_id(source), '777777777777')
self.assertEqual('777777777777', short_id.get_id(source))
def test_get_id_uuid_0(self):
source = uuid.UUID('00000000-0000-4000-bfff-ffffffffffff')
self.assertEqual(short_id.get_id(source), 'aaaaaaaaaaaa')
self.assertEqual('aaaaaaaaaaaa', short_id.get_id(source))
def test_get_id_uuid_endianness(self):
source = uuid.UUID('ffffffff-00ff-4000-aaaa-aaaaaaaaaaaa')
self.assertEqual(short_id.get_id(source), 'aaaa77777777')
self.assertEqual('aaaa77777777', short_id.get_id(source))
def test_get_id_uuid1(self):
source = uuid.uuid1()
@ -68,6 +68,6 @@ class ShortIdTest(testtools.TestCase):
ids = [short_id.generate_id() for i in range(25)]
for id in ids:
self.assertEqual(len(id), 12)
self.assertEqual(12, len(id))
self.assertFalse(id.translate(None, allowed_chars))
self.assertEqual(ids.count(id), 1)
self.assertEqual(1, ids.count(id))

16
heat/tests/test_signal.py
View File

@ -195,7 +195,7 @@ class SignalTest(HeatTestCase):
rsrc = self.stack['signal_handler']
created_time = datetime.datetime(2012, 11, 29, 13, 49, 37)
rsrc.created_time = created_time
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
expected_url = "".join([
'http://server.test:8000/v1/signal/',
@ -220,7 +220,7 @@ class SignalTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['signal_handler']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
first_url = rsrc.FnGetAtt('AlarmUrl')
second_url = rsrc.FnGetAtt('AlarmUrl')
@ -235,7 +235,7 @@ class SignalTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['signal_handler']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertIn('http://server.test:8000/v1/signal',
rsrc.FnGetAtt('AlarmUrl'))
@ -285,7 +285,7 @@ class SignalTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['signal_handler']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertTrue(rsrc.requires_deferred_auth)
rsrc.signal(details=test_d)
@ -298,7 +298,7 @@ class SignalTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['signal_handler']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertTrue(rsrc.requires_deferred_auth)
ceilo_details = {'current': 'foo', 'reason': 'apples',
@ -354,7 +354,7 @@ class SignalTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['resource_X']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
err_metadata = {'Data': 'foo', 'Status': 'SUCCESS', 'UniqueId': '123'}
self.assertRaises(exception.ResourceFailure, rsrc.signal,
@ -372,7 +372,7 @@ class SignalTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['signal_handler']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
# manually override the action to DELETE
rsrc.action = rsrc.DELETE
@ -401,7 +401,7 @@ class SignalTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['signal_handler']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertRaises(exception.ResourceFailure,
rsrc.signal, details=test_d)

28
heat/tests/test_sqlalchemy_api.py
View File

@ -254,12 +254,12 @@ class SqlAlchemyTest(HeatTestCase):
stack.id)
encrypted_key = rs.data[0]['value']
self.assertNotEqual(encrypted_key, "fake secret")
decrypted_key = cs.my_secret
self.assertEqual(decrypted_key, "fake secret")
# Test private_key property returns decrypted value
self.assertEqual("fake secret", cs.my_secret)
#do this twice to verify that the orm does not commit the unencrypted
#value.
self.assertEqual(cs.my_secret, "fake secret")
self.assertEqual("fake secret", cs.my_secret)
scheduler.TaskRunner(cs.destroy)()
def test_resource_data_delete(self):
@ -575,14 +575,14 @@ class SqlAlchemyTest(HeatTestCase):
db_creds = db_api.user_creds_create(self.ctx)
load_creds = db_api.user_creds_get(db_creds.id)
self.assertEqual(load_creds.get('username'), 'test_username')
self.assertEqual(load_creds.get('password'), 'password')
self.assertEqual(load_creds.get('tenant'), 'test_tenant')
self.assertEqual(load_creds.get('tenant_id'), 'test_tenant_id')
self.assertEqual('test_username', load_creds.get('username'))
self.assertEqual('password', load_creds.get('password'))
self.assertEqual('test_tenant', load_creds.get('tenant'))
self.assertEqual('test_tenant_id', load_creds.get('tenant_id'))
self.assertIsNotNone(load_creds.get('created_at'))
self.assertIsNone(load_creds.get('updated_at'))
self.assertEqual(load_creds.get('auth_url'),
'http://server.test:5000/v2.0')
self.assertEqual('http://server.test:5000/v2.0',
load_creds.get('auth_url'))
self.assertIsNone(load_creds.get('trust_id'))
self.assertIsNone(load_creds.get('trustor_user_id'))
@ -601,10 +601,10 @@ class SqlAlchemyTest(HeatTestCase):
self.assertIsNotNone(load_creds.get('created_at'))
self.assertIsNone(load_creds.get('updated_at'))
self.assertIsNone(load_creds.get('auth_url'))
self.assertEqual(load_creds.get('tenant_id'), 'atenant123')
self.assertEqual(load_creds.get('tenant'), 'atenant')
self.assertEqual(load_creds.get('trust_id'), 'atrust123')
self.assertEqual(load_creds.get('trustor_user_id'), 'atrustor123')
self.assertEqual('atenant123', load_creds.get('tenant_id'))
self.assertEqual('atenant', load_creds.get('tenant'))
self.assertEqual('atrust123', load_creds.get('trust_id'))
self.assertEqual('atrustor123', load_creds.get('trustor_user_id'))
def test_user_creds_none(self):
self.ctx.username = None
@ -1154,7 +1154,7 @@ class DBAPIResourceDataTest(HeatTestCase):
self.assertEqual('test_value', val)
vals = db_api.resource_data_get_all(self.resource)
self.assertEqual(len(vals), 2)
self.assertEqual(2, len(vals))
self.assertEqual('foo', vals.get('test_resource_key'))
self.assertEqual('test_value', vals.get('encryped_resource_key'))

8
heat/tests/test_stack_resource.py
View File

@ -188,14 +188,14 @@ class StackResourceTest(HeatTestCase):
updater.run_to_completion()
self.assertIs(True,
self.parent_resource.check_update_complete(updater))
self.assertEqual(self.stack.state, ('UPDATE', 'COMPLETE'))
self.assertEqual(set(self.stack.keys()),
set(["WebServer", "WebServer2"]))
self.assertEqual(('UPDATE', 'COMPLETE'), self.stack.state)
self.assertEqual(set(["WebServer", "WebServer2"]),
set(self.stack.keys()))
# The stack's owner_id is maintained.
saved_stack = parser.Stack.load(
self.parent_stack.context, self.stack.id)
self.assertEqual(saved_stack.owner_id, self.parent_stack.id)
self.assertEqual(self.parent_stack.id, saved_stack.owner_id)
@utils.stack_delete_after
def test_update_with_template_state_err(self):

4
heat/tests/test_urlfetch.py
View File

@ -75,7 +75,7 @@ class UrlFetchTest(HeatTestCase):
response = Response(data)
requests.get(url, stream=True).AndReturn(response)
self.m.ReplayAll()
self.assertEqual(urlfetch.get(url), data)
self.assertEqual(data, urlfetch.get(url))
self.m.VerifyAll()
def test_https_scheme(self):
@ -84,7 +84,7 @@ class UrlFetchTest(HeatTestCase):
response = Response(data)
requests.get(url, stream=True).AndReturn(response)
self.m.ReplayAll()
self.assertEqual(urlfetch.get(url), data)
self.assertEqual(data, urlfetch.get(url))
self.m.VerifyAll()
def test_http_error(self):

4
heat/tests/test_user.py
View File

@ -304,8 +304,8 @@ class AccessKeyTest(UserPolicyTestCase):
self.assertEqual(utils.PhysName(stack.name, 'CfnUser'),
rsrc.FnGetAtt('UserName'))
rsrc._secret = None
self.assertEqual(rsrc.FnGetAtt('SecretAccessKey'),
self.fc.secret)
self.assertEqual(self.fc.secret,
rsrc.FnGetAtt('SecretAccessKey'))
self.assertRaises(exception.InvalidTemplateAttribute,
rsrc.FnGetAtt, 'Foo')

23
heat/tests/test_validate.py
View File

@ -573,7 +573,7 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(res['Description'], 'test.')
self.assertEqual('test.', res['Description'])
def test_validate_hot_valid(self):
t = template_format.parse(
@ -592,7 +592,7 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(res['Description'], 'test.')
self.assertEqual('test.', res['Description'])
def test_validate_ref_invalid(self):
t = template_format.parse(test_template_ref % 'WikiDatabasez')
@ -618,7 +618,7 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(res['Description'], 'test.')
self.assertEqual('test.', res['Description'])
def test_validate_findinmap_invalid(self):
t = template_format.parse(test_template_findinmap_invalid)
@ -644,10 +644,11 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(res['Parameters'], {'KeyName': {
expected = {'KeyName': {
'Type': 'String',
'Description': 'Name of an existing EC2KeyPair to enable SSH '
'access to the instances'}})
'access to the instances'}}
self.assertEqual(expected, res['Parameters'])
def test_validate_properties(self):
t = template_format.parse(test_template_invalid_property)
@ -659,7 +660,7 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(res, {'Error': 'Unknown Property UnknownProperty'})
self.assertEqual({'Error': 'Unknown Property UnknownProperty'}, res)
def test_invalid_resources(self):
t = template_format.parse(test_template_invalid_resources)
@ -686,8 +687,8 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(
res,
{'Error': 'Property SourceDestCheck not implemented yet'})
{'Error': 'Property SourceDestCheck not implemented yet'},
res)
def test_invalid_deletion_policy(self):
t = template_format.parse(test_template_invalid_deletion_policy)
@ -699,7 +700,7 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(res, {'Error': 'Invalid DeletionPolicy Destroy'})
self.assertEqual({'Error': 'Invalid DeletionPolicy Destroy'}, res)
def test_snapshot_deletion_policy(self):
t = template_format.parse(test_template_snapshot_deletion_policy)
@ -712,7 +713,7 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(
res, {'Error': 'Snapshot DeletionPolicy not supported'})
{'Error': 'Snapshot DeletionPolicy not supported'}, res)
@skipIf(try_import('cinderclient.v1.volume_backups') is None,
'unable to import volume_backups')
@ -726,7 +727,7 @@ class validateTest(HeatTestCase):
engine = service.EngineService('a', 't')
res = dict(engine.validate_template(None, t))
self.assertEqual(res, {'Description': u'test.', 'Parameters': {}})
self.assertEqual({'Description': u'test.', 'Parameters': {}}, res)
def test_unregistered_key(self):
t = template_format.parse(test_unregistered_key)

36
heat/tests/test_volume.py
View File

@ -95,7 +95,7 @@ class VolumeTest(HeatTestCase):
rsrc = vol.Volume(resource_name, data, stack)
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
return rsrc
def create_attachment(self, t, stack, resource_name):
@ -104,7 +104,7 @@ class VolumeTest(HeatTestCase):
stack)
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
return rsrc
def _mock_create_volume(self, fv, stack_name):
@ -150,7 +150,7 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
rsrc = self.create_volume(t, stack, 'DataVolume')
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
self.assertRaises(resource.UpdateReplace,
rsrc.handle_update, {}, {}, {})
@ -206,7 +206,7 @@ class VolumeTest(HeatTestCase):
rsrc = stack['DataVolume']
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(stack.create)()
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
scheduler.TaskRunner(stack.delete)()
@ -260,7 +260,7 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
rsrc = vol.VolumeAttachment('MountPoint',
t['Resources']['MountPoint'],
stack)
@ -291,7 +291,7 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
rsrc = self.create_attachment(t, stack, 'MountPoint')
self.assertRaises(resource.UpdateReplace,
@ -341,7 +341,7 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
rsrc = self.create_attachment(t, stack, 'MountPoint')
self.assertRaises(resource.UpdateReplace,
@ -400,7 +400,7 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
rsrc = self.create_attachment(t, stack, 'MountPoint')
scheduler.TaskRunner(rsrc.delete)()
@ -429,7 +429,7 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
rsrc = self.create_attachment(t, stack, 'MountPoint')
detach_task = scheduler.TaskRunner(rsrc.delete)
@ -562,7 +562,7 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
self.create_volume(t, stack, 'DataVolume')
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
self.m.VerifyAll()
@ -639,8 +639,8 @@ class VolumeTest(HeatTestCase):
stack)
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual(fv.status, 'available')
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertEqual('available', fv.status)
self.m.VerifyAll()
@ -677,8 +677,8 @@ class VolumeTest(HeatTestCase):
stack)
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual(fv.status, 'available')
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertEqual('available', fv.status)
self.m.VerifyAll()
@ -708,8 +708,8 @@ class VolumeTest(HeatTestCase):
stack)
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual(fv.status, 'available')
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertEqual('available', fv.status)
self.m.VerifyAll()
@ -793,13 +793,13 @@ class VolumeTest(HeatTestCase):
stack = utils.parse_stack(t, stack_name=stack_name)
scheduler.TaskRunner(stack['DataVolume'].create)()
self.assertEqual(fv.status, 'available')
self.assertEqual('available', fv.status)
rsrc = vol.CinderVolumeAttachment('MountPoint',
t['Resources']['MountPoint'],
stack)
self.assertIsNone(rsrc.validate())
scheduler.TaskRunner(rsrc.create)()
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertRaises(resource.UpdateReplace, rsrc.handle_update,
{}, {}, {})

4
heat/tests/test_vpc.py
View File

@ -610,7 +610,7 @@ Resources:
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
rsrc = stack['the_nic']
self.assertResourceState(rsrc, 'dddd')
self.assertEqual(rsrc.FnGetAtt('PrivateIpAddress'), '10.0.0.100')
self.assertEqual('10.0.0.100', rsrc.FnGetAtt('PrivateIpAddress'))
self.assertRaises(resource.UpdateReplace,
rsrc.handle_update, {}, {}, {})
@ -762,7 +762,7 @@ Resources:
attachment.handle_update, {}, {}, {})
route_table = stack['the_route_table']
self.assertEqual([route_table], list(attachment._vpc_route_tables()))
self.assertEqual(list(attachment._vpc_route_tables()), [route_table])
stack.delete()
self.m.VerifyAll()

62
heat/tests/test_waitcondition.py
View File

@ -136,12 +136,12 @@ class WaitConditionTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state,
(rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE),
rsrc.state)
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
@utils.stack_delete_after
@ -156,13 +156,13 @@ class WaitConditionTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.FAILED))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
@utils.stack_delete_after
@ -179,12 +179,12 @@ class WaitConditionTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state,
(rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE),
rsrc.state)
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
@utils.stack_delete_after
@ -199,13 +199,13 @@ class WaitConditionTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.FAILED))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionFailure:'))
r = db_api.resource_get_by_name_and_stack(None, 'WaitHandle',
self.stack.id)
self.assertEqual(r.name, 'WaitHandle')
self.assertEqual('WaitHandle', r.name)
self.m.VerifyAll()
@utils.stack_delete_after
@ -234,7 +234,7 @@ class WaitConditionTest(HeatTestCase):
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.FAILED))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
reason = rsrc.status_reason
self.assertTrue(reason.startswith('WaitConditionTimeout:'))
@ -249,25 +249,25 @@ class WaitConditionTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
wc_att = rsrc.FnGetAtt('Data')
self.assertEqual(wc_att, unicode({}))
self.assertEqual(unicode({}), wc_att)
handle = self.stack['WaitHandle']
self.assertEqual(handle.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), handle.state)
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
handle.metadata_update(new_metadata=test_metadata)
wc_att = rsrc.FnGetAtt('Data')
self.assertEqual(wc_att, '{"123": "foo"}')
self.assertEqual('{"123": "foo"}', wc_att)
test_metadata = {'Data': 'dog', 'Reason': 'cat',
'Status': 'SUCCESS', 'UniqueId': '456'}
handle.metadata_update(new_metadata=test_metadata)
wc_att = rsrc.FnGetAtt('Data')
self.assertEqual(wc_att, u'{"123": "foo", "456": "dog"}')
self.assertEqual(u'{"123": "foo", "456": "dog"}', wc_att)
self.m.VerifyAll()
@utils.stack_delete_after
@ -427,7 +427,7 @@ class WaitConditionHandleTest(HeatTestCase):
db_api.resource_data_set(rsrc, 'ec2_signed_url', None, False)
rsrc.created_time = created_time
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
expected_url = "".join([
'http://server.test:8000/v1/waitcondition/',
@ -451,7 +451,7 @@ class WaitConditionHandleTest(HeatTestCase):
def test_metadata_update(self):
self.stack = self.create_stack()
rsrc = self.stack['WaitHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
@ -466,7 +466,7 @@ class WaitConditionHandleTest(HeatTestCase):
def test_metadata_update_invalid(self):
self.stack = self.create_stack()
rsrc = self.stack['WaitHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
# metadata_update should raise a ValueError if the metadata
# is missing any of the expected keys
@ -510,23 +510,23 @@ class WaitConditionHandleTest(HeatTestCase):
def test_get_status(self):
self.stack = self.create_stack()
rsrc = self.stack['WaitHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
# UnsetStubs, don't want get_status stubbed anymore..
self.m.VerifyAll()
self.m.UnsetStubs()
self.assertEqual(rsrc.get_status(), [])
self.assertEqual([], rsrc.get_status())
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
rsrc.metadata_update(new_metadata=test_metadata)
self.assertEqual(rsrc.get_status(), ['SUCCESS'])
self.assertEqual(['SUCCESS'], rsrc.get_status())
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '456'}
rsrc.metadata_update(new_metadata=test_metadata)
self.assertEqual(rsrc.get_status(), ['SUCCESS', 'SUCCESS'])
self.assertEqual(['SUCCESS', 'SUCCESS'], rsrc.get_status())
# re-stub keystone() with fake client or stack delete fails
self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone')
@ -537,7 +537,7 @@ class WaitConditionHandleTest(HeatTestCase):
def test_get_status_reason(self):
self.stack = self.create_stack()
rsrc = self.stack['WaitHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
test_metadata = {'Data': 'foo', 'Reason': 'bar',
'Status': 'SUCCESS', 'UniqueId': '123'}
@ -612,7 +612,7 @@ class WaitConditionUpdateTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
self.m.UnsetStubs()
@ -628,7 +628,7 @@ class WaitConditionUpdateTest(HeatTestCase):
updater = scheduler.TaskRunner(rsrc.update, update_snippet)
updater()
self.assertEqual(rsrc.state, (rsrc.UPDATE, rsrc.COMPLETE))
self.assertEqual((rsrc.UPDATE, rsrc.COMPLETE), rsrc.state)
@utils.stack_delete_after
def test_handle_update(self):
@ -637,7 +637,7 @@ class WaitConditionUpdateTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
self.m.UnsetStubs()
@ -657,7 +657,7 @@ class WaitConditionUpdateTest(HeatTestCase):
updater.run_to_completion()
self.assertEqual(5, rsrc.properties['Count'])
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
@utils.stack_delete_after
def test_handle_update_restored_from_db(self):
@ -666,7 +666,7 @@ class WaitConditionUpdateTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
self.m.UnsetStubs()
@ -691,7 +691,7 @@ class WaitConditionUpdateTest(HeatTestCase):
updater.run_to_completion()
self.assertEqual(5, rsrc.properties['Count'])
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
def _metadata_update(self, rsrc, metadata, times=1):
for time in range(times):
@ -705,7 +705,7 @@ class WaitConditionUpdateTest(HeatTestCase):
self.stack.create()
rsrc = self.stack['WaitForTheHandle']
self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE))
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
self.m.UnsetStubs()

104
heat/tests/test_watch.py
View File

@ -102,7 +102,7 @@ class WatchRuleTest(HeatTestCase):
stack_id=self.stack_id,
last_evaluated=last)
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'NORMAL')
self.assertEqual('NORMAL', new_state)
data.append(WatchData(25, now - datetime.timedelta(seconds=250)))
self.wr = watchrule.WatchRule(context=self.ctx,
@ -112,7 +112,7 @@ class WatchRuleTest(HeatTestCase):
stack_id=self.stack_id,
last_evaluated=last)
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'ALARM')
self.assertEqual('ALARM', new_state)
def test_maximum(self):
rule = {'EvaluationPeriods': '1',
@ -136,7 +136,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'NORMAL')
self.assertEqual('NORMAL', new_state)
data.append(WatchData(35, now - datetime.timedelta(seconds=150)))
self.wr = watchrule.WatchRule(context=self.ctx,
@ -147,7 +147,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'ALARM')
self.assertEqual('ALARM', new_state)
def test_samplecount(self):
@ -172,7 +172,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'NORMAL')
self.assertEqual('NORMAL', new_state)
# only 3 samples -> ALARM
data.append(WatchData(1, now - datetime.timedelta(seconds=200)))
@ -184,7 +184,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'ALARM')
self.assertEqual('ALARM', new_state)
# only 3 samples (one old) -> NORMAL
data.pop(0)
@ -197,7 +197,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'NORMAL')
self.assertEqual('NORMAL', new_state)
def test_sum(self):
rule = {'EvaluationPeriods': '1',
@ -221,7 +221,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'NORMAL')
self.assertEqual('NORMAL', new_state)
# sum > 100 -> ALARM
data.append(WatchData(85, now - datetime.timedelta(seconds=150)))
@ -233,7 +233,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'ALARM')
self.assertEqual('ALARM', new_state)
def test_ave(self):
rule = {'EvaluationPeriods': '1',
@ -256,7 +256,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'NORMAL')
self.assertEqual('NORMAL', new_state)
data.append(WatchData(195, now - datetime.timedelta(seconds=250)))
self.wr = watchrule.WatchRule(context=self.ctx,
@ -267,7 +267,7 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
self.wr.now = now
new_state = self.wr.get_alarm_state()
self.assertEqual(new_state, 'ALARM')
self.assertEqual('ALARM', new_state)
@utils.wr_delete_after
def test_load(self):
@ -303,11 +303,11 @@ class WatchRuleTest(HeatTestCase):
for wn in ('HttpFailureAlarm', 'AnotherWatch'):
wr = watchrule.WatchRule.load(self.ctx, wn)
self.assertIsInstance(wr, watchrule.WatchRule)
self.assertEqual(wr.name, wn)
self.assertEqual(wr.state, 'NORMAL')
self.assertEqual(wr.rule, rule)
self.assertEqual(wr.timeperiod, datetime.timedelta(
seconds=int(rule['Period'])))
self.assertEqual(wn, wr.name)
self.assertEqual('NORMAL', wr.state)
self.assertEqual(rule, wr.rule)
self.assertEqual(datetime.timedelta(seconds=int(rule['Period'])),
wr.timeperiod)
@utils.wr_delete_after
def test_store(self):
@ -326,9 +326,9 @@ class WatchRuleTest(HeatTestCase):
dbwr = db_api.watch_rule_get_by_name(self.ctx, 'storetest')
self.assertIsNotNone(dbwr)
self.assertEqual(dbwr.name, 'storetest')
self.assertEqual(dbwr.state, watchrule.WatchRule.NODATA)
self.assertEqual(dbwr.rule, rule)
self.assertEqual('storetest', dbwr.name)
self.assertEqual(watchrule.WatchRule.NODATA, dbwr.state)
self.assertEqual(rule, dbwr.rule)
@utils.wr_delete_after
def test_evaluate(self):
@ -355,8 +355,8 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'NODATA')
self.assertEqual(actions, [])
self.assertEqual('NODATA', self.wr.state)
self.assertEqual([], actions)
# now - last == Period, so should set NORMAL
last = now - datetime.timedelta(seconds=300)
@ -369,9 +369,9 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'NORMAL')
self.assertEqual(self.wr.last_evaluated, now)
self.assertEqual(actions, [])
self.assertEqual('NORMAL', self.wr.state)
self.assertEqual(now, self.wr.last_evaluated)
self.assertEqual([], actions)
# Now data breaches Threshold, so should set ALARM
last = now - datetime.timedelta(seconds=300)
@ -384,9 +384,9 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'ALARM')
self.assertEqual(self.wr.last_evaluated, now)
self.assertEqual(actions, [])
self.assertEqual('ALARM', self.wr.state)
self.assertEqual(now, self.wr.last_evaluated)
self.assertEqual([], actions)
@utils.wr_delete_after
def test_evaluate_suspend(self):
@ -415,8 +415,8 @@ class WatchRuleTest(HeatTestCase):
self.wr.state_set(self.wr.SUSPENDED)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, self.wr.SUSPENDED)
self.assertEqual(actions, [])
self.assertEqual(self.wr.SUSPENDED, self.wr.state)
self.assertEqual([], actions)
@utils.wr_delete_after
def test_rule_actions_alarm_normal(self):
@ -442,8 +442,8 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'NORMAL')
self.assertEqual(actions, [])
self.assertEqual('NORMAL', self.wr.state)
self.assertEqual([], actions)
self.m.VerifyAll()
@utils.wr_delete_after
@ -470,15 +470,15 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'ALARM')
self.assertEqual(actions, ['DummyAction'])
self.assertEqual('ALARM', self.wr.state)
self.assertEqual(['DummyAction'], actions)
# re-set last_evaluated so the rule will be evaluated again.
last = now - datetime.timedelta(seconds=300)
self.wr.last_evaluated = last
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'ALARM')
self.assertEqual(actions, ['DummyAction'])
self.assertEqual('ALARM', self.wr.state)
self.assertEqual(['DummyAction'], actions)
self.m.VerifyAll()
@utils.wr_delete_after
@ -505,8 +505,8 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'ALARM')
self.assertEqual(actions, ['DummyAction', 'DummyAction'])
self.assertEqual('ALARM', self.wr.state)
self.assertEqual(['DummyAction', 'DummyAction'], actions)
self.m.VerifyAll()
@utils.wr_delete_after
@ -532,8 +532,8 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'NODATA')
self.assertEqual(actions, [])
self.assertEqual('NODATA', self.wr.state)
self.assertEqual([], actions)
# Move time forward and add data below threshold so we transition from
# ALARM -> NORMAL, so evaluate() should output a 'DummyAction'
@ -546,8 +546,8 @@ class WatchRuleTest(HeatTestCase):
self.wr.watch_data = [data]
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'NORMAL')
self.assertEqual(actions, ['DummyAction'])
self.assertEqual('NORMAL', self.wr.state)
self.assertEqual(['DummyAction'], actions)
self.m.VerifyAll()
@utils.wr_delete_after
@ -574,8 +574,8 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'ALARM')
self.assertEqual(actions, [])
self.assertEqual('ALARM', self.wr.state)
self.assertEqual([], actions)
# Move time forward and don't add data so we transition from
# ALARM -> NODATA, so evaluate() should output a 'DummyAction'
@ -585,8 +585,8 @@ class WatchRuleTest(HeatTestCase):
self._action_set_stubs(now)
actions = self.wr.evaluate()
self.assertEqual(self.wr.state, 'NODATA')
self.assertEqual(actions, ['DummyAction'])
self.assertEqual('NODATA', self.wr.state)
self.assertEqual(['DummyAction'], actions)
self.m.VerifyAll()
@utils.wr_delete_after
@ -610,7 +610,7 @@ class WatchRuleTest(HeatTestCase):
self.wr.create_watch_data(data)
dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test')
self.assertEqual(dbwr.watch_data[0].data, data)
self.assertEqual(data, dbwr.watch_data[0].data)
# Note, would be good to write another datapoint and check it
# but sqlite seems to not interpret the backreference correctly
@ -641,7 +641,7 @@ class WatchRuleTest(HeatTestCase):
self.wr.create_watch_data(data)
dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test')
self.assertEqual(dbwr.watch_data, [])
self.assertEqual([], dbwr.watch_data)
@utils.wr_delete_after
def test_create_watch_data_match(self):
@ -820,11 +820,11 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
watcher.state_set(watcher.SUSPENDED)
self.assertEqual(watcher.state, watcher.SUSPENDED)
self.assertEqual(watcher.SUSPENDED, watcher.state)
check = watchrule.WatchRule.load(context=self.ctx,
watch_name="testwatch_set_state")
self.assertEqual(check.state, watchrule.WatchRule.SUSPENDED)
self.assertEqual(watchrule.WatchRule.SUSPENDED, check.state)
def test_set_watch_state(self):
rule = {'EvaluationPeriods': '1',
@ -848,13 +848,13 @@ class WatchRuleTest(HeatTestCase):
last_evaluated=last)
actions = self.wr.set_watch_state(watchrule.WatchRule.NODATA)
self.assertEqual(actions, [])
self.assertEqual([], actions)
actions = self.wr.set_watch_state(watchrule.WatchRule.NORMAL)
self.assertEqual(actions, [])
self.assertEqual([], actions)
actions = self.wr.set_watch_state(watchrule.WatchRule.ALARM)
self.assertEqual(actions, ['DummyAction'])
self.assertEqual(['DummyAction'], actions)
self.m.VerifyAll()
def test_set_watch_state_invalid(self):

48
heat/tests/test_wsgi.py
View File

@ -48,38 +48,38 @@ class RequestTest(HeatTestCase):
request = wsgi.Request.blank('/tests/123')
request.headers["Content-Type"] = "application/json; charset=UTF-8"
result = request.get_content_type(('application/json'))
self.assertEqual(result, "application/json")
self.assertEqual("application/json", result)
def test_content_type_from_accept_xml(self):
request = wsgi.Request.blank('/tests/123')
request.headers["Accept"] = "application/xml"
result = request.best_match_content_type()
self.assertEqual(result, "application/json")
self.assertEqual("application/json", result)
def test_content_type_from_accept_json(self):
request = wsgi.Request.blank('/tests/123')
request.headers["Accept"] = "application/json"
result = request.best_match_content_type()
self.assertEqual(result, "application/json")
self.assertEqual("application/json", result)
def test_content_type_from_accept_xml_json(self):
request = wsgi.Request.blank('/tests/123')
request.headers["Accept"] = "application/xml, application/json"
result = request.best_match_content_type()
self.assertEqual(result, "application/json")
self.assertEqual("application/json", result)
def test_content_type_from_accept_json_xml_quality(self):
request = wsgi.Request.blank('/tests/123')
request.headers["Accept"] = ("application/json; q=0.3, "
"application/xml; q=0.9")
result = request.best_match_content_type()
self.assertEqual(result, "application/json")
self.assertEqual("application/json", result)
def test_content_type_accept_default(self):
request = wsgi.Request.blank('/tests/123.unsupported')
request.headers["Accept"] = "application/unsupported1"
result = request.best_match_content_type()
self.assertEqual(result, "application/json")
self.assertEqual("application/json", result)
def test_best_match_language(self):
# Test that we are actually invoking language negotiation by webop
@ -125,13 +125,13 @@ class ResourceTest(HeatTestCase):
expected = {'action': 'update', 'id': 12}
actual = wsgi.Resource(None, None, None).get_action_args(env)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_get_action_args_invalid_index(self):
env = {'wsgiorg.routing_args': []}
expected = {}
actual = wsgi.Resource(None, None, None).get_action_args(env)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_get_action_args_del_controller_error(self):
actions = {'format': None,
@ -140,14 +140,14 @@ class ResourceTest(HeatTestCase):
env = {'wsgiorg.routing_args': [None, actions]}
expected = {'action': 'update', 'id': 12}
actual = wsgi.Resource(None, None, None).get_action_args(env)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_get_action_args_del_format_error(self):
actions = {'action': 'update', 'id': 12}
env = {'wsgiorg.routing_args': [None, actions]}
expected = {'action': 'update', 'id': 12}
actual = wsgi.Resource(None, None, None).get_action_args(env)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_dispatch(self):
class Controller(object):
@ -157,7 +157,7 @@ class ResourceTest(HeatTestCase):
resource = wsgi.Resource(None, None, None)
actual = resource.dispatch(Controller(), 'index', 'on', pants='off')
expected = ('on', 'off')
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_dispatch_default(self):
class Controller(object):
@ -167,7 +167,7 @@ class ResourceTest(HeatTestCase):
resource = wsgi.Resource(None, None, None)
actual = resource.dispatch(Controller(), 'index', 'on', pants='off')
expected = ('on', 'off')
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_dispatch_no_default(self):
class Controller(object):
@ -265,30 +265,30 @@ class JSONResponseSerializerTest(HeatTestCase):
fixture = {"key": "value"}
expected = '{"key": "value"}'
actual = wsgi.JSONResponseSerializer().to_json(fixture)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_to_json_with_date_format_value(self):
fixture = {"date": datetime.datetime(1, 3, 8, 2)}
expected = '{"date": "0001-03-08T02:00:00"}'
actual = wsgi.JSONResponseSerializer().to_json(fixture)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_to_json_with_more_deep_format(self):
fixture = {"is_public": True, "name": [{"name1": "test"}]}
expected = '{"is_public": true, "name": [{"name1": "test"}]}'
actual = wsgi.JSONResponseSerializer().to_json(fixture)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_default(self):
fixture = {"key": "value"}
response = webob.Response()
wsgi.JSONResponseSerializer().default(response, fixture)
self.assertEqual(response.status_int, 200)
self.assertEqual(200, response.status_int)
content_types = filter(lambda h: h[0] == 'Content-Type',
response.headerlist)
self.assertEqual(len(content_types), 1)
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.body, '{"key": "value"}')
self.assertEqual(1, len(content_types))
self.assertEqual('application/json', response.content_type)
self.assertEqual('{"key": "value"}', response.body)
class JSONRequestDeserializerTest(HeatTestCase):
@ -378,7 +378,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
fixture = '{"key": "value"}'
expected = {"key": "value"}
actual = wsgi.JSONRequestDeserializer().from_json(fixture)
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_from_json_malformed(self):
fixture = 'kjasdklfjsklajf'
@ -389,7 +389,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request = wsgi.Request.blank('/')
actual = wsgi.JSONRequestDeserializer().default(request)
expected = {}
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_default_with_body(self):
request = wsgi.Request.blank('/')
@ -397,7 +397,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request.body = '{"key": "value"}'
actual = wsgi.JSONRequestDeserializer().default(request)
expected = {"body": {"key": "value"}}
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_default_with_get_with_body(self):
request = wsgi.Request.blank('/')
@ -405,7 +405,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request.body = '{"key": "value"}'
actual = wsgi.JSONRequestDeserializer().default(request)
expected = {"body": {"key": "value"}}
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_default_with_get_with_body_with_aws(self):
request = wsgi.Request.blank('/?ContentType=JSON')
@ -413,7 +413,7 @@ class JSONRequestDeserializerTest(HeatTestCase):
request.body = '{"key": "value"}'
actual = wsgi.JSONRequestDeserializer().default(request)
expected = {"body": {"key": "value"}}
self.assertEqual(actual, expected)
self.assertEqual(expected, actual)
def test_from_json_exceeds_max_json_mb(self):
cfg.CONF.set_override('max_json_body_size', 10)