def test_is_valid_raises_exception(self, sam_parser, sam_translator):
managed_policy_mock = Mock()
managed_policy_mock.load.return_value = {"policy": "SomePolicy"}
template = {"a": "b"}
parser = Mock()
sam_parser.Parser.return_value = parser
translate_mock = Mock()
translate_mock.translate.side_effect = InvalidDocumentException(
[Exception("message")])
sam_translator.return_value = translate_mock
validator = SamTemplateValidator(template, managed_policy_mock)
with self.assertRaises(InvalidSamDocumentException):
validator.is_valid()
sam_translator.assert_called_once_with(
managed_policy_map={"policy": "SomePolicy"},
sam_parser=parser,
plugins=[])
translate_mock.translate.assert_called_once_with(sam_template=template,
parameter_values={})
sam_parser.Parser.assert_called_once()
def on_before_transform_template(self, template_dict):
"""
Hook method that runs before a template gets transformed. In this method, we parse and process Globals section
from the template (if present).
:param dict template_dict: SAM template as a dictionary
"""
try:
global_section = Globals(template_dict)
except InvalidGlobalsSectionException as ex:
raise InvalidDocumentException([ex])
# For each resource in template, try and merge with Globals if necessary
template = SamTemplate(template_dict)
for logicalId, resource in template.iterate():
resource.properties = global_section.merge(resource.type,
resource.properties)
template.set(logicalId, resource)
# Remove the Globals section from template if necessary
Globals.del_section(template_dict)
# If there was a global openApiVersion flag, check and convert swagger
# to the right version
Globals.fix_openapi_definitions(template_dict)
def on_before_transform_template(self, template_dict):
"""
Hook method that gets called before the SAM template is processed.
The template has pass the validation and is guaranteed to contain a non-empty "Resources" section.
:param dict template_dict: Dictionary of the SAM template
:return: Nothing
"""
template = SamTemplate(template_dict)
# Temporarily add Serverless::Api resource corresponding to Implicit API to the template.
# This will allow the processing code to work the same way for both Implicit & Explicit APIs
# If there are no implicit APIs, we will remove from the template later.
# If the customer has explicitly defined a resource with the id of "ServerlessRestApi",
# capture it. If the template ends up not defining any implicit api's, instead of just
# removing the "ServerlessRestApi" resource, we just restore what the author defined.
self.existing_implicit_api_resource = copy.deepcopy(
template.get(self.implicit_api_logical_id))
template.set(self.implicit_api_logical_id,
self._generate_implicit_api_resource())
errors = []
for logicalId, resource in template.iterate({
SamResourceType.Function.value,
SamResourceType.StateMachine.value
}):
api_events = self._get_api_events(resource)
condition = resource.condition
deletion_policy = resource.deletion_policy
update_replace_policy = resource.update_replace_policy
if len(api_events) == 0:
continue
try:
self._process_api_events(resource, api_events, template,
condition, deletion_policy,
update_replace_policy)
except InvalidEventException as ex:
errors.append(InvalidResourceException(logicalId, ex.message))
self._maybe_add_condition_to_implicit_api(template_dict)
self._maybe_add_deletion_policy_to_implicit_api(template_dict)
self._maybe_add_update_replace_policy_to_implicit_api(template_dict)
self._maybe_add_conditions_to_implicit_api_paths(template)
self._maybe_remove_implicit_api(template)
if len(errors) > 0:
raise InvalidDocumentException(errors)