def test_transform_template_raises_exception_on_embedded_reference(self):
        template_dict = {
            'key1': {"foo": ["|foo|foo", "b"]}
        }

        with self.assertRaises(TemplateErrorException):
            CloudFormationTemplateTransformer.transform_template(CloudFormationTemplate(template_dict, 'foo'))
    def test_transform_template_raises_exception_on_unknown_at_reference_key(self):
        template_dict = {
            '@foo@': "foo"
        }

        with self.assertRaises(TemplateErrorException):
            CloudFormationTemplateTransformer.transform_template(CloudFormationTemplate(template_dict, 'foo'))
コード例 #3
0
ファイル: main.py プロジェクト: transacid/cfn-sphere
    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)

            template_url = stack_config.template_url
            working_dir = stack_config.working_dir

            template = CloudFormationTemplateLoader.get_template_from_url(template_url, working_dir)
            template = CloudFormationTemplateTransformer.transform_template(template)

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

            stack = CloudFormationStack(template, parameters, stack_name, self.region, stack_config.timeout)

            if stack_name in existing_stacks:

                self.cfn.validate_stack_is_ready_for_updates(stack_name)
                self.cfn.update_stack(stack)
            else:
                self.cfn.create_stack(stack)

            CustomResourceHandler.process_post_resources(stack)
    def test_transform_template_transforms_join_with_embedded_ref(self):
        template_dict = {
            'key1': {"|join|.": ["|ref|foo", "b"]}
        }

        result = CloudFormationTemplateTransformer.transform_template(CloudFormationTemplate(template_dict, 'foo'))
        expected = {'key1': {'Fn::Join': ['.', [{'Ref': 'foo'}, 'b']]}}

        self.assertEqual(expected, result.body_dict)
    def test_transform_template_transforms_dict_list_items(self):
        template_dict = {
            'key1': {'key2': [{'key3': 'value3', 'foo': {'|Join|': ['a', 'b']}}]}
        }

        result = CloudFormationTemplateTransformer.transform_template(CloudFormationTemplate(template_dict, 'foo'))
        expected = {'key1': {'key2': [{'foo': {'Fn::Join': ['', ['a', 'b']]}, 'key3': 'value3'}]}}

        self.assertEqual(expected, result.body_dict)
    def test_transform_template_transforms_list_values(self):
        template_dict = {
            'key1': ["|ref|foo", "a", "b"]
        }

        result = CloudFormationTemplateTransformer.transform_template(CloudFormationTemplate(template_dict, 'foo'))
        expected = {'key1': [{'Ref': 'foo'}, 'a', 'b']}

        self.assertEqual(expected, result.body_dict)
    def test_transform_template_properly_renders_dict(self):
        template_dict = {
            'key1': '|ref|value',
            'key2': '|getatt|resource|attribute',
            '@TaupageUserData@':
                {
                    'key1': 'value',
                    'key2': {'ref': 'value'},
                    'key3': {'|join|.': ['a', 'b', 'c']}
                }
        }

        result = CloudFormationTemplateTransformer.transform_template(CloudFormationTemplate(template_dict, 'foo'))
        expected = {
            "key1": {
                "Ref": "value"
            },
            "key2": {
                "Fn::GetAtt": [
                    "resource",
                    "attribute"
                ]
            },
            "UserData": {
                "Fn::Base64": {
                    "Fn::Join": [
                        "\n",
                        [
                            "#taupage-ami-config",
                            {
                                "Fn::Join": [
                                    ": ",
                                    [
                                        "key1",
                                        "value"
                                    ]
                                ]
                            },
                            {
                                "Fn::Join": [
                                    ": ",
                                    [
                                        "key2",
                                        {
                                            "ref": "value"
                                        }
                                    ]
                                ]
                            },
                            {
                                "Fn::Join": [
                                    ": ",
                                    [
                                        "key3",
                                        {
                                            "Fn::Join": [
                                                ".",
                                                [
                                                    "a",
                                                    "b",
                                                    "c"
                                                ]
                                            ]
                                        }
                                    ]
                                ]
                            }
                        ]
                    ]
                }
            }
        }

        self.assertEqual(expected, result.body_dict)