def setUp(self):
super(TemplateSeedTests, self).setUp()
self.seed_template = parser.parse_template(SEED_TEMPLATE)
self.role_template = parser.parse_template(ROLE_TEMPLATE)
self.destination_template = heat.Template()
self.environment = heat.Environment()
def test_compose_nested_resource(self):
# Setup
t = heat.Template()
t.add_resource(heat.Resource('r1', 't1'))
# With add_scaling enabled, the plan will automatically wrap the
# added template in a grouping resource, so we can use that as the
# test data.
p = plan.DeploymentPlan(add_scaling=True)
p.add_template('ns1', t, 't.yaml')
# Test
composed = composer.compose_template(p.master_template)
# Verify
template = yaml.safe_load(composed)
self.assertEqual(1, len(template['resources']))
wrapper_resource_name = plan._generate_group_id(
plan._generate_resource_id('ns1'))
group_resource = template['resources'][wrapper_resource_name]
self.assertEqual(p.master_template.resources[0].resource_type,
group_resource['type'])
self.assertTrue('resource_def' in group_resource['properties'])
nested_resource_details = group_resource['properties']['resource_def']
self.assertEqual(ns_utils.apply_resource_alias_namespace('ns1'),
nested_resource_details['type'])
def test_add_remove_output(self):
t = heat.Template()
o = heat.Output('n', 'v')
# Test Add
t.add_output(o)
self.assertEqual(1, len(t.outputs))
self.assertEqual(o, t.outputs[0])
def test_existing_pieces(self):
# Test
t = heat.Template()
e = heat.Environment()
p = plan.DeploymentPlan(master_template=t, environment=e)
# Verify
self.assertTrue(p.master_template is t)
self.assertTrue(p.environment is e)
def _generate_template(self):
t = heat.Template()
t.add_parameter(heat.Parameter('param-1', 'type-1'))
t.add_parameter(heat.Parameter('param-2', 'type-2'))
t.add_output(heat.Output('out-1', 'value-1'))
t.add_output(heat.Output('out-2', 'value-2'))
return t
def test_add_template_with_colliding_namespace(self):
# Test
p = plan.DeploymentPlan()
p.environment.add_parameter(
heat.EnvironmentParameter('ns1::param-1', 'value-1'))
t = heat.Template()
t.add_parameter(heat.Parameter('param-2', 'type-1'))
# Verify
self.assertRaises(ValueError, p.add_template, 'ns1', t,
'template-1.yaml')
def test_find_output_by_name(self):
# Setup
t = heat.Template()
t.add_output(heat.Output('a', 'a1'))
t.add_output(heat.Output('b', 'b1'))
# Test
found = t.find_output_by_name('b')
# Verify
self.assertEqual(found.value, 'b1')
def test_remove_resource_by_id(self):
# Test
t = heat.Template()
t.add_resource(heat.Resource('id1', 't1'))
t.add_resource(heat.Resource('id2', 't2'))
t.remove_resource_by_id('id1')
# Verify
self.assertEqual(1, len(t.resources))
self.assertEqual(t.resources[0].resource_type, 't2')
def test_find_parameter_group_by_label(self):
# Setup
t = heat.Template()
t.add_parameter_group(heat.ParameterGroup('a', description='a1'))
t.add_parameter_group(heat.ParameterGroup('b', description='b1'))
# Test
found = t.find_parameter_group_by_label('b')
# Verify
self.assertTrue(found is not None)
self.assertEqual(found.description, 'b1')
def test_find_resource_by_id(self):
# Setup
t = heat.Template()
t.add_resource(heat.Resource('a', 'a1'))
t.add_resource(heat.Resource('b', 'b1'))
# Test
found = t.find_resource_by_id('b')
# Verify
self.assertTrue(found is not None)
self.assertEqual(found.resource_type, 'b1')
def test_find_parameter_by_name(self):
# Setup
t = heat.Template()
t.add_parameter(heat.Parameter('a', 'a1'))
t.add_parameter(heat.Parameter('b', 'b1'))
# Test
found = t.find_parameter_by_name('b')
# Verify
self.assertTrue(found is not None)
self.assertEqual(found.param_type, 'b1')
def test_add_remove_resource(self):
t = heat.Template()
r = heat.Resource('id', 't')
# Test Add
t.add_resource(r)
self.assertEqual(1, len(t.resources))
self.assertEqual(r, t.resources[0])
# Test Remove
t.remove_resource(r)
self.assertEqual(0, len(t.resources))
def test_add_remove_parameter(self):
t = heat.Template()
p = heat.Parameter('test-param', 'test-type')
# Test Add
t.add_parameter(p)
self.assertEqual(1, len(t.parameters))
self.assertEqual(p, t.parameters[0])
# Test Remove
t.remove_parameter(p)
self.assertEqual(0, len(t.parameters))
def test_add_remove_parameter_group(self):
t = heat.Template()
pg = heat.ParameterGroup('test-label', 'test-desc')
# Test Add
t.add_parameter_group(pg)
self.assertEqual(1, len(t.parameter_groups))
self.assertEqual(pg, t.parameter_groups[0])
# Test Remove
t.remove_parameter_group(pg)
self.assertEqual(0, len(t.parameter_groups))
def test_init(self):
# Test
t = heat.Template(description='test template')
str(t) # should not raise an exception
# Verify
self.assertEqual(t.version, heat.DEFAULT_VERSION)
self.assertEqual(t.description, 'test template')
self.assertEqual(0, len(t.parameters))
self.assertEqual(0, len(t.parameter_groups))
self.assertEqual(0, len(t.resources))
self.assertEqual(0, len(t.outputs))
def test_remove_parameters_by_namespace(self):
# Setup
t = heat.Template()
p1 = heat.Parameter(ns.apply_template_namespace('ns1', 'foo'), 't')
p2 = heat.Parameter(ns.apply_template_namespace('ns2', 'bar'), 't')
p3 = heat.Parameter(ns.apply_template_namespace('ns1', 'baz'), 't')
t.add_parameter(p1)
t.add_parameter(p2)
t.add_parameter(p3)
# Test
t.remove_parameters_by_namespace('ns1')
# Verify
self.assertEqual(1, len(t.parameters))
self.assertEqual(p2, t.parameters[0])
def test_remove_outputs_by_namespace(self):
# Setup
t = heat.Template()
o1 = heat.Output(ns.apply_template_namespace('ns1', 'foo'), 'v')
o2 = heat.Output(ns.apply_template_namespace('ns2', 'bar'), 'v')
o3 = heat.Output(ns.apply_template_namespace('ns1', 'foo'), 'v')
t.add_output(o1)
t.add_output(o2)
t.add_output(o3)
# Test
t.remove_outputs_by_namespace('ns1')
# Verify
self.assertEqual(1, len(t.outputs))
self.assertEqual(o2, t.outputs[0])
def test_add_template_with_default_parameter_value(self):
# Test
p = plan.DeploymentPlan()
t = heat.Template()
t.add_parameter(heat.Parameter('param-1', 'type-1', default='d1'))
t.add_parameter(heat.Parameter('param-2', 'type-2'))
p.add_template('ns1', t, 'template-1.yaml')
# Verify
p1 = p.environment.parameters[0]
self.assertEqual(ns_utils.apply_template_namespace('ns1', 'param-1'),
p1.name)
self.assertEqual('d1', p1.value)
p2 = p.environment.parameters[1]
self.assertEqual(ns_utils.apply_template_namespace('ns1', 'param-2'),
p2.name)
self.assertEqual('', p2.value)
def _sample_template(self):
t = heat.Template(description='template-desc')
# Complex Parameter
param = heat.Parameter('p1',
't1',
description='desc-1',
label='l1',
default='def-1',
hidden=True)
param.add_constraint(
heat.ParameterConstraint('t1', 'def-1', description='desc-1'))
t.add_parameter(param)
# Simple Parameter
t.add_parameter(heat.Parameter('p2', 't2'))
# Simple Parameter Group
t.add_parameter_group(heat.ParameterGroup('l1'))
# Complex Parameter Group
group = heat.ParameterGroup('l2', description='d2')
group.add_parameter_name('foo', 'bar', 'baz')
t.add_parameter_group(group)
# Complex Resource
resource = heat.Resource('r1',
't1',
metadata='m1',
depends_on='r2',
update_policy={'u1': 'u2'},
deletion_policy={'d1': 'd2'})
t.add_resource(resource)
# Simple Resource
t.add_resource(heat.Resource('r2', 't2'))
# Complex Output
t.add_output(heat.Output('n1', 'v1', description='desc-1'))
# Simple Output
t.add_output(heat.Output('n2', 'v2'))
return t
def test_remove_parameter_not_found(self):
t = heat.Template()
self.assertRaises(ValueError, t.remove_parameter,
heat.Parameter('n', 't'))
def test_remove_output_not_found(self):
t = heat.Template()
self.assertRaises(ValueError, t.remove_output, heat.Output('n', 'v'))
def test_find_resource_by_id_missing(self):
t = heat.Template()
found = t.find_resource_by_id('missing')
self.assertEqual(found, None)
def test_find_parameter_by_name_missing(self):
t = heat.Template()
found = t.find_parameter_by_name('missing')
self.assertEqual(found, None)
def test_find_parameter_group_by_label_missing(self):
t = heat.Template()
found = t.find_parameter_group_by_label('missing')
self.assertEqual(found, None)
