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