Allow "aws cloudformation package" to succeed when a Resource is not a key-value pair

awscli/customizations/cloudformation/artifact_exporter.py

@@ -659,9 +659,23 @@ def export(self):
 
         self.template_dict = self.export_global_artifacts(self.template_dict)
 
-        for resource_id, resource in self.template_dict["Resources"].items():
+        self.export_resources(self.template_dict["Resources"])
+
+        return self.template_dict
+
+    def export_resources(self, resource_dict):
+        for resource_id, resource in resource_dict.items():
+
+            if resource_id.startswith("Fn::ForEach"):
+                if not isinstance(resource, list) or len(resource) < 3:
+                    raise ValueError("Fn::ForEach with name {0} has invalid format".format(resource_id))
+                if isinstance(resource[2], dict):
+                    self.export_resources(resource[2])
+                continue
 
             resource_type = resource.get("Type", None)
+            if resource_type is None:
+                continue
             resource_dict = resource.get("Properties", None)
 
             for exporter_class in self.resources_to_export:
@@ -671,5 +685,3 @@ def export(self):
                 # Export code resources
                 exporter = exporter_class(self.uploader)
                 exporter.export(resource_id, resource_dict, self.template_dir)
-
-        return self.template_dict

tests/unit/customizations/cloudformation/test_artifact_exporter.py

@@ -1016,6 +1016,151 @@ def test_template_export(self, yaml_parse_mock):
             resource_type2_instance.export.assert_called_once_with(
                 "Resource2", mock.ANY, template_dir)
 
+    @mock.patch("awscli.customizations.cloudformation.artifact_exporter.yaml_parse")
+    def test_template_export_foreach_valid(self, yaml_parse_mock):
+        parent_dir = os.path.sep
+        template_dir = os.path.join(parent_dir, 'foo', 'bar')
+        template_path = os.path.join(template_dir, 'path')
+        template_str = self.example_yaml_template()
+
+        resource_type1_class = mock.Mock()
+        resource_type1_class.RESOURCE_TYPE = "resource_type1"
+        resource_type1_instance = mock.Mock()
+        resource_type1_class.return_value = resource_type1_instance
+        resource_type2_class = mock.Mock()
+        resource_type2_class.RESOURCE_TYPE = "resource_type2"
+        resource_type2_instance = mock.Mock()
+        resource_type2_class.return_value = resource_type2_instance
+
+        resources_to_export = [
+            resource_type1_class,
+            resource_type2_class
+        ]
+
+        properties = {"foo": "bar"}
+        template_dict = {
+            "Resources": {
+                "Resource1": {
+                    "Type": "resource_type1",
+                    "Properties": properties
+                },
+                "Resource2": {
+                    "Type": "resource_type2",
+                    "Properties": properties
+                },
+                "Resource3": {
+                    "Type": "some-other-type",
+                    "Properties": properties
+                },
+                "Fn::ForEach::OuterLoopName": [
+                    "Identifier1",
+                    ["4", "5"],
+                    {
+                        "Fn::ForEach::InnerLoopName": [
+                            "Identifier2",
+                            ["6", "7"],
+                            {
+                                "Resource${Identifier1}${Identifier2}": {
+                                    "Type": "resource_type2",
+                                    "Properties": properties
+                                }
+                            }
+                        ],
+                        "Resource${Identifier1}": {
+                            "Type": "resource_type1",
+                            "Properties": properties
+                        }
+                    }
+                ]
+            }
+        }
+
+        open_mock = mock.mock_open()
+        yaml_parse_mock.return_value = template_dict
+
+        # Patch the file open method to return template string
+        with mock.patch(
+                "awscli.customizations.cloudformation.artifact_exporter.open",
+                open_mock(read_data=template_str)) as open_mock:
+
+            template_exporter = Template(
+                template_path, parent_dir, self.s3_uploader_mock,
+                resources_to_export)
+            exported_template = template_exporter.export()
+            self.assertEqual(exported_template, template_dict)
+
+            open_mock.assert_called_once_with(
+                    make_abs_path(parent_dir, template_path), "r")
+
+            self.assertEqual(1, yaml_parse_mock.call_count)
+
+            resource_type1_class.assert_called_with(self.s3_uploader_mock)
+            resource_type1_instance.export.assert_called_with(
+                "Resource${Identifier1}", mock.ANY, template_dir)
+            resource_type2_class.assert_called_with(self.s3_uploader_mock)
+            resource_type2_instance.export.assert_called_with(
+                "Resource${Identifier1}${Identifier2}", mock.ANY, template_dir)
+
+    @mock.patch("awscli.customizations.cloudformation.artifact_exporter.yaml_parse")
+    def test_template_export_foreach_invalid(self, yaml_parse_mock):
+        parent_dir = os.path.sep
+        template_dir = os.path.join(parent_dir, 'foo', 'bar')
+        template_path = os.path.join(template_dir, 'path')
+        template_str = self.example_yaml_template()
+
+        resource_type1_class = mock.Mock()
+        resource_type1_class.RESOURCE_TYPE = "resource_type1"
+        resource_type1_instance = mock.Mock()
+        resource_type1_class.return_value = resource_type1_instance
+        resource_type2_class = mock.Mock()
+        resource_type2_class.RESOURCE_TYPE = "resource_type2"
+        resource_type2_instance = mock.Mock()
+        resource_type2_class.return_value = resource_type2_instance
+
+        resources_to_export = [
+            resource_type1_class,
+            resource_type2_class
+        ]
+
+        properties = {"foo": "bar"}
+        template_dict = {
+            "Resources": {
+                "Resource1": {
+                    "Type": "resource_type1",
+                    "Properties": properties
+                },
+                "Resource2": {
+                    "Type": "resource_type2",
+                    "Properties": properties
+                },
+                "Resource3": {
+                    "Type": "some-other-type",
+                    "Properties": properties
+                },
+                "Fn::ForEach::OuterLoopName": [
+                    "Identifier1",
+                    {
+                        "Resource${Identifier1}": {
+                        }
+                    }
+                ]
+            }
+        }
+
+        open_mock = mock.mock_open()
+        yaml_parse_mock.return_value = template_dict
+
+        # Patch the file open method to return template string
+        with mock.patch(
+                "awscli.customizations.cloudformation.artifact_exporter.open",
+                open_mock(read_data=template_str)) as open_mock:
+            template_exporter = Template(
+                template_path, parent_dir, self.s3_uploader_mock,
+                resources_to_export)
+            with self.assertRaises(ValueError):
+                template_exporter.export()
+
+
     @mock.patch("awscli.customizations.cloudformation.artifact_exporter.yaml_parse")
     def test_template_global_export(self, yaml_parse_mock):
         parent_dir = os.path.sep