From 240fec9eef800a53aec890ce9ba14b4d07f136d5 Mon Sep 17 00:00:00 2001 From: Pavlo Shchelokovskyy Date: Mon, 30 Dec 2013 11:15:54 +0200 Subject: [PATCH] Fix order of arguments in assertEqual (patch 2/2) Some tests used incorrect order assertEqual(observed, expected). The correct order expected by testtools is assertEqual(expected, observed). This patch includes the other half of the files touched by these changes (starting from test_n* plus contrib code) to ease the review. Change-Id: I870386871581980abd796304dd91be0c662cb73e Partial-Bug: #1259292 --- .../tests/test_docker_container.py | 16 +- .../rackspace/heat/tests/test_auto_scale.py | 73 +-- .../heat/tests/test_cloud_loadbalancer.py | 15 +- .../heat/tests/test_clouddatabase.py | 6 +- .../heat/tests/test_rackspace_cloud_server.py | 44 +- heat/tests/test_nested_stack.py | 18 +- heat/tests/test_neutron_autoscaling.py | 8 +- heat/tests/test_notifications.py | 29 +- heat/tests/test_nova_keypair.py | 6 +- heat/tests/test_parameters.py | 54 +- heat/tests/test_parser.py | 498 +++++++++--------- heat/tests/test_plugin_loader.py | 12 +- heat/tests/test_properties.py | 55 +- heat/tests/test_provider_template.py | 6 +- heat/tests/test_resource.py | 68 +-- heat/tests/test_rpc_client.py | 2 +- heat/tests/test_scheduler.py | 20 +- heat/tests/test_server.py | 68 +-- heat/tests/test_server_tags.py | 4 +- heat/tests/test_short_id.py | 30 +- heat/tests/test_signal.py | 16 +- heat/tests/test_sqlalchemy_api.py | 28 +- heat/tests/test_stack_resource.py | 8 +- heat/tests/test_urlfetch.py | 4 +- heat/tests/test_user.py | 4 +- heat/tests/test_validate.py | 23 +- heat/tests/test_volume.py | 36 +- heat/tests/test_vpc.py | 4 +- heat/tests/test_waitcondition.py | 62 +-- heat/tests/test_watch.py | 104 ++-- heat/tests/test_wsgi.py | 48 +- 31 files changed, 687 insertions(+), 682 deletions(-) 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)