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"))
