def setUp(self): super(TemplateResourceCrudTest, self).setUp() files = {'test_resource.template': json.dumps(self.provider)} self.ctx = utils.dummy_context() class DummyResource(object): support_status = support.SupportStatus() properties_schema = { "Foo": properties.Schema(properties.Schema.STRING, required=True) } attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) self.stack = parser.Stack(self.ctx, 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) self.defn = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "bar"}) self.res = template_resource.TemplateResource('test_t_res', self.defn, self.stack) self.assertIsNone(self.res.validate())
def test_properties_type_mismatch(self): provider = { 'Parameters': { 'Foo': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {"Foo": properties.Schema(properties.Schema.MAP)} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "bar", }, } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_incorrect_template_provided_with_url(self): wrong_template = ''' <head prefix="og: http://ogp.me/ns# fb: http://ogp.me/ns/fb# ''' env = environment.Environment() test_templ_name = 'http://heatr/bad_tmpl.yaml' env.load({'resource_registry': {'Test::Tmpl': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndReturn(wrong_template) self.m.ReplayAll() definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Tmpl') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) err = self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.assertIn('Error parsing template: ', six.text_type(err)) self.m.VerifyAll()
def test_properties_missing(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Blarg': {'Type': 'String', 'Default': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {"Foo": properties.Schema(properties.Schema.STRING, required=True)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_incorrect_template_provided_with_url(self): wrong_template = ''' <head prefix="og: http://ogp.me/ns# fb: http://ogp.me/ns/fb# ''' env = environment.Environment() test_templ_name = 'http://heatr/bad_tmpl.yaml' env.load({'resource_registry': {'Test::Tmpl': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) mock_get = self.patchobject(urlfetch, "get", return_value=wrong_template) definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Tmpl') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) err = self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.assertIn('Error parsing template http://heatr/bad_tmpl.yaml', str(err)) mock_get.assert_called_once_with(test_templ_name, allowed_schemes=( 'http', 'https', ))
def test_resource_info_special(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'Boolean'}, }, } files = {'test_resource.template': json.dumps(provider), 'foo.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {"Foo": properties.Schema(properties.Schema.BOOLEAN)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template', 'resources': {'foo': {'DummyResource': 'foo.template'}}}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('foo', 'DummyResource', {"Foo": "False"}) temp_res = template_resource.TemplateResource('foo', definition, stack) self.assertEqual('foo.template', temp_res.template_name)
def test_system_template_retrieve_by_file(self): # make sure that a TemplateResource defined in the global environment # can be created and the template retrieved using the "file:" # scheme. g_env = resources.global_env() test_templ_name = 'file:///etc/heatr/frodo.yaml' g_env.load({'resource_registry': {'Test::Frodo': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template), stack_id=str(uuid.uuid4())) minimal_temp = json.dumps({ 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': {}, 'Resources': {} }) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https', 'file')).AndReturn(minimal_temp) self.m.ReplayAll() definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Frodo') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate()) self.m.VerifyAll()
def test_attributes_missing_based_on_class(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Blarg': { 'Value': 'wibble' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): attributes_schema = {"Foo": attributes.Schema("A test attribute")} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_properties_extra_required(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Blarg': { 'Type': 'String' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Blarg": "wibble"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_attributes_missing(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Blarg': { 'Value': 'wibble' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {"Foo": "A test attribute"} json_snippet = { "Type": "DummyResource", } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_properties_missing(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Blarg': { 'Type': 'String', 'Default': 'wibble' }, }, } files = {'test_resource.template': json.dumps(provider)} env = environment.Environment() env.load({ 'resource_registry': { 'ResourceWithRequiredPropsAndEmptyAttrs': 'test_resource.template' } }) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition( 'test_t_res', "ResourceWithRequiredPropsAndEmptyAttrs") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_attributes_extra(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Foo': { 'Value': 'bar' }, 'Blarg': { 'Value': 'wibble' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {"Foo": attributes.Schema("A test attribute")} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate())
def setUp(self): super(TemplateResourceCrudTest, self).setUp() files = {'test_resource.template': json.dumps(self.provider)} self.ctx = utils.dummy_context() env = environment.Environment() env.load({ 'resource_registry': { 'ResourceWithRequiredPropsAndEmptyAttrs': 'test_resource.template' } }) self.stack = parser.Stack(self.ctx, 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) self.defn = rsrc_defn.ResourceDefinition( 'test_t_res', "ResourceWithRequiredPropsAndEmptyAttrs", {"Foo": "bar"}) self.res = template_resource.TemplateResource('test_t_res', self.defn, self.stack) self.assertIsNone(self.res.validate())
def test_metadata_update_called(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'Boolean'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {"Foo": properties.Schema(properties.Schema.BOOLEAN)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "False"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) temp_res.metadata_set = mock.Mock() temp_res.metadata_update() temp_res.metadata_set.assert_called_once_with({})
def test_properties_normal(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'String'}, 'Blarg': {'Type': 'String', 'Default': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {"Foo": properties.Schema(properties.Schema.STRING, required=True)} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "bar", }, } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertIsNone(temp_res.validate())
def test_properties_type_match(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Length': {'Type': 'Number'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): support_status = support.SupportStatus() properties_schema = {"Length": properties.Schema(properties.Schema.INTEGER)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Length": 10}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate())
def test_user_template_retrieve_fail(self): # make sure that a TemplateResource defined in the user environment # fails gracefully if the template file specified is inaccessible # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() env = environment.Environment() test_templ_name = 'http://heatr/noexist.yaml' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template), env=env, stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https'))\ .AndRaise(urlfetch.URLFetchError(_('Failed to retrieve template'))) self.m.ReplayAll() definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Flippy') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll()
def test_properties_type_mismatch(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): support_status = support.SupportStatus() properties_schema = {"Foo": properties.Schema(properties.Schema.MAP)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "bar"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) ex = self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.assertEqual("Property Foo type mismatch between facade " "DummyResource (Map) and provider (String)", six.text_type(ex))
def test_attributes_missing_no_class(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Blarg': {'Value': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} env = environment.Environment() env.load({'resource_registry': {'DummyResource2': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource2") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) nested = mock.Mock() nested.outputs = {'Blarg': {'Value': 'fluffy'}} temp_res._nested = nested self.assertRaises(exception.InvalidTemplateAttribute, temp_res.FnGetAtt, 'Foo')
def test_system_template_retrieve_fail(self): # make sure that a TemplateResource defined in the global environment # fails gracefully if the template file specified is inaccessible # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() g_env = resources.global_env() test_templ_name = 'file:///etc/heatr/frodo.yaml' g_env.load({'resource_registry': {'Test::Frodo': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https', 'file')).AndRaise(IOError) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Frodo'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll()
def test_system_template_retrieve_fail(self): # make sure that a TemplateResource defined in the global environment # fails gracefully if the template file specified is inaccessible # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() g_env = resources.global_env() test_templ_name = 'file:///etc/heatr/frodo.yaml' g_env.load({'resource_registry': {'Test::Frodo': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template), stack_id=str(uuid.uuid4())) mock_get = self.patchobject(urlfetch, "get", side_effect=urlfetch.URLFetchError( _('Failed to retrieve template'))) definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Frodo') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) mock_get.assert_called_once_with(test_templ_name, allowed_schemes=( 'http', 'https', 'file', ))
def test_attributes_not_parsable(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Foo': { 'Value': 'bar' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): support_status = support.SupportStatus() properties_schema = {} attributes_schema = {"Foo": attributes.Schema("A test attribute")} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) temp_res.resource_id = 'dummy_id' temp_res.nested_identifier = mock.Mock() temp_res.nested_identifier.return_value = {'foo': 'bar'} temp_res._rpc_client = mock.MagicMock() output = { 'outputs': [{ 'output_key': 'Foo', 'output_value': None, 'output_error': 'it is all bad' }] } temp_res._rpc_client.show_stack.return_value = [output] temp_res._rpc_client.list_stack_resources.return_value = [] self.assertIsNone(temp_res.validate()) self.assertRaises(exception.TemplateOutputError, temp_res.FnGetAtt, 'Foo')
def test_user_template_not_retrieved_by_file(self): # make sure that a TemplateResource defined in the user environment # can NOT be retrieved using the "file:" scheme, validation should fail env = environment.Environment() test_templ_name = 'file:///etc/heatr/flippy.yaml' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Flippy') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_user_template_not_retrieved_by_file(self): # make sure that a TemplateResource defined in the user environment # can NOT be retrieved using the "file:" scheme, validation should fail env = environment.Environment() test_templ_name = 'file:///etc/heatr/flippy.yaml' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Flippy'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_attributes_not_parsable(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Foo': { 'Value': 'bar' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): support_status = support.SupportStatus() properties_schema = {} attributes_schema = {"Foo": attributes.Schema("A test attribute")} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate()) nested = mock.Mock() nested.outputs = { 'Foo': { 'Value': 'not-this', 'error_msg': 'it is all bad' } } nested.output.return_value = None temp_res._nested = nested self.assertRaises(exception.InvalidTemplateAttribute, temp_res.FnGetAtt, 'Foo')
def test_user_template_retrieve_fail_ext(self): # make sure that a TemplateResource defined in the user environment # fails gracefully if the template file is the wrong extension # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() env = environment.Environment() test_templ_name = 'http://heatr/letter_to_granny.docx' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Flippy') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_attributes_missing_no_class(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Blarg': { 'Value': 'wibble' }, }, } files = {'test_resource.template': json.dumps(provider)} env = environment.Environment() env.load({ 'resource_registry': { 'DummyResource2': 'test_resource.template' } }) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource2") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) temp_res.resource_id = 'dummy_id' temp_res.nested_identifier = mock.Mock() temp_res.nested_identifier.return_value = {'foo': 'bar'} temp_res._rpc_client = mock.MagicMock() output = { 'outputs': [{ 'output_key': 'Blarg', 'output_value': 'fluffy' }] } temp_res._rpc_client.show_stack.return_value = [output] self.assertRaises(exception.InvalidTemplateAttribute, temp_res.FnGetAtt, 'Foo')
def test_attributes_not_parsable(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Blarg': { 'Value': 'wibble' }, }, } files = {'test_resource.template': json.dumps(provider)} env = environment.Environment() env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate()) nested = mock.Mock() nested.outputs = { 'Blarg': { 'Value': 'not-this', 'error_msg': 'it is all bad' } } nested.output.return_value = None temp_res._nested = nested self.assertRaises(exception.InvalidTemplateAttribute, temp_res.FnGetAtt, 'Blarg')
def test_boolean_type_provider(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': { 'Type': 'Boolean' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = { "Foo": properties.Schema(properties.Schema.BOOLEAN) } attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load( {'resource_registry': { 'DummyResource': 'test_resource.template' }}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "False"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate())
def test_system_template_retrieve_by_file(self): # make sure that a TemplateResource defined in the global environment # can be created and the template retrieved using the "file:" # scheme. g_env = resources.global_env() test_templ_name = 'file:///etc/heatr/frodo.yaml' g_env.load({'resource_registry': {'Test::Frodo': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), stack_id=uuidutils.generate_uuid()) minimal_temp = json.dumps({'Parameters': {}, 'Resources': {}}) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https', 'file')).AndReturn(minimal_temp) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Frodo'}, stack) self.assertEqual(None, temp_res.validate()) self.m.VerifyAll()