cloud-radar 0.14.0a8__py3-none-any.whl → 0.14.0a9__py3-none-any.whl

cloud_radar/cf/unit/_template.py

@@ -81,6 +81,7 @@ class Template:
         self.transforms: Optional[Union[str, List[str]]] = self.template.get(
             "Transform", None
         )
+        self.allowed_functions: functions.Dispatch = self.load_allowed_functions()
 
         # All loaded, validate against any template level hooks
         # that have been configured
@@ -207,7 +208,7 @@ class Template:
             # If we get this far then we do not support this type of configuration file
             raise ValueError("Parameter file is not in a supported format")
 
-    def load_allowed_functions(self) -> functions.Dispatch:
+    def load_allowed_functions(self):
         """Loads the allowed functions for this template.
 
         Raises:
@@ -231,8 +232,9 @@ class Template:
             return {**functions.ALL_FUNCTIONS, **transform_functions}
 
         if isinstance(self.transforms, list):
-            # dict of transform functions
+
             transform_functions = {}
+
             for transform in self.transforms:
                 if transform not in functions.TRANSFORMS:
                     raise ValueError(f"Transform {transform} not supported")
@@ -249,13 +251,8 @@ class Template:
     def render_all_sections(self, template: Dict[str, Any]) -> Dict[str, Any]:
         """Solves all conditionals, references and pseudo variables for all sections"""
 
-        allowed_functions = self.load_allowed_functions()
-
         if "Conditions" in template:
-            template["Conditions"] = self.resolve_values(
-                template["Conditions"],
-                allowed_functions,
-            )
+            template["Conditions"] = self.resolve_values(template["Conditions"])
 
         template_sections = ["Resources", "Outputs"]
 
@@ -278,10 +275,7 @@ class Template:
                     if not condition_value:
                         continue
 
-                template[section][r_name] = self.resolve_values(
-                    r_value,
-                    allowed_functions,
-                )
+                template[section][r_name] = self.resolve_values(r_value)
 
         return template
 
@@ -346,7 +340,6 @@ class Template:
     def resolve_values(  # noqa: max-complexity: 13
         self,
         data: Any,
-        allowed_func: functions.Dispatch,
     ) -> Any:
         """Recurses through a Cloudformation template. Solving all
         references and variables along the way.
@@ -366,10 +359,7 @@ class Template:
                 # This takes care of keys that not intrinsic functions,
                 #  except for the condition func
                 if "Fn::" not in key and key != "Condition":
-                    data[key] = self.resolve_values(
-                        value,
-                        allowed_func,
-                    )
+                    data[key] = self.resolve_values(value)
                     continue
 
                 # Takes care of the tricky 'Condition' key
@@ -387,21 +377,15 @@ class Template:
                         return functions.condition(self, value)
 
                     # Normal key like in an IAM role
-                    data[key] = self.resolve_values(
-                        value,
-                        allowed_func,
-                    )
+                    data[key] = self.resolve_values(value)
                     continue
 
-                if key not in allowed_func:
+                if key not in self.allowed_functions:
                     raise ValueError(f"{key} with value ({value}) not allowed here")
 
-                value = self.resolve_values(
-                    value,
-                    functions.ALLOWED_FUNCTIONS[key],
-                )
+                value = self.resolve_values(value)
 
-                funct_result = allowed_func[key](self, value)
+                funct_result = self.allowed_functions[key](self, value)
 
                 if isinstance(funct_result, str):
                     # If the result is a string then process any
@@ -412,13 +396,7 @@ class Template:
 
             return data
         elif isinstance(data, list):
-            return [
-                self.resolve_values(
-                    item,
-                    allowed_func,
-                )
-                for item in data
-            ]
+            return [self.resolve_values(item) for item in data]
         elif isinstance(data, str):
             return self.resolve_dynamic_references(data)
         else:

cloud_radar/cf/unit/functions.py

@@ -283,9 +283,7 @@ def condition(template: "Template", name: Any) -> bool:
     condition_value = template.template["Conditions"][name]
 
     if not isinstance(condition_value, bool):
-        condition_value: bool = template.resolve_values(  # type: ignore
-            condition_value, allowed_func=ALLOWED_NESTED_CONDITIONS
-        )
+        condition_value: bool = template.resolve_values(condition_value)  # type: ignore
 
     return condition_value
 
@@ -942,106 +940,6 @@ ALL_FUNCTIONS: Dispatch = {
     **INTRINSICS,
 }
 
-ALLOWED_NESTED_CONDITIONS: Dispatch = {
-    "Fn::FindInMap": find_in_map,
-    "Ref": ref,
-    **CONDITIONS,
-}
-
-# Cloudformation only allows certain functions to be called from inside
-# other functions. The keys are the function name and the values are the
-# functions that are allowed to be nested inside it.
-ALLOWED_FUNCTIONS: Dict[str, Dispatch] = {
-    "Fn::And": ALLOWED_NESTED_CONDITIONS,
-    "Fn::Equals": {**ALLOWED_NESTED_CONDITIONS, "Fn::Join": join, "Fn::Select": select},
-    "Fn::If": {
-        "Fn::Base64": base64,
-        "Fn::FindInMap": find_in_map,
-        "Fn::GetAtt": get_att,
-        "Fn::GetAZs": get_azs,
-        "Fn::If": if_,
-        "Fn::Join": join,
-        "Fn::Select": select,
-        "Fn::Sub": sub,
-        "Ref": ref,
-        "Fn::ImportValue": import_value,
-    },
-    "Fn::Not": ALLOWED_NESTED_CONDITIONS,
-    "Fn::Or": ALLOWED_NESTED_CONDITIONS,
-    "Condition": {},  # Only allows strings
-    "Fn::Base64": ALL_FUNCTIONS,
-    "Fn::Cidr": {
-        "Fn::Select": select,
-        "Ref": ref,
-    },
-    "Fn::FindInMap": {
-        "Fn::FindInMap": find_in_map,
-        "Ref": ref,
-    },
-    "Fn::GetAtt": {},  # This one is complicated =/
-    "Fn::GetAZs": {
-        "Ref": ref,
-    },
-    "Fn::ImportValue": {
-        "Fn::Base64": base64,
-        "Fn::FindInMap": find_in_map,
-        "Fn::If": if_,
-        "Fn::Join": join,
-        "Fn::Select": select,
-        "Fn::Split": split,
-        "Fn::Sub": sub,
-        "Ref": ref,
-    },  # Import value can't depend on resources (not implemented)
-    "Fn::Join": {
-        "Fn::Base64": base64,
-        "Fn::FindInMap": find_in_map,
-        "Fn::GetAtt": get_att,
-        "Fn::GetAZs": get_azs,
-        "Fn::If": if_,
-        "Fn::ImportValue": import_value,
-        "Fn::Join": join,
-        "Fn::Split": split,
-        "Fn::Select": select,
-        "Fn::Sub": sub,
-        "Ref": ref,
-    },
-    "Fn::Select": {
-        "Fn::FindInMap": find_in_map,
-        "Fn::GetAtt": get_att,
-        "Fn::GetAZs": get_azs,
-        "Fn::If": if_,
-        "Fn::Split": split,
-        "Ref": ref,
-    },
-    "Fn::Split": {
-        "Fn::Base64": base64,
-        "Fn::FindInMap": find_in_map,
-        "Fn::GetAtt": get_att,
-        "Fn::GetAZs": get_azs,
-        "Fn::If": if_,
-        "Fn::ImportValue": import_value,
-        "Fn::Join": join,
-        "Fn::Split": split,
-        "Fn::Select": select,
-        "Fn::Sub": sub,
-        "Ref": ref,
-    },
-    "Fn::Sub": {
-        "Fn::Base64": base64,
-        "Fn::FindInMap": find_in_map,
-        "Fn::GetAtt": get_att,
-        "Fn::GetAZs": get_azs,
-        "Fn::If": if_,
-        "Fn::ImportValue": import_value,
-        "Fn::Join": join,
-        "Fn::Select": select,
-        "Ref": ref,
-        "Fn::Sub": sub,
-    },
-    "Fn::Transform": {},  # Transform isn't fully implemented
-    "Ref": {},  # String only.
-}
-
 # Extra functions that are allowed if the template is using a transform.
 TRANSFORMS: Dict[str, Dispatch] = {
     "AWS::CodeDeployBlueGreen": {},

cloud_radar/cf/unit/test__template.py

@@ -7,40 +7,38 @@ from cloud_radar.cf.unit._template import Template
 
 def test_load_allowed_functions_no_transforms():
     template = Template({})
-    result = template.load_allowed_functions()
-    assert result == functions.ALL_FUNCTIONS
+    template.load_allowed_functions()
+    assert template.allowed_functions == functions.ALL_FUNCTIONS
 
 
 def test_load_allowed_functions_single_transform():
     template = Template({"Transform": "AWS::Serverless-2016-10-31"})
-    result = template.load_allowed_functions()
+    template.load_allowed_functions()
     expected = {
         **functions.ALL_FUNCTIONS,
         **functions.TRANSFORMS["AWS::Serverless-2016-10-31"],
     }
-    assert result == expected
+    assert template.allowed_functions == expected
 
 
 def test_load_allowed_functions_multiple_transforms():
     template = Template({"Transform": ["AWS::Serverless-2016-10-31", "AWS::Include"]})
-    result = template.load_allowed_functions()
+    template.load_allowed_functions()
     expected = {
         **functions.ALL_FUNCTIONS,
         **functions.TRANSFORMS["AWS::Serverless-2016-10-31"],
         **functions.TRANSFORMS["AWS::Include"],
     }
-    assert result == expected
+    assert template.allowed_functions == expected
 
 
 def test_load_allowed_functions_invalid_transform():
-    template = Template({"Transform": "InvalidTransform"})
+
     with pytest.raises(ValueError):
-        template.load_allowed_functions()
+        Template({"Transform": "InvalidTransform"})
 
 
 def test_load_allowed_functions_invalid_transforms():
-    template = Template(
-        {"Transform": ["AWS::Serverless-2016-10-31", "InvalidTransform"]}
-    )
+
     with pytest.raises(ValueError):
-        template.load_allowed_functions()
+        Template({"Transform": ["AWS::Serverless-2016-10-31", "InvalidTransform"]})

{cloud_radar-0.14.0a8.dist-info → cloud_radar-0.14.0a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cloud-radar
-Version: 0.14.0a8
+Version: 0.14.0a9
 Summary: Run functional tests on cloudformation stacks.
 License: Apache-2.0
 Keywords: aws,cloudformation,cloud-radar,testing,taskcat,cloud,radar

{cloud_radar-0.14.0a8.dist-info → cloud_radar-0.14.0a9.dist-info}/RECORD

@@ -9,10 +9,10 @@ cloud_radar/cf/unit/_output.py,sha256=rhQQ4aJu06bxAoG7GOXkuOPzAmLCrTA2Ytb8rNXA4V
 cloud_radar/cf/unit/_parameter.py,sha256=AdPIqc2ggSW1VR0USF30zjphX3z1HHbGKQt8n-Kzhfo,3199
 cloud_radar/cf/unit/_resource.py,sha256=dWaR-5s6ea5mIu6Dhf1hY31Wd4WLHbHsbyxnu2Tz6QI,8512
 cloud_radar/cf/unit/_stack.py,sha256=_S0L9O7Lw-QAJDKubClp2b6UYtYfyzg272_7WQkUdo8,5785
-cloud_radar/cf/unit/_template.py,sha256=ESpor5rputwtCKJuvlfp_M0VUuYrciRaLNE8TfdqhRU,32782
-cloud_radar/cf/unit/functions.py,sha256=iWBhc9JmyObusAAZ2iAXf7dXof36mdqoHOLR4UzuC58,29234
-cloud_radar/cf/unit/test__template.py,sha256=jVPMJTn6Q0sSZ8BjRGyutuR9-NjdHdwDTVsd2kvjQbs,1491
-cloud_radar-0.14.0a8.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cloud_radar-0.14.0a8.dist-info/METADATA,sha256=7Wq8pX3tWCJa_Np9l6NKLb9yclnwFGLcSzVG1h1D-hc,16784
-cloud_radar-0.14.0a8.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-cloud_radar-0.14.0a8.dist-info/RECORD,,
+cloud_radar/cf/unit/_template.py,sha256=RSZjqD0FgBYMgyZb_KUkIOaO_mTODLJH9czvhZ_ii3U,32196
+cloud_radar/cf/unit/functions.py,sha256=NSJh14wJK4dmTibmGqB0aK_kAP1RFW9RjdkZZsD11tc,26332
+cloud_radar/cf/unit/test__template.py,sha256=nHc9WziIeGDo0d-rsn3HV4X7BsoKmwwHUxcp3qzuZo8,1414
+cloud_radar-0.14.0a9.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cloud_radar-0.14.0a9.dist-info/METADATA,sha256=C9i9uowVgleXdUvo0i9lrmbwlSZ9SudJPIEYBCChQGA,16784
+cloud_radar-0.14.0a9.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+cloud_radar-0.14.0a9.dist-info/RECORD,,