def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, {}, stack_id=uuidutils.generate_uuid()) return (t, stack)
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, {}, stack_id=uuidutils.generate_uuid()) return (t, stack)
def test_attributes_missing(self): provider = { '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({}, files=files), env=env, stack_id=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_instance_create_delete(self): f = open("%s/WordPress_Single_Instance_gold.template" % self.path) t = template_format.parse(f.read()) f.close() stack_name = 'instance_create_delete_test_stack' template = parser.Template(t) params = parser.Parameters(stack_name, template, {'KeyName': 'test'}) stack = parser.Stack(None, stack_name, template, params, stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance('create_delete_instance_name', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = instance._build_userdata( instance.t['Properties']['UserData']) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name='%s.%s' % (stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None).AndReturn(self.fc.servers.list()[1]) self.m.ReplayAll() self.assertEqual(instance.create(), None) instance.resource_id = 1234 # this makes sure the auto increment worked on instance creation self.assertTrue(instance.id > 0) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndRaise(instances.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) instance.delete() self.assertTrue(instance.resource_id is None) self.assertEqual(instance.state, instance.DELETE_COMPLETE) self.m.VerifyAll() AZ = instance.FnGetAtt('AvailabilityZone') self.assertEqual(AZ, 'nova') private_ip = instance.FnGetAtt('PublicIp') self.assertEqual(private_ip, '4.5.6.7') private_ip = instance.FnGetAtt('PrivateIp') self.assertEqual(private_ip, '4.5.6.7') private_ip = instance.FnGetAtt('PrivateDnsName') self.assertEqual(private_ip, '4.5.6.7') private_ip = instance.FnGetAtt('PrivateDnsName') self.assertEqual(private_ip, '4.5.6.7')
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.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=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, 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({}), env=env, stack_id=uuidutils.generate_uuid()) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndRaise(IOError) urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndRaise(IOError) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Flippy'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll()
def setUp(self): self.m = mox.Mox() self.stack = parser.Stack(None, 'test_stack', parser.Template({}), stack_id=uuidutils.generate_uuid()) resource._register_class('GenericResourceType', generic_rsrc.GenericResource)
def _setup_test_group(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(group_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['Tags'] = intags # create the launch configuration conf = stack.resources['Config'] self.assertEqual(None, conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) group = stack.resources['WebServer'] self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(self.fc) group.t = group.stack.resolve_runtime_data(group.t) # need to resolve the template functions self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return group
def _setup_test_clouddbinstance(self, name, inject_property_error=False): stack_name = '%s_stack' % name t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({ 'InstanceName': 'Test', 'FlavorRef': '1GB', 'VolumeSize': '30' }), stack_id=uuidutils.generate_uuid()) if inject_property_error: # database name given in users list is not a valid database t['Resources']['MySqlCloudDB']['Properties']['Databases'] = \ [{"Name": "onedb"}] t['Resources']['MySqlCloudDB']['Properties']['Users'] = \ [{"Name": "testuser", "Password": "******", "Databases": ["invaliddb"]}] else: t['Resources']['MySqlCloudDB']['Properties']['Databases'] = \ [{"Name": "validdb"}] t['Resources']['MySqlCloudDB']['Properties']['Users'] = \ [{"Name": "testuser", "Password": "******", "Databases": ["validdb"]}] instance = clouddatabase.CloudDBInstance( '%s_name' % name, t['Resources']['MySqlCloudDB'], stack) instance.resource_id = 1234 self.m.StubOutWithMock(instance, 'cloud_db') return instance
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(self.ctx, stack_name, template, environment.Environment({'key_name': 'test'}), stack_id=uuidutils.generate_uuid()) return (template, stack)
def test_properties_normal(self): provider = { '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.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=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertEqual(None, temp_res.validate())
def test_nokey_create(self): stack_name = 'instance_create_test_nokey_stack' t = template_format.parse(nokey_template) stack = parse_stack(t, stack_name=stack_name, stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance('create_instance_name', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = instance._build_userdata( instance.t['Properties']['UserData']) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name=None, name='%s.%s' % (stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) self.m.ReplayAll() scheduler.TaskRunner(instance.create)()
def create_stack(self, stack_id=None, template=test_template_waitcondition, params={}, stub=True): temp = template_format.parse(template) template = parser.Template(temp) ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack(ctx, 'test_stack', template, environment.Environment(params), disable_rollback=True) # Stub out the stack ID so we have a known value if stack_id is None: stack_id = uuidutils.generate_uuid() self.stack_id = stack_id with utils.UUIDStub(self.stack_id): stack.store() if stub: self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone') wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn( self.fc) id = identifier.ResourceIdentifier('test_tenant', stack.name, stack.id, '', 'WaitHandle') self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier') wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id) return stack
def create_stack(self, stack_id=None, template=test_template_waitcondition, params={}, stub=True): temp = template_format.parse(template) template = parser.Template(temp) ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack(ctx, 'test_stack', template, environment.Environment(params), disable_rollback=True) # Stub out the stack ID so we have a known value if stack_id is None: stack_id = uuidutils.generate_uuid() self.stack_id = stack_id with utils.UUIDStub(self.stack_id): stack.store() if stub: self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone') wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn( self.fc) id = identifier.ResourceIdentifier('test_tenant', stack.name, stack.id, '', 'WaitHandle') self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier') wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id) return stack
def _setup_test_group(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(group_template) template = parser.Template(t) stack = parser.Stack(dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['Tags'] = intags group = autoscaling.InstanceGroup('WebServer', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(self.fc) group.t = group.stack.resolve_runtime_data(group.t) # need to resolve the template functions self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return group
def test_attributes_missing(self): provider = { '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({}, files=files), env=env, stack_id=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def _setup_test_clouddbinstance(self, name, inject_property_error=False): stack_name = '%s_stack' % name t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'InstanceName': 'Test', 'FlavorRef': '1GB', 'VolumeSize': '30'}), stack_id=uuidutils.generate_uuid()) if inject_property_error: # database name given in users list is not a valid database t['Resources']['MySqlCloudDB']['Properties']['Databases'] = \ [{"Name": "onedb"}] t['Resources']['MySqlCloudDB']['Properties']['Users'] = \ [{"Name": "testuser", "Password": "******", "Databases": ["invaliddb"]}] else: t['Resources']['MySqlCloudDB']['Properties']['Databases'] = \ [{"Name": "validdb"}] t['Resources']['MySqlCloudDB']['Properties']['Users'] = \ [{"Name": "testuser", "Password": "******", "Databases": ["validdb"]}] instance = clouddatabase.CloudDBInstance( '%s_name' % name, t['Resources']['MySqlCloudDB'], stack) instance.resource_id = 1234 self.m.StubOutWithMock(instance, 'cloud_db') return instance
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'key_name': 'test'}), stack_id=uuidutils.generate_uuid()) return (t, stack)
def _setup_test_instance(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(instance_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['Tags'] = intags instance = instances.Instance(stack_name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData']) instance.mime_string = server_userdata self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return instance
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(dummy_context(), stack_name, template, environment.Environment({'flavor': '2'}), stack_id=uuidutils.generate_uuid()) return (t, stack)
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) params = parser.Parameters(stack_name, template, {'KeyName': 'test'}) stack = parser.Stack(None, stack_name, template, params, stack_id=uuidutils.generate_uuid()) return (t, stack)
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({}), env=env, stack_id=uuidutils.generate_uuid()) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndRaise(IOError) urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndRaise(IOError) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', {"Type": 'Test::Flippy'}, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll()
def _setup_test_instance(self, return_server, name): stack_name = '%s_stack' % name t = template_format.parse(wp_template) template = parser.Template(t) params = parser.Parameters(stack_name, template, {'KeyName': 'test'}) stack = parser.Stack(None, stack_name, template, params, stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance('%s_name' % name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = instance._build_userdata( instance.t['Properties']['UserData']) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( return_server) return instance
def _create_test_instance_with_nic(self, return_server, name): stack_name = '%s_s' % name t = template_format.parse(wp_template_with_nic) template = parser.Template(t) kwargs = { 'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861' } stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment(kwargs), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' nic = network_interfaces.NetworkInterface('%s_nic' % name, t['Resources']['nic1'], stack) instance = instances.Instance('%s_name' % name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(nic, 'neutron') nic.neutron().MultipleTimes().AndReturn(FakeNeutron()) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) nic.t = nic.stack.resolve_runtime_data(nic.t) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData']) instance.mime_string = server_userdata self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create(image=1, flavor=3, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=[{ 'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251' }], availability_zone=None).AndReturn(return_server) self.m.ReplayAll() # create network interface scheduler.TaskRunner(nic.create)() stack.resources["nic1"] = nic scheduler.TaskRunner(instance.create)() return instance
def setUp(self): super(ResourceTest, self).setUp() setup_dummy_db() self.stack = parser.Stack(None, 'test_stack', parser.Template({}), stack_id=uuidutils.generate_uuid()) resource._register_class('GenericResourceType', generic_rsrc.GenericResource)
def setUp(self): super(ResourceTest, self).setUp() setup_dummy_db() self.stack = parser.Stack( dummy_context(), "test_stack", parser.Template({}), stack_id=uuidutils.generate_uuid() ) resource._register_class("GenericResourceType", generic_rsrc.GenericResource)
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) templ = template.Template(t) stack = parser.Stack(self.ctx, stack_name, templ, environment.Environment({'key_name': 'test'}), stack_id=uuidutils.generate_uuid()) return (templ, stack)
def test_to_parameters(self): """Tests property conversion to parameter values.""" utils.setup_dummy_db() class DummyResource(object): attributes_schema = {"Foo": "A test attribute"} properties_schema = { "Foo": {"Type": "String"}, "AList": {"Type": "List"}, "ANum": {"Type": "Number"}, "AMap": {"Type": "Map"} } 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({}), env=env, stack_id=uuidutils.generate_uuid()) map_prop_val = { "key1": "val1", "key2": ["lval1", "lval2", "lval3"], "key3": { "key4": 4, "key5": False } } json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "Bar", "AList": ["one", "two", "three"], "ANum": 5, "AMap": map_prop_val } } self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.m.VerifyAll() converted_params = temp_res._to_parameters() self.assertTrue(converted_params) for key in DummyResource.properties_schema: self.assertIn(key, converted_params) # verify String conversion self.assertEqual("Bar", converted_params.get("Foo")) # verify List conversion self.assertEqual(",".join(json_snippet.get("Properties", {}).get("AList", [])), converted_params.get("AList")) # verify Number conversion self.assertEqual(5, converted_params.get("ANum")) # verify Map conversion self.assertEqual(map_prop_val, converted_params.get("AMap"))
def _setup_test_stack(self, stack_name, stack_id=None): t = template_format.parse(wp_template) template = parser.Template(t) stack_id = stack_id or uuidutils.generate_uuid() stack = parser.Stack(self.ctx, stack_name, template, environment.Environment({'KeyName': 'test'})) with utils.UUIDStub(stack_id): stack.store() return (t, stack)
def setUp(self): self.m = mox.Mox() self.stack = parser.Stack(None, 'test_stack', parser.Template({}), stack_id=uuidutils.generate_uuid()) resource._register_class('GenericResourceType', generic_rsrc.GenericResource)
def _setup_test_stack(self, stack_name, stack_id=None): t = template_format.parse(wp_template) template = parser.Template(t) stack_id = stack_id or uuidutils.generate_uuid() stack = parser.Stack(self.ctx, stack_name, template, environment.Environment({'KeyName': 'test'})) with utils.UUIDStub(stack_id): stack.store() return (t, stack)
def setUp(self): super(ResourceTest, self).setUp() setup_dummy_db() self.stack = parser.Stack(None, 'test_stack', parser.Template({}), stack_id=uuidutils.generate_uuid()) resource._register_class('GenericResourceType', generic_rsrc.GenericResource)
def test_to_parameters(self): """Tests property conversion to parameter values.""" setup_dummy_db() stack = parser.Stack(dummy_context(), 'test_stack', parser.Template({}), stack_id=uuidutils.generate_uuid()) class DummyResource(object): attributes_schema = {"Foo": "A test attribute"} properties_schema = { "Foo": {"Type": "String"}, "AList": {"Type": "List"}, "ANum": {"Type": "Number"}, "AMap": {"Type": "Map"} } map_prop_val = { "key1": "val1", "key2": ["lval1", "lval2", "lval3"], "key3": { "key4": 4, "key5": False } } json_snippet = { "Type": "test_resource.template", "Properties": { "Foo": "Bar", "AList": ["one", "two", "three"], "ANum": 5, "AMap": map_prop_val } } self.m.StubOutWithMock(template_resource.resource, "get_class") (template_resource.resource.get_class("test_resource.template") .AndReturn(DummyResource)) self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.m.VerifyAll() converted_params = temp_res._to_parameters() self.assertTrue(converted_params) for key in DummyResource.properties_schema: self.assertIn(key, converted_params) # verify String conversion self.assertEqual("Bar", converted_params.get("Foo")) # verify List conversion self.assertEqual(",".join(json_snippet.get("Properties", {}).get("AList", [])), converted_params.get("AList")) # verify Number conversion self.assertEqual(5, converted_params.get("ANum")) # verify Map conversion self.assertEqual(map_prop_val, converted_params.get("AMap"))
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack( utils.dummy_context(), stack_name, template, environment.Environment({"key_name": "test"}), stack_id=uuidutils.generate_uuid(), ) return (t, stack)
def setUp(self): super(StackResourceTest, self).setUp() setup_dummy_db() resource._register_class('some_magic_type', MyStackResource) t = parser.Template({template.RESOURCES: {"provider_resource": ws_res_snippet}}) self.parent_stack = parser.Stack(dummy_context(), 'test_stack', t, stack_id=uuidutils.generate_uuid()) self.parent_resource = MyStackResource('test', ws_res_snippet, self.parent_stack) self.templ = template_format.parse(wp_template)
def _create_test_instance_with_nic(self, return_server, name): stack_name = '%s_stack' % name t = template_format.parse(wp_template_with_nic) template = parser.Template(t) kwargs = {'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'} stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment(kwargs), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' nic = network_interfaces.NetworkInterface('%s_nic' % name, t['Resources']['nic1'], stack) instance = instances.Instance('%s_name' % name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(nic, 'neutron') nic.neutron().MultipleTimes().AndReturn(FakeNeutron()) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) nic.t = nic.stack.resolve_runtime_data(nic.t) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData']) instance.mime_string = server_userdata self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=3, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=[{'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251'}], availability_zone=None).AndReturn( return_server) self.m.ReplayAll() # create network interface scheduler.TaskRunner(nic.create)() stack.resources["nic1"] = nic scheduler.TaskRunner(instance.create)() return instance
def test_template_as_resource(self): """ Test that the resulting resource has the right prop and attrib schema. Note that this test requires the Wordpress_Single_Instance.yaml template in the templates directory since we want to test using a non-trivial template. """ test_templ_name = "WordPress_Single_Instance.yaml" path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'templates', test_templ_name) # check if its in the directory list vs. exists to work around # case-insensitive file systems self.assertIn(test_templ_name, os.listdir(os.path.dirname(path))) with open(path) as test_templ_file: test_templ = test_templ_file.read() self.assertTrue(test_templ, "Empty test template") self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https')).AndReturn(test_templ) parsed_test_templ = template_format.parse(test_templ) self.m.ReplayAll() json_snippet = { "Type": test_templ_name, "Properties": { "KeyName": "mykeyname", "DBName": "wordpress1", "DBUsername": "******", "DBPassword": "******", "DBRootPassword": "******", "LinuxDistribution": "U10" } } stack = parser.Stack(None, 'test_stack', parser.Template({}), stack_id=uuidutils.generate_uuid()) templ_resource = resource.Resource("test_templ_resource", json_snippet, stack) self.m.VerifyAll() self.assertIsInstance(templ_resource, template_resource.TemplateResource) for prop in parsed_test_templ.get("Parameters", {}): self.assertIn(prop, templ_resource.properties) for attrib in parsed_test_templ.get("Outputs", {}): self.assertIn(attrib, templ_resource.attributes) for k, v in json_snippet.get("Properties").items(): self.assertEqual(v, templ_resource.properties[k]) self.assertNotIn('WordPress_Single_Instance.yaml', resources.global_env().registry._registry)
def setUp(self): super(ResourceTest, self).setUp() utils.setup_dummy_db() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) env = environment.Environment() env.load({u'resource_registry': {u'OS::Test::GenericResource': u'GenericResourceType'}}) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=uuidutils.generate_uuid())
def test_instance_create_delete(self): f = open("%s/WordPress_Single_Instance_gold.template" % self.path) t = template_format.parse(f.read()) f.close() stack_name = 'instance_create_delete_test_stack' template = parser.Template(t) params = parser.Parameters(stack_name, template, {'KeyName': 'test'}) stack = parser.Stack(None, stack_name, template, params, stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance('create_delete_instance_name', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = instance._build_userdata( instance.t['Properties']['UserData']) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name='%s.%s' % (stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) self.m.ReplayAll() self.assertEqual(instance.create(), None) instance.resource_id = 1234 # this makes sure the auto increment worked on instance creation self.assertTrue(instance.id > 0) self.m.StubOutWithMock(self.fc.client, 'get_servers_1234') get = self.fc.client.get_servers_1234 get().AndRaise(instances.clients.novaclient.exceptions.NotFound(404)) mox.Replay(get) instance.delete() self.assertTrue(instance.resource_id is None) self.assertEqual(instance.state, instance.DELETE_COMPLETE) self.m.VerifyAll()
def setUp(self): super(ResourceTest, self).setUp() utils.setup_dummy_db() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) env = environment.Environment() env.load({u'resource_registry': {u'OS::Test::GenericResource': u'GenericResourceType'}}) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=uuidutils.generate_uuid())
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. 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()) self.assertRaises(ValueError, template_resource.TemplateResource, 'test_t_res', {"Type": 'Test::Flippy'}, stack)
def _create_test_instance(self, return_server, name): stack_name = '%s_stack' % name t = template_format.parse(wp_template) template = parser.Template(t) kwargs = { 'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861' } params = parser.Parameters(stack_name, template, kwargs) stack = parser.Stack(None, stack_name, template, params, stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' instance = instances.Instance('%s_name' % name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(instance, 'quantum') instance.quantum().MultipleTimes().AndReturn(FakeQuantum()) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = instance._build_userdata( instance.t['Properties']['UserData']) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create(image=1, flavor=3, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=[{ 'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251' }], availability_zone=None).AndReturn(return_server) self.m.ReplayAll() scheduler.TaskRunner(instance.create)() return instance
def _setup_test_group_autoscaling(self, intags=None, nova_tags=None): stack_name = "tag_as_name" t = template_format.parse(autoscaling_template) template = parser.Template(t) stack = parser.Stack( utils.dummy_context(), stack_name, template, environment.Environment({"KeyName": "test"}), stack_id=uuidutils.generate_uuid(), ) t["Resources"]["WebServer"]["Properties"]["Tags"] += intags # create the launch configuration conf = stack["Config"] self.assertEqual(None, conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) group = stack["WebServer"] group_refid = utils.PhysName(stack.name, group.name) nova_tags["metering.groupname"] = group_refid nova_tags["AutoScalingGroupName"] = group_refid self.m.StubOutWithMock(group, "_cooldown_timestamp") group._cooldown_timestamp(mox.IgnoreArg()).AndReturn(None) self.m.StubOutWithMock(instances.Instance, "nova") instances.Instance.nova().MultipleTimes().AndReturn(self.fc) group.t = group.stack.resolve_runtime_data(group.t) # need to resolve the template functions self.m.StubOutWithMock(self.fc.servers, "create") self.fc.servers.create( image=1, flavor=1, key_name="test", name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None, ).AndReturn(self.fc.servers.list()[1]) return group
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 _setup_test_cloud_dns_instance(self, name, parsed_t): stack_name = '%s_stack' % name t = parsed_t template = parser.Template(t) stack = parser.Stack(None, stack_name, template, environment.Environment({'name': 'test'}), stack_id=uuidutils.generate_uuid()) instance = cloud_dns.CloudDns( '%s_name' % name, t['Resources']['domain'], stack) instance.t = instance.stack.resolve_runtime_data(instance.t) return instance
def setUp(self): super(FormatTest, self).setUp() setup_dummy_db() template = parser.Template({ 'Resources': { 'generic1': {'Type': 'GenericResourceType'}, 'generic2': { 'Type': 'GenericResourceType', 'DependsOn': 'generic1'} } }) resource._register_class('GenericResourceType', generic_rsrc.GenericResource) self.stack = parser.Stack(dummy_context(), 'test_stack', template, stack_id=uuidutils.generate_uuid())
def _setup_test_group_autoscaling(self, intags=None, nova_tags=None): stack_name = 'tag_as_name' t = template_format.parse(autoscaling_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['Tags'] += intags # create the launch configuration conf = stack['Config'] self.assertEqual(None, conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) group = stack['WebServer'] group_refid = utils.PhysName(stack.name, group.name) nova_tags['metering.groupname'] = group_refid nova_tags['AutoScalingGroupName'] = group_refid self.m.StubOutWithMock(group, '_cooldown_timestamp') group._cooldown_timestamp(mox.IgnoreArg()).AndReturn(None) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(self.fc) group.t = group.stack.resolve_runtime_data(group.t) # need to resolve the template functions self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create(image=1, flavor=1, key_name='test', name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return group
def setUp(self): super(StackResourceTest, self).setUp() utils.setup_dummy_db() resource._register_class('some_magic_type', MyStackResource) resource._register_class('GenericResource', generic_rsrc.GenericResource) t = parser.Template( {template.RESOURCES: { "provider_resource": ws_res_snippet }}) self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack', t, stack_id=uuidutils.generate_uuid()) self.parent_resource = MyStackResource('test', ws_res_snippet, self.parent_stack) self.templ = template_format.parse(param_template) self.simple_template = template_format.parse(simple_template)
def test_instance_update_metadata(self): f = open("%s/WordPress_Single_Instance_gold.template" % self.path) t = template_format.parse(f.read()) f.close() stack_name = 'instance_update_test_stack' template = parser.Template(t) params = parser.Parameters(stack_name, template, {'KeyName': 'test'}) stack = parser.Stack(None, stack_name, template, params, stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance('create_instance_name', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = instance._build_userdata( instance.t['Properties']['UserData']) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name='%s.%s' % (stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) self.m.ReplayAll() self.assertEqual(instance.create(), None) update_template = copy.deepcopy(instance.t) update_template['Metadata'] = {'test': 123} self.assertEqual(instance.update(update_template), instance.UPDATE_COMPLETE) self.assertEqual(instance.metadata, {'test': 123})
def test_properties_normal(self): provider = { '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.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=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertEqual(None, temp_res.validate())
def setUp(self): super(FormatTest, self).setUp() utils.setup_dummy_db() template = parser.Template({ 'Resources': { 'generic1': { 'Type': 'GenericResourceType' }, 'generic2': { 'Type': 'GenericResourceType', 'DependsOn': 'generic1' } } }) resource._register_class('GenericResourceType', generic_rsrc.GenericResource) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', template, stack_id=uuidutils.generate_uuid())
def _setup_test_instance(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(instance_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['Tags'] = intags instance = instances.Instance(stack_name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData']) instance.mime_string = server_userdata self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create(image=1, flavor=1, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return instance
def test_nokey_create(self): stack_name = 'instance_create_test_nokey_stack' t = template_format.parse(nokey_template) stack = parse_stack(t, stack_name=stack_name, stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['InstanceType'] = \ '256 MB Server' instance = instances.Instance('create_instance_name', t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = instance._build_userdata( instance.t['Properties']['UserData']) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create(image=1, flavor=1, key_name=None, name='%s.%s' % (stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) self.m.ReplayAll() scheduler.TaskRunner(instance.create)()
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()
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.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=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
}, "Resources" : { "WebServer": { "Type": "AWS::EC2::Instance", "Properties": { "ImageId" : "F17-x86_64-gold", "InstanceType" : "m1.large", "KeyName" : "test", "UserData" : "wordpress" } } } } ''' UUIDs = (UUID1, UUID2) = sorted([uuidutils.generate_uuid() for x in range(2)]) class MyResource(Resource): properties_schema = { 'ServerName': {'Type': 'String', 'Required': True}, 'Flavor': {'Type': 'String', 'Required': True}, 'ImageName': {'Type': 'String', 'Required': True}, 'UserData': {'Type': 'String'}, 'PublicKey': {'Type': 'String'} } @property def my_secret(self): return db_api.resource_data_get(self, 'my_secret')
def test_to_parameters(self): """Tests property conversion to parameter values.""" utils.setup_dummy_db() class DummyResource(object): attributes_schema = {"Foo": "A test attribute"} properties_schema = { "Foo": { "Type": "String" }, "AList": { "Type": "List" }, "ANum": { "Type": "Number" }, "AMap": { "Type": "Map" } } 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({}), env=env, stack_id=uuidutils.generate_uuid()) map_prop_val = { "key1": "val1", "key2": ["lval1", "lval2", "lval3"], "key3": { "key4": 4, "key5": False } } json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "Bar", "AList": ["one", "two", "three"], "ANum": 5, "AMap": map_prop_val } } self.m.ReplayAll() temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.m.VerifyAll() converted_params = temp_res._to_parameters() self.assertTrue(converted_params) for key in DummyResource.properties_schema: self.assertIn(key, converted_params) # verify String conversion self.assertEqual("Bar", converted_params.get("Foo")) # verify List conversion self.assertEqual( ",".join(json_snippet.get("Properties", {}).get("AList", [])), converted_params.get("AList")) # verify Number conversion self.assertEqual(5, converted_params.get("ANum")) # verify Map conversion self.assertEqual(map_prop_val, converted_params.get("AMap"))
def test_to_parameters(self): """Tests property conversion to parameter values.""" provider = { 'Parameters': { 'Foo': { 'Type': 'String' }, 'AList': { 'Type': 'CommaDelimitedList' }, 'ListEmpty': { 'Type': 'CommaDelimitedList' }, 'ANum': { 'Type': 'Number' }, 'AMap': { 'Type': 'Json' }, }, 'Outputs': { 'Foo': { 'Value': 'bar' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): attributes_schema = {"Foo": "A test attribute"} properties_schema = { "Foo": { "Type": "String" }, "AList": { "Type": "List" }, "ListEmpty": { "Type": "List" }, "ANum": { "Type": "Number" }, "AMap": { "Type": "Map" } } 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=uuidutils.generate_uuid()) map_prop_val = { "key1": "val1", "key2": ["lval1", "lval2", "lval3"], "key3": { "key4": 4, "key5": False } } json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "Bar", "AList": ["one", "two", "three"], "ListEmpty": [], "ANum": 5, "AMap": map_prop_val } } temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) temp_res.validate() converted_params = temp_res._to_parameters() self.assertTrue(converted_params) for key in DummyResource.properties_schema: self.assertIn(key, converted_params) # verify String conversion self.assertEqual("Bar", converted_params.get("Foo")) # verify List conversion self.assertEqual( ",".join(json_snippet.get("Properties", {}).get("AList", [])), converted_params.get("AList")) # verify Number conversion self.assertEqual(5, converted_params.get("ANum")) # verify Map conversion self.assertEqual(map_prop_val, converted_params.get("AMap"))