def test_set_parameter_values(self): # Setup test_role = self._add_test_role() test_plan = self.plans_manager.create_plan('p1', 'd1') self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid) # Test ns = name_utils.generate_role_namespace(test_role.name, test_role.version) update_us = [ ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'), 'test-key'), ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'), 'test-image'), ] updated_plan = self.plans_manager.set_parameter_values(test_plan.uuid, update_us) # Verify self.assertTrue(updated_plan is not None) self.assertTrue(isinstance(updated_plan, DeploymentPlan)) # Pull it from the database again to make sure it was saved found = self.plans_manager.retrieve_plan(test_plan.uuid) found_params = sorted(found.parameters, key=lambda x: x.name) self.assertEqual(4, len(found_params)) # 3 + 1 for scaling self.assertEqual(found_params[0].value, '1') self.assertEqual(found_params[1].value, 'test-image') self.assertEqual(found_params[2].value, 'm1.small') self.assertEqual(found_params[3].value, 'test-key')
def test_set_parameter_values(self): # Setup test_role = self._add_test_role() test_plan = self.plans_manager.create_plan('p1', 'd1') self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid) # Test ns = name_utils.generate_role_namespace(test_role.name, test_role.version) update_us = [ ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'), 'test-key'), ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'), 'test-image'), ] updated_plan = self.plans_manager.set_parameter_values( test_plan.uuid, update_us) # Verify self.assertTrue(updated_plan is not None) self.assertTrue(isinstance(updated_plan, DeploymentPlan)) # Pull it from the database again to make sure it was saved found = self.plans_manager.retrieve_plan(test_plan.uuid) found_params = sorted(found.parameters, key=lambda x: x.name) self.assertEqual(4, len(found_params)) # 3 + 1 for scaling self.assertEqual(found_params[0].value, '1') self.assertEqual(found_params[1].value, 'test-image') self.assertEqual(found_params[2].value, 'm1.small') self.assertEqual(found_params[3].value, 'test-key')
def _add_resource(self, namespace, template, resource_alias): resource = Resource(_generate_resource_id(namespace), resource_alias) for map_me in template.parameters: name = map_me.name master_name = ns_utils.apply_template_namespace(namespace, map_me.name) value = {'get_param': [master_name]} resource_property = ResourceProperty(name, value) resource.add_property(resource_property) # If scaling features are being automatically added in, wrap the # resource in a resource group. The _add_parameters call will add # a corresponding parameter for the count of this resource. if self.add_scaling: group_resource_id = _generate_group_id(resource.resource_id) heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP) count_prop = ResourceProperty( PROPERTY_SCALING_COUNT, {'get_param': [_generate_count_property_name(namespace)]}) heat_group.add_property(count_prop) def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource) heat_group.add_property(def_prop) outer_resource = heat_group else: outer_resource = resource self.master_template.add_resource(outer_resource) return outer_resource
def _add_to_environment(self, namespace, template, filename, resource_alias, override_properties): # Add Parameters for add_me in template.parameters: # For overridden properties, don't add a template property; the # user does not need to specify a value for them. if add_me.name in override_properties: continue name = ns_utils.apply_template_namespace(namespace, add_me.name) param_default = add_me.default if param_default is None: param_default = '' env_parameter = EnvironmentParameter(name, param_default) self.environment.add_parameter(env_parameter) if self.add_scaling: count_param_name = generate_count_property_name(namespace) count_param = EnvironmentParameter(count_param_name, '1') self.environment.add_parameter(count_param) removal_param_name = generate_removal_policies_name(namespace) removal_param = EnvironmentParameter(removal_param_name, []) self.environment.add_parameter(removal_param) # Add Resource Registry Entry registry_entry = RegistryEntry(resource_alias, filename) self.environment.add_registry_entry(registry_entry)
def _add_to_environment(self, namespace, template, filename, resource_alias, override_properties): # Add Parameters for add_me in template.parameters: # For overridden properties, don't add a template property; the # user does not need to specify a value for them. if add_me.name in override_properties: continue name = ns_utils.apply_template_namespace(namespace, add_me.name) param_default = add_me.default if param_default is None: param_default = '' env_parameter = EnvironmentParameter(name, param_default) self.environment.add_parameter(env_parameter) if self.add_scaling: count_param_name = generate_count_property_name(namespace) count_param = EnvironmentParameter(count_param_name, '1') self.environment.add_parameter(count_param) # Add Resource Registry Entry registry_entry = RegistryEntry(resource_alias, filename) self.environment.add_registry_entry(registry_entry)
def _add_resource(self, namespace, template, resource_alias): resource = Resource(_generate_resource_id(namespace), resource_alias) for map_me in template.parameters: name = map_me.name master_name = ns_utils.apply_template_namespace( namespace, map_me.name) value = {'get_param': [master_name]} resource_property = ResourceProperty(name, value) resource.add_property(resource_property) # If scaling features are being automatically added in, wrap the # resource in a resource group. The _add_parameters call will add # a corresponding parameter for the count of this resource. if self.add_scaling: group_resource_id = _generate_group_id(resource.resource_id) heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP) count_prop = ResourceProperty( PROPERTY_SCALING_COUNT, {'get_param': [_generate_count_property_name(namespace)]}) heat_group.add_property(count_prop) def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource) heat_group.add_property(def_prop) outer_resource = heat_group else: outer_resource = resource self.master_template.add_resource(outer_resource) return outer_resource
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_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_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_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 _update_property(check_me): if isinstance(check_me, dict): for k, v in check_me.items(): if k == 'get_param' and v in all_role_property_keys: check_me[k] = ns_utils.apply_template_namespace(namespace, v) else: # It could be a nested dictionary, so recurse further _update_property(v)
def generate_removal_policies_name(namespace): """Generates the name of the property to hold the removal policies for a group. The property will be prefixed by the namespace in the same way as other parameters for the resource. :type namespace: str :rtype: str """ return ns_utils.apply_template_namespace(namespace, 'removal_policies')
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 _update_property(check_me): if isinstance(check_me, dict): for k, v in check_me.items(): if k == 'get_param' and v in all_role_property_keys: check_me[k] = ns_utils.apply_template_namespace( namespace, v) else: # It could be a nested dictionary, so recurse further _update_property(v)
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 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 generate_count_property_name(namespace): """Generates the name of the property to hold the count of a particular resource as identified by its namespace. The count property will be prefixed by the namespace in the same way as other parameters for the resource. :type namespace: str :rtype: str """ return ns_utils.apply_template_namespace(namespace, 'count')
def _generate_count_property_name(namespace): """Generates the name of the property to hold the count of a particular resource as identified by its namespace. The count property will be prefixed by the namespace in the same way as other parameters for the resource. :type namespace: str :rtype: str """ return ns_utils.apply_template_namespace(namespace, 'count')
def test_set_non_existent_parameters(self): # Setup test_role = self._add_test_role() test_plan = self.plans_manager.create_plan('p1', 'd1') self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid) # Test ns = name_utils.generate_role_namespace(test_role.name, test_role.version) not_present_in_role_1_name = ns_utils.apply_template_namespace( ns, 'not_present_in_role_1') not_present_in_role_2_name = ns_utils.apply_template_namespace( ns, 'not_present_in_role_2') update_us = [ ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'), 'test-key'), ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'), 'test-image'), ParameterValue(not_present_in_role_1_name, 'not-present-in-role-1-value'), ParameterValue(not_present_in_role_2_name, 'not-present-in-role-2-value'), ] # Verify exc = self.assertRaises(exception.PlanParametersNotExist, self.plans_manager.set_parameter_values, test_plan.uuid, update_us) self.assertIn(not_present_in_role_1_name, str(exc)) self.assertIn(not_present_in_role_2_name, str(exc)) # Pull it from the database to make sure it was modified found = self.plans_manager.retrieve_plan(test_plan.uuid) found_params = sorted(found.parameters, key=lambda x: x.name) self.assertEqual(4, len(found_params)) # 3 + 1 for scaling self.assertEqual(found_params[0].value, '1') self.assertEqual(found_params[1].value, '3e6270da-fbf7-4aef-bc78-6d0cfc3ad11b') self.assertEqual(found_params[2].value, 'm1.small') self.assertEqual(found_params[3].value, '')
def test_remove_parameters_by_namespace(self): # Setup e = heat.Environment() p1 = heat.EnvironmentParameter( ns.apply_template_namespace('ns1', 'n1'), 'v') p2 = heat.EnvironmentParameter( ns.apply_template_namespace('ns2', 'n2'), 'v') p3 = heat.EnvironmentParameter( ns.apply_template_namespace('ns1', 'n3'), 'v') e.add_parameter(p1) e.add_parameter(p2) e.add_parameter(p3) # Test e.remove_parameters_by_namespace('ns1') # Verify self.assertEqual(1, len(e.parameters)) self.assertEqual(p2, e.parameters[0])
def _add_outputs(self, namespace, template, resource): for add_me in template.outputs: # The output creation is a bit trickier than simply copying the # original. The master output is namespaced like the other pieces, # and it's value is retrieved from the resource that's created in # the master template, but will be present in that resource # under it's original name. output_name = ns_utils.apply_template_namespace(namespace, add_me.name) output_value = {'get_attr': [resource.resource_id, add_me.name]} master_out = Output(output_name, output_value) self.master_template.add_output(master_out)
def test_remove_parameters_by_namespace(self): # Setup e = heat.Environment() p1 = heat.EnvironmentParameter( ns.apply_template_namespace('ns1', 'n1'), 'v') p2 = heat.EnvironmentParameter( ns.apply_template_namespace('ns2', 'n2'), 'v') p3 = heat.EnvironmentParameter( ns.apply_template_namespace('ns1', 'n3'), 'v') e.add_parameter(p1) e.add_parameter(p2) e.add_parameter(p3) # Test e.remove_parameters_by_namespace('ns1') # Verify self.assertEqual(1, len(e.parameters)) self.assertEqual(p2, e.parameters[0])
def _add_outputs(self, namespace, template, resource): for add_me in template.outputs: # The output creation is a bit trickier than simply copying the # original. The master output is namespaced like the other pieces, # and it's value is retrieved from the resource that's created in # the master template, but will be present in that resource # under it's original name. output_name = ns_utils.apply_template_namespace( namespace, add_me.name) output_value = {'get_attr': [resource.resource_id, add_me.name]} master_out = Output(output_name, output_value) self.master_template.add_output(master_out)
def test_set_non_existent_parameters(self): # Setup test_role = self._add_test_role() test_plan = self.plans_manager.create_plan('p1', 'd1') self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid) # Test ns = name_utils.generate_role_namespace(test_role.name, test_role.version) not_present_in_role_1_name = ns_utils.apply_template_namespace( ns, 'not_present_in_role_1') not_present_in_role_2_name = ns_utils.apply_template_namespace( ns, 'not_present_in_role_2') update_us = [ ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'), 'test-key'), ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'), 'test-image'), ParameterValue(not_present_in_role_1_name, 'not-present-in-role-1-value'), ParameterValue(not_present_in_role_2_name, 'not-present-in-role-2-value'), ] # Verify exc = self.assertRaises(exception.PlanParametersNotExist, self.plans_manager.set_parameter_values, test_plan.uuid, update_us) self.assertIn(not_present_in_role_1_name, str(exc)) self.assertIn(not_present_in_role_2_name, str(exc)) # Pull it from the database to make sure it was modified found = self.plans_manager.retrieve_plan(test_plan.uuid) found_params = sorted(found.parameters, key=lambda x: x.name) self.assertEqual(4, len(found_params)) # 3 + 1 for scaling self.assertEqual(found_params[0].value, '1') self.assertEqual(found_params[1].value, '3e6270da-fbf7-4aef-bc78-6d0cfc3ad11b') self.assertEqual(found_params[2].value, 'm1.small') self.assertEqual(found_params[3].value, '')
def _add_parameters(self, namespace, template): for add_me in template.parameters: cloned = copy.deepcopy(add_me) cloned.name = ns_utils.apply_template_namespace( namespace, add_me.name) self.master_template.add_parameter(cloned) # If scaling features are being automatically added in, create the # template parameter for accepting the count for the resource with # this namespace if self.add_scaling: count_param = Parameter(_generate_count_property_name(namespace), 'number') constraint = ParameterConstraint('range', {'min': 1}) count_param.add_constraint(constraint) self.master_template.add_parameter(count_param)
def _add_to_environment(self, namespace, template, filename, resource_alias): # Add Parameters for add_me in template.parameters: name = ns_utils.apply_template_namespace(namespace, add_me.name) env_parameter = EnvironmentParameter(name, add_me.default or '') self.environment.add_parameter(env_parameter) if self.add_scaling: count_param_name = _generate_count_property_name(namespace) count_param = EnvironmentParameter(count_param_name, 1) self.environment.add_parameter(count_param) # Add Resource Registry Entry registry_entry = RegistryEntry(resource_alias, filename) self.environment.add_registry_entry(registry_entry)
def _add_parameters(self, namespace, template): for add_me in template.parameters: cloned = copy.deepcopy(add_me) cloned.name = ns_utils.apply_template_namespace(namespace, add_me.name) self.master_template.add_parameter(cloned) # If scaling features are being automatically added in, create the # template parameter for accepting the count for the resource with # this namespace if self.add_scaling: count_param = Parameter(_generate_count_property_name(namespace), 'number') constraint = ParameterConstraint('range', {'min': '1'}) count_param.add_constraint(constraint) self.master_template.add_parameter(count_param)
def _add_to_environment(self, namespace, template, filename, resource_alias): # Add Parameters for add_me in template.parameters: name = ns_utils.apply_template_namespace(namespace, add_me.name) env_parameter = EnvironmentParameter(name, add_me.default or '') self.environment.add_parameter(env_parameter) if self.add_scaling: count_param_name = _generate_count_property_name(namespace) count_param = EnvironmentParameter(count_param_name, '1') self.environment.add_parameter(count_param) # Add Resource Registry Entry registry_entry = RegistryEntry(resource_alias, filename) self.environment.add_registry_entry(registry_entry)
def _add_resource(self, namespace, template, resource_alias, override_properties): resource = Resource(generate_resource_id(namespace), resource_alias) for map_me in template.parameters: name = map_me.name # If an explicit value is specified, use that. Otherwise, create # a look up within the master template. if name in override_properties: value = override_properties[name] else: master_name = ns_utils.apply_template_namespace( namespace, map_me.name) value = {'get_param': [master_name]} resource_property = ResourceProperty(name, value) resource.add_property(resource_property) # If scaling features are being automatically added in, wrap the # resource in a resource group. The _add_parameters call will add # a corresponding parameter for the count of this resource. if self.add_scaling: group_resource_id = generate_group_id(namespace) heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP) count_prop = ResourceProperty( PROPERTY_SCALING_COUNT, {'get_param': [generate_count_property_name(namespace)]}) heat_group.add_property(count_prop) removal_prop = ResourceProperty( PROPERTY_REMOVAL_POLICIES, {'get_param': [generate_removal_policies_name(namespace)]}) heat_group.add_property(removal_prop) def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource) heat_group.add_property(def_prop) outer_resource = heat_group else: outer_resource = resource self.master_template.add_resource(outer_resource) return outer_resource
def _add_resource(self, namespace, template, resource_alias, override_properties): resource = Resource(generate_resource_id(namespace), resource_alias) for map_me in template.parameters: name = map_me.name # If an explicit value is specified, use that. Otherwise, create # a look up within the master template. if name in override_properties: value = override_properties[name] else: master_name = ns_utils.apply_template_namespace(namespace, map_me.name) value = {'get_param': [master_name]} resource_property = ResourceProperty(name, value) resource.add_property(resource_property) # If scaling features are being automatically added in, wrap the # resource in a resource group. The _add_parameters call will add # a corresponding parameter for the count of this resource. if self.add_scaling: group_resource_id = generate_group_id(namespace) heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP) count_prop = ResourceProperty( PROPERTY_SCALING_COUNT, {'get_param': [generate_count_property_name(namespace)]}) heat_group.add_property(count_prop) def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource) heat_group.add_property(def_prop) outer_resource = heat_group else: outer_resource = resource self.master_template.add_resource(outer_resource) return outer_resource
def _add_parameters(self, namespace, template, override_properties): for add_me in template.parameters: if add_me.name in override_properties: continue cloned = copy.deepcopy(add_me) cloned.name = ns_utils.apply_template_namespace( namespace, add_me.name) self.master_template.add_parameter(cloned) # If scaling features are being automatically added in, create the # template parameters for configuring the group if self.add_scaling: count_param = Parameter(generate_count_property_name(namespace), 'number') constraint = ParameterConstraint('range', {'min': '0'}) count_param.add_constraint(constraint) self.master_template.add_parameter(count_param) removal_param = Parameter( generate_removal_policies_name(namespace), 'json') removal_param.default = [] self.master_template.add_parameter(removal_param)
def test_apply_template_namespace(self): namespaced = namespace.apply_template_namespace('test-ns', 'test-name') self.assertEqual(namespaced, 'test-ns::test-name') self.assertTrue(namespace.matches_template_namespace('test-ns', namespaced))
def test_apply_template_namespace(self): namespaced = namespace.apply_template_namespace('test-ns', 'test-name') self.assertEqual(namespaced, 'test-ns::test-name') self.assertTrue( namespace.matches_template_namespace('test-ns', namespaced))