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
This commit is contained in:
parent
cb8404910b
commit
499b7cccac
|
@ -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)
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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 '
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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')
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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)
|
||||
|
||||
|
|
|
@ -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')
|
||||
|
|
|
@ -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()))
|
||||
|
|
|
@ -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):
|
||||
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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'))
|
||||
|
|
|
@ -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),
|
||||
|
|
|
@ -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 '
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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')
|
||||
|
|
|
@ -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()
|
||||
|
|
Loading…
Reference in New Issue