def test_update_role_property_references(self):
# Setup
dp = plan.DeploymentPlan()
dp.add_template('ns1', self.role_template, 'foo.yaml')
template_seed.add_top_level_resources(self.seed_template,
dp.master_template)
template_seed.add_top_level_resources(self.seed_template,
dp.master_template)
# Test
seed_role = template_seed.find_role_from_type(
self.seed_template.resources,
'OS::TripleO::Controller')
template_seed.update_role_property_references(
dp.master_template,
seed_role, 'ns1')
# Verify
tlr2 = dp.master_template.find_resource_by_id('TopLevelResource2')
self.assertTrue(tlr2 is not None)
c3 = tlr2.find_property_by_name('config-3')
sub2 = c3.value['sub-1']['sub-2']
self.assertTrue('get_param' in sub2)
self.assertEqual('ns1::RoleParameter1', sub2['get_param'])
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 _plan_to_template_object(db_plan):
master_template = parser.parse_template(
db_plan.master_template.contents)
environment = parser.parse_environment(
db_plan.environment_file.contents)
deployment_plan = plan.DeploymentPlan(master_template=master_template,
environment=environment)
return deployment_plan
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 test_empty(self):
# Test
p = plan.DeploymentPlan(description='test-desc')
str(p) # should not error
# Verify
self.assertTrue(isinstance(p.master_template, heat.Template))
self.assertTrue(isinstance(p.environment, heat.Environment))
self.assertEqual('test-desc', p.master_template.description)
self.assertEqual(p.add_scaling, True)
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_set_value(self):
# Setup
p = plan.DeploymentPlan()
set_me = heat.EnvironmentParameter('p1', 'v1')
p.environment.add_parameter(set_me)
# Test
p.set_value('p1', 'v2')
# Verify
self.assertEqual(
p.environment.find_parameter_by_name('p1').value, 'v2')
def test_add_template_no_scaling(self):
# Test
p = plan.DeploymentPlan(add_scaling=False)
t = self._generate_template()
p.add_template('ns1', t, 'template-1.yaml')
# Verify Master Template Parameters
self.assertEqual(2, len(p.master_template.parameters))
for original, added in zip(t.parameters, p.master_template.parameters):
self.assertTrue(added is not original)
expected_name = ns_utils.apply_template_namespace(
'ns1', original.name)
self.assertEqual(added.name, expected_name)
self.assertEqual(added.param_type, original.param_type)
# Verify Resource
self.assertEqual(1, len(p.master_template.resources))
added = p.master_template.resources[0]
expected_id = plan.generate_resource_id('ns1')
self.assertEqual(added.resource_id, expected_id)
expected_type = ns_utils.apply_resource_alias_namespace('ns1')
self.assertEqual(added.resource_type, expected_type)
for param, prop in zip(t.parameters, added.properties):
v = ns_utils.apply_template_namespace('ns1', param.name)
expected_value = {'get_param': [v]}
self.assertEqual(prop.value, expected_value)
# Verify Environment Parameters
self.assertEqual(2, len(p.environment.parameters))
for env_param, template_param in zip(p.environment.parameters,
t.parameters):
expected_name = (ns_utils.apply_template_namespace(
'ns1', template_param.name))
self.assertEqual(env_param.name, expected_name)
self.assertEqual(env_param.value, '')
# Verify Resource Registry Entry
self.assertEqual(1, len(p.environment.registry_entries))
added = p.environment.registry_entries[0]
expected_alias = ns_utils.apply_resource_alias_namespace('ns1')
self.assertEqual(added.alias, expected_alias)
self.assertEqual(added.filename, 'template-1.yaml')
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 create_plan(self, name, description):
"""Creates a new plan, persisting it to Tuskar's storage backend.
:type name: str
:type description: str
:return: domain model instance of the created plan
:rtype: tuskar.manager.models.DeploymentPlan
:raises tuskar.storage.exceptions.NameAlreadyUsed: if there is a plan
with the given name
"""
# Create the plan using the template generation code first to
# stub out the master template and environment files correctly.
new_plan = plan.DeploymentPlan(description=description)
# Save the newly created master template and environment to the
# storage layer so they can be associated with the plan.
master_template_contents = composer.compose_template(
new_plan.master_template
)
master_template_file = self.master_template_store.create(
name_utils.master_template_filename(name),
master_template_contents,
)
environment_contents = composer.compose_environment(
new_plan.environment
)
environment_file = self.environment_store.create(
environment_contents
)
# Create the plan in storage, seeding it with the stored files for
# the template and environment.
db_plan = self.plan_store.create(
name,
master_template_uuid=master_template_file.uuid,
environment_uuid=environment_file.uuid,
)
# Return the created plan.
created_plan = self.retrieve_plan(db_plan.uuid)
return created_plan
def test_add_scaling_with_scaling(self):
# Test
p = plan.DeploymentPlan(add_scaling=True)
t = self._generate_template()
p.add_template('ns1', t, 'template-1.yaml')
# Verify Master Template Count Parameters
self.assertEqual(3, len(p.master_template.parameters))
count_param = p.master_template.parameters[2]
expected_count_name = plan.generate_count_property_name('ns1')
self.assertEqual(count_param.name, expected_count_name)
self.assertEqual(count_param.param_type, 'number')
self.assertEqual(1, len(count_param.constraints))
const = count_param.constraints[0]
self.assertTrue(isinstance(const, heat.ParameterConstraint))
self.assertEqual(const.constraint_type, 'range')
self.assertEqual(const.definition, {'min': '0'})
# Verify Resource Group Wrapper
self.assertEqual(1, len(p.master_template.resources))
group_res = p.master_template.resources[0]
group_id = plan.generate_group_id('ns1')
self.assertEqual(group_res.resource_id, group_id)
self.assertEqual(group_res.resource_type,
plan.HEAT_TYPE_RESOURCE_GROUP)
self.assertEqual(2, len(group_res.properties))
count_prop = group_res.properties[0]
self.assertEqual(count_prop.name, plan.PROPERTY_SCALING_COUNT)
self.assertEqual(count_prop.value,
{'get_param': [expected_count_name]})
def_prop = group_res.properties[1]
self.assertEqual(def_prop.name, plan.PROPERTY_RESOURCE_DEFINITION)
self.assertTrue(isinstance(def_prop.value, heat.Resource))
# Verify Environment Parameters
self.assertEqual(3, len(p.environment.parameters))
count_param = p.environment.parameters[2]
self.assertEqual(count_param.name, expected_count_name)
self.assertEqual(count_param.value, '1')
def test_remove_template(self):
# Setup & Sanity Check
p = plan.DeploymentPlan(add_scaling=False)
t = self._generate_template()
p.add_template('ns1', t, 'template-1.yaml')
p.add_template('ns2', t, 'template-2.yaml')
self.assertEqual(4, len(p.master_template.parameters))
self.assertEqual(0, len(p.master_template.outputs))
self.assertEqual(2, len(p.master_template.resources))
self.assertEqual(4, len(p.environment.parameters))
self.assertEqual(2, len(p.environment.registry_entries))
# Test
p.remove_template('ns1')
# Verify
self.assertEqual(2, len(p.master_template.parameters))
self.assertEqual(0, len(p.master_template.outputs))
self.assertEqual(1, len(p.master_template.resources))
self.assertEqual(2, len(p.environment.parameters))
self.assertEqual(1, len(p.environment.registry_entries))
def test_set_value_missing_parameter(self):
# Setup
p = plan.DeploymentPlan()
# Test
self.assertRaises(ValueError, p.set_value, 'missing', 'irrelevant')