From 499b7cccac96e134941dc1e6cd84afe41302fce5 Mon Sep 17 00:00:00 2001 From: Pavlo Shchelokovskyy Date: Wed, 11 Dec 2013 17:15:54 +0200 Subject: [PATCH] Fix order of arguments in assertEqual (patch 1/2) Some tests used incorrect order assertEqual(observed, expected). The correct order expected by testtools is assertEqual(expected, observed). This patch includes roughly half of the files touched by these changes (up to and including test_m* sans contrib code) to ease the review. Partial-Bug: #1259292 Change-Id: I44bff827c7c50726d48aa649b7685712a233ee62 --- heat/tests/test_api_aws.py | 68 +++--- heat/tests/test_api_cfn_v1.py | 36 +-- heat/tests/test_api_ec2token.py | 50 ++--- heat/tests/test_api_openstack_v1.py | 205 +++++++++--------- heat/tests/test_auth_password.py | 10 +- heat/tests/test_autoscaling.py | 146 ++++++------- heat/tests/test_autoscaling_update_policy.py | 62 +++--- heat/tests/test_common_context.py | 8 +- heat/tests/test_common_policy.py | 4 +- heat/tests/test_cw_alarm.py | 8 +- heat/tests/test_dependencies.py | 28 +-- heat/tests/test_engine_api_utils.py | 6 +- heat/tests/test_engine_service.py | 4 +- heat/tests/test_heatclient.py | 6 +- heat/tests/test_hot.py | 36 +-- heat/tests/test_identifier.py | 180 +++++++-------- heat/tests/test_instance.py | 77 +++---- heat/tests/test_instance_group.py | 6 +- .../test_instance_group_update_policy.py | 62 +++--- heat/tests/test_instance_network.py | 16 +- heat/tests/test_iso8601_utils.py | 18 +- heat/tests/test_metadata_refresh.py | 26 +-- 22 files changed, 532 insertions(+), 530 deletions(-) diff --git a/heat/tests/test_api_aws.py b/heat/tests/test_api_aws.py index abbaef77db..6a9c40f98d 100644 --- a/heat/tests/test_api_aws.py +++ b/heat/tests/test_api_aws.py @@ -25,7 +25,7 @@ class AWSCommonTest(HeatTestCase): def test_format_response(self): response = api_utils.format_response("Foo", "Bar") expected = {'FooResponse': {'FooResult': 'Bar'}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_params_extract(self): p = {'Parameters.member.1.ParameterKey': 'foo', @@ -35,11 +35,11 @@ class AWSCommonTest(HeatTestCase): params = api_utils.extract_param_pairs(p, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') - self.assertEqual(len(params), 2) + self.assertEqual(2, len(params)) self.assertIn('foo', params) - self.assertEqual(params['foo'], 'bar') + self.assertEqual('bar', params['foo']) self.assertIn('blarg', params) - self.assertEqual(params['blarg'], 'wibble') + self.assertEqual('wibble', params['blarg']) def test_params_extract_dots(self): p = {'Parameters.member.1.1.ParameterKey': 'foo', @@ -59,9 +59,9 @@ class AWSCommonTest(HeatTestCase): params = api_utils.extract_param_pairs(p, prefix='Parameters', keyname='ParameterKey', valuename='ParameterValue') - self.assertEqual(len(params), 1) + self.assertEqual(1, len(params)) self.assertIn('foo', params) - self.assertEqual(params['foo'], 'bar') + self.assertEqual('bar', params['foo']) def test_params_extract_garbage_prefix(self): p = {'prefixParameters.member.Foo.Bar.ParameterKey': 'foo', @@ -84,44 +84,44 @@ class AWSCommonTest(HeatTestCase): 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') - self.assertEqual(len(params), 1) + self.assertEqual(1, len(params)) self.assertIn('MetricName', params[0]) self.assertIn('Unit', params[0]) self.assertIn('Value', params[0]) - self.assertEqual(params[0]['MetricName'], 'foo') - self.assertEqual(params[0]['Unit'], 'Bytes') - self.assertEqual(params[0]['Value'], 234333) + self.assertEqual('foo', params[0]['MetricName']) + self.assertEqual('Bytes', params[0]['Unit']) + self.assertEqual(234333, params[0]['Value']) def test_extract_param_list_garbage_prefix(self): p = {'AMetricData.member.1.MetricName': 'foo', 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') - self.assertEqual(len(params), 1) + self.assertEqual(1, len(params)) self.assertNotIn('MetricName', params[0]) self.assertIn('Unit', params[0]) self.assertIn('Value', params[0]) - self.assertEqual(params[0]['Unit'], 'Bytes') - self.assertEqual(params[0]['Value'], 234333) + self.assertEqual('Bytes', params[0]['Unit']) + self.assertEqual(234333, params[0]['Value']) def test_extract_param_list_garbage_prefix2(self): p = {'AMetricData.member.1.MetricName': 'foo', 'BMetricData.member.1.Unit': 'Bytes', 'CMetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') - self.assertEqual(len(params), 0) + self.assertEqual(0, len(params)) def test_extract_param_list_garbage_suffix(self): p = {'MetricData.member.1.AMetricName': 'foo', 'MetricData.member.1.Unit': 'Bytes', 'MetricData.member.1.Value': 234333} params = api_utils.extract_param_list(p, prefix='MetricData') - self.assertEqual(len(params), 1) + self.assertEqual(1, len(params)) self.assertNotIn('MetricName', params[0]) self.assertIn('Unit', params[0]) self.assertIn('Value', params[0]) - self.assertEqual(params[0]['Unit'], 'Bytes') - self.assertEqual(params[0]['Value'], 234333) + self.assertEqual('Bytes', params[0]['Unit']) + self.assertEqual(234333, params[0]['Value']) def test_extract_param_list_multiple(self): p = {'MetricData.member.1.MetricName': 'foo', @@ -131,15 +131,15 @@ class AWSCommonTest(HeatTestCase): 'MetricData.member.2.Unit': 'Bytes', 'MetricData.member.2.Value': 12345} params = api_utils.extract_param_list(p, prefix='MetricData') - self.assertEqual(len(params), 2) + self.assertEqual(2, len(params)) self.assertIn('MetricName', params[0]) self.assertIn('MetricName', params[1]) - self.assertEqual(params[0]['MetricName'], 'foo') - self.assertEqual(params[0]['Unit'], 'Bytes') - self.assertEqual(params[0]['Value'], 234333) - self.assertEqual(params[1]['MetricName'], 'foo2') - self.assertEqual(params[1]['Unit'], 'Bytes') - self.assertEqual(params[1]['Value'], 12345) + self.assertEqual('foo', params[0]['MetricName']) + self.assertEqual('Bytes', params[0]['Unit']) + self.assertEqual(234333, params[0]['Value']) + self.assertEqual('foo2', params[1]['MetricName']) + self.assertEqual('Bytes', params[1]['Unit']) + self.assertEqual(12345, params[1]['Value']) def test_extract_param_list_multiple_missing(self): # Handle case where there is an empty list item @@ -150,15 +150,15 @@ class AWSCommonTest(HeatTestCase): 'MetricData.member.3.Unit': 'Bytes', 'MetricData.member.3.Value': 12345} params = api_utils.extract_param_list(p, prefix='MetricData') - self.assertEqual(len(params), 2) + self.assertEqual(2, len(params)) self.assertIn('MetricName', params[0]) self.assertIn('MetricName', params[1]) - self.assertEqual(params[0]['MetricName'], 'foo') - self.assertEqual(params[0]['Unit'], 'Bytes') - self.assertEqual(params[0]['Value'], 234333) - self.assertEqual(params[1]['MetricName'], 'foo2') - self.assertEqual(params[1]['Unit'], 'Bytes') - self.assertEqual(params[1]['Value'], 12345) + self.assertEqual('foo', params[0]['MetricName']) + self.assertEqual('Bytes', params[0]['Unit']) + self.assertEqual(234333, params[0]['Value']) + self.assertEqual('foo2', params[1]['MetricName']) + self.assertEqual('Bytes', params[1]['Unit']) + self.assertEqual(12345, params[1]['Value']) def test_extract_param_list_badindex(self): p = {'MetricData.member.xyz.MetricName': 'foo', @@ -168,18 +168,18 @@ class AWSCommonTest(HeatTestCase): 'MetricData.member._3.Unit': 'Bytes', 'MetricData.member.-1000.Value': 12345} params = api_utils.extract_param_list(p, prefix='MetricData') - self.assertEqual(len(params), 0) + self.assertEqual(0, len(params)) def test_reformat_dict_keys(self): keymap = {"foo": "bar"} data = {"foo": 123} expected = {"bar": 123} result = api_utils.reformat_dict_keys(keymap, data) - self.assertEqual(result, expected) + self.assertEqual(expected, result) def test_reformat_dict_keys_missing(self): keymap = {"foo": "bar", "foo2": "bar2"} data = {"foo": 123} expected = {"bar": 123} result = api_utils.reformat_dict_keys(keymap, data) - self.assertEqual(result, expected) + self.assertEqual(expected, result) diff --git a/heat/tests/test_api_cfn_v1.py b/heat/tests/test_api_cfn_v1.py index e1ea415cc2..890b816c71 100644 --- a/heat/tests/test_api_cfn_v1.py +++ b/heat/tests/test_api_cfn_v1.py @@ -93,7 +93,7 @@ class CfnStackControllerTest(HeatTestCase): }) expected = {'StackName': 'Foo', 'StackId': 'arn:openstack:heat::t:stacks/Foo/123'} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_enforce_ok(self): params = {'Action': 'ListStacks'} @@ -155,7 +155,7 @@ class CfnStackControllerTest(HeatTestCase): u'CreationTime': u'2012-07-09T09:12:45Z', u'StackName': u'wordpress', u'StackStatus': u'CREATE_COMPLETE'}]}}} - self.assertEqual(result, expected) + self.assertEqual(expected, result) default_args = {'limit': None, 'sort_keys': None, 'marker': None, 'sort_dir': None, 'filters': None} mock_call.assert_called_once_with(dummy_req.context, self.topic, @@ -292,7 +292,7 @@ class CfnStackControllerTest(HeatTestCase): 'DisableRollback': 'true', 'LastUpdatedTime': u'2012-07-09T09:13:11Z'}]}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_describe_arn(self): # Format a dummy GET request to pass into the WSGI handler @@ -377,7 +377,7 @@ class CfnStackControllerTest(HeatTestCase): 'DisableRollback': 'true', 'LastUpdatedTime': u'2012-07-09T09:13:11Z'}]}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_describe_arn_invalidtenant(self): # Format a dummy GET request to pass into the WSGI handler @@ -457,7 +457,7 @@ class CfnStackControllerTest(HeatTestCase): dummy_req = self._dummy_GET_request(params) result = self.controller._get_template(dummy_req) expected = "abcdef" - self.assertEqual(result, expected) + self.assertEqual(expected, result) # TODO(shardy) : test the _get_template TemplateUrl case @@ -506,7 +506,7 @@ class CfnStackControllerTest(HeatTestCase): } } - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_create_rollback(self): # Format a dummy request @@ -553,7 +553,7 @@ class CfnStackControllerTest(HeatTestCase): } } - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_create_onfailure_true(self): # Format a dummy request @@ -600,7 +600,7 @@ class CfnStackControllerTest(HeatTestCase): } } - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_create_onfailure_false_delete(self): # Format a dummy request @@ -647,7 +647,7 @@ class CfnStackControllerTest(HeatTestCase): } } - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_create_onfailure_false_rollback(self): # Format a dummy request @@ -694,7 +694,7 @@ class CfnStackControllerTest(HeatTestCase): } } - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_create_onfailure_err(self): # Format a dummy request @@ -925,7 +925,7 @@ class CfnStackControllerTest(HeatTestCase): } } - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_update_bad_name(self): stack_name = "wibble" @@ -989,7 +989,7 @@ class CfnStackControllerTest(HeatTestCase): {'GetTemplateResult': {'TemplateBody': template}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_get_template_err_rpcerr(self): stack_name = "wordpress" @@ -1151,7 +1151,7 @@ class CfnStackControllerTest(HeatTestCase): expected = {'DeleteStackResponse': {'DeleteStackResult': ''}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_delete_err_rpcerr(self): stack_name = "wordpress" @@ -1270,7 +1270,7 @@ class CfnStackControllerTest(HeatTestCase): 'ResourceStatusReason': u'state changed', 'LogicalResourceId': u'WikiDatabase'}]}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_events_list_err_rpcerr(self): stack_name = "wordpress" @@ -1389,7 +1389,7 @@ class CfnStackControllerTest(HeatTestCase): 'Metadata': {u'wordpress': []}, 'LogicalResourceId': u'WikiDatabase'}}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_describe_stack_resource_nonexistent_stack(self): # Format a dummy request @@ -1515,7 +1515,7 @@ class CfnStackControllerTest(HeatTestCase): u'a3455d8c-9f88-404d-a85b-5315293e67de', 'LogicalResourceId': u'WikiDatabase'}]}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_describe_stack_resources_bad_name(self): stack_name = "wibble" @@ -1608,7 +1608,7 @@ class CfnStackControllerTest(HeatTestCase): u'a3455d8c-9f88-404d-a85b-5315293e67de', 'LogicalResourceId': u'WikiDatabase'}]}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_describe_stack_resources_physical_not_found(self): # Format a dummy request @@ -1705,7 +1705,7 @@ class CfnStackControllerTest(HeatTestCase): u'a3455d8c-9f88-404d-a85b-5315293e67de', 'LogicalResourceId': u'WikiDatabase'}]}}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) def test_list_stack_resources_bad_name(self): stack_name = "wibble" diff --git a/heat/tests/test_api_ec2token.py b/heat/tests/test_api_ec2token.py index 30694cb57d..c388b7db68 100644 --- a/heat/tests/test_api_ec2token.py +++ b/heat/tests/test_api_ec2token.py @@ -45,31 +45,31 @@ class Ec2TokenTest(HeatTestCase): def test_conf_get_paste(self): dummy_conf = {'auth_uri': 'http://192.0.2.9/v2.0'} ec2 = ec2token.EC2Token(app=None, conf=dummy_conf) - self.assertEqual(ec2._conf_get('auth_uri'), 'http://192.0.2.9/v2.0') + self.assertEqual('http://192.0.2.9/v2.0', ec2._conf_get('auth_uri')) self.assertEqual( - ec2._conf_get_keystone_ec2_uri('http://192.0.2.9/v2.0'), - 'http://192.0.2.9/v2.0/ec2tokens') + 'http://192.0.2.9/v2.0/ec2tokens', + ec2._conf_get_keystone_ec2_uri('http://192.0.2.9/v2.0')) def test_conf_get_opts(self): cfg.CONF.set_default('auth_uri', 'http://192.0.2.9/v2.0/', group='ec2authtoken') ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._conf_get('auth_uri'), 'http://192.0.2.9/v2.0/') + self.assertEqual('http://192.0.2.9/v2.0/', ec2._conf_get('auth_uri')) self.assertEqual( - ec2._conf_get_keystone_ec2_uri('http://192.0.2.9/v2.0/'), - 'http://192.0.2.9/v2.0/ec2tokens') + 'http://192.0.2.9/v2.0/ec2tokens', + ec2._conf_get_keystone_ec2_uri('http://192.0.2.9/v2.0/')) def test_get_signature_param_old(self): params = {'Signature': 'foo'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_signature(dummy_req), 'foo') + self.assertEqual('foo', ec2._get_signature(dummy_req)) def test_get_signature_param_new(self): params = {'X-Amz-Signature': 'foo'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_signature(dummy_req), 'foo') + self.assertEqual('foo', ec2._get_signature(dummy_req)) def test_get_signature_header_space(self): req_env = {'HTTP_AUTHORIZATION': @@ -78,7 +78,7 @@ class Ec2TokenTest(HeatTestCase): 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_signature(dummy_req), 'xyz') + self.assertEqual('xyz', ec2._get_signature(dummy_req)) def test_get_signature_header_notlast(self): req_env = {'HTTP_AUTHORIZATION': @@ -87,7 +87,7 @@ class Ec2TokenTest(HeatTestCase): 'SignedHeaders=content-type;host;x-amz-date ')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_signature(dummy_req), 'xyz') + self.assertEqual('xyz', ec2._get_signature(dummy_req)) def test_get_signature_header_nospace(self): req_env = {'HTTP_AUTHORIZATION': @@ -96,19 +96,19 @@ class Ec2TokenTest(HeatTestCase): 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_signature(dummy_req), 'xyz') + self.assertEqual('xyz', ec2._get_signature(dummy_req)) def test_get_access_param_old(self): params = {'AWSAccessKeyId': 'foo'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_access(dummy_req), 'foo') + self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_param_new(self): params = {'X-Amz-Credential': 'foo/bar'} dummy_req = self._dummy_GET_request(params) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_access(dummy_req), 'foo') + self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_header_space(self): req_env = {'HTTP_AUTHORIZATION': @@ -117,7 +117,7 @@ class Ec2TokenTest(HeatTestCase): 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_access(dummy_req), 'foo') + self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_header_nospace(self): req_env = {'HTTP_AUTHORIZATION': @@ -126,7 +126,7 @@ class Ec2TokenTest(HeatTestCase): 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_access(dummy_req), 'foo') + self.assertEqual('foo', ec2._get_access(dummy_req)) def test_get_access_header_last(self): req_env = {'HTTP_AUTHORIZATION': @@ -135,13 +135,13 @@ class Ec2TokenTest(HeatTestCase): 'Signature=xyz,Credential=foo/bar')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app=None, conf={}) - self.assertEqual(ec2._get_access(dummy_req), 'foo') + self.assertEqual('foo', ec2._get_access(dummy_req)) def test_call_x_auth_user(self): req_env = {'HTTP_X_AUTH_USER': 'foo'} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app='xyz', conf={}) - self.assertEqual(ec2.__call__(dummy_req), 'xyz') + self.assertEqual('xyz', ec2.__call__(dummy_req)) def test_call_auth_nosig(self): req_env = {'HTTP_AUTHORIZATION': @@ -179,7 +179,7 @@ class Ec2TokenTest(HeatTestCase): 'Signature=xyz')} dummy_req = self._dummy_GET_request(environ=req_env) ec2 = ec2token.EC2Token(app='xyz', conf={}) - self.assertEqual(ec2.__call__(dummy_req), 'xyz') + self.assertEqual('xyz', ec2.__call__(dummy_req)) def _stub_http_connection(self, headers={}, params={}, response=None, req_url='http://123:5000/v2.0/ec2tokens'): @@ -224,7 +224,7 @@ class Ec2TokenTest(HeatTestCase): self._stub_http_connection(headers={'Authorization': auth_str}, response=ok_resp) self.m.ReplayAll() - self.assertEqual(ec2.__call__(dummy_req), 'woot') + self.assertEqual('woot', ec2.__call__(dummy_req)) self.assertEqual('tenant', dummy_req.headers['X-Tenant-Name']) self.assertEqual('abcd1234', dummy_req.headers['X-Tenant-Id']) @@ -252,7 +252,7 @@ class Ec2TokenTest(HeatTestCase): self._stub_http_connection(headers={'Authorization': auth_str}, response=ok_resp) self.m.ReplayAll() - self.assertEqual(ec2.__call__(dummy_req), 'woot') + self.assertEqual('woot', ec2.__call__(dummy_req)) self.assertEqual('aa,bb,cc', dummy_req.headers['X-Roles']) self.m.VerifyAll() @@ -340,7 +340,7 @@ class Ec2TokenTest(HeatTestCase): self._stub_http_connection(response=ok_resp, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() - self.assertEqual(ec2.__call__(dummy_req), 'woot') + self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() @@ -376,7 +376,7 @@ class Ec2TokenTest(HeatTestCase): params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() - self.assertEqual(ec2.__call__(dummy_req), 'woot') + self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() @@ -446,7 +446,7 @@ class Ec2TokenTest(HeatTestCase): self.m.ReplayAll() ex = self.assertRaises(exception.HeatInternalFailureError, ec2.__call__, dummy_req) - self.assertEqual(str(ex), 'Service misconfigured') + self.assertEqual('Service misconfigured', str(ex)) self.m.VerifyAll() @@ -467,7 +467,7 @@ class Ec2TokenTest(HeatTestCase): self._stub_http_connection(response=ok_resp, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() - self.assertEqual(ec2.__call__(dummy_req), 'woot') + self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() @@ -490,6 +490,6 @@ class Ec2TokenTest(HeatTestCase): self._stub_http_connection(response=ok_resp, params={'AWSAccessKeyId': 'foo'}) self.m.ReplayAll() - self.assertEqual(ec2.__call__(dummy_req), 'woot') + self.assertEqual('woot', ec2.__call__(dummy_req)) self.m.VerifyAll() diff --git a/heat/tests/test_api_openstack_v1.py b/heat/tests/test_api_openstack_v1.py index ef850ad7cb..c40eebd8ce 100644 --- a/heat/tests/test_api_openstack_v1.py +++ b/heat/tests/test_api_openstack_v1.py @@ -67,7 +67,7 @@ class InstantiationDataTest(HeatTestCase): data = {"key1": ["val1[0]", "val1[1]"], "key2": "val2"} json_repr = '{ "key1": [ "val1[0]", "val1[1]" ], "key2": "val2" }' parsed = stacks.InstantiationData.format_parse(json_repr, 'foo') - self.assertEqual(parsed, data) + self.assertEqual(data, parsed) def test_format_parse_invalid(self): self.assertRaises(webob.exc.HTTPBadRequest, @@ -91,7 +91,7 @@ parameters: def test_stack_name(self): body = {'stack_name': 'wibble'} data = stacks.InstantiationData(body) - self.assertEqual(data.stack_name(), 'wibble') + self.assertEqual('wibble', data.stack_name()) def test_stack_name_missing(self): body = {'not the stack_name': 'wibble'} @@ -102,13 +102,13 @@ parameters: template = {'foo': 'bar', 'blarg': 'wibble'} body = {'template': template} data = stacks.InstantiationData(body) - self.assertEqual(data.template(), template) + self.assertEqual(template, data.template()) def test_template_string_json(self): template = '{"foo": "bar", "blarg": "wibble"}' body = {'template': template} data = stacks.InstantiationData(body) - self.assertEqual(data.template(), json.loads(template)) + self.assertEqual(json.loads(template), data.template()) def test_template_string_yaml(self): template = '''foo: bar @@ -124,7 +124,7 @@ blarg: wibble body = {'template': template} data = stacks.InstantiationData(body) - self.assertEqual(data.template(), parsed) + self.assertEqual(parsed, data.template()) def test_template_url(self): template = {'foo': 'bar', 'blarg': 'wibble'} @@ -136,7 +136,7 @@ blarg: wibble urlfetch.get(url).AndReturn(json.dumps(template)) self.m.ReplayAll() - self.assertEqual(data.template(), template) + self.assertEqual(template, data.template()) self.m.VerifyAll() def test_template_priority(self): @@ -148,7 +148,7 @@ blarg: wibble self.m.StubOutWithMock(urlfetch, 'get') self.m.ReplayAll() - self.assertEqual(data.template(), template) + self.assertEqual(template, data.template()) self.m.VerifyAll() def test_template_missing(self): @@ -162,13 +162,13 @@ blarg: wibble body = {'parameters': params, 'resource_registry': {}} data = stacks.InstantiationData(body) - self.assertEqual(data.environment(), body) + self.assertEqual(body, data.environment()) def test_environment_only_params(self): env = {'parameters': {'foo': 'bar', 'blarg': 'wibble'}} body = {'environment': env} data = stacks.InstantiationData(body) - self.assertEqual(data.environment(), env) + self.assertEqual(env, data.environment()) def test_environment_and_parameters(self): body = {'parameters': {'foo': 'bar'}, @@ -177,7 +177,7 @@ blarg: wibble 'foo': 'bar'}, 'resource_registry': {}} data = stacks.InstantiationData(body) - self.assertEqual(data.environment(), expect) + self.assertEqual(expect, data.environment()) def test_parameters_override_environment(self): # This tests that the cli parameters will override @@ -191,7 +191,7 @@ blarg: wibble 'tester': 'Yes'}, 'resource_registry': {}} data = stacks.InstantiationData(body) - self.assertEqual(data.environment(), expect) + self.assertEqual(expect, data.environment()) def test_environment_bad_format(self): env = {'somethingnotsupported': {'blarg': 'wibble'}} @@ -203,9 +203,8 @@ blarg: wibble env = {'foo': 'bar', 'blarg': 'wibble'} body = {'not the environment': env} data = stacks.InstantiationData(body) - self.assertEqual(data.environment(), - {'parameters': {}, - 'resource_registry': {}}) + self.assertEqual({'parameters': {}, 'resource_registry': {}}, + data.environment()) def test_args(self): body = { @@ -217,7 +216,7 @@ blarg: wibble 'timeout_mins': 60, } data = stacks.InstantiationData(body) - self.assertEqual(data.args(), {'timeout_mins': 60}) + self.assertEqual({'timeout_mins': 60}, data.args()) class ControllerTest(object): @@ -369,14 +368,14 @@ class StackControllerTest(ControllerTest, HeatTestCase): } ] } - self.assertEqual(result, expected) + self.assertEqual(expected, result) default_args = {'limit': None, 'sort_keys': None, 'marker': None, 'sort_dir': None, 'filters': {}} mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, - 'method': 'list_stacks', - 'args': default_args, - 'version': self.api_version}, + 'method': 'list_stacks', + 'args': default_args, + 'version': self.api_version}, None) @mock.patch.object(rpc, 'call') @@ -521,14 +520,14 @@ class StackControllerTest(ControllerTest, HeatTestCase): ] } - self.assertEqual(result, expected) + self.assertEqual(expected, result) default_args = {'limit': None, 'sort_keys': None, 'marker': None, 'sort_dir': None, 'filters': None} mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, - 'method': 'list_stacks', - 'args': default_args, - 'version': self.api_version}, + 'method': 'list_stacks', + 'args': default_args, + 'version': self.api_version}, None) @mock.patch.object(rpc, 'call') @@ -542,13 +541,13 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.controller.index, req, tenant_id=self.tenant) - self.assertEqual(resp.json['code'], 400) - self.assertEqual(resp.json['error']['type'], 'AttributeError') + self.assertEqual(400, resp.json['code']) + self.assertEqual('AttributeError', resp.json['error']['type']) mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, - 'method': 'list_stacks', - 'args': mock.ANY, - 'version': self.api_version}, + 'method': 'list_stacks', + 'args': mock.ANY, + 'version': self.api_version}, None) def test_index_err_denied_policy(self, mock_enforce): @@ -574,13 +573,13 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.controller.index, req, tenant_id=self.tenant) - self.assertEqual(resp.json['code'], 500) - self.assertEqual(resp.json['error']['type'], 'Exception') + self.assertEqual(500, resp.json['code']) + self.assertEqual('Exception', resp.json['error']['type']) mock_call.assert_called_once_with(req.context, self.topic, {'namespace': None, - 'method': 'list_stacks', - 'args': mock.ANY, - 'version': self.api_version}, + 'method': 'list_stacks', + 'args': mock.ANY, + 'version': self.api_version}, None) def test_create(self, mock_enforce): @@ -616,7 +615,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): expected = {'stack': {'id': '1', 'links': [{'href': self._url(identity), 'rel': 'self'}]}} - self.assertEqual(response, expected) + self.assertEqual(expected, response) self.m.VerifyAll() @@ -653,7 +652,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): expected = {'stack': {'id': '1', 'links': [{'href': self._url(identity), 'rel': 'self'}]}} - self.assertEqual(result, expected) + self.assertEqual(expected, result) self.m.VerifyAll() @@ -710,22 +709,22 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.controller.create, req, tenant_id=self.tenant, body=body) - self.assertEqual(resp.json['code'], 400) - self.assertEqual(resp.json['error']['type'], 'AttributeError') + self.assertEqual(400, resp.json['code']) + self.assertEqual('AttributeError', resp.json['error']['type']) resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) - self.assertEqual(resp.json['code'], 400) - self.assertEqual(resp.json['error']['type'], 'UnknownUserParameter') + self.assertEqual(400, resp.json['code']) + self.assertEqual('UnknownUserParameter', resp.json['error']['type']) resp = request_with_middleware(fault.FaultWrapper, self.controller.create, req, tenant_id=self.tenant, body=body) - self.assertEqual(resp.json['code'], 400) - self.assertEqual(resp.json['error']['type'], 'UserParameterMissing') + self.assertEqual(400, resp.json['code']) + self.assertEqual('UserParameterMissing', resp.json['error']['type']) self.m.VerifyAll() def test_create_err_existing(self, mock_enforce): @@ -759,8 +758,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.controller.create, req, tenant_id=self.tenant, body=body) - self.assertEqual(resp.json['code'], 409) - self.assertEqual(resp.json['error']['type'], 'StackExists') + self.assertEqual(409, resp.json['code']) + self.assertEqual('StackExists', resp.json['error']['type']) self.m.VerifyAll() def test_create_err_denied_policy(self, mock_enforce): @@ -813,8 +812,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.controller.create, req, tenant_id=self.tenant, body=body) - self.assertEqual(resp.json['code'], 400) - self.assertEqual(resp.json['error']['type'], 'StackValidationFailed') + self.assertEqual(400, resp.json['code']) + self.assertEqual('StackValidationFailed', resp.json['error']['type']) self.m.VerifyAll() def test_create_err_stack_bad_reqest(self, mock_enforce): @@ -835,8 +834,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): # When HTTP disguised exceptions reach the fault app, they are # converted into regular responses, just like non-HTTP exceptions - self.assertEqual(resp.json['code'], 400) - self.assertEqual(resp.json['error']['type'], 'HTTPBadRequest') + self.assertEqual(400, resp.json['code']) + self.assertEqual('HTTPBadRequest', resp.json['error']['type']) self.assertIsNotNone(resp.json['error']['traceback']) def test_lookup(self, mock_enforce): @@ -858,7 +857,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): found = self.assertRaises( webob.exc.HTTPFound, self.controller.lookup, req, tenant_id=identity.tenant, stack_name=identity.stack_name) - self.assertEqual(found.location, self._url(identity)) + self.assertEqual(self._url(identity), found.location) self.m.VerifyAll() @@ -873,7 +872,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): found = self.assertRaises( webob.exc.HTTPFound, self.controller.lookup, req, tenant_id=identity.tenant, stack_name=identity.arn()) - self.assertEqual(found.location, self._url(identity)) + self.assertEqual(self._url(identity), found.location) self.m.VerifyAll() @@ -899,8 +898,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): req, tenant_id=self.tenant, stack_name=stack_name) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_lookup_err_policy(self, mock_enforce): @@ -933,12 +932,14 @@ class StackControllerTest(ControllerTest, HeatTestCase): None).AndReturn(identity) self.m.ReplayAll() + found = self.assertRaises( webob.exc.HTTPFound, self.controller.lookup, req, tenant_id=identity.tenant, stack_name=identity.stack_name, path='resources') - self.assertEqual(found.location, - self._url(identity) + '/resources') + self.assertEqual(self._url(identity) + '/resources', + found.location) + self.m.VerifyAll() def test_lookup_resource_nonexistent(self, mock_enforce): @@ -964,8 +965,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): stack_name=stack_name, path='resources') - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_lookup_resource_err_denied_policy(self, mock_enforce): @@ -1051,7 +1052,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): u'timeout_mins': 60, } } - self.assertEqual(response, expected) + self.assertEqual(expected, response) self.m.VerifyAll() def test_show_notfound(self, mock_enforce): @@ -1076,8 +1077,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): stack_name=identity.stack_name, stack_id=identity.stack_id) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_invalidtenant(self, mock_enforce): @@ -1093,7 +1094,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): stack_name=identity.stack_name, stack_id=identity.stack_id) - self.assertEqual(resp.status_int, 403) + self.assertEqual(403, resp.status_int) self.assertIn('403 Forbidden', str(resp)) self.m.VerifyAll() @@ -1131,7 +1132,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): stack_name=identity.stack_name, stack_id=identity.stack_id) - self.assertEqual(response, template) + self.assertEqual(template, response) self.m.VerifyAll() def test_get_template_err_denied_policy(self, mock_enforce): @@ -1173,8 +1174,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): stack_name=identity.stack_name, stack_id=identity.stack_id) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_update(self, mock_enforce): @@ -1247,8 +1248,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): stack_id=identity.stack_id, body=body) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_update_err_denied_policy(self, mock_enforce): @@ -1373,8 +1374,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): stack_name=identity.stack_name, stack_id=identity.stack_id) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_validate_template(self, mock_enforce): @@ -1407,7 +1408,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): response = self.controller.validate_template(req, tenant_id=self.tenant, body=body) - self.assertEqual(response, engine_response) + self.assertEqual(engine_response, response) self.m.VerifyAll() def test_validate_template_error(self, mock_enforce): @@ -1464,7 +1465,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.m.ReplayAll() response = self.controller.list_resource_types(req, tenant_id=self.tenant) - self.assertEqual(response, {'resource_types': engine_response}) + self.assertEqual({'resource_types': engine_response}, response) self.m.VerifyAll() def test_list_resource_types_error(self, mock_enforce): @@ -1484,8 +1485,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): resp = request_with_middleware(fault.FaultWrapper, self.controller.list_resource_types, req, tenant_id=self.tenant) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'ResourceTypeNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('ResourceTypeNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_list_resource_types_err_denied_policy(self, mock_enforce): @@ -1524,7 +1525,7 @@ class StackControllerTest(ControllerTest, HeatTestCase): response = self.controller.resource_schema(req, tenant_id=self.tenant, type_name=type_name) - self.assertEqual(response, engine_response) + self.assertEqual(engine_response, response) self.m.VerifyAll() def test_resource_schema_nonexist(self, mock_enforce): @@ -1546,8 +1547,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.controller.resource_schema, req, tenant_id=self.tenant, type_name=type_name) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'ResourceTypeNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('ResourceTypeNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_resource_schema_err_denied_policy(self, mock_enforce): @@ -1597,8 +1598,8 @@ class StackControllerTest(ControllerTest, HeatTestCase): self.controller.generate_template, req, tenant_id=self.tenant, type_name='NOT_FOUND') - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'ResourceTypeNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('ResourceTypeNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_generate_template_err_denied_policy(self, mock_enforce): @@ -1625,9 +1626,9 @@ class StackSerializerTest(HeatTestCase): 'links': [{'href': 'location', "rel": "self"}]}} response = webob.Response() response = self.serializer.create(response, result) - self.assertEqual(response.status_int, 201) - self.assertEqual(response.headers['Location'], 'location') - self.assertEqual(response.headers['Content-Type'], 'application/json') + self.assertEqual(201, response.status_int) + self.assertEqual('location', response.headers['Location']) + self.assertEqual('application/json', response.headers['Content-Type']) @mock.patch.object(policy.Enforcer, 'enforce') @@ -1699,7 +1700,7 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): u'a3455d8c-9f88-404d-a85b-5315293e67de', u'resource_type': u'AWS::EC2::Instance'}]} - self.assertEqual(result, expected) + self.assertEqual(expected, result) self.m.VerifyAll() def test_index_nonexist(self, mock_enforce): @@ -1725,8 +1726,8 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_index_denied_policy(self, mock_enforce): @@ -1805,7 +1806,7 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): } } - self.assertEqual(result, expected) + self.assertEqual(expected, result) self.m.VerifyAll() def test_show_nonexist(self, mock_enforce): @@ -1836,8 +1837,8 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): stack_id=stack_identity.stack_id, resource_name=res_name) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_nonexist_resource(self, mock_enforce): @@ -1868,8 +1869,8 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): stack_id=stack_identity.stack_id, resource_name=res_name) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'ResourceNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('ResourceNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_uncreated_resource(self, mock_enforce): @@ -1900,8 +1901,8 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): stack_id=stack_identity.stack_id, resource_name=res_name) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'ResourceNotAvailable') + self.assertEqual(404, resp.json['code']) + self.assertEqual('ResourceNotAvailable', resp.json['error']['type']) self.m.VerifyAll() def test_show_err_denied_policy(self, mock_enforce): @@ -1965,7 +1966,7 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): expected = {'metadata': {u'ensureRunning': u'true'}} - self.assertEqual(result, expected) + self.assertEqual(expected, result) self.m.VerifyAll() def test_metadata_show_nonexist(self, mock_enforce): @@ -1996,8 +1997,8 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): stack_id=stack_identity.stack_id, resource_name=res_name) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_metadata_show_nonexist_resource(self, mock_enforce): @@ -2028,8 +2029,8 @@ class ResourceControllerTest(ControllerTest, HeatTestCase): stack_id=stack_identity.stack_id, resource_name=res_name) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'ResourceNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('ResourceNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_metadata_show_err_denied_policy(self, mock_enforce): @@ -2151,7 +2152,7 @@ class EventControllerTest(ControllerTest, HeatTestCase): ] } - self.assertEqual(result, expected) + self.assertEqual(expected, result) self.m.VerifyAll() def test_stack_index_event_id_integer(self, mock_enforce): @@ -2220,7 +2221,7 @@ class EventControllerTest(ControllerTest, HeatTestCase): ] } - self.assertEqual(result, expected) + self.assertEqual(expected, result) self.m.VerifyAll() def test_index_stack_nonexist(self, mock_enforce): @@ -2246,8 +2247,8 @@ class EventControllerTest(ControllerTest, HeatTestCase): stack_name=stack_identity.stack_name, stack_id=stack_identity.stack_id) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_index_err_denied_policy(self, mock_enforce): @@ -2396,7 +2397,7 @@ class EventControllerTest(ControllerTest, HeatTestCase): } } - self.assertEqual(result, expected) + self.assertEqual(expected, result) self.m.VerifyAll() def test_show_nonexist_event_id_integer(self, mock_enforce): @@ -2526,8 +2527,8 @@ class EventControllerTest(ControllerTest, HeatTestCase): resource_name=res_name, event_id=event_id) - self.assertEqual(resp.json['code'], 404) - self.assertEqual(resp.json['error']['type'], 'StackNotFound') + self.assertEqual(404, resp.json['code']) + self.assertEqual('StackNotFound', resp.json['error']['type']) self.m.VerifyAll() def test_show_err_denied_policy(self, mock_enforce): @@ -2998,8 +2999,8 @@ class ActionControllerTest(ControllerTest, HeatTestCase): stack_id=stack_identity.stack_id, body=body) - self.assertEqual(resp.json['code'], 400) - self.assertEqual(resp.json['error']['type'], 'AttributeError') + self.assertEqual(400, resp.json['code']) + self.assertEqual('AttributeError', resp.json['error']['type']) self.m.VerifyAll() def test_action_err_denied_policy(self, mock_enforce): diff --git a/heat/tests/test_auth_password.py b/heat/tests/test_auth_password.py index 080584622d..d46c22efb2 100644 --- a/heat/tests/test_auth_password.py +++ b/heat/tests/test_auth_password.py @@ -112,12 +112,12 @@ class KeystonePasswordAuthProtocolTest(HeatTestCase): req.headers['X_AUTH_KEY'] = 'badpassword' self.middleware(req.environ, self._start_fake_response) self.m.VerifyAll() - self.assertEqual(self.response_status, 401) + self.assertEqual(401, self.response_status) def test_request_with_no_tenant_in_url_or_auth_headers(self): req = webob.Request.blank('/') self.middleware(req.environ, self._start_fake_response) - self.assertEqual(self.response_status, 401) + self.assertEqual(401, self.response_status) def test_multi_cloud(self): allowed_auth_uris = ['http://multicloud.test.com:5000/v2.0'] @@ -154,7 +154,7 @@ class KeystonePasswordAuthProtocolTest(HeatTestCase): req.headers['X_AUTH_KEY'] = 'goodpassword' req.headers['X_AUTH_URL'] = auth_url self.middleware(req.environ, self._start_fake_response) - self.assertEqual(self.response_status, 401) + self.assertEqual(401, self.response_status) def test_multi_cloud_target_not_allowed(self): cfg.CONF.set_override('multi_cloud', True, group='auth_password') @@ -167,7 +167,7 @@ class KeystonePasswordAuthProtocolTest(HeatTestCase): req.headers['X_AUTH_KEY'] = 'goodpassword' req.headers['X_AUTH_URL'] = auth_url self.middleware(req.environ, self._start_fake_response) - self.assertEqual(self.response_status, 401) + self.assertEqual(401, self.response_status) def test_multi_cloud_no_auth_url(self): cfg.CONF.set_override('multi_cloud', True, group='auth_password') @@ -175,4 +175,4 @@ class KeystonePasswordAuthProtocolTest(HeatTestCase): req.headers['X_AUTH_USER'] = 'user_name1' req.headers['X_AUTH_KEY'] = 'goodpassword' self.middleware(req.environ, self._start_fake_response) - self.assertEqual(self.response_status, 400) + self.assertEqual(400, self.response_status) diff --git a/heat/tests/test_autoscaling.py b/heat/tests/test_autoscaling.py index c51df9ff98..b1607b3f41 100644 --- a/heat/tests/test_autoscaling.py +++ b/heat/tests/test_autoscaling.py @@ -228,7 +228,7 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') instance_names = rsrc.get_instance_names() - self.assertEqual(len(instance_names), 1) + self.assertEqual(1, len(instance_names)) # Reduce the min size to 0, should complete without adjusting update_snippet = copy.deepcopy(rsrc.parsed_template()) @@ -258,7 +258,7 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['AvailabilityZones'] = ['foo'] updater = scheduler.TaskRunner(rsrc.update, update_snippet) @@ -279,8 +279,8 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 1) - self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE)) + self.assertEqual(1, len(rsrc.get_instance_names())) + self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() @@ -294,7 +294,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() scheduler.TaskRunner(rsrc.suspend)() - self.assertEqual(rsrc.state, (rsrc.SUSPEND, rsrc.COMPLETE)) + self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) rsrc.delete() self.m.VerifyAll() @@ -311,8 +311,8 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 1) - self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE)) + self.assertEqual(1, len(rsrc.get_instance_names())) + self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() @@ -330,7 +330,7 @@ class AutoScalingTest(HeatTestCase): i.state_set(rsrc.SUSPEND, rsrc.COMPLETE) 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() @@ -349,8 +349,8 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 2) - self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE)) + self.assertEqual(2, len(rsrc.get_instance_names())) + self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() @@ -368,7 +368,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() scheduler.TaskRunner(rsrc.suspend)() - self.assertEqual(rsrc.state, (rsrc.SUSPEND, rsrc.COMPLETE)) + self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) rsrc.delete() self.m.VerifyAll() @@ -387,8 +387,8 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 2) - self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE)) + self.assertEqual(2, len(rsrc.get_instance_names())) + self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() @@ -410,7 +410,7 @@ class AutoScalingTest(HeatTestCase): i.state_set(rsrc.SUSPEND, rsrc.COMPLETE) 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() @@ -427,8 +427,8 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 1) - self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE)) + self.assertEqual(1, len(rsrc.get_instance_names())) + self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() @@ -440,9 +440,9 @@ class AutoScalingTest(HeatTestCase): sus_task = scheduler.TaskRunner(rsrc.suspend) self.assertRaises(exception.ResourceFailure, sus_task, ()) - self.assertEqual(rsrc.state, (rsrc.SUSPEND, rsrc.FAILED)) - self.assertEqual(rsrc.status_reason, - 'Error: Resource suspend failed: Exception: oops') + self.assertEqual((rsrc.SUSPEND, rsrc.FAILED), rsrc.state) + self.assertEqual('Error: Resource suspend failed: Exception: oops', + rsrc.status_reason) rsrc.delete() self.m.VerifyAll() @@ -459,8 +459,8 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 1) - self.assertEqual(rsrc.state, (rsrc.CREATE, rsrc.COMPLETE)) + self.assertEqual(1, len(rsrc.get_instance_names())) + self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll() self.m.UnsetStubs() @@ -476,9 +476,9 @@ class AutoScalingTest(HeatTestCase): sus_task = scheduler.TaskRunner(rsrc.resume) self.assertRaises(exception.ResourceFailure, sus_task, ()) - self.assertEqual(rsrc.state, (rsrc.RESUME, rsrc.FAILED)) - self.assertEqual(rsrc.status_reason, - 'Error: Resource resume failed: Exception: oops') + self.assertEqual((rsrc.RESUME, rsrc.FAILED), rsrc.state) + self.assertEqual('Error: Resource resume failed: Exception: oops', + rsrc.status_reason) rsrc.delete() self.m.VerifyAll() @@ -522,7 +522,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) instance_names = rsrc.get_instance_names() # Reduce the max size to 2, should complete without adjusting @@ -548,7 +548,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Increase min size to 2, should trigger an ExactCapacity adjust self._stub_lb_reload(2) @@ -559,7 +559,7 @@ class AutoScalingTest(HeatTestCase): update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['MinSize'] = '2' scheduler.TaskRunner(rsrc.update, update_snippet)() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) self.assertEqual('2', rsrc.properties['MinSize']) rsrc.delete() @@ -578,7 +578,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Increase min size to 2 via DesiredCapacity, should adjust self._stub_lb_reload(2) @@ -589,7 +589,7 @@ class AutoScalingTest(HeatTestCase): update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['DesiredCapacity'] = '2' scheduler.TaskRunner(rsrc.update, update_snippet)() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) self.assertEqual(2, rsrc.properties['DesiredCapacity']) rsrc.delete() @@ -607,7 +607,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(2) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) instance_names = rsrc.get_instance_names() # Remove DesiredCapacity from the updated template, which should @@ -636,7 +636,7 @@ class AutoScalingTest(HeatTestCase): self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['Cooldown'] = '61' scheduler.TaskRunner(rsrc.update, update_snippet)() @@ -681,7 +681,7 @@ class AutoScalingTest(HeatTestCase): rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) update_snippet = copy.deepcopy(rsrc.parsed_template()) update_snippet['Properties']['Cooldown'] = '61' scheduler.TaskRunner(rsrc.update, update_snippet)() @@ -761,7 +761,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(3) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') - self.assertEqual(len(rsrc.get_instance_names()), 3) + self.assertEqual(3, len(rsrc.get_instance_names())) # reduce to 1 self._stub_lb_reload(1) @@ -769,7 +769,7 @@ class AutoScalingTest(HeatTestCase): self._stub_meta_expected(now, 'ChangeInCapacity : -2') self.m.ReplayAll() rsrc.adjust(-2) - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # raise to 3 self._stub_lb_reload(3) @@ -777,7 +777,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(2) self.m.ReplayAll() rsrc.adjust(2) - self.assertEqual(len(rsrc.get_instance_names()), 3) + self.assertEqual(3, len(rsrc.get_instance_names())) # set to 2 self._stub_lb_reload(2) @@ -785,7 +785,7 @@ class AutoScalingTest(HeatTestCase): self._stub_meta_expected(now, 'ExactCapacity : 2') self.m.ReplayAll() rsrc.adjust(2, 'ExactCapacity') - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) self.m.VerifyAll() def test_scaling_group_scale_up_failure(self): @@ -799,7 +799,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) self.m.VerifyAll() self.m.UnsetStubs() @@ -811,7 +811,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() self.assertRaises(exception.Error, rsrc.adjust, 1) - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) self.m.VerifyAll() @@ -829,7 +829,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # raise above the max self._stub_lb_reload(5) @@ -837,7 +837,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(3) self.m.ReplayAll() rsrc.adjust(4) - self.assertEqual(len(rsrc.get_instance_names()), 5) + self.assertEqual(5, len(rsrc.get_instance_names())) # lower below the min self._stub_lb_reload(1) @@ -845,11 +845,11 @@ class AutoScalingTest(HeatTestCase): self._stub_meta_expected(now, 'ChangeInCapacity : -5') self.m.ReplayAll() rsrc.adjust(-5) - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # no change rsrc.adjust(0) - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -869,7 +869,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by decrease % self._stub_lb_reload(lowest) @@ -878,7 +878,7 @@ class AutoScalingTest(HeatTestCase): self._stub_validate() self.m.ReplayAll() rsrc.adjust(decrease, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), lowest) + self.assertEqual(lowest, len(rsrc.get_instance_names())) # raise by increase % self._stub_lb_reload(highest) @@ -887,7 +887,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(create) self.m.ReplayAll() rsrc.adjust(increase, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), highest) + self.assertEqual(highest, len(rsrc.get_instance_names())) rsrc.delete() @@ -915,7 +915,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by 50% self._stub_lb_reload(1) @@ -923,7 +923,7 @@ class AutoScalingTest(HeatTestCase): self._stub_meta_expected(now, 'PercentChangeInCapacity : -50') self.m.ReplayAll() rsrc.adjust(-50, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Now move time on 10 seconds - Cooldown in template is 60 # so this should not update the policy metadata, and the @@ -948,7 +948,7 @@ class AutoScalingTest(HeatTestCase): # raise by 200%, too soon for Cooldown so there should be no change rsrc.adjust(200, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) rsrc.delete() @@ -967,7 +967,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by 50% self._stub_lb_reload(1) @@ -975,7 +975,7 @@ class AutoScalingTest(HeatTestCase): self._stub_meta_expected(now, 'PercentChangeInCapacity : -50') self.m.ReplayAll() rsrc.adjust(-50, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Now move time on 61 seconds - Cooldown in template is 60 # so this should update the policy metadata, and the @@ -1002,7 +1002,7 @@ class AutoScalingTest(HeatTestCase): self._stub_meta_expected(now, 'PercentChangeInCapacity : 200') self.m.ReplayAll() rsrc.adjust(200, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), 3) + self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() @@ -1021,7 +1021,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # reduce by 50% self._stub_lb_reload(1) @@ -1029,7 +1029,7 @@ class AutoScalingTest(HeatTestCase): self._stub_validate() self.m.ReplayAll() rsrc.adjust(-50, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Don't move time, since cooldown is zero, it should work previous_meta = {timeutils.strtime(now): @@ -1052,7 +1052,7 @@ class AutoScalingTest(HeatTestCase): self._stub_create(2) self.m.ReplayAll() rsrc.adjust(200, 'PercentChangeInCapacity') - self.assertEqual(len(rsrc.get_instance_names()), 3) + self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -1090,7 +1090,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Scale up one self._stub_lb_reload(2) @@ -1108,7 +1108,7 @@ class AutoScalingTest(HeatTestCase): alarm_url = up_policy.FnGetAtt('AlarmUrl') self.assertIsNotNone(alarm_url) up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -1182,7 +1182,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # Scale down one self._stub_lb_reload(1) @@ -1197,7 +1197,7 @@ class AutoScalingTest(HeatTestCase): down_policy = self.create_scaling_policy(t, stack, 'WebServerScaleDownPolicy') down_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -1214,7 +1214,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Scale up one self._stub_lb_reload(2) @@ -1229,7 +1229,7 @@ class AutoScalingTest(HeatTestCase): up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # Now move time on 10 seconds - Cooldown in template is 60 # so this should not update the policy metadata, and the @@ -1251,7 +1251,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -1268,7 +1268,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Scale up one self._stub_lb_reload(2) @@ -1283,7 +1283,7 @@ class AutoScalingTest(HeatTestCase): up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # Now move time on 61 seconds - Cooldown in template is 60 # so this should trigger a scale-up @@ -1307,7 +1307,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 3) + self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -1324,7 +1324,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Create the scaling policy (with Cooldown=0) and scale up one properties = t['Resources']['WebServerScaleUpPolicy']['Properties'] @@ -1341,7 +1341,7 @@ class AutoScalingTest(HeatTestCase): up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # Now trigger another scale-up without changing time, should work previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'} @@ -1363,7 +1363,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 3) + self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -1380,7 +1380,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Create the scaling policy no Cooldown property, should behave the # same as when Cooldown==0 @@ -1399,7 +1399,7 @@ class AutoScalingTest(HeatTestCase): up_policy = self.create_scaling_policy(t, stack, 'WebServerScaleUpPolicy') up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # Now trigger another scale-up without changing time, should work previous_meta = {timeutils.strtime(now): 'ChangeInCapacity : 1'} @@ -1421,7 +1421,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 3) + self.assertEqual(3, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() @@ -1442,7 +1442,7 @@ class AutoScalingTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') stack['WebServerGroup'] = rsrc - self.assertEqual(len(rsrc.get_instance_names()), 1) + self.assertEqual(1, len(rsrc.get_instance_names())) # Create initial scaling policy up_policy = self.create_scaling_policy(t, stack, @@ -1457,7 +1457,7 @@ class AutoScalingTest(HeatTestCase): # Trigger alarm up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 2) + self.assertEqual(2, len(rsrc.get_instance_names())) # Update scaling policy update_snippet = copy.deepcopy(up_policy.parsed_template()) @@ -1491,7 +1491,7 @@ class AutoScalingTest(HeatTestCase): # Trigger alarm up_policy.signal() - self.assertEqual(len(rsrc.get_instance_names()), 4) + self.assertEqual(4, len(rsrc.get_instance_names())) rsrc.delete() self.m.VerifyAll() diff --git a/heat/tests/test_autoscaling_update_policy.py b/heat/tests/test_autoscaling_update_policy.py index ed3b23db09..444a0b6b32 100644 --- a/heat/tests/test_autoscaling_update_policy.py +++ b/heat/tests/test_autoscaling_update_policy.py @@ -337,13 +337,13 @@ class AutoScalingGroupTest(HeatTestCase): tmpl_batch_sz = int(tmpl_policy['MaxBatchSize']) grp = stack['WebServerGroup'] self.assertTrue(grp.update_policy) - self.assertTrue(len(grp.update_policy) == 1) + self.assertEqual(1, len(grp.update_policy)) self.assertIn('AutoScalingRollingUpdate', grp.update_policy) policy = grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(policy and len(policy) > 0) - self.assertEqual(int(policy['MinInstancesInService']), 1) - self.assertEqual(int(policy['MaxBatchSize']), tmpl_batch_sz) - self.assertEqual(policy['PauseTime'], 'PT1S') + self.assertEqual(1, int(policy['MinInstancesInService'])) + self.assertEqual(tmpl_batch_sz, int(policy['MaxBatchSize'])) + self.assertEqual('PT1S', policy['PauseTime']) def test_parse_with_default_update_policy(self): tmpl = template_format.parse(asg_tmpl_with_default_updt_policy) @@ -351,13 +351,13 @@ class AutoScalingGroupTest(HeatTestCase): stack.validate() grp = stack['WebServerGroup'] self.assertTrue(grp.update_policy) - self.assertTrue(len(grp.update_policy) == 1) + self.assertEqual(1, len(grp.update_policy)) self.assertIn('AutoScalingRollingUpdate', grp.update_policy) policy = grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(policy and len(policy) > 0) - self.assertEqual(int(policy['MinInstancesInService']), 0) - self.assertEqual(int(policy['MaxBatchSize']), 1) - self.assertEqual(policy['PauseTime'], 'PT0S') + self.assertEqual(0, int(policy['MinInstancesInService'])) + self.assertEqual(1, int(policy['MaxBatchSize'])) + self.assertEqual('PT0S', policy['PauseTime']) def test_parse_with_bad_update_policy(self): tmpl = template_format.parse(asg_tmpl_with_bad_updt_policy) @@ -399,7 +399,7 @@ class AutoScalingGroupTest(HeatTestCase): updated_policy = (updated_grp.t['UpdatePolicy'] if 'UpdatePolicy' in updated_grp.t else None) expected = {u'UpdatePolicy': updated_policy} - self.assertEqual(tmpl_diff, expected) + self.assertEqual(expected, tmpl_diff) def test_update_policy_added(self): self.validate_update_policy_diff(asg_tmpl_without_updt_policy, @@ -437,7 +437,7 @@ class AutoScalingGroupTest(HeatTestCase): self.m.ReplayAll() stack.create() self.m.VerifyAll() - self.assertEqual(stack.state, ('CREATE', 'COMPLETE')) + self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['WebServerGroup'] @@ -449,7 +449,7 @@ class AutoScalingGroupTest(HeatTestCase): init_updt_policy = tmpl['Resources']['WebServerGroup']['UpdatePolicy'] init_roll_updt = init_updt_policy['AutoScalingRollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) - self.assertEqual(int(current_policy['MaxBatchSize']), init_batch_sz) + self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['LaunchConfig'] @@ -461,7 +461,7 @@ class AutoScalingGroupTest(HeatTestCase): # test the number of instances created nested = stack['WebServerGroup'].nested() - self.assertEqual(len(nested.resources), size) + self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() @@ -492,7 +492,7 @@ class AutoScalingGroupTest(HeatTestCase): self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() - self.assertEqual(stack.state, ('UPDATE', 'COMPLETE')) + self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that the update policy is updated updated_grp = stack['WebServerGroup'] @@ -502,7 +502,7 @@ class AutoScalingGroupTest(HeatTestCase): updated_policy = updated_grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) - self.assertEqual(int(updated_policy['MaxBatchSize']), new_batch_sz) + self.assertEqual(new_batch_sz, int(updated_policy['MaxBatchSize'])) # test that the launch configuration is replaced updated_conf_name = self.get_launch_conf_name(stack, 'WebServerGroup') @@ -511,19 +511,19 @@ class AutoScalingGroupTest(HeatTestCase): # test that the group size are the same updt_instances = updated_grp.get_instances() updt_names = updated_grp.get_instance_names() - self.assertEqual(len(updt_names), len(init_names)) + self.assertEqual(len(init_names), len(updt_names)) # test that appropriate number of instance names are the same matched_names = set(updt_names) & set(init_names) - self.assertEqual(len(matched_names), num_updates_expected_on_updt) + self.assertEqual(num_updates_expected_on_updt, len(matched_names)) # test that the appropriate number of new instances are created - self.assertEqual(len(set(updt_names) - set(init_names)), - num_creates_expected_on_updt) + self.assertEqual(num_creates_expected_on_updt, + len(set(updt_names) - set(init_names))) # test that the appropriate number of instances are deleted - self.assertEqual(len(set(init_names) - set(updt_names)), - num_deletes_expected_on_updt) + self.assertEqual(num_deletes_expected_on_updt, + len(set(init_names) - set(updt_names))) # test that the older instances are the ones being deleted if num_deletes_expected_on_updt > 0: @@ -535,12 +535,12 @@ class AutoScalingGroupTest(HeatTestCase): # test that the image id is changed for all instances updt_images = [(i.name, i.t['Properties']['ImageId']) for i in updt_instances] - self.assertEqual(len(set(updt_images) & set(init_images)), 0) + self.assertEqual(0, len(set(updt_images) & set(init_images))) else: # test that instance type is changed for all instances updt_flavors = [(i.name, i.t['Properties']['InstanceType']) for i in updt_instances] - self.assertEqual(len(set(updt_flavors) & set(init_flavors)), 0) + self.assertEqual(0, len(set(updt_flavors) & set(init_flavors))) def test_autoscaling_group_update_replace(self): """ @@ -684,7 +684,7 @@ class AutoScalingGroupTest(HeatTestCase): self.m.ReplayAll() stack.create() self.m.VerifyAll() - self.assertEqual(stack.state, ('CREATE', 'COMPLETE')) + self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['WebServerGroup'] @@ -695,7 +695,7 @@ class AutoScalingGroupTest(HeatTestCase): init_updt_policy = tmpl['Resources']['WebServerGroup']['UpdatePolicy'] init_roll_updt = init_updt_policy['AutoScalingRollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) - self.assertEqual(int(current_policy['MaxBatchSize']), init_batch_sz) + self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['LaunchConfig'] @@ -704,7 +704,7 @@ class AutoScalingGroupTest(HeatTestCase): # test the number of instances created nested = stack['WebServerGroup'].nested() - self.assertEqual(len(nested.resources), size) + self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() @@ -718,7 +718,7 @@ class AutoScalingGroupTest(HeatTestCase): self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() - self.assertEqual(stack.state, ('UPDATE', 'COMPLETE')) + self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that update policy is removed updated_grp = stack['WebServerGroup'] @@ -736,7 +736,7 @@ class AutoScalingGroupTest(HeatTestCase): self.m.ReplayAll() stack.create() self.m.VerifyAll() - self.assertEqual(stack.state, ('CREATE', 'COMPLETE')) + self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['WebServerGroup'] @@ -747,11 +747,11 @@ class AutoScalingGroupTest(HeatTestCase): init_updt_policy = tmpl['Resources']['WebServerGroup']['UpdatePolicy'] init_roll_updt = init_updt_policy['AutoScalingRollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) - self.assertEqual(int(current_policy['MaxBatchSize']), init_batch_sz) + self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test the number of instances created nested = stack['WebServerGroup'].nested() - self.assertEqual(len(nested.resources), size) + self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() @@ -772,7 +772,7 @@ class AutoScalingGroupTest(HeatTestCase): self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() - self.assertEqual(stack.state, ('UPDATE', 'FAILED')) + self.assertEqual(('UPDATE', 'FAILED'), stack.state) # test that the update policy is updated updated_grp = stack['WebServerGroup'] @@ -780,7 +780,7 @@ class AutoScalingGroupTest(HeatTestCase): updated_policy = updated_grp.update_policy['AutoScalingRollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) - self.assertEqual(updated_policy['PauseTime'], new_pause_time) + self.assertEqual(new_pause_time, updated_policy['PauseTime']) # test that error message match expected_error_message = ('The current UpdatePolicy will result ' diff --git a/heat/tests/test_common_context.py b/heat/tests/test_common_context.py index 9b0ddbabb7..95dabdba1b 100644 --- a/heat/tests/test_common_context.py +++ b/heat/tests/test_common_context.py @@ -53,22 +53,22 @@ class TestRequestContext(HeatTestCase): is_admin=self.ctx.get('is_admin')) ctx_dict = ctx.to_dict() del(ctx_dict['request_id']) - self.assertEqual(ctx_dict, self.ctx) + self.assertEqual(self.ctx, ctx_dict) def test_request_context_from_dict(self): ctx = context.RequestContext.from_dict(self.ctx) ctx_dict = ctx.to_dict() del(ctx_dict['request_id']) - self.assertEqual(ctx_dict, self.ctx) + self.assertEqual(self.ctx, ctx_dict) def test_request_context_update(self): ctx = context.RequestContext.from_dict(self.ctx) for k in self.ctx: - self.assertEqual(ctx.to_dict().get(k), self.ctx.get(k)) + self.assertEqual(self.ctx.get(k), ctx.to_dict().get(k)) override = '%s_override' % k setattr(ctx, k, override) - self.assertEqual(ctx.to_dict().get(k), override) + self.assertEqual(override, ctx.to_dict().get(k)) def test_get_admin_context(self): ctx = context.get_admin_context() diff --git a/heat/tests/test_common_policy.py b/heat/tests/test_common_policy.py index 4bc7048e06..461010ed05 100644 --- a/heat/tests/test_common_policy.py +++ b/heat/tests/test_common_policy.py @@ -129,7 +129,7 @@ class TestPolicyEnforcer(HeatTestCase): enforcer = policy.Enforcer() enforcer.load_rules(force_reload=True) enforcer.clear() - self.assertEqual(enforcer.enforcer.rules, {}) + self.assertEqual({}, enforcer.enforcer.rules) def test_set_rules_overwrite_true(self): self.stub_policyfile('deny_stack_user.json') @@ -137,7 +137,7 @@ class TestPolicyEnforcer(HeatTestCase): enforcer = policy.Enforcer() enforcer.load_rules(True) enforcer.set_rules({'test_heat_rule': 1}, True) - self.assertEqual(enforcer.enforcer.rules, {'test_heat_rule': 1}) + self.assertEqual({'test_heat_rule': 1}, enforcer.enforcer.rules) def test_set_rules_overwrite_false(self): self.stub_policyfile('deny_stack_user.json') diff --git a/heat/tests/test_cw_alarm.py b/heat/tests/test_cw_alarm.py index 58dd8a4912..ebad819dc0 100644 --- a/heat/tests/test_cw_alarm.py +++ b/heat/tests/test_cw_alarm.py @@ -131,22 +131,22 @@ class CloudWatchAlarmTest(HeatTestCase): self.m.ReplayAll() rsrc = self.create_alarm(t, stack, 'MEMAlarmHigh') scheduler.TaskRunner(rsrc.suspend)() - self.assertEqual(rsrc.state, (rsrc.SUSPEND, rsrc.COMPLETE)) + self.assertEqual((rsrc.SUSPEND, rsrc.COMPLETE), rsrc.state) self.ctx = utils.dummy_context() wr = watchrule.WatchRule.load( self.ctx, watch_name="test_stack-MEMAlarmHigh") - self.assertEqual(wr.state, watchrule.WatchRule.SUSPENDED) + self.assertEqual(watchrule.WatchRule.SUSPENDED, wr.state) scheduler.TaskRunner(rsrc.resume)() - self.assertEqual(rsrc.state, (rsrc.RESUME, rsrc.COMPLETE)) + self.assertEqual((rsrc.RESUME, rsrc.COMPLETE), rsrc.state) wr = watchrule.WatchRule.load( self.ctx, watch_name="test_stack-MEMAlarmHigh") - self.assertEqual(wr.state, watchrule.WatchRule.NODATA) + self.assertEqual(watchrule.WatchRule.NODATA, wr.state) scheduler.TaskRunner(rsrc.delete)() self.m.VerifyAll() diff --git a/heat/tests/test_dependencies.py b/heat/tests/test_dependencies.py index 21abb1b9ff..3f1d0915d3 100644 --- a/heat/tests/test_dependencies.py +++ b/heat/tests/test_dependencies.py @@ -29,9 +29,9 @@ class dependenciesTest(testtools.TestCase): for n in nodes: self.assertTrue(n in order, '"%s" is not in the sequence' % n) - self.assertEqual(order.count(n), 1) + self.assertEqual(1, order.count(n)) - self.assertEqual(len(order), len(nodes)) + self.assertEqual(len(nodes), len(order)) for l, f in deps: checkorder(order.index(f), order.index(l)) @@ -51,23 +51,23 @@ class dependenciesTest(testtools.TestCase): def test_edges(self): input_edges = [('1', None), ('2', '3'), ('2', '4')] dp = Dependencies(input_edges) - self.assertEqual(set(dp.graph().edges()), set(input_edges)) + self.assertEqual(set(input_edges), set(dp.graph().edges())) def test_repr(self): dp = Dependencies([('1', None), ('2', '3'), ('2', '4')]) s = "Dependencies([('1', None), ('2', '3'), ('2', '4')])" - self.assertEqual(repr(dp), s) + self.assertEqual(s, repr(dp)) def test_single_node(self): d = Dependencies([('only', None)]) l = list(iter(d)) - self.assertEqual(len(l), 1) - self.assertEqual(l[0], 'only') + self.assertEqual(1, len(l)) + self.assertEqual('only', l[0]) def test_disjoint(self): d = Dependencies([('1', None), ('2', None)]) l = list(iter(d)) - self.assertEqual(len(l), 2) + self.assertEqual(2, len(l)) self.assertIn('1', l) self.assertIn('2', l) @@ -164,14 +164,14 @@ class dependenciesTest(testtools.TestCase): d = Dependencies([('last', 'first')]) p = d['last'] l = list(iter(p)) - self.assertEqual(len(l), 1) - self.assertEqual(l[0], 'last') + self.assertEqual(1, len(l)) + self.assertEqual('last', l[0]) def test_simple_partial(self): d = Dependencies([('last', 'middle'), ('middle', 'first')]) p = d['middle'] order = list(iter(p)) - self.assertEqual(len(order), 2) + self.assertEqual(2, len(order)) for n in ('last', 'middle'): self.assertTrue(n in order, "'%s' not found in dependency order" % n) @@ -183,7 +183,7 @@ class dependenciesTest(testtools.TestCase): ('target', 'first')]) p = d['target'] order = list(iter(p)) - self.assertEqual(len(order), 3) + self.assertEqual(3, len(order)) for n in ('last', 'middle', 'target'): self.assertTrue(n in order, "'%s' not found in dependency order" % n) @@ -195,7 +195,7 @@ class dependenciesTest(testtools.TestCase): ('mid3', 'e3')]) p = d['mid3'] order = list(iter(p)) - self.assertEqual(len(order), 4) + self.assertEqual(4, len(order)) for n in ('last', 'mid1', 'mid2', 'mid3'): self.assertTrue(n in order, "'%s' not found in dependency order" % n) @@ -209,13 +209,13 @@ class dependenciesTest(testtools.TestCase): self.assertEqual(0, len(list(d.required_by('last')))) required_by = list(d.required_by('mid3')) - self.assertEqual(len(required_by), 2) + self.assertEqual(2, len(required_by)) for n in ('mid1', 'mid2'): self.assertTrue(n in required_by, "'%s' not found in required_by" % n) required_by = list(d.required_by('e2')) - self.assertEqual(len(required_by), 1) + self.assertEqual(1, len(required_by)) self.assertTrue('mid1' in required_by, "'%s' not found in required_by" % n) diff --git a/heat/tests/test_engine_api_utils.py b/heat/tests/test_engine_api_utils.py index fdb7c07f9d..3a6d7c6aed 100644 --- a/heat/tests/test_engine_api_utils.py +++ b/heat/tests/test_engine_api_utils.py @@ -30,7 +30,7 @@ class EngineApiTest(HeatTestCase): def test_timeout_extract(self): p = {'timeout_mins': '5'} args = api.extract_args(p) - self.assertEqual(args['timeout_mins'], 5) + self.assertEqual(5, args['timeout_mins']) def test_timeout_extract_zero(self): p = {'timeout_mins': '0'} @@ -145,8 +145,8 @@ class FormatTest(HeatTestCase): def test_format_stack_resource_required_by(self): res1 = api.format_stack_resource(self.stack['generic1']) res2 = api.format_stack_resource(self.stack['generic2']) - self.assertEqual(res1['required_by'], ['generic2']) - self.assertEqual(res2['required_by'], []) + self.assertEqual(['generic2'], res1['required_by']) + self.assertEqual([], res2['required_by']) def test_format_event_id_integer(self): self._test_format_event('42') diff --git a/heat/tests/test_engine_service.py b/heat/tests/test_engine_service.py index bb3064f3d3..a95a83bff3 100644 --- a/heat/tests/test_engine_service.py +++ b/heat/tests/test_engine_service.py @@ -2088,7 +2088,7 @@ class StackServiceTest(HeatTestCase): resources = stack.resources self.assertIsInstance(resources, dict) - self.assertEqual(len(resources), 2) + self.assertEqual(2, len(resources)) self.assertIsInstance(resources.get('foo'), generic_rsrc.GenericResource) self.assertIsInstance(resources.get('bar'), @@ -2096,4 +2096,4 @@ class StackServiceTest(HeatTestCase): stack_dependencies = stack.dependencies self.assertIsInstance(stack_dependencies, dependencies.Dependencies) - self.assertEqual(len(stack_dependencies.graph()), 2) + self.assertEqual(2, len(stack_dependencies.graph())) diff --git a/heat/tests/test_heatclient.py b/heat/tests/test_heatclient.py index 1d0f79e324..796095503f 100644 --- a/heat/tests/test_heatclient.py +++ b/heat/tests/test_heatclient.py @@ -259,7 +259,7 @@ class KeystoneClientTest(HeatTestCase): heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) trust_context = heat_ks_client.create_trust_context() - self.assertEqual(trust_context.to_dict(), ctx.to_dict()) + self.assertEqual(ctx.to_dict(), trust_context.to_dict()) def test_create_trust_context_trust_create(self): @@ -296,8 +296,8 @@ class KeystoneClientTest(HeatTestCase): ctx.trust_id = None heat_ks_client = heat_keystoneclient.KeystoneClient(ctx) trust_context = heat_ks_client.create_trust_context() - self.assertEqual(trust_context.trust_id, 'atrust123') - self.assertEqual(trust_context.trustor_user_id, '5678') + self.assertEqual('atrust123', trust_context.trust_id) + self.assertEqual('5678', trust_context.trustor_user_id) def test_trust_init(self): diff --git a/heat/tests/test_hot.py b/heat/tests/test_hot.py index e9889b0b0c..ea2d7167f0 100644 --- a/heat/tests/test_hot.py +++ b/heat/tests/test_hot.py @@ -41,11 +41,11 @@ class HOTemplateTest(HeatTestCase): self.assertNotIn('foobar', tmpl) # test defaults for valid sections - self.assertEqual(tmpl[hot.VERSION], '2013-05-23') - self.assertEqual(tmpl[hot.DESCRIPTION], 'No description') - self.assertEqual(tmpl[hot.PARAMETERS], {}) - self.assertEqual(tmpl[hot.RESOURCES], {}) - self.assertEqual(tmpl[hot.OUTPUTS], {}) + self.assertEqual('2013-05-23', tmpl[hot.VERSION]) + self.assertEqual('No description', tmpl[hot.DESCRIPTION]) + self.assertEqual({}, tmpl[hot.PARAMETERS]) + self.assertEqual({}, tmpl[hot.RESOURCES]) + self.assertEqual({}, tmpl[hot.OUTPUTS]) def test_translate_parameters(self): """Test translation of parameters into internal engine format.""" @@ -64,7 +64,7 @@ class HOTemplateTest(HeatTestCase): 'Default': 'boo'}} tmpl = parser.Template(hot_tpl) - self.assertEqual(tmpl[hot.PARAMETERS], expected) + self.assertEqual(expected, tmpl[hot.PARAMETERS]) def test_translate_parameters_unsupported_type(self): """Test translation of parameters into internal engine format @@ -85,7 +85,7 @@ class HOTemplateTest(HeatTestCase): 'Type': 'UnsupportedType'}} tmpl = parser.Template(hot_tpl) - self.assertEqual(tmpl[hot.PARAMETERS], expected) + self.assertEqual(expected, tmpl[hot.PARAMETERS]) def test_translate_parameters_hidden(self): hot_tpl = template_format.parse(''' @@ -124,7 +124,7 @@ class HOTemplateTest(HeatTestCase): 'Properties': {'property1': 'value1'}}} tmpl = parser.Template(hot_tpl) - self.assertEqual(tmpl[hot.RESOURCES], expected) + self.assertEqual(expected, tmpl[hot.RESOURCES]) def test_translate_outputs(self): """Test translation of outputs into internal engine format.""" @@ -140,7 +140,7 @@ class HOTemplateTest(HeatTestCase): expected = {'output1': {'Description': 'output1', 'Value': 'value1'}} tmpl = parser.Template(hot_tpl) - self.assertEqual(tmpl[hot.OUTPUTS], expected) + self.assertEqual(expected, tmpl[hot.OUTPUTS]) def test_param_refs(self): """Test if parameter references work.""" @@ -150,8 +150,8 @@ class HOTemplateTest(HeatTestCase): snippet_resolved = {'properties': {'key1': 'bar', 'key2': 'wibble'}} tmpl = parser.Template(hot_tpl_empty) - self.assertEqual(tmpl.resolve_param_refs(snippet, params), - snippet_resolved) + self.assertEqual(snippet_resolved, + tmpl.resolve_param_refs(snippet, params)) snippet = {'properties': {'key1': {'Ref': 'foo'}, 'key2': {'Ref': 'blarg'}}} snippet_resolved = {'properties': {'key1': 'bar', @@ -193,7 +193,7 @@ class HOTemplateTest(HeatTestCase): tmpl = parser.Template(hot_tpl_empty) - self.assertEqual(tmpl.resolve_replace(snippet), snippet_resolved) + self.assertEqual(snippet_resolved, tmpl.resolve_replace(snippet)) def test_str_replace_syntax(self): """ @@ -269,8 +269,8 @@ class StackTest(test_parser.StackTest): template.Template(hot_tpl)) 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) snippet = {'Value': {'get_attr': ['resource1', 'foo']}} rsrc = self.stack['resource1'] @@ -286,7 +286,7 @@ class StackTest(test_parser.StackTest): resolved = hot.HOTemplate.resolve_attributes(snippet, self.stack) # GenericResourceType has an attribute 'foo' which yields the # resource name. - self.assertEqual(resolved, {'Value': 'resource1'}) + self.assertEqual({'Value': 'resource1'}, resolved) # test invalid reference self.assertRaises(exception.InvalidTemplateAttribute, hot.HOTemplate.resolve_attributes, @@ -312,12 +312,12 @@ class StackTest(test_parser.StackTest): template.Template(hot_tpl)) 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) snippet = {'value': {'get_resource': 'resource1'}} resolved = hot.HOTemplate.resolve_resource_refs(snippet, self.stack) - self.assertEqual(resolved, {'value': 'resource1'}) + self.assertEqual({'value': 'resource1'}, resolved) class HOTParamValidatorTest(HeatTestCase): diff --git a/heat/tests/test_identifier.py b/heat/tests/test_identifier.py index 1d7ea372f9..4bc8721c09 100644 --- a/heat/tests/test_identifier.py +++ b/heat/tests/test_identifier.py @@ -23,21 +23,21 @@ class IdentifierTest(testtools.TestCase): def test_attrs(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') - self.assertEqual(hi.tenant, 't') - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '/p') + self.assertEqual('t', hi.tenant) + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('/p', hi.path) def test_path_default(self): hi = identifier.HeatIdentifier('t', 's', 'i') - self.assertEqual(hi.path, '') + self.assertEqual('', hi.path) def test_items(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') - self.assertEqual(hi['tenant'], 't') - self.assertEqual(hi['stack_name'], 's') - self.assertEqual(hi['stack_id'], 'i') - self.assertEqual(hi['path'], '/p') + self.assertEqual('t', hi['tenant']) + self.assertEqual('s', hi['stack_name']) + self.assertEqual('i', hi['stack_id']) + self.assertEqual('/p', hi['path']) def test_invalid_attr(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') @@ -51,72 +51,72 @@ class IdentifierTest(testtools.TestCase): def test_arn(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') - self.assertEqual(hi.arn(), 'arn:openstack:heat::t:stacks/s/i/p') + self.assertEqual('arn:openstack:heat::t:stacks/s/i/p', hi.arn()) def test_arn_url(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') - self.assertEqual(hi.arn_url_path(), - '/arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2Fi%2Fp') + self.assertEqual('/arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2Fi%2Fp', + hi.arn_url_path()) def test_arn_id_int(self): hi = identifier.HeatIdentifier('t', 's', 42, 'p') - self.assertEqual(hi.arn(), 'arn:openstack:heat::t:stacks/s/42/p') + self.assertEqual('arn:openstack:heat::t:stacks/s/42/p', hi.arn()) def test_arn_parse(self): arn = 'arn:openstack:heat::t:stacks/s/i/p' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.tenant, 't') - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '/p') + self.assertEqual('t', hi.tenant) + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('/p', hi.path) def test_arn_url_parse(self): url = self.url_prefix + 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i/p' hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.tenant, 't') - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '/p') + self.assertEqual('t', hi.tenant) + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('/p', hi.path) def test_arn_parse_path_default(self): arn = 'arn:openstack:heat::t:stacks/s/i' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.tenant, 't') - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '') + self.assertEqual('t', hi.tenant) + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('', hi.path) def test_arn_url_parse_default(self): url = self.url_prefix + 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i' hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.tenant, 't') - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '') + self.assertEqual('t', hi.tenant) + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('', hi.path) def test_arn_parse_upper(self): arn = 'ARN:openstack:heat::t:stacks/s/i/p' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '/p') + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('/p', hi.path) def test_arn_url_parse_upper(self): url = self.url_prefix + 'ARN%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i/p' hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.tenant, 't') - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '/p') + self.assertEqual('t', hi.tenant) + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('/p', hi.path) def test_arn_url_parse_qs(self): url = self.url_prefix +\ 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks/s/i/p?foo=bar' hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.tenant, 't') - self.assertEqual(hi.stack_name, 's') - self.assertEqual(hi.stack_id, 'i') - self.assertEqual(hi.path, '/p') + self.assertEqual('t', hi.tenant) + self.assertEqual('s', hi.stack_name) + self.assertEqual('i', hi.stack_id) + self.assertEqual('/p', hi.path) def test_arn_parse_arn_invalid(self): arn = 'urn:openstack:heat::t:stacks/s/i' @@ -195,122 +195,122 @@ class IdentifierTest(testtools.TestCase): def test_arn_round_trip(self): hii = identifier.HeatIdentifier('t', 's', 'i', 'p') hio = identifier.HeatIdentifier.from_arn(hii.arn()) - self.assertEqual(hio.tenant, hii.tenant) - self.assertEqual(hio.stack_name, hii.stack_name) - self.assertEqual(hio.stack_id, hii.stack_id) - self.assertEqual(hio.path, hii.path) + self.assertEqual(hii.tenant, hio.tenant) + self.assertEqual(hii.stack_name, hio.stack_name) + self.assertEqual(hii.stack_id, hio.stack_id) + self.assertEqual(hii.path, hio.path) def test_arn_parse_round_trip(self): arn = 'arn:openstack:heat::t:stacks/s/i/p' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.arn(), arn) + self.assertEqual(arn, hi.arn()) def test_arn_url_parse_round_trip(self): arn = '/arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2Fi%2Fp' url = 'http://1.2.3.4/foo' + arn hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.arn_url_path(), arn) + self.assertEqual(arn, hi.arn_url_path()) def test_dict_round_trip(self): hii = identifier.HeatIdentifier('t', 's', 'i', 'p') hio = identifier.HeatIdentifier(**dict(hii)) - self.assertEqual(hio.tenant, hii.tenant) - self.assertEqual(hio.stack_name, hii.stack_name) - self.assertEqual(hio.stack_id, hii.stack_id) - self.assertEqual(hio.path, hii.path) + self.assertEqual(hii.tenant, hio.tenant) + self.assertEqual(hii.stack_name, hio.stack_name) + self.assertEqual(hii.stack_id, hio.stack_id) + self.assertEqual(hii.path, hio.path) def test_url_path(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p') - self.assertEqual(hi.url_path(), 't/stacks/s/i/p') + self.assertEqual('t/stacks/s/i/p', hi.url_path()) def test_url_path_default(self): hi = identifier.HeatIdentifier('t', 's', 'i') - self.assertEqual(hi.url_path(), 't/stacks/s/i') + self.assertEqual('t/stacks/s/i', hi.url_path()) def test_url_path_with_unicode_path(self): hi = identifier.HeatIdentifier('t', 's', 'i', u'\u5de5') - self.assertEqual(hi.url_path(), 't/stacks/s/i/%E5%B7%A5') + self.assertEqual('t/stacks/s/i/%E5%B7%A5', hi.url_path()) def test_tenant_escape(self): hi = identifier.HeatIdentifier(':/', 's', 'i') - self.assertEqual(hi.tenant, ':/') - self.assertEqual(hi.url_path(), '%3A%2F/stacks/s/i') - self.assertEqual(hi.arn(), 'arn:openstack:heat::%3A%2F:stacks/s/i') + self.assertEqual(':/', hi.tenant) + self.assertEqual('%3A%2F/stacks/s/i', hi.url_path()) + self.assertEqual('arn:openstack:heat::%3A%2F:stacks/s/i', hi.arn()) def test_name_escape(self): hi = identifier.HeatIdentifier('t', ':%', 'i') - self.assertEqual(hi.stack_name, ':%') - self.assertEqual(hi.url_path(), 't/stacks/%3A%25/i') - self.assertEqual(hi.arn(), 'arn:openstack:heat::t:stacks/%3A%25/i') + self.assertEqual(':%', hi.stack_name) + self.assertEqual('t/stacks/%3A%25/i', hi.url_path()) + self.assertEqual('arn:openstack:heat::t:stacks/%3A%25/i', hi.arn()) def test_id_escape(self): hi = identifier.HeatIdentifier('t', 's', ':/') - self.assertEqual(hi.stack_id, ':/') - self.assertEqual(hi.url_path(), 't/stacks/s/%3A%2F') - self.assertEqual(hi.arn(), 'arn:openstack:heat::t:stacks/s/%3A%2F') + self.assertEqual(':/', hi.stack_id) + self.assertEqual('t/stacks/s/%3A%2F', hi.url_path()) + self.assertEqual('arn:openstack:heat::t:stacks/s/%3A%2F', hi.arn()) def test_path_escape(self): hi = identifier.HeatIdentifier('t', 's', 'i', ':/') - self.assertEqual(hi.path, '/:/') - self.assertEqual(hi.url_path(), 't/stacks/s/i/%3A/') - self.assertEqual(hi.arn(), 'arn:openstack:heat::t:stacks/s/i/%3A/') + self.assertEqual('/:/', hi.path) + self.assertEqual('t/stacks/s/i/%3A/', hi.url_path()) + self.assertEqual('arn:openstack:heat::t:stacks/s/i/%3A/', hi.arn()) def test_tenant_decode(self): arn = 'arn:openstack:heat::%3A%2F:stacks/s/i' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.tenant, ':/') + self.assertEqual(':/', hi.tenant) def test_url_tenant_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3A%253A%252F%3Astacks%2Fs%2Fi' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.tenant, ':/') + self.assertEqual(':/', hi.tenant) def test_name_decode(self): arn = 'arn:openstack:heat::t:stacks/%3A%25/i' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.stack_name, ':%') + self.assertEqual(':%', hi.stack_name) def test_url_name_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2F%253A%2525%2Fi' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.stack_name, ':%') + self.assertEqual(':%', hi.stack_name) def test_id_decode(self): arn = 'arn:openstack:heat::t:stacks/s/%3A%2F' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.stack_id, ':/') + self.assertEqual(':/', hi.stack_id) def test_url_id_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2F%253A%252F' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.stack_id, ':/') + self.assertEqual(':/', hi.stack_id) def test_path_decode(self): arn = 'arn:openstack:heat::t:stacks/s/i/%3A%2F' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.path, '/:/') + self.assertEqual('/:/', hi.path) def test_url_path_decode(self): enc_arn = 'arn%3Aopenstack%3Aheat%3A%3At%3Astacks%2Fs%2Fi%2F%253A%252F' url = self.url_prefix + enc_arn hi = identifier.HeatIdentifier.from_arn_url(url) - self.assertEqual(hi.path, '/:/') + self.assertEqual('/:/', hi.path) def test_arn_escape_decode_round_trip(self): hii = identifier.HeatIdentifier(':/', ':%', ':/', ':/') hio = identifier.HeatIdentifier.from_arn(hii.arn()) - self.assertEqual(hio.tenant, hii.tenant) - self.assertEqual(hio.stack_name, hii.stack_name) - self.assertEqual(hio.stack_id, hii.stack_id) - self.assertEqual(hio.path, hii.path) + self.assertEqual(hii.tenant, hio.tenant) + self.assertEqual(hii.stack_name, hio.stack_name) + self.assertEqual(hii.stack_id, hio.stack_id) + self.assertEqual(hii.path, hio.path) def test_arn_decode_escape_round_trip(self): arn = 'arn:openstack:heat::%3A%2F:stacks/%3A%25/%3A%2F/%3A/' hi = identifier.HeatIdentifier.from_arn(arn) - self.assertEqual(hi.arn(), arn) + self.assertEqual(arn, hi.arn()) def test_arn_url_decode_escape_round_trip(self): enc_arn = "".join(['arn%3Aopenstack%3Aheat%3A%3A%253A%252F%3A', @@ -355,34 +355,34 @@ class IdentifierTest(testtools.TestCase): def test_path_components(self): hi = identifier.HeatIdentifier('t', 's', 'i', 'p1/p2/p3') - self.assertEqual(hi._path_components(), ['p1', 'p2', 'p3']) + self.assertEqual(['p1', 'p2', 'p3'], hi._path_components()) class ResourceIdentifierTest(testtools.TestCase): def test_resource_init_no_path(self): si = identifier.HeatIdentifier('t', 's', 'i') ri = identifier.ResourceIdentifier(resource_name='r', **si) - self.assertEqual(ri.path, '/resources/r') + self.assertEqual('/resources/r', ri.path) def test_resource_init_path(self): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='p', **si) ri = identifier.ResourceIdentifier(resource_name='r', **pi) - self.assertEqual(ri.path, '/resources/p/resources/r') + self.assertEqual('/resources/p/resources/r', ri.path) def test_resource_init_from_dict(self): hi = identifier.HeatIdentifier('t', 's', 'i', '/resources/r') ri = identifier.ResourceIdentifier(**hi) - self.assertEqual(ri, hi) + self.assertEqual(hi, ri) def test_resource_stack(self): si = identifier.HeatIdentifier('t', 's', 'i') ri = identifier.ResourceIdentifier(resource_name='r', **si) - self.assertEqual(ri.stack(), si) + self.assertEqual(si, ri.stack()) def test_resource_id(self): ri = identifier.ResourceIdentifier('t', 's', 'i', '', 'r') - self.assertEqual(ri.resource_name, 'r') + self.assertEqual('r', ri.resource_name) def test_resource_name_slash(self): self.assertRaises(ValueError, identifier.ResourceIdentifier, @@ -400,28 +400,28 @@ class EventIdentifierTest(testtools.TestCase): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='p', **si) ei = identifier.EventIdentifier(event_id=event_id, **pi) - self.assertEqual(ei.path, '/resources/p/events/{0}'.format(event_id)) + self.assertEqual('/resources/p/events/{0}'.format(event_id), ei.path) def test_event_init_from_dict(self): hi = identifier.HeatIdentifier('t', 's', 'i', '/resources/p/events/42') ei = identifier.EventIdentifier(**hi) - self.assertEqual(ei, hi) + self.assertEqual(hi, ei) def test_event_stack(self): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='r', **si) ei = identifier.EventIdentifier(event_id='e', **pi) - self.assertEqual(ei.stack(), si) + self.assertEqual(si, ei.stack()) def test_event_resource(self): si = identifier.HeatIdentifier('t', 's', 'i') pi = identifier.ResourceIdentifier(resource_name='r', **si) ei = identifier.EventIdentifier(event_id='e', **pi) - self.assertEqual(ei.resource(), pi) + self.assertEqual(pi, ei.resource()) def test_resource_name(self): ei = identifier.EventIdentifier('t', 's', 'i', '/resources/p', 'e') - self.assertEqual(ei.resource_name, 'p') + self.assertEqual('p', ei.resource_name) def test_event_id_integer(self): self._test_event_id('42') @@ -432,4 +432,4 @@ class EventIdentifierTest(testtools.TestCase): def _test_event_id(self, event_id): ei = identifier.EventIdentifier('t', 's', 'i', '/resources/p', event_id) - self.assertEqual(ei.event_id, event_id) + self.assertEqual(event_id, ei.event_id) diff --git a/heat/tests/test_instance.py b/heat/tests/test_instance.py index ea03935d80..00d774cbbb 100644 --- a/heat/tests/test_instance.py +++ b/heat/tests/test_instance.py @@ -130,10 +130,10 @@ class InstancesTest(HeatTestCase): self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] - self.assertEqual(instance.FnGetAtt('PublicIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip) + self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() @@ -152,10 +152,10 @@ class InstancesTest(HeatTestCase): self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] - self.assertEqual(instance.FnGetAtt('PublicIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PublicDnsName'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip) + self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PublicDnsName')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() @@ -309,7 +309,7 @@ class InstancesTest(HeatTestCase): scheduler.TaskRunner(instance.delete)() self.assertIsNone(instance.resource_id) - self.assertEqual(instance.state, (instance.DELETE, instance.COMPLETE)) + self.assertEqual((instance.DELETE, instance.COMPLETE), instance.state) self.m.VerifyAll() def test_instance_update_metadata(self): @@ -320,7 +320,7 @@ class InstancesTest(HeatTestCase): update_template = copy.deepcopy(instance.t) update_template['Metadata'] = {'test': 123} scheduler.TaskRunner(instance.update, update_template)() - self.assertEqual(instance.metadata, {'test': 123}) + self.assertEqual({'test': 123}, instance.metadata) def test_instance_update_instance_type(self): """ @@ -350,7 +350,7 @@ class InstancesTest(HeatTestCase): self.m.ReplayAll() 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 test_instance_update_instance_type_failed(self): @@ -383,7 +383,7 @@ class InstancesTest(HeatTestCase): self.assertEqual( "Error: Resizing to 'm1.small' failed, status 'ACTIVE'", str(error)) - self.assertEqual(instance.state, (instance.UPDATE, instance.FAILED)) + self.assertEqual((instance.UPDATE, instance.FAILED), instance.state) self.m.VerifyAll() def test_instance_update_replace(self): @@ -419,7 +419,7 @@ class InstancesTest(HeatTestCase): self.m.ReplayAll() scheduler.TaskRunner(instance.create)() - self.assertEqual(instance.state, (instance.CREATE, instance.COMPLETE)) + self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state) def test_instance_status_suspend_immediate(self): return_server = self.fc.servers.list()[1] @@ -438,7 +438,7 @@ class InstancesTest(HeatTestCase): mox.Replay(get) scheduler.TaskRunner(instance.suspend)() - self.assertEqual(instance.state, (instance.SUSPEND, instance.COMPLETE)) + self.assertEqual((instance.SUSPEND, instance.COMPLETE), instance.state) self.m.VerifyAll() @@ -460,7 +460,7 @@ class InstancesTest(HeatTestCase): instance.state_set(instance.SUSPEND, instance.COMPLETE) scheduler.TaskRunner(instance.resume)() - self.assertEqual(instance.state, (instance.RESUME, instance.COMPLETE)) + self.assertEqual((instance.RESUME, instance.COMPLETE), instance.state) self.m.VerifyAll() @@ -486,7 +486,7 @@ class InstancesTest(HeatTestCase): self.m.ReplayAll() scheduler.TaskRunner(instance.suspend)() - self.assertEqual(instance.state, (instance.SUSPEND, instance.COMPLETE)) + self.assertEqual((instance.SUSPEND, instance.COMPLETE), instance.state) self.m.VerifyAll() @@ -514,7 +514,7 @@ class InstancesTest(HeatTestCase): instance.state_set(instance.SUSPEND, instance.COMPLETE) scheduler.TaskRunner(instance.resume)() - self.assertEqual(instance.state, (instance.RESUME, instance.COMPLETE)) + self.assertEqual((instance.RESUME, instance.COMPLETE), instance.state) self.m.VerifyAll() @@ -543,7 +543,7 @@ class InstancesTest(HeatTestCase): self.m.ReplayAll() scheduler.TaskRunner(instance.suspend)() - self.assertEqual(instance.state, (instance.SUSPEND, instance.COMPLETE)) + self.assertEqual((instance.SUSPEND, instance.COMPLETE), instance.state) self.m.VerifyAll() @@ -575,7 +575,7 @@ class InstancesTest(HeatTestCase): instance.state_set(instance.SUSPEND, instance.COMPLETE) scheduler.TaskRunner(instance.resume)() - self.assertEqual(instance.state, (instance.RESUME, instance.COMPLETE)) + self.assertEqual((instance.RESUME, instance.COMPLETE), instance.state) self.m.VerifyAll() @@ -629,7 +629,7 @@ class InstancesTest(HeatTestCase): self.m.ReplayAll() scheduler.TaskRunner(instance.create)() - self.assertEqual(instance.state, (instance.CREATE, instance.COMPLETE)) + self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state) self.m.VerifyAll() @@ -644,27 +644,28 @@ class InstancesTest(HeatTestCase): {'port-id': 'id3'}, {'port-id': 'id1'}, {'port-id': 'id2'}], instance._build_nics([ 'id3', 'id1', 'id2'])) - self.assertEqual([ - {'port-id': 'id1'}, - {'port-id': 'id2'}, - {'port-id': 'id3'}], instance._build_nics([ + self.assertEqual( + [{'port-id': 'id1'}, + {'port-id': 'id2'}, + {'port-id': 'id3'}], + instance._build_nics([ {'NetworkInterfaceId': 'id3', 'DeviceIndex': '3'}, {'NetworkInterfaceId': 'id1', 'DeviceIndex': '1'}, {'NetworkInterfaceId': 'id2', 'DeviceIndex': 2}, ])) - self.assertEqual([ - {'port-id': 'id1'}, - {'port-id': 'id2'}, - {'port-id': 'id3'}, - {'port-id': 'id4'}, - {'port-id': 'id5'} - ], instance._build_nics([ - {'NetworkInterfaceId': 'id3', 'DeviceIndex': '3'}, - {'NetworkInterfaceId': 'id1', 'DeviceIndex': '1'}, - {'NetworkInterfaceId': 'id2', 'DeviceIndex': 2}, - 'id4', - 'id5' - ])) + self.assertEqual( + [{'port-id': 'id1'}, + {'port-id': 'id2'}, + {'port-id': 'id3'}, + {'port-id': 'id4'}, + {'port-id': 'id5'}], + instance._build_nics([ + {'NetworkInterfaceId': 'id3', 'DeviceIndex': '3'}, + {'NetworkInterfaceId': 'id1', 'DeviceIndex': '1'}, + {'NetworkInterfaceId': 'id2', 'DeviceIndex': 2}, + 'id4', + 'id5'] + )) def test_build_nics_with_security_groups(self): """ @@ -813,4 +814,4 @@ class InstancesTest(HeatTestCase): instance = self._create_test_instance(return_server, 'wo_ipaddr') - self.assertEqual(instance.FnGetAtt('PrivateIp'), '0.0.0.0') + self.assertEqual('0.0.0.0', instance.FnGetAtt('PrivateIp')) diff --git a/heat/tests/test_instance_group.py b/heat/tests/test_instance_group.py index 5d26a1d4af..795fc7e4bc 100644 --- a/heat/tests/test_instance_group.py +++ b/heat/tests/test_instance_group.py @@ -222,7 +222,7 @@ class InstanceGroupTest(HeatTestCase): self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) # The failed inner resource remains - self.assertEqual(len(rsrc.nested().resources), 1) + self.assertEqual(1, len(rsrc.nested().resources)) child_resource = rsrc.nested().resources.values()[0] self.assertEqual((child_resource.CREATE, child_resource.FAILED), child_resource.state) @@ -242,7 +242,7 @@ class InstanceGroupTest(HeatTestCase): self.m.ReplayAll() self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') - self.assertEqual(len(rsrc.nested().resources), 1) + self.assertEqual(1, len(rsrc.nested().resources)) succeeded_instance = rsrc.nested().resources.values()[0] self.m.VerifyAll() @@ -263,7 +263,7 @@ class InstanceGroupTest(HeatTestCase): self.assertEqual((rsrc.UPDATE, rsrc.FAILED), rsrc.state) # The failed inner resource remains - self.assertEqual(len(rsrc.nested().resources), 2) + self.assertEqual(2, len(rsrc.nested().resources)) child_resource = [r for r in rsrc.nested().resources.values() if r.name != succeeded_instance.name][0] self.assertEqual((child_resource.CREATE, child_resource.FAILED), diff --git a/heat/tests/test_instance_group_update_policy.py b/heat/tests/test_instance_group_update_policy.py index 57a9db7ed3..ce4af1af02 100644 --- a/heat/tests/test_instance_group_update_policy.py +++ b/heat/tests/test_instance_group_update_policy.py @@ -244,13 +244,13 @@ class InstanceGroupTest(HeatTestCase): stack.validate() grp = stack['JobServerGroup'] self.assertTrue(grp.update_policy) - self.assertTrue(len(grp.update_policy) == 1) + self.assertEqual(1, len(grp.update_policy)) self.assertIn('RollingUpdate', grp.update_policy) policy = grp.update_policy['RollingUpdate'] self.assertTrue(policy and len(policy) > 0) - self.assertEqual(int(policy['MinInstancesInService']), 1) - self.assertEqual(int(policy['MaxBatchSize']), 2) - self.assertEqual(policy['PauseTime'], 'PT1S') + self.assertEqual(1, int(policy['MinInstancesInService'])) + self.assertEqual(2, int(policy['MaxBatchSize'])) + self.assertEqual('PT1S', policy['PauseTime']) def test_parse_with_default_update_policy(self): tmpl = template_format.parse(ig_tmpl_with_default_updt_policy) @@ -258,13 +258,13 @@ class InstanceGroupTest(HeatTestCase): stack.validate() grp = stack['JobServerGroup'] self.assertTrue(grp.update_policy) - self.assertTrue(len(grp.update_policy) == 1) + self.assertEqual(1, len(grp.update_policy)) self.assertIn('RollingUpdate', grp.update_policy) policy = grp.update_policy['RollingUpdate'] self.assertTrue(policy and len(policy) > 0) - self.assertEqual(int(policy['MinInstancesInService']), 0) - self.assertEqual(int(policy['MaxBatchSize']), 1) - self.assertEqual(policy['PauseTime'], 'PT0S') + self.assertEqual(0, int(policy['MinInstancesInService'])) + self.assertEqual(1, int(policy['MaxBatchSize'])) + self.assertEqual('PT0S', policy['PauseTime']) def test_parse_with_bad_update_policy(self): tmpl = template_format.parse(ig_tmpl_with_bad_updt_policy) @@ -313,7 +313,7 @@ class InstanceGroupTest(HeatTestCase): updated_policy = (updated_grp.t['UpdatePolicy'] if 'UpdatePolicy' in updated_grp.t else None) expected = {u'UpdatePolicy': updated_policy} - self.assertEqual(tmpl_diff, expected) + self.assertEqual(expected, tmpl_diff) def test_update_policy_added(self): self.validate_update_policy_diff(ig_tmpl_without_updt_policy, @@ -350,7 +350,7 @@ class InstanceGroupTest(HeatTestCase): self.m.ReplayAll() stack.create() self.m.VerifyAll() - self.assertEqual(stack.state, ('CREATE', 'COMPLETE')) + self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['JobServerGroup'] @@ -361,7 +361,7 @@ class InstanceGroupTest(HeatTestCase): init_grp_tmpl = tmpl['Resources']['JobServerGroup'] init_roll_updt = init_grp_tmpl['UpdatePolicy']['RollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) - self.assertEqual(int(current_policy['MaxBatchSize']), init_batch_sz) + self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['JobServerConfig'] @@ -373,7 +373,7 @@ class InstanceGroupTest(HeatTestCase): # test the number of instances created nested = stack['JobServerGroup'].nested() - self.assertEqual(len(nested.resources), size) + self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() @@ -402,7 +402,7 @@ class InstanceGroupTest(HeatTestCase): self.m.ReplayAll() stack.update(updated_stack) self.m.VerifyAll() - self.assertEqual(stack.state, ('UPDATE', 'COMPLETE')) + self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that the update policy is updated updated_grp = stack['JobServerGroup'] @@ -410,7 +410,7 @@ class InstanceGroupTest(HeatTestCase): updated_policy = updated_grp.update_policy['RollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) - self.assertEqual(int(updated_policy['MaxBatchSize']), new_batch_sz) + self.assertEqual(new_batch_sz, int(updated_policy['MaxBatchSize'])) # test that the launch configuration is replaced updated_conf_name = self.get_launch_conf_name(stack, 'JobServerGroup') @@ -419,19 +419,19 @@ class InstanceGroupTest(HeatTestCase): # test that the group size are the same updt_instances = updated_grp.get_instances() updt_names = updated_grp.get_instance_names() - self.assertEqual(len(updt_names), len(init_names)) + self.assertEqual(len(init_names), len(updt_names)) # test that the appropriate number of instance names are the same matched_names = set(updt_names) & set(init_names) - self.assertEqual(len(matched_names), num_updates_expected_on_updt) + self.assertEqual(num_updates_expected_on_updt, len(matched_names)) # test that the appropriate number of new instances are created - self.assertEqual(len(set(updt_names) - set(init_names)), - num_creates_expected_on_updt) + self.assertEqual(num_creates_expected_on_updt, + len(set(updt_names) - set(init_names))) # test that the appropriate number of instances are deleted - self.assertEqual(len(set(init_names) - set(updt_names)), - num_deletes_expected_on_updt) + self.assertEqual(num_deletes_expected_on_updt, + len(set(init_names) - set(updt_names))) # test that the older instances are the ones being deleted if num_deletes_expected_on_updt > 0: @@ -443,12 +443,12 @@ class InstanceGroupTest(HeatTestCase): # test that the image id is changed for all instances updt_images = [(i.name, i.t['Properties']['ImageId']) for i in updt_instances] - self.assertEqual(len(set(updt_images) & set(init_images)), 0) + self.assertEqual(0, len(set(updt_images) & set(init_images))) else: # test that instance type is changed for all instances updt_flavors = [(i.name, i.t['Properties']['InstanceType']) for i in updt_instances] - self.assertEqual(len(set(updt_flavors) & set(init_flavors)), 0) + self.assertEqual(0, len(set(updt_flavors) & set(init_flavors))) def test_instance_group_update_replace(self): """ @@ -585,7 +585,7 @@ class InstanceGroupTest(HeatTestCase): self.m.ReplayAll() stack.create() self.m.VerifyAll() - self.assertEqual(stack.state, ('CREATE', 'COMPLETE')) + self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['JobServerGroup'] @@ -596,7 +596,7 @@ class InstanceGroupTest(HeatTestCase): init_grp_tmpl = tmpl['Resources']['JobServerGroup'] init_roll_updt = init_grp_tmpl['UpdatePolicy']['RollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) - self.assertEqual(int(current_policy['MaxBatchSize']), init_batch_sz) + self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test that physical resource name of launch configuration is used conf = stack['JobServerConfig'] @@ -605,13 +605,13 @@ class InstanceGroupTest(HeatTestCase): # test the number of instances created nested = stack['JobServerGroup'].nested() - self.assertEqual(len(nested.resources), size) + self.assertEqual(size, len(nested.resources)) # test stack update updated_tmpl = template_format.parse(ig_tmpl_without_updt_policy) updated_stack = utils.parse_stack(updated_tmpl) stack.update(updated_stack) - self.assertEqual(stack.state, ('UPDATE', 'COMPLETE')) + self.assertEqual(('UPDATE', 'COMPLETE'), stack.state) # test that update policy is removed updated_grp = stack['JobServerGroup'] @@ -629,7 +629,7 @@ class InstanceGroupTest(HeatTestCase): self.m.ReplayAll() stack.create() self.m.VerifyAll() - self.assertEqual(stack.state, ('CREATE', 'COMPLETE')) + self.assertEqual(('CREATE', 'COMPLETE'), stack.state) # test that update policy is loaded current_grp = stack['JobServerGroup'] @@ -640,11 +640,11 @@ class InstanceGroupTest(HeatTestCase): init_grp_tmpl = tmpl['Resources']['JobServerGroup'] init_roll_updt = init_grp_tmpl['UpdatePolicy']['RollingUpdate'] init_batch_sz = int(init_roll_updt['MaxBatchSize']) - self.assertEqual(int(current_policy['MaxBatchSize']), init_batch_sz) + self.assertEqual(init_batch_sz, int(current_policy['MaxBatchSize'])) # test the number of instances created nested = stack['JobServerGroup'].nested() - self.assertEqual(len(nested.resources), size) + self.assertEqual(size, len(nested.resources)) # clean up for next test self.m.UnsetStubs() @@ -660,7 +660,7 @@ class InstanceGroupTest(HeatTestCase): updated_tmpl = template_format.parse(json.dumps(updt_template)) updated_stack = utils.parse_stack(updated_tmpl) stack.update(updated_stack) - self.assertEqual(stack.state, ('UPDATE', 'FAILED')) + self.assertEqual(('UPDATE', 'FAILED'), stack.state) # test that the update policy is updated updated_grp = stack['JobServerGroup'] @@ -668,7 +668,7 @@ class InstanceGroupTest(HeatTestCase): updated_policy = updated_grp.update_policy['RollingUpdate'] self.assertTrue(updated_policy) self.assertTrue(len(updated_policy) > 0) - self.assertEqual(updated_policy['PauseTime'], new_pause_time) + self.assertEqual(new_pause_time, updated_policy['PauseTime']) # test that error message match expected_error_message = ('The current UpdatePolicy will result ' diff --git a/heat/tests/test_instance_network.py b/heat/tests/test_instance_network.py index 4a4b3ba5de..b818e154b5 100644 --- a/heat/tests/test_instance_network.py +++ b/heat/tests/test_instance_network.py @@ -260,10 +260,10 @@ class instancesTest(HeatTestCase): self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] - self.assertEqual(instance.FnGetAtt('PublicIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip) + self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() @@ -276,9 +276,9 @@ class instancesTest(HeatTestCase): self.assertTrue(instance.id > 0) expected_ip = return_server.networks['public'][0] - self.assertEqual(instance.FnGetAtt('PublicIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateIp'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip) - self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip) + self.assertEqual(expected_ip, instance.FnGetAtt('PublicIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateIp')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) + self.assertEqual(expected_ip, instance.FnGetAtt('PrivateDnsName')) self.m.VerifyAll() diff --git a/heat/tests/test_iso8601_utils.py b/heat/tests/test_iso8601_utils.py index 0c4ff4a430..c661f0b816 100644 --- a/heat/tests/test_iso8601_utils.py +++ b/heat/tests/test_iso8601_utils.py @@ -24,15 +24,15 @@ class ISO8601UtilityTest(HeatTestCase): utils.setup_dummy_db() def test_valid_durations(self): - self.assertEqual(util.parse_isoduration('PT'), 0) - self.assertEqual(util.parse_isoduration('PT1H'), 3600) - self.assertEqual(util.parse_isoduration('PT2M'), 120) - self.assertEqual(util.parse_isoduration('PT3S'), 3) - self.assertEqual(util.parse_isoduration('PT1H5M'), 3900) - self.assertEqual(util.parse_isoduration('PT1H5S'), 3605) - self.assertEqual(util.parse_isoduration('PT5M3S'), 303) - self.assertEqual(util.parse_isoduration('PT1H5M3S'), 3903) - self.assertEqual(util.parse_isoduration('PT24H'), 24 * 3600) + self.assertEqual(0, util.parse_isoduration('PT')) + self.assertEqual(3600, util.parse_isoduration('PT1H')) + self.assertEqual(120, util.parse_isoduration('PT2M')) + self.assertEqual(3, util.parse_isoduration('PT3S')) + self.assertEqual(3900, util.parse_isoduration('PT1H5M')) + self.assertEqual(3605, util.parse_isoduration('PT1H5S')) + self.assertEqual(303, util.parse_isoduration('PT5M3S')) + self.assertEqual(3903, util.parse_isoduration('PT1H5M3S')) + self.assertEqual(24 * 3600, util.parse_isoduration('PT24H')) def test_invalid_durations(self): self.assertRaises(ValueError, util.parse_isoduration, 'P1Y') diff --git a/heat/tests/test_metadata_refresh.py b/heat/tests/test_metadata_refresh.py index 94f05ff7b3..d81406ce9e 100644 --- a/heat/tests/test_metadata_refresh.py +++ b/heat/tests/test_metadata_refresh.py @@ -169,21 +169,21 @@ class MetadataRefreshTest(HeatTestCase): self.m.ReplayAll() 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) s1 = self.stack['S1'] s2 = self.stack['S2'] files = s1.metadata['AWS::CloudFormation::Init']['config']['files'] cont = files['/tmp/random_file']['content'] self.assertEqual((s2.CREATE, s2.COMPLETE), s2.state) - self.assertEqual(cont, 's2-ip=1.2.3.5') + self.assertEqual('s2-ip=1.2.3.5', cont) s1.metadata_update() s2.metadata_update() files = s1.metadata['AWS::CloudFormation::Init']['config']['files'] cont = files['/tmp/random_file']['content'] - self.assertEqual(cont, 's2-ip=10.0.0.5') + self.assertEqual('s2-ip=10.0.0.5', cont) self.m.VerifyAll() @@ -248,7 +248,7 @@ class WaitCondMetadataUpdateTest(HeatTestCase): inst = self.stack['S2'] def check_empty(sleep_time): - self.assertEqual(watch.FnGetAtt('Data'), '{}') + self.assertEqual('{}', watch.FnGetAtt('Data')) self.assertIsNone(inst.metadata['test']) def update_metadata(id, data, reason): @@ -269,16 +269,16 @@ class WaitCondMetadataUpdateTest(HeatTestCase): self.m.ReplayAll() 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.assertEqual(watch.FnGetAtt('Data'), '{"123": "foo"}') - self.assertEqual(inst.metadata['test'], '{"123": "foo"}') + self.assertEqual('{"123": "foo"}', watch.FnGetAtt('Data')) + self.assertEqual('{"123": "foo"}', inst.metadata['test']) update_metadata('456', 'blarg', 'wibble') - self.assertEqual(watch.FnGetAtt('Data'), - '{"123": "foo", "456": "blarg"}') - self.assertEqual(inst.metadata['test'], - '{"123": "foo", "456": "blarg"}') + self.assertEqual('{"123": "foo", "456": "blarg"}', + watch.FnGetAtt('Data')) + self.assertEqual('{"123": "foo", "456": "blarg"}', + inst.metadata['test']) self.m.VerifyAll()