def test_throws_when_resources_not_all_dicts(self):
template = {"Resources": {"notadict": None, "MyResource": {}}}
with self.assertRaises(InvalidDocumentException):
sam_parser = Parser()
translator = Translator({}, sam_parser)
translator.translate(template, {})
def test_throws_when_resource_not_found(self):
template = {"foo": "bar"}
with self.assertRaises(InvalidDocumentException):
sam_parser = Parser()
translator = Translator({}, sam_parser)
translator.translate(template, {})
def test_throws_when_resource_is_not_dict(self):
template = {"Resources": [1, 2, 3]}
with self.assertRaises(InvalidDocumentException):
sam_parser = Parser()
translator = Translator({}, sam_parser)
translator.translate(template, {})
def __init__(self, sam_template, managed_policy_loader):
"""
Construct a SamTemplateValidator
Design Details:
managed_policy_loader is injected into the `__init__` to allow future expansion
and overriding capabilities. A typically pattern is to pass the name of the class into
the `__init__` as keyword args. As long as the class 'conforms' to the same 'interface'.
This allows the class to be changed by the client and allowing customization of the class being
initialized. Something I had in mind would be allowing a template to be run and checked
'offline' (not needing aws creds). To make this an easier transition in the future, we ingest
the ManagedPolicyLoader class.
Parameters
----------
sam_template dict
Dictionary representing a SAM Template
managed_policy_loader ManagedPolicyLoader
Sam ManagedPolicyLoader
"""
self.sam_template = sam_template
self.managed_policy_loader = managed_policy_loader
self.sam_parser = Parser()
def test_transform_method_must_inject_plugins_when_creating_resources(
self, prepare_plugins_mock, sam_plugins_class_mock,
resource_from_dict_mock):
manifest = {
"Resources": {
"MyTable": {
"Type": "AWS::Serverless::SimpleTable",
"Properties": {}
}
}
}
sam_plugins_object_mock = Mock()
sam_plugins_class_mock.return_value = sam_plugins_object_mock
prepare_plugins_mock.return_value = sam_plugins_object_mock
resource_from_dict_mock.return_value = SamSimpleTable("MyFunction")
initial_plugins = [1, 2, 3]
sam_parser = Parser()
translator = Translator({}, sam_parser, plugins=initial_plugins)
translator.translate(manifest, {})
resource_from_dict_mock.assert_called_with(
"MyTable",
manifest["Resources"]["MyTable"],
sam_plugins=sam_plugins_object_mock)
prepare_plugins_mock.assert_called_once_with(initial_plugins, {
"AWS::Region": "ap-southeast-1",
"AWS::Partition": "aws"
})
def transform(input_fragment, parameter_values, managed_policy_loader):
"""Translates the SAM manifest provided in the and returns the translation to CloudFormation.
:param dict input_fragment: the SAM template to transform
:param dict parameter_values: Parameter values provided by the user
:returns: the transformed CloudFormation template
:rtype: dict
"""
sam_parser = Parser()
translator = Translator(managed_policy_loader.load(), sam_parser)
return translator.translate(input_fragment, parameter_values=parameter_values)
def test_add_default_parameter_values_must_ignore_invalid_template_parameters(
self, template_parameters):
parameter_values = {"Param1": "value1"}
expected = {"Param1": "value1"}
sam_template = {"Parameters": template_parameters}
sam_parser = Parser()
translator = Translator({}, sam_parser)
result = translator._add_default_parameter_values(
sam_template, parameter_values)
self.assertEquals(expected, result)
def __translate(self, parameter_values):
"""
This method is unused and a Work In Progress
"""
template_copy = self.template
sam_parser = Parser()
sam_translator = Translator(managed_policy_map=self.__managed_policy_map(),
sam_parser=sam_parser,
# Default plugins are already initialized within the Translator
plugins=self.extra_plugins)
return sam_translator.translate(sam_template=template_copy,
parameter_values=parameter_values)
def test_add_default_parameter_values_must_merge(self):
parameter_values = {"Param1": "value1"}
sam_template = {
"Parameters": {
"Param2": {
"Type": "String",
"Default": "template default"
}
}
}
expected = {"Param1": "value1", "Param2": "template default"}
sam_parser = Parser()
translator = Translator({}, sam_parser)
result = translator._add_default_parameter_values(
sam_template, parameter_values)
self.assertEquals(expected, result)
def test_add_default_parameter_values_must_skip_params_without_defaults(
self):
parameter_values = {"Param1": "value1"}
sam_template = {
"Parameters": {
"Param1": {
"Type": "String"
},
"Param2": {
"Type": "String"
}
}
}
expected = {"Param1": "value1"}
sam_parser = Parser()
translator = Translator({}, sam_parser)
result = translator._add_default_parameter_values(
sam_template, parameter_values)
self.assertEqual(expected, result)
