diff --git a/contrib/docker-plugin/tests/test_docker_container.py b/contrib/docker-plugin/tests/test_docker_container.py index 529340e7b7..9c325f4bd1 100644 --- a/contrib/docker-plugin/tests/test_docker_container.py +++ b/contrib/docker-plugin/tests/test_docker_container.py @@ -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() diff --git a/contrib/rackspace/heat/tests/test_auto_scale.py b/contrib/rackspace/heat/tests/test_auto_scale.py index 1962537f7d..fae5b4ca81 100644 --- a/contrib/rackspace/heat/tests/test_auto_scale.py +++ b/contrib/rackspace/heat/tests/test_auto_scale.py @@ -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) diff --git a/contrib/rackspace/heat/tests/test_cloud_loadbalancer.py b/contrib/rackspace/heat/tests/test_cloud_loadbalancer.py index a7f1ca1757..daf4b34eeb 100644 --- a/contrib/rackspace/heat/tests/test_cloud_loadbalancer.py +++ b/contrib/rackspace/heat/tests/test_cloud_loadbalancer.py @@ -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" diff --git a/contrib/rackspace/heat/tests/test_clouddatabase.py b/contrib/rackspace/heat/tests/test_clouddatabase.py index 5a683eb4b5..515dd4e4ce 100644 --- a/contrib/rackspace/heat/tests/test_clouddatabase.py +++ b/contrib/rackspace/heat/tests/test_clouddatabase.py @@ -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): diff --git a/contrib/rackspace/heat/tests/test_rackspace_cloud_server.py b/contrib/rackspace/heat/tests/test_rackspace_cloud_server.py index 85792517dc..a41af80228 100644 --- a/contrib/rackspace/heat/tests/test_rackspace_cloud_server.py +++ b/contrib/rackspace/heat/tests/test_rackspace_cloud_server.py @@ -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): diff --git a/heat/tests/test_nested_stack.py b/heat/tests/test_nested_stack.py index 2a819088a8..889ff055aa 100644 --- a/heat/tests/test_nested_stack.py +++ b/heat/tests/test_nested_stack.py @@ -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') diff --git a/heat/tests/test_neutron_autoscaling.py b/heat/tests/test_neutron_autoscaling.py index e16ba7c19d..904e799d81 100644 --- a/heat/tests/test_neutron_autoscaling.py +++ b/heat/tests/test_neutron_autoscaling.py @@ -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())) diff --git a/heat/tests/test_notifications.py b/heat/tests/test_notifications.py index 9f371c5b91..a1cdb1a9e3 100644 --- a/heat/tests/test_notifications.py +++ b/heat/tests/test_notifications.py @@ -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) diff --git a/heat/tests/test_nova_keypair.py b/heat/tests/test_nova_keypair.py index f233fb6426..8118b8f04f 100644 --- a/heat/tests/test_nova_keypair.py +++ b/heat/tests/test_nova_keypair.py @@ -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() diff --git a/heat/tests/test_parameters.py b/heat/tests/test_parameters.py index e04b7a14ea..37f4f96d6f 100644 --- a/heat/tests/test_parameters.py +++ b/heat/tests/test_parameters.py @@ -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'} diff --git a/heat/tests/test_parser.py b/heat/tests/test_parser.py index 95e506f7fe..40cc18b64d 100644 --- a/heat/tests/test_parser.py +++ b/heat/tests/test_parser.py @@ -49,22 +49,22 @@ class ParserTest(HeatTestCase): raw = ['foo', 'bar', 'baz'] parsed = join(raw) for i in xrange(len(raw)): - self.assertEqual(parsed[i], raw[i]) + self.assertEqual(raw[i], parsed[i]) self.assertIsNot(raw, parsed) def test_dict(self): raw = {'foo': 'bar', 'blarg': 'wibble'} parsed = join(raw) for k in raw: - self.assertEqual(parsed[k], raw[k]) + self.assertEqual(raw[k], parsed[k]) self.assertIsNot(raw, parsed) def test_dict_list(self): raw = {'foo': ['bar', 'baz'], 'blarg': 'wibble'} parsed = join(raw) - self.assertEqual(parsed['blarg'], raw['blarg']) + self.assertEqual(raw['blarg'], parsed['blarg']) for i in xrange(len(raw['foo'])): - self.assertEqual(parsed['foo'][i], raw['foo'][i]) + self.assertEqual(raw['foo'][i], parsed['foo'][i]) self.assertIsNot(raw, parsed) self.assertIsNot(raw['foo'], parsed['foo']) @@ -72,34 +72,34 @@ class ParserTest(HeatTestCase): raw = [{'foo': 'bar', 'blarg': 'wibble'}, 'baz', 'quux'] parsed = join(raw) for i in xrange(1, len(raw)): - self.assertEqual(parsed[i], raw[i]) + self.assertEqual(raw[i], parsed[i]) for k in raw[0]: - self.assertEqual(parsed[0][k], raw[0][k]) + self.assertEqual(raw[0][k], parsed[0][k]) self.assertIsNot(raw, parsed) self.assertIsNot(raw[0], parsed[0]) def test_join(self): raw = {'Fn::Join': [' ', ['foo', 'bar', 'baz']]} - self.assertEqual(join(raw), 'foo bar baz') + self.assertEqual('foo bar baz', join(raw)) def test_join_none(self): raw = {'Fn::Join': [' ', ['foo', None, 'baz']]} - self.assertEqual(join(raw), 'foo baz') + self.assertEqual('foo baz', join(raw)) def test_join_list(self): raw = [{'Fn::Join': [' ', ['foo', 'bar', 'baz']]}, 'blarg', 'wibble'] parsed = join(raw) - self.assertEqual(parsed[0], 'foo bar baz') + self.assertEqual('foo bar baz', parsed[0]) for i in xrange(1, len(raw)): - self.assertEqual(parsed[i], raw[i]) + self.assertEqual(raw[i], parsed[i]) self.assertIsNot(raw, parsed) def test_join_dict_val(self): raw = {'quux': {'Fn::Join': [' ', ['foo', 'bar', 'baz']]}, 'blarg': 'wibble'} parsed = join(raw) - self.assertEqual(parsed['quux'], 'foo bar baz') - self.assertEqual(parsed['blarg'], raw['blarg']) + self.assertEqual('foo bar baz', parsed['quux']) + self.assertEqual(raw['blarg'], parsed['blarg']) self.assertIsNot(raw, parsed) @@ -127,11 +127,11 @@ class TemplateTest(HeatTestCase): def test_defaults(self): empty = parser.Template({}) self.assertNotIn(template.VERSION, empty) - self.assertEqual(empty[template.DESCRIPTION], 'No description') - self.assertEqual(empty[template.MAPPINGS], {}) - self.assertEqual(empty[template.PARAMETERS], {}) - self.assertEqual(empty[template.RESOURCES], {}) - self.assertEqual(empty[template.OUTPUTS], {}) + self.assertEqual('No description', empty[template.DESCRIPTION]) + self.assertEqual({}, empty[template.MAPPINGS]) + self.assertEqual({}, empty[template.PARAMETERS]) + self.assertEqual({}, empty[template.RESOURCES]) + self.assertEqual({}, empty[template.OUTPUTS]) def test_invalid_template(self): scanner_error = ''' @@ -156,7 +156,7 @@ Mappings: def test_find_in_map(self): tmpl = parser.Template(mapping_template) find = {'Fn::FindInMap': ["ValidMapping", "TestKey", "TestValue"]} - self.assertEqual(tmpl.resolve_find_in_map(find), "wibble") + self.assertEqual("wibble", tmpl.resolve_find_in_map(find)) def test_find_in_invalid_map(self): tmpl = parser.Template(mapping_template) @@ -181,14 +181,14 @@ Mappings: def test_param_refs(self): params = {'foo': 'bar', 'blarg': 'wibble'} p_snippet = {"Ref": "foo"} - self.assertEqual(parser.Template.resolve_param_refs(p_snippet, params), - "bar") + self.assertEqual("bar", + parser.Template.resolve_param_refs(p_snippet, params)) def test_param_refs_resource(self): params = {'foo': 'bar', 'blarg': 'wibble'} r_snippet = {"Ref": "baz"} - self.assertEqual(parser.Template.resolve_param_refs(r_snippet, params), - r_snippet) + self.assertEqual(r_snippet, + parser.Template.resolve_param_refs(r_snippet, params)) def test_param_ref_missing(self): tmpl = {'Parameters': {'foo': {'Type': 'String', 'Required': True}}} @@ -206,107 +206,107 @@ Mappings: self.m.ReplayAll() r_snippet = {"Ref": "foo"} - self.assertEqual(parser.Template.resolve_resource_refs(r_snippet, - resources), - "bar") + self.assertEqual("bar", + parser.Template.resolve_resource_refs(r_snippet, + resources)) self.m.VerifyAll() def test_resource_refs_param(self): resources = {'foo': 'bar', 'blarg': 'wibble'} p_snippet = {"Ref": "baz"} - self.assertEqual(parser.Template.resolve_resource_refs(p_snippet, - resources), - p_snippet) + self.assertEqual(p_snippet, + parser.Template.resolve_resource_refs(p_snippet, + resources)) def test_select_from_list(self): data = {"Fn::Select": ["1", ["foo", "bar"]]} - self.assertEqual(parser.Template.resolve_select(data), "bar") + self.assertEqual("bar", parser.Template.resolve_select(data)) def test_select_from_list_integer_index(self): data = {"Fn::Select": [1, ["foo", "bar"]]} - self.assertEqual(parser.Template.resolve_select(data), "bar") + self.assertEqual("bar", parser.Template.resolve_select(data)) def test_select_from_list_out_of_bound(self): data = {"Fn::Select": ["0", ["foo", "bar"]]} - self.assertEqual(parser.Template.resolve_select(data), "foo") + self.assertEqual("foo", parser.Template.resolve_select(data)) data = {"Fn::Select": ["1", ["foo", "bar"]]} - self.assertEqual(parser.Template.resolve_select(data), "bar") + self.assertEqual("bar", parser.Template.resolve_select(data)) data = {"Fn::Select": ["2", ["foo", "bar"]]} - self.assertEqual(parser.Template.resolve_select(data), "") + self.assertEqual("", parser.Template.resolve_select(data)) def test_select_from_dict(self): data = {"Fn::Select": ["red", {"red": "robin", "re": "foo"}]} - self.assertEqual(parser.Template.resolve_select(data), "robin") + self.assertEqual("robin", parser.Template.resolve_select(data)) def test_select_from_none(self): data = {"Fn::Select": ["red", None]} - self.assertEqual(parser.Template.resolve_select(data), "") + self.assertEqual("", parser.Template.resolve_select(data)) def test_select_from_dict_not_existing(self): data = {"Fn::Select": ["green", {"red": "robin", "re": "foo"}]} - self.assertEqual(parser.Template.resolve_select(data), "") + self.assertEqual("", parser.Template.resolve_select(data)) def test_select_from_serialized_json_map(self): js = json.dumps({"red": "robin", "re": "foo"}) data = {"Fn::Select": ["re", js]} - self.assertEqual(parser.Template.resolve_select(data), "foo") + self.assertEqual("foo", parser.Template.resolve_select(data)) def test_select_from_serialized_json_list(self): js = json.dumps(["foo", "fee", "fum"]) data = {"Fn::Select": ["0", js]} - self.assertEqual(parser.Template.resolve_select(data), "foo") + self.assertEqual("foo", parser.Template.resolve_select(data)) def test_select_empty_string(self): data = {"Fn::Select": ["0", '']} - self.assertEqual(parser.Template.resolve_select(data), "") + self.assertEqual("", parser.Template.resolve_select(data)) data = {"Fn::Select": ["1", '']} - self.assertEqual(parser.Template.resolve_select(data), "") + self.assertEqual("", parser.Template.resolve_select(data)) data = {"Fn::Select": ["one", '']} - self.assertEqual(parser.Template.resolve_select(data), "") + self.assertEqual("", parser.Template.resolve_select(data)) def test_join_reduce(self): join = {"Fn::Join": [" ", ["foo", "bar", "baz", {'Ref': 'baz'}, "bink", "bonk"]]} self.assertEqual( - parser.Template.reduce_joins(join), - {"Fn::Join": [" ", ["foo bar baz", {'Ref': 'baz'}, "bink bonk"]]}) + {"Fn::Join": [" ", ["foo bar baz", {'Ref': 'baz'}, "bink bonk"]]}, + parser.Template.reduce_joins(join)) join = {"Fn::Join": [" ", ["foo", {'Ref': 'baz'}, "bink"]]} self.assertEqual( - parser.Template.reduce_joins(join), - {"Fn::Join": [" ", ["foo", {'Ref': 'baz'}, "bink"]]}) + {"Fn::Join": [" ", ["foo", {'Ref': 'baz'}, "bink"]]}, + parser.Template.reduce_joins(join)) join = {"Fn::Join": [" ", [{'Ref': 'baz'}]]} self.assertEqual( - parser.Template.reduce_joins(join), - {"Fn::Join": [" ", [{'Ref': 'baz'}]]}) + {"Fn::Join": [" ", [{'Ref': 'baz'}]]}, + parser.Template.reduce_joins(join)) def test_join(self): join = {"Fn::Join": [" ", ["foo", "bar"]]} - self.assertEqual(parser.Template.resolve_joins(join), "foo bar") + self.assertEqual("foo bar", parser.Template.resolve_joins(join)) def test_split_ok(self): data = {"Fn::Split": [";", "foo; bar; achoo"]} - self.assertEqual(parser.Template.resolve_split(data), - ['foo', ' bar', ' achoo']) + self.assertEqual(['foo', ' bar', ' achoo'], + parser.Template.resolve_split(data)) def test_split_no_delim_in_str(self): data = {"Fn::Split": [";", "foo, bar, achoo"]} - self.assertEqual(parser.Template.resolve_split(data), - ['foo, bar, achoo']) + self.assertEqual(['foo, bar, achoo'], + parser.Template.resolve_split(data)) def test_base64(self): snippet = {"Fn::Base64": "foobar"} # For now, the Base64 function just returns the original text, and # does not convert to base64 (see issue #133) - self.assertEqual(parser.Template.resolve_base64(snippet), "foobar") + self.assertEqual("foobar", parser.Template.resolve_base64(snippet)) def test_get_azs(self): snippet = {"Fn::GetAZs": ""} self.assertEqual( - parser.Template.resolve_availability_zones(snippet, None), - ["nova"]) + ["nova"], + parser.Template.resolve_availability_zones(snippet, None)) def test_get_azs_with_stack(self): snippet = {"Fn::GetAZs": ""} @@ -316,8 +316,8 @@ Mappings: clients.OpenStackClients.nova().MultipleTimes().AndReturn(fc) self.m.ReplayAll() self.assertEqual( - parser.Template.resolve_availability_zones(snippet, stack), - ["nova1"]) + ["nova1"], + parser.Template.resolve_availability_zones(snippet, stack)) def test_replace_string_values(self): snippet = {"Fn::Replace": [ @@ -325,8 +325,8 @@ Mappings: '$var1 is %var2%' ]} self.assertEqual( - parser.Template.resolve_replace(snippet), - 'foo is bar') + 'foo is bar', + parser.Template.resolve_replace(snippet)) def test_replace_number_values(self): snippet = {"Fn::Replace": [ @@ -334,16 +334,16 @@ Mappings: '$var1 is not %var2%' ]} self.assertEqual( - parser.Template.resolve_replace(snippet), - '1 is not 2') + '1 is not 2', + parser.Template.resolve_replace(snippet)) snippet = {"Fn::Replace": [ {'$var1': 1.3, '%var2%': 2.5}, '$var1 is not %var2%' ]} self.assertEqual( - parser.Template.resolve_replace(snippet), - '1.3 is not 2.5') + '1.3 is not 2.5', + parser.Template.resolve_replace(snippet)) def test_replace_none_values(self): snippet = {"Fn::Replace": [ @@ -351,8 +351,8 @@ Mappings: '"$var1" is "${var2}"' ]} self.assertEqual( - parser.Template.resolve_replace(snippet), - '"" is ""') + '"" is ""', + parser.Template.resolve_replace(snippet)) def test_replace_missing_key(self): snippet = {"Fn::Replace": [ @@ -360,8 +360,8 @@ Mappings: '"$var1" is "${var3}"' ]} self.assertEqual( - parser.Template.resolve_replace(snippet), - '"foo" is "${var3}"') + '"foo" is "${var3}"', + parser.Template.resolve_replace(snippet)) def test_member_list2map_good(self): snippet = {"Fn::MemberListToMap": [ @@ -400,14 +400,16 @@ Mappings: parser.Template({}), parent_resource=parent_resource) self.assertEqual( - parser.Template.resolve_resource_facade(metadata_snippet, stack), - '{"foo": "bar"}') + '{"foo": "bar"}', + parser.Template.resolve_resource_facade(metadata_snippet, stack)) self.assertEqual( + 'Retain', parser.Template.resolve_resource_facade(deletion_policy_snippet, - stack), 'Retain') + stack)) self.assertEqual( + '{"foo": "bar"}', parser.Template.resolve_resource_facade(update_policy_snippet, - stack), '{"foo": "bar"}') + stack)) def test_resource_facade_invalid_arg(self): snippet = {'Fn::ResourceFacade': 'wibble'} @@ -722,8 +724,8 @@ class StackTest(HeatTestCase): def test_state_defaults(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({})) - self.assertEqual(stack.state, (None, None)) - self.assertEqual(stack.status_reason, '') + self.assertEqual((None, None), stack.state) + self.assertEqual('', stack.status_reason) def test_no_auth_token(self): ctx = utils.dummy_context() @@ -742,21 +744,21 @@ class StackTest(HeatTestCase): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), action=parser.Stack.CREATE, status=parser.Stack.IN_PROGRESS) - self.assertEqual(stack.state, - (parser.Stack.CREATE, parser.Stack.IN_PROGRESS)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.IN_PROGRESS), + stack.state) stack.state_set(parser.Stack.CREATE, parser.Stack.COMPLETE, 'test') - self.assertEqual(stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + stack.state) stack.state_set(parser.Stack.DELETE, parser.Stack.COMPLETE, 'test') - self.assertEqual(stack.state, - (parser.Stack.DELETE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), + stack.state) def test_state_bad(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), action=parser.Stack.CREATE, status=parser.Stack.IN_PROGRESS) - self.assertEqual(stack.state, - (parser.Stack.CREATE, parser.Stack.IN_PROGRESS)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.IN_PROGRESS), + stack.state) self.assertRaises(ValueError, stack.state_set, 'baad', parser.Stack.COMPLETE, 'test') self.assertRaises(ValueError, stack.state_set, @@ -765,10 +767,10 @@ class StackTest(HeatTestCase): def test_status_reason(self): stack = parser.Stack(self.ctx, 'test_stack', parser.Template({}), status_reason='quux') - self.assertEqual(stack.status_reason, 'quux') + self.assertEqual('quux', stack.status_reason) stack.state_set(parser.Stack.CREATE, parser.Stack.IN_PROGRESS, 'wibble') - self.assertEqual(stack.status_reason, 'wibble') + self.assertEqual('wibble', stack.status_reason) def test_load_nonexistant_id(self): self.assertRaises(exception.NotFound, parser.Stack.load, @@ -857,8 +859,8 @@ class StackTest(HeatTestCase): parser.Template({})) self.stack.store() identifier = self.stack.identifier() - self.assertEqual(identifier.tenant, self.ctx.tenant_id) - self.assertEqual(identifier.stack_name, 'identifier_test') + self.assertEqual(self.ctx.tenant_id, identifier.tenant) + self.assertEqual('identifier_test', identifier.stack_name) self.assertTrue(identifier.stack_id) self.assertFalse(identifier.path) @@ -926,8 +928,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) stack_arn = self.stack.parameters['AWS::StackId'] @@ -940,11 +942,11 @@ class StackTest(HeatTestCase): template.Template(tmpl2)) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'xyz') + self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('xyz', self.stack['AResource'].properties['Foo']) - self.assertEqual(self.stack['AResource'].metadata['Bar'], stack_arn) + self.assertEqual(stack_arn, self.stack['AResource'].metadata['Bar']) @utils.stack_delete_after def test_load_param_id(self): @@ -956,7 +958,7 @@ class StackTest(HeatTestCase): identifier.arn()) newstack = parser.Stack.load(self.ctx, stack_id=self.stack.id) - self.assertEqual(newstack.parameters['AWS::StackId'], identifier.arn()) + self.assertEqual(identifier.arn(), newstack.parameters['AWS::StackId']) @utils.stack_delete_after def test_created_time(self): @@ -990,8 +992,8 @@ class StackTest(HeatTestCase): db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) - self.assertEqual(self.stack.state, - (parser.Stack.DELETE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), + self.stack.state) @utils.stack_delete_after def test_delete_trust(self): @@ -1013,8 +1015,8 @@ class StackTest(HeatTestCase): db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) - self.assertEqual(self.stack.state, - (parser.Stack.DELETE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.DELETE, parser.Stack.COMPLETE), + self.stack.state) @utils.stack_delete_after def test_delete_trust_fail(self): @@ -1040,8 +1042,8 @@ class StackTest(HeatTestCase): db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) - self.assertEqual(self.stack.state, - (parser.Stack.DELETE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.DELETE, parser.Stack.FAILED), + self.stack.state) self.assertIn('Error deleting trust', self.stack.status_reason) @utils.stack_delete_after @@ -1052,18 +1054,18 @@ class StackTest(HeatTestCase): parser.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (self.stack.CREATE, self.stack.COMPLETE)) + self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), + self.stack.state) self.stack.suspend() - self.assertEqual(self.stack.state, - (self.stack.SUSPEND, self.stack.COMPLETE)) + self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), + self.stack.state) self.stack.resume() - self.assertEqual(self.stack.state, - (self.stack.RESUME, self.stack.COMPLETE)) + self.assertEqual((self.stack.RESUME, self.stack.COMPLETE), + self.stack.state) self.m.VerifyAll() @@ -1080,15 +1082,15 @@ class StackTest(HeatTestCase): self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (self.stack.CREATE, self.stack.COMPLETE)) + self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), + self.stack.state) self.stack.suspend() - self.assertEqual(self.stack.state, - (self.stack.SUSPEND, self.stack.FAILED)) - self.assertEqual(self.stack.status_reason, - 'Resource suspend failed: Exception: foo') + self.assertEqual((self.stack.SUSPEND, self.stack.FAILED), + self.stack.state) + self.assertEqual('Resource suspend failed: Exception: foo', + self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after @@ -1103,20 +1105,20 @@ class StackTest(HeatTestCase): self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (self.stack.CREATE, self.stack.COMPLETE)) + self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), + self.stack.state) self.stack.suspend() - self.assertEqual(self.stack.state, - (self.stack.SUSPEND, self.stack.COMPLETE)) + self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), + self.stack.state) self.stack.resume() - self.assertEqual(self.stack.state, - (self.stack.RESUME, self.stack.FAILED)) - self.assertEqual(self.stack.status_reason, - 'Resource resume failed: Exception: foo') + self.assertEqual((self.stack.RESUME, self.stack.FAILED), + self.stack.state) + self.assertEqual('Resource resume failed: Exception: foo', + self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after @@ -1132,14 +1134,14 @@ class StackTest(HeatTestCase): self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (self.stack.CREATE, self.stack.COMPLETE)) + self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), + self.stack.state) self.stack.suspend() - self.assertEqual(self.stack.state, - (self.stack.SUSPEND, self.stack.FAILED)) - self.assertEqual(self.stack.status_reason, 'Suspend timed out') + self.assertEqual((self.stack.SUSPEND, self.stack.FAILED), + self.stack.state) + self.assertEqual('Suspend timed out', self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after @@ -1155,20 +1157,20 @@ class StackTest(HeatTestCase): self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (self.stack.CREATE, self.stack.COMPLETE)) + self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), + self.stack.state) self.stack.suspend() - self.assertEqual(self.stack.state, - (self.stack.SUSPEND, self.stack.COMPLETE)) + self.assertEqual((self.stack.SUSPEND, self.stack.COMPLETE), + self.stack.state) self.stack.resume() - self.assertEqual(self.stack.state, - (self.stack.RESUME, self.stack.FAILED)) + self.assertEqual((self.stack.RESUME, self.stack.FAILED), + self.stack.state) - self.assertEqual(self.stack.status_reason, 'Resume timed out') + self.assertEqual('Resume timed out', self.stack.status_reason) self.m.VerifyAll() @utils.stack_delete_after @@ -1184,8 +1186,8 @@ class StackTest(HeatTestCase): db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNone(db_s) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), + self.stack.state) @utils.stack_delete_after def test_delete_badaction(self): @@ -1200,8 +1202,8 @@ class StackTest(HeatTestCase): db_s = db_api.stack_get(self.ctx, stack_id) self.assertIsNotNone(db_s) - self.assertEqual(self.stack.state, - (parser.Stack.DELETE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.DELETE, parser.Stack.FAILED), + self.stack.state) @utils.stack_delete_after def test_update_badstate(self): @@ -1209,11 +1211,11 @@ class StackTest(HeatTestCase): action=parser.Stack.CREATE, status=parser.Stack.FAILED) self.stack.store() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.FAILED), + self.stack.state) self.stack.update({}) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), + self.stack.state) @utils.stack_delete_after def test_resource_by_refid(self): @@ -1223,8 +1225,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) self.assertIn('AResource', self.stack) rsrc = self.stack['AResource'] rsrc.resource_id_set('aaaa') @@ -1255,8 +1257,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, @@ -1264,8 +1266,8 @@ class StackTest(HeatTestCase): updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), + self.stack.state) self.assertIn('BResource', self.stack) @utils.stack_delete_after @@ -1278,16 +1280,16 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), + self.stack.state) self.assertNotIn('BResource', self.stack) @utils.stack_delete_after @@ -1299,8 +1301,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Description': 'BTemplate', 'Resources': {'AResource': {'Type': 'GenericResourceType'}}} @@ -1308,9 +1310,9 @@ class StackTest(HeatTestCase): updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack.t[template.DESCRIPTION], 'BTemplate') + self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('BTemplate', self.stack.t[template.DESCRIPTION]) @utils.stack_delete_after def test_update_modify_ok_replace(self): @@ -1321,8 +1323,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} @@ -1336,9 +1338,9 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'xyz') + self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('xyz', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after @@ -1351,8 +1353,8 @@ class StackTest(HeatTestCase): disable_rollback=True) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) res = self.stack['AResource'] res.update_allowed_keys = ('Properties',) @@ -1374,8 +1376,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), + self.stack.state) self.m.VerifyAll() @utils.stack_delete_after @@ -1388,8 +1390,8 @@ class StackTest(HeatTestCase): disable_rollback=True) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} @@ -1407,8 +1409,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), + self.stack.state) self.m.VerifyAll() # Unset here so destroy() is not stubbed for stack.delete cleanup self.m.UnsetStubs() @@ -1423,8 +1425,8 @@ class StackTest(HeatTestCase): disable_rollback=True) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} @@ -1442,8 +1444,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), + self.stack.state) self.m.VerifyAll() @utils.stack_delete_after @@ -1454,8 +1456,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, @@ -1469,8 +1471,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.UPDATE, parser.Stack.FAILED), + self.stack.state) self.assertIn('BResource', self.stack) # Reload the stack from the DB and prove that it contains the failed @@ -1489,8 +1491,8 @@ class StackTest(HeatTestCase): disable_rollback=False) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} @@ -1509,9 +1511,9 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'abc') + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after @@ -1524,8 +1526,8 @@ class StackTest(HeatTestCase): disable_rollback=False) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} @@ -1546,8 +1548,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.FAILED)) + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.FAILED), + self.stack.state) self.m.VerifyAll() @utils.stack_delete_after @@ -1559,8 +1561,8 @@ class StackTest(HeatTestCase): disable_rollback=False) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': { 'AResource': {'Type': 'GenericResourceType'}, @@ -1576,8 +1578,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), + self.stack.state) self.assertNotIn('BResource', self.stack) self.m.VerifyAll() @@ -1592,8 +1594,8 @@ class StackTest(HeatTestCase): disable_rollback=False) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'GenericResourceType'}}} @@ -1606,8 +1608,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), + self.stack.state) self.assertIn('BResource', self.stack) self.m.VerifyAll() # Unset here so delete() is not stubbed for stack.delete cleanup @@ -1624,8 +1626,8 @@ class StackTest(HeatTestCase): disable_rollback=False) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) tmpl2 = {'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'bar'}}}} @@ -1641,8 +1643,8 @@ class StackTest(HeatTestCase): self.m.ReplayAll() self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), + self.stack.state) self.m.VerifyAll() # Unset here so delete() is not stubbed for stack.delete cleanup self.m.UnsetStubs() @@ -1675,11 +1677,11 @@ class StackTest(HeatTestCase): self.stack.store() self.stack.create() self.m.VerifyAll() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'abc') - self.assertEqual(self.stack['BResource'].properties['Foo'], - 'AResource') + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('abc', self.stack['AResource'].properties['Foo']) + self.assertEqual('AResource', + self.stack['BResource'].properties['Foo']) # Calls to GenericResource.handle_update will raise # resource.UpdateReplace because we've not specified the modified @@ -1695,10 +1697,10 @@ class StackTest(HeatTestCase): updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl2)) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'smelly') - self.assertEqual(self.stack['BResource'].properties['Foo'], 'inst-007') + self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('smelly', self.stack['AResource'].properties['Foo']) + self.assertEqual('inst-007', self.stack['BResource'].properties['Foo']) self.m.VerifyAll() @utils.stack_delete_after @@ -1731,11 +1733,11 @@ class StackTest(HeatTestCase): self.stack.create() self.m.VerifyAll() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'abc') - self.assertEqual(self.stack['BResource'].properties['Foo'], - 'AResource') + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('abc', self.stack['AResource'].properties['Foo']) + self.assertEqual('AResource', + self.stack['BResource'].properties['Foo']) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'FnGetRefId') self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') @@ -1756,9 +1758,9 @@ class StackTest(HeatTestCase): template.Template(tmpl2), disable_rollback=False) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'abc') + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('abc', self.stack['AResource'].properties['Foo']) self.m.VerifyAll() @@ -1802,11 +1804,11 @@ class StackTest(HeatTestCase): self.stack.create() self.m.VerifyAll() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'abc') - self.assertEqual(self.stack['BResource'].properties['Foo'], - 'AResource1') + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('abc', self.stack['AResource'].properties['Foo']) + self.assertEqual('AResource1', + self.stack['BResource'].properties['Foo']) self.m.StubOutWithMock(generic_rsrc.ResourceWithProps, 'handle_create') @@ -1824,11 +1826,11 @@ class StackTest(HeatTestCase): template.Template(tmpl2), disable_rollback=False) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.ROLLBACK, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'abc') - self.assertEqual(self.stack['BResource'].properties['Foo'], - 'AResource1') + self.assertEqual((parser.Stack.ROLLBACK, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('abc', self.stack['AResource'].properties['Foo']) + self.assertEqual('AResource1', + self.stack['BResource'].properties['Foo']) self.m.VerifyAll() @@ -1852,17 +1854,17 @@ class StackTest(HeatTestCase): self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'abc') + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('abc', self.stack['AResource'].properties['Foo']) updated_stack = parser.Stack(self.ctx, 'updated_stack', template.Template(tmpl), environment.Environment(env2)) self.stack.update(updated_stack) - self.assertEqual(self.stack.state, - (parser.Stack.UPDATE, parser.Stack.COMPLETE)) - self.assertEqual(self.stack['AResource'].properties['Foo'], 'smelly') + self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE), + self.stack.state) + self.assertEqual('smelly', self.stack['AResource'].properties['Foo']) def test_stack_create_timeout(self): self.m.StubOutWithMock(scheduler.DependencyTaskGroup, '__call__') @@ -1884,9 +1886,9 @@ class StackTest(HeatTestCase): stack.create() - self.assertEqual(stack.state, - (parser.Stack.CREATE, parser.Stack.FAILED)) - self.assertEqual(stack.status_reason, 'Create timed out') + self.assertEqual((parser.Stack.CREATE, parser.Stack.FAILED), + stack.state) + self.assertEqual('Create timed out', stack.status_reason) self.m.VerifyAll() @@ -1913,9 +1915,9 @@ class StackTest(HeatTestCase): self.m.ReplayAll() stack.delete() - self.assertEqual(stack.state, - (parser.Stack.DELETE, parser.Stack.FAILED)) - self.assertEqual(stack.status_reason, 'Delete timed out') + self.assertEqual((parser.Stack.DELETE, parser.Stack.FAILED), + stack.state) + self.assertEqual('Delete timed out', stack.status_reason) self.m.VerifyAll() @@ -1931,15 +1933,15 @@ class StackTest(HeatTestCase): self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (self.stack.CREATE, self.stack.COMPLETE)) + self.assertEqual((self.stack.CREATE, self.stack.COMPLETE), + self.stack.state) self.stack.delete() - self.assertEqual(self.stack.state, - (self.stack.DELETE, self.stack.FAILED)) - self.assertEqual(self.stack.status_reason, - 'Resource delete failed: Exception: foo') + self.assertEqual((self.stack.DELETE, self.stack.FAILED), + self.stack.state) + self.assertEqual('Resource delete failed: Exception: foo', + self.stack.status_reason) self.m.VerifyAll() def test_stack_name_valid(self): @@ -2003,8 +2005,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) self.assertIn('AResource', self.stack) rsrc = self.stack['AResource'] rsrc.resource_id_set('aaaa') @@ -2042,8 +2044,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) self.assertEqual(['BResource'], self.stack['AResource'].required_by()) @@ -2068,8 +2070,8 @@ class StackTest(HeatTestCase): template.Template(tmpl)) self.stack.store() self.stack.create() - self.assertEqual(self.stack.state, - (parser.Stack.CREATE, parser.Stack.COMPLETE)) + self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), + self.stack.state) for r in ['AResource', 'BResource', 'CResource']: self.assertEqual(['DResource'], @@ -2087,7 +2089,7 @@ class StackTest(HeatTestCase): owner_id=self.stack.id) stack_ownee.store() db_stack = db_api.stack_get(self.ctx, stack_ownee.id) - self.assertEqual(db_stack.owner_id, self.stack.id) + self.assertEqual(self.stack.id, db_stack.owner_id) @utils.stack_delete_after def test_store_saves_creds(self): @@ -2162,7 +2164,7 @@ class StackTest(HeatTestCase): stack_ownee.store() saved_stack = parser.Stack.load(self.ctx, stack_id=stack_ownee.id) - self.assertEqual(saved_stack.owner_id, self.stack.id) + self.assertEqual(self.stack.id, saved_stack.owner_id) @utils.stack_delete_after def test_requires_deferred_auth(self): diff --git a/heat/tests/test_plugin_loader.py b/heat/tests/test_plugin_loader.py index da2dace9a2..eed863784e 100644 --- a/heat/tests/test_plugin_loader.py +++ b/heat/tests/test_plugin_loader.py @@ -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 diff --git a/heat/tests/test_properties.py b/heat/tests/test_properties.py index 2e1461ee52..f1334b8e1b 100644 --- a/heat/tests/test_properties.py +++ b/heat/tests/test_properties.py @@ -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'}} diff --git a/heat/tests/test_provider_template.py b/heat/tests/test_provider_template.py index 85d106f2ab..bc6139b378 100644 --- a/heat/tests/test_provider_template.py +++ b/heat/tests/test_provider_template.py @@ -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')) diff --git a/heat/tests/test_resource.py b/heat/tests/test_resource.py index 82de90557c..96d2d82078 100644 --- a/heat/tests/test_resource.py +++ b/heat/tests/test_resource.py @@ -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) diff --git a/heat/tests/test_rpc_client.py b/heat/tests/test_rpc_client.py index c8fef7cd43..1dcf8f4afc 100644 --- a/heat/tests/test_rpc_client.py +++ b/heat/tests/test_rpc_client.py @@ -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 diff --git a/heat/tests/test_scheduler.py b/heat/tests/test_scheduler.py index a6a0c0cf6d..c013ecea1d 100644 --- a/heat/tests/test_scheduler.py +++ b/heat/tests/test_scheduler.py @@ -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), '') + self.assertEqual('', 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): diff --git a/heat/tests/test_server.py b/heat/tests/test_server.py index 45081a8642..b8d01495b5 100644 --- a/heat/tests/test_server.py +++ b/heat/tests/test_server.py @@ -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([])) diff --git a/heat/tests/test_server_tags.py b/heat/tests/test_server_tags.py index 354954d784..e648664702 100644 --- a/heat/tests/test_server_tags.py +++ b/heat/tests/test_server_tags.py @@ -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): diff --git a/heat/tests/test_short_id.py b/heat/tests/test_short_id.py index b9b0f7414c..8519fdeaca 100644 --- a/heat/tests/test_short_id.py +++ b/heat/tests/test_short_id.py @@ -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)) diff --git a/heat/tests/test_signal.py b/heat/tests/test_signal.py index b6179e5893..21202b45d8 100644 --- a/heat/tests/test_signal.py +++ b/heat/tests/test_signal.py @@ -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) diff --git a/heat/tests/test_sqlalchemy_api.py b/heat/tests/test_sqlalchemy_api.py index cf90cf5212..9e694734f4 100644 --- a/heat/tests/test_sqlalchemy_api.py +++ b/heat/tests/test_sqlalchemy_api.py @@ -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')) diff --git a/heat/tests/test_stack_resource.py b/heat/tests/test_stack_resource.py index 6d94ef0bb6..afbaee4821 100644 --- a/heat/tests/test_stack_resource.py +++ b/heat/tests/test_stack_resource.py @@ -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): diff --git a/heat/tests/test_urlfetch.py b/heat/tests/test_urlfetch.py index 89036b9f84..20557fa45f 100644 --- a/heat/tests/test_urlfetch.py +++ b/heat/tests/test_urlfetch.py @@ -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): diff --git a/heat/tests/test_user.py b/heat/tests/test_user.py index 1a74e03581..43adf71f6f 100644 --- a/heat/tests/test_user.py +++ b/heat/tests/test_user.py @@ -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') diff --git a/heat/tests/test_validate.py b/heat/tests/test_validate.py index 0e7ee794f3..edd78be4d8 100644 --- a/heat/tests/test_validate.py +++ b/heat/tests/test_validate.py @@ -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) diff --git a/heat/tests/test_volume.py b/heat/tests/test_volume.py index b0498216e0..7a8dbdc9df 100644 --- a/heat/tests/test_volume.py +++ b/heat/tests/test_volume.py @@ -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, {}, {}, {}) diff --git a/heat/tests/test_vpc.py b/heat/tests/test_vpc.py index 7aef9dd976..9687fcbd75 100644 --- a/heat/tests/test_vpc.py +++ b/heat/tests/test_vpc.py @@ -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() diff --git a/heat/tests/test_waitcondition.py b/heat/tests/test_waitcondition.py index 2f679fd575..7b3ebb9121 100644 --- a/heat/tests/test_waitcondition.py +++ b/heat/tests/test_waitcondition.py @@ -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() diff --git a/heat/tests/test_watch.py b/heat/tests/test_watch.py index d2c51fa70f..34c23a20cf 100644 --- a/heat/tests/test_watch.py +++ b/heat/tests/test_watch.py @@ -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): diff --git a/heat/tests/test_wsgi.py b/heat/tests/test_wsgi.py index 899c551708..b7f631d836 100644 --- a/heat/tests/test_wsgi.py +++ b/heat/tests/test_wsgi.py @@ -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)