Python parameter_resolver.ParameterResolver类代码示例

    def test_get_latest_value_returns_default_value(self):
        self.cfn_mock.return_value.get_stack_parameters_dict.side_effect = CfnSphereBotoError(
            BotoServerError("500", "foo")
        )

        resolver = ParameterResolver()
        with self.assertRaises(CfnSphereException):
            resolver.get_latest_value("my-key", "|keepOrUse|default-value", "my-stack")

    def test_get_latest_value_returns_default_value_called_once_with_stack(self):
        self.cfn_mock.return_value.get_stack_parameters_dict.return_value = {"not-my-key": "my-actual-value"}

        pr = ParameterResolver()
        result = pr.get_latest_value("my-key", "|keepOrUse|default-value", "my-stack")

        self.cfn_mock.return_value.get_stack_parameters_dict.assert_called_once_with("my-stack")
        self.assertEqual("default-value", result)

    def test_get_latest_value_returns_stacks_actual_value(self, kms,  ec2_api, cfn_mock):
        cfn_mock.return_value.get_stack_parameters_dict.return_value = {'my-key': 'my-actual-value'}

        pr = ParameterResolver()
        result = pr.get_latest_value('my-key', '|keepOrUse|default-value', 'my-stack')

        cfn_mock.return_value.get_stack_parameters_dict.assert_called_once_with('my-stack')
        self.assertEqual('my-actual-value', result)

class StackActionHandler(object):
    def __init__(self, config):
        self.logger = get_logger(root=True)
        self.config = config
        self.cfn = CloudFormation(region=self.config.region)
        self.parameter_resolver = ParameterResolver(region=self.config.region)
        self.cli_parameters = config.cli_params

    def create_or_update_stacks(self):
        existing_stacks = self.cfn.get_stack_names()
        desired_stacks = self.config.stacks
        stack_processing_order = DependencyResolver().get_stack_order(desired_stacks)

        if len(stack_processing_order) > 1:
            self.logger.info(
                "Will process stacks in the following order: {0}".format(", ".join(stack_processing_order)))

        for stack_name in stack_processing_order:
            stack_config = self.config.stacks.get(stack_name)

            raw_template = FileLoader.get_file_from_url(stack_config.template_url, stack_config.working_dir)
            template = CloudFormationTemplateTransformer.transform_template(raw_template)

            parameters = self.parameter_resolver.resolve_parameter_values(stack_config.parameters, stack_name)

            merged_parameters = self.parameter_resolver.update_parameters_with_cli_parameters(
                parameters=parameters,
                cli_parameters=self.cli_parameters,
                stack_name=stack_name)

            stack = CloudFormationStack(template=template, parameters=merged_parameters, tags=self.config.tags,
                                        name=stack_name, region=self.config.region, timeout=stack_config.timeout)

            if stack_name in existing_stacks:

                self.cfn.validate_stack_is_ready_for_action(stack)
                self.cfn.update_stack(stack)
            else:
                self.cfn.create_stack(stack)

            CustomResourceHandler.process_post_resources(stack)

    def delete_stacks(self):
        existing_stacks = self.cfn.get_stack_names()
        stacks = self.config.stacks

        stack_processing_order = DependencyResolver().get_stack_order(stacks)
        stack_processing_order.reverse()

        self.logger.info("Will delete stacks in the following order: {0}".format(", ".join(stack_processing_order)))

        for stack_name in stack_processing_order:
            if stack_name in existing_stacks:
                stack = CloudFormationStack(None, None, stack_name, None, None)
                self.cfn.validate_stack_is_ready_for_action(stack)
                self.cfn.delete_stack(stack)
            else:
                self.logger.info("Stack {0} is already deleted".format(stack_name))

    def test_handle_file_value_loads_file_for_reference_with_pattern(self, get_yaml_or_json_file_mock):
        get_yaml_or_json_file_mock.return_value = {"accounts": [{"id": 1}, {"id": 2}, {"id": 3}]}

        result = ParameterResolver.handle_file_value("|file|s3://myBucket/myAwsAccounts.json|accounts[*].id", None)

        get_yaml_or_json_file_mock.assert_called_once_with("s3://myBucket/myAwsAccounts.json", None)
        self.assertEqual([1, 2, 3], result)

    def test_handle_file_value_loads_file_for_simple_file_reference(self, get_file_mock):
        get_file_mock.return_value = "myValue"

        result = ParameterResolver.handle_file_value("|file|s3://myBucket/myParameter.txt", None)

        get_file_mock.assert_called_once_with("s3://myBucket/myParameter.txt", None)
        self.assertEqual("myValue", result)

 def test_is_keep_value_returns_false_for_empty_value(self):
     result = ParameterResolver.is_keep_value('')
     self.assertFalse(result)

 def test_is_keep_value_returns_true_for_mixed_case_keep_keyword(self):
     result = ParameterResolver.is_keep_value('|keepOrUse|')
     self.assertTrue(result)

 def test_is_keep_value_returns_true_for_uppercase_keep_keyword(self):
     result = ParameterResolver.is_keep_value('|KEEPORUSE|')
     self.assertTrue(result)

    def test_get_latest_value_raises_exception_on_error(self):
        self.cfn_mock.return_value.get_stack_parameters_dict.side_effect = CfnSphereBotoError(Exception("foo"))

        resolver = ParameterResolver()
        with self.assertRaises(CfnSphereException):
            resolver.get_latest_value('my-key', '|keepOrUse|default-value', 'my-stack')

 def test_get_default_from_keep_value_returns_proper_string(self):
     result = ParameterResolver.get_default_from_keep_value("|keepOrUse|foo")
     self.assertEqual("foo", result)

 def test_is_keep_value_returns_true_for_keep_keyword(self):
     result = ParameterResolver.is_keep_value("|keeporuse|")
     self.assertTrue(result)

 def test_convert_list_to_string_returns_empty_list_on_empty_list(self):
     self.assertEqual("", ParameterResolver.convert_list_to_string([]))

 def test_convert_list_to_string_returns_valid_string(self):
     list = ['a', 'b', 'c']
     self.assertEqual("a,b,c", ParameterResolver.convert_list_to_string(list))

 def test_get_default_from_keep_value_returns_proper_string_if_it_contains_separator(self):
     result = ParameterResolver.get_default_from_keep_value('|keepOrUse|foo|foo.de')
     self.assertEqual('foo|foo.de', result)