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)