def setUp(self):
self.plugin = ImplicitRestApiPlugin()
# Mock all methods but the one we are testing
self.plugin._get_api_events = Mock()
self.plugin._process_api_events = Mock()
self.plugin._maybe_remove_implicit_api = Mock()
class TestImplicitRestApiPlugin_add_implicit_api_id_if_necessary(TestCase):
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
def test_must_add_if_not_present(self):
input = {"a": "b"}
expected = {"a": "b", "RestApiId": {"Ref": IMPLICIT_API_LOGICAL_ID}}
self.plugin._add_implicit_api_id_if_necessary(input)
self.assertEqual(input, expected)
def test_must_skip_if_present(self):
input = {"a": "b", "RestApiId": "Something"}
expected = {"a": "b", "RestApiId": "Something"}
self.plugin._add_implicit_api_id_if_necessary(input)
self.assertEqual(input, expected)
class TestImplicitApiPlugin_generate_resource_attributes(TestCase):
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
self.plugin.api_conditions = {}
def test_maybe_add_condition(self):
template_dict = {"Resources": {"ServerlessRestApi": {"Type": "AWS::Serverless::Api"}}}
self.plugin.api_conditions = {"ServerlessRestApi": {"/{proxy+}": {"any": "C1"}}}
self.plugin._maybe_add_condition_to_implicit_api(template_dict)
print(template_dict)
self.assertEqual(
template_dict, {"Resources": {"ServerlessRestApi": {"Type": "AWS::Serverless::Api", "Condition": "C1"}}}
)
def test_maybe_add_deletion_policies(self):
template_dict = {"Resources": {"ServerlessRestApi": {"Type": "AWS::Serverless::Api"}}}
self.plugin.api_deletion_policies = {"ServerlessRestApi": {"Delete", "Retain"}}
self.plugin._maybe_add_deletion_policy_to_implicit_api(template_dict)
print(template_dict)
self.assertEqual(
template_dict,
{"Resources": {"ServerlessRestApi": {"Type": "AWS::Serverless::Api", "DeletionPolicy": "Retain"}}},
)
def test_maybe_add_update_replace_policies(self):
template_dict = {"Resources": {"ServerlessRestApi": {"Type": "AWS::Serverless::Api"}}}
self.plugin.api_update_replace_policies = {"ServerlessRestApi": {"Snapshot", "Retain"}}
self.plugin._maybe_add_update_replace_policy_to_implicit_api(template_dict)
print(template_dict)
self.assertEqual(
template_dict,
{"Resources": {"ServerlessRestApi": {"Type": "AWS::Serverless::Api", "UpdateReplacePolicy": "Retain"}}},
)
class TestImplicitRestApiPlugin_maybe_remove_implicit_api(TestCase):
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
def test_must_remove_if_no_path_present(self):
resource = SamResource({"Type": "AWS::Serverless::Api", "Properties": {"DefinitionBody": {"paths": {}}}})
template = Mock()
template.get = Mock()
template.delete = Mock()
template.get.return_value = resource
self.plugin._maybe_remove_implicit_api(template)
template.get.assert_called_with(IMPLICIT_API_LOGICAL_ID)
template.delete.assert_called_with(IMPLICIT_API_LOGICAL_ID)
def test_must_skip_if_path_present(self):
resource = SamResource(
{"Type": "AWS::Serverless::Api", "Properties": {"DefinitionBody": {"paths": {"a": "b"}}}}
)
template = Mock()
template.get = Mock()
template.delete = Mock()
template.get.return_value = resource
self.plugin._maybe_remove_implicit_api(template)
template.get.assert_called_with(IMPLICIT_API_LOGICAL_ID)
# Must not delete
template.delete.assert_not_called()
def test_must_restore_if_existing_resource_present(self):
resource = SamResource({"Type": "AWS::Serverless::Api", "Properties": {"DefinitionBody": {"paths": {}}}})
template = Mock()
template.get = Mock()
template.set = Mock()
template.get.return_value = resource
self.plugin.existing_implicit_api_resource = resource
self.plugin._maybe_remove_implicit_api(template)
template.get.assert_called_with(IMPLICIT_API_LOGICAL_ID)
# Must restore original resource
template.set.assert_called_with(IMPLICIT_API_LOGICAL_ID, resource)
def make_implicit_rest_api_plugin():
# This is necessary to prevent a circular dependency on imports when loading package
from samtranslator.plugins.api.implicit_rest_api_plugin import ImplicitRestApiPlugin
return ImplicitRestApiPlugin()
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
class TestImplicitRestApiPlugin_add_api_to_swagger(TestCase):
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
@patch("samtranslator.plugins.api.implicit_rest_api_plugin.SwaggerEditor")
def test_must_add_path_method_to_swagger_of_api_resource(
self, SwaggerEditorMock):
event_id = "id"
properties = {
"RestApiId": {
"Ref": "restid"
},
"Path": "/hello",
"Method": "GET"
}
original_swagger = {"this": "is", "valid": "swagger"}
updated_swagger = "updated swagger"
mock_api = SamResource({
"Type": "AWS::Serverless::Api",
"Properties": {
"__MANAGE_SWAGGER": True,
"DefinitionBody": original_swagger,
"a": "b"
}
})
SwaggerEditorMock.is_valid = Mock()
SwaggerEditorMock.is_valid.return_value = True
editor_mock = Mock()
SwaggerEditorMock.return_value = editor_mock
editor_mock.swagger = updated_swagger
self.plugin.editor = SwaggerEditorMock
template_mock = Mock()
template_mock.get = Mock()
template_mock.set = Mock()
template_mock.get.return_value = mock_api
self.plugin._add_api_to_swagger(event_id, properties, template_mock)
SwaggerEditorMock.is_valid.assert_called_with(original_swagger)
template_mock.get.assert_called_with('restid')
editor_mock.add_path("/hello", "GET")
template_mock.set.assert_called_with("restid", mock_api)
self.assertEqual(mock_api.properties["DefinitionBody"],
updated_swagger)
@patch("samtranslator.plugins.api.implicit_rest_api_plugin.SwaggerEditor")
def test_must_work_with_rest_api_id_as_string(self, SwaggerEditorMock):
event_id = "id"
properties = {
# THIS IS A STRING, not a {"Ref"}
"RestApiId": "restid",
"Path": "/hello",
"Method": "GET"
}
original_swagger = {"this": "is", "valid": "swagger"}
updated_swagger = "updated swagger"
mock_api = SamResource({
"Type": "AWS::Serverless::Api",
"Properties": {
"__MANAGE_SWAGGER": True,
"DefinitionBody": original_swagger,
"a": "b"
}
})
SwaggerEditorMock.is_valid = Mock()
SwaggerEditorMock.is_valid.return_value = True
editor_mock = Mock()
SwaggerEditorMock.return_value = editor_mock
editor_mock.swagger = updated_swagger
self.plugin.editor = SwaggerEditorMock
template_mock = Mock()
template_mock.get = Mock()
template_mock.set = Mock()
template_mock.get.return_value = mock_api
self.plugin._add_api_to_swagger(event_id, properties, template_mock)
SwaggerEditorMock.is_valid.assert_called_with(original_swagger)
template_mock.get.assert_called_with('restid')
editor_mock.add_path("/hello", "GET")
template_mock.set.assert_called_with("restid", mock_api)
self.assertEqual(mock_api.properties["DefinitionBody"],
updated_swagger)
def test_must_raise_when_api_is_not_found(self):
event_id = "id"
properties = {
"RestApiId": "unknown",
"Path": "/hello",
"Method": "GET"
}
template_mock = Mock()
template_mock.get = Mock()
template_mock.get.return_value = None
with self.assertRaises(InvalidEventException) as context:
self.plugin._add_api_to_swagger(event_id, properties,
template_mock)
self.assertEqual(event_id, context.exception._event_id)
def test_must_raise_when_api_id_is_intrinsic(self):
event_id = "id"
properties = {
"RestApiId": {
"Fn::GetAtt": "restapi"
},
"Path": "/hello",
"Method": "GET"
}
template_mock = Mock()
template_mock.get = Mock()
template_mock.get.return_value = None
with self.assertRaises(InvalidEventException) as context:
self.plugin._add_api_to_swagger(event_id, properties,
template_mock)
self.assertEqual(event_id, context.exception._event_id)
@patch("samtranslator.plugins.api.implicit_rest_api_plugin.SwaggerEditor")
def test_must_skip_invalid_swagger(self, SwaggerEditorMock):
event_id = "id"
properties = {
"RestApiId": {
"Ref": "restid"
},
"Path": "/hello",
"Method": "GET"
}
original_swagger = {"this": "is", "valid": "swagger"}
mock_api = SamResource({
"Type": "AWS::Serverless::Api",
"Properties": {
"DefinitionBody": original_swagger,
"a": "b"
}
})
SwaggerEditorMock.is_valid = Mock()
SwaggerEditorMock.is_valid.return_value = False
self.plugin.editor = SwaggerEditorMock
template_mock = Mock()
template_mock.get = Mock()
template_mock.set = Mock()
template_mock.get.return_value = mock_api
self.plugin._add_api_to_swagger(event_id, properties, template_mock)
SwaggerEditorMock.is_valid.assert_called_with(original_swagger)
template_mock.get.assert_called_with('restid')
SwaggerEditorMock.assert_not_called()
template_mock.set.assert_not_called()
@patch("samtranslator.plugins.api.implicit_rest_api_plugin.SwaggerEditor")
def test_must_skip_if_definition_body_is_not_present(
self, SwaggerEditorMock):
event_id = "id"
properties = {
"RestApiId": {
"Ref": "restid"
},
"Path": "/hello",
"Method": "GET"
}
mock_api = SamResource({
"Type": "AWS::Serverless::Api",
"Properties": {
"DefinitionUri": "s3://bucket/key",
}
})
SwaggerEditorMock.is_valid = Mock()
SwaggerEditorMock.is_valid.return_value = False
self.plugin.editor = SwaggerEditorMock
template_mock = Mock()
template_mock.get = Mock()
template_mock.set = Mock()
template_mock.get.return_value = mock_api
self.plugin._add_api_to_swagger(event_id, properties, template_mock)
SwaggerEditorMock.is_valid.assert_called_with(None)
template_mock.get.assert_called_with('restid')
SwaggerEditorMock.assert_not_called()
template_mock.set.assert_not_called()
@patch("samtranslator.plugins.api.implicit_rest_api_plugin.SwaggerEditor")
def test_must_skip_if_api_resource_properties_are_invalid(
self, SwaggerEditorMock):
event_id = "id"
properties = {
"RestApiId": {
"Ref": "restid"
},
"Path": "/hello",
"Method": "GET"
}
mock_api = SamResource({
"Type": "AWS::Serverless::Api",
"Properties": "this is not a valid property"
})
SwaggerEditorMock.is_valid = Mock()
self.plugin.editor = SwaggerEditorMock
template_mock = Mock()
template_mock.get = Mock()
template_mock.set = Mock()
template_mock.get.return_value = mock_api
self.plugin._add_api_to_swagger(event_id, properties, template_mock)
SwaggerEditorMock.is_valid.assert_not_called()
template_mock.get.assert_called_with('restid')
SwaggerEditorMock.assert_not_called()
template_mock.set.assert_not_called()
@patch("samtranslator.plugins.api.implicit_rest_api_plugin.SwaggerEditor")
def test_must_skip_if_api_manage_swagger_flag_is_false(
self, SwaggerEditorMock):
event_id = "id"
properties = {
"RestApiId": {
"Ref": "restid"
},
"Path": "/hello",
"Method": "GET"
}
original_swagger = {"this": "is a valid swagger"}
mock_api = SamResource({
"Type": "AWS::Serverless::Api",
"Properties": {
"DefinitionBody": original_swagger,
"StageName": "prod",
# Don't manage swagger
"__MANAGE_SWAGGER": False
}
})
SwaggerEditorMock.is_valid = Mock()
self.plugin.editor = SwaggerEditorMock
template_mock = Mock()
template_mock.get = Mock()
template_mock.set = Mock()
template_mock.get.return_value = mock_api
self.plugin._add_api_to_swagger(event_id, properties, template_mock)
SwaggerEditorMock.is_valid.assert_called_with(original_swagger)
template_mock.get.assert_called_with('restid')
SwaggerEditorMock.assert_not_called()
template_mock.set.assert_not_called()
@patch("samtranslator.plugins.api.implicit_rest_api_plugin.SwaggerEditor")
def test_must_skip_if_api_manage_swagger_flag_is_not_present(
self, SwaggerEditorMock):
event_id = "id"
properties = {
"RestApiId": {
"Ref": "restid"
},
"Path": "/hello",
"Method": "GET"
}
original_swagger = {"this": "is a valid swagger"}
mock_api = SamResource({
"Type": "AWS::Serverless::Api",
"Properties": {
"DefinitionBody": original_swagger,
"StageName": "prod",
# __MANAGE_SWAGGER flag is *not* present
}
})
SwaggerEditorMock.is_valid = Mock()
self.plugin.editor = SwaggerEditorMock
template_mock = Mock()
template_mock.get = Mock()
template_mock.set = Mock()
template_mock.get.return_value = mock_api
self.plugin._add_api_to_swagger(event_id, properties, template_mock)
SwaggerEditorMock.is_valid.assert_called_with(original_swagger)
template_mock.get.assert_called_with('restid')
SwaggerEditorMock.assert_not_called()
template_mock.set.assert_not_called()
class TestImplicitRestApiPlugin_on_before_transform_template(TestCase):
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
# Mock all methods but the one we are testing
self.plugin._get_api_events = Mock()
self.plugin._process_api_events = Mock()
self.plugin._maybe_remove_implicit_api = Mock()
@patch("samtranslator.plugins.api.implicit_api_plugin.SamTemplate")
def test_must_process_functions(self, SamTemplateMock):
template_dict = {"a": "b"}
function1 = SamResource({"Type": "AWS::Serverless::Function"})
function2 = SamResource({"Type": "AWS::Serverless::Function"})
function3 = SamResource({"Type": "AWS::Serverless::Function"})
function_resources = [("id1", function1), ("id2", function2),
("id3", function3)]
api_events = ["event1", "event2"]
sam_template = Mock()
SamTemplateMock.return_value = sam_template
sam_template.set = Mock()
sam_template.iterate = Mock()
sam_template.iterate.return_value = function_resources
self.plugin._get_api_events.return_value = api_events
self.plugin.on_before_transform_template(template_dict)
SamTemplateMock.assert_called_with(template_dict)
sam_template.set.assert_called_with(IMPLICIT_API_LOGICAL_ID,
ImplicitApiResource().to_dict())
# Make sure this is called only for Functions
sam_template.iterate.assert_any_call("AWS::Serverless::Function")
sam_template.iterate.assert_any_call("AWS::Serverless::Api")
self.plugin._get_api_events.assert_has_calls(
[call(function1),
call(function2),
call(function3)])
self.plugin._process_api_events.assert_has_calls([
call(function1, ["event1", "event2"], sam_template, None),
call(function2, ["event1", "event2"], sam_template, None),
call(function3, ["event1", "event2"], sam_template, None),
])
self.plugin._maybe_remove_implicit_api.assert_called_with(sam_template)
@patch("samtranslator.plugins.api.implicit_api_plugin.SamTemplate")
def test_must_skip_functions_without_events(self, SamTemplateMock):
template_dict = {"a": "b"}
function1 = SamResource({"Type": "AWS::Serverless::Function"})
function2 = SamResource({"Type": "AWS::Serverless::Function"})
function3 = SamResource({"Type": "AWS::Serverless::Function"})
function_resources = [("id1", function1), ("id2", function2),
("id3", function3)]
# NO EVENTS for any function
api_events = []
sam_template = Mock()
SamTemplateMock.return_value = sam_template
sam_template.set = Mock()
sam_template.iterate = Mock()
sam_template.iterate.return_value = function_resources
self.plugin._get_api_events.return_value = api_events
self.plugin.on_before_transform_template(template_dict)
self.plugin._get_api_events.assert_has_calls(
[call(function1),
call(function2),
call(function3)])
self.plugin._process_api_events.assert_not_called()
self.plugin._maybe_remove_implicit_api.assert_called_with(sam_template)
@patch("samtranslator.plugins.api.implicit_api_plugin.SamTemplate")
def test_must_skip_without_functions(self, SamTemplateMock):
template_dict = {"a": "b"}
# NO FUNCTIONS
function_resources = []
sam_template = Mock()
SamTemplateMock.return_value = sam_template
sam_template.set = Mock()
sam_template.iterate = Mock()
sam_template.iterate.return_value = function_resources
self.plugin.on_before_transform_template(template_dict)
self.plugin._get_api_events.assert_not_called()
self.plugin._process_api_events.assert_not_called()
# This is called always, even if there are no functions
self.plugin._maybe_remove_implicit_api.assert_called_with(sam_template)
@patch("samtranslator.plugins.api.implicit_api_plugin.SamTemplate")
def test_must_collect_errors_and_raise_on_invalid_events(
self, SamTemplateMock):
template_dict = {"a": "b"}
function_resources = [
("id1", SamResource({"Type": "AWS::Serverless::Function"})),
("id2", SamResource({"Type": "AWS::Serverless::Function"})),
("id3", SamResource({"Type": "AWS::Serverless::Function"}))
]
api_event_errors = [
InvalidEventException("eventid1", "msg"),
InvalidEventException("eventid3", "msg"),
InvalidEventException("eventid3", "msg")
]
sam_template = Mock()
SamTemplateMock.return_value = sam_template
sam_template.set = Mock()
sam_template.iterate = Mock()
sam_template.iterate.return_value = function_resources
self.plugin._get_api_events.return_value = ["1", "2"]
self.plugin._process_api_events.side_effect = api_event_errors
with self.assertRaises(InvalidDocumentException) as context:
self.plugin.on_before_transform_template(template_dict)
# Verify the content of exception. There are two exceptions embedded one inside another
# InvalidDocumentException -> InvalidResourceException -> contains the msg from InvalidEventException
causes = context.exception.causes
self.assertEqual(3, len(causes))
for index, cause in enumerate(causes):
self.assertTrue(isinstance(cause, InvalidResourceException))
# Resource's logicalID must be correctly passed
self.assertEqual(function_resources[index][0], cause._logical_id)
# Message must directly come from InvalidEventException
self.assertEqual(api_event_errors[index].message, cause._message)
# Must cleanup even if there an exception
self.plugin._maybe_remove_implicit_api.assert_called_with(sam_template)
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
self.plugin._add_api_to_swagger = Mock()
self.plugin._add_implicit_api_id_if_necessary = Mock()
class TestImplicitRestApiPlugin_process_api_events(TestCase):
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
self.plugin._add_api_to_swagger = Mock()
self.plugin._add_implicit_api_id_if_necessary = Mock()
def test_must_work_with_api_events(self):
api_events = {
"Api1": {
"Type": "Api",
"Properties": {
"Path": "/",
"Method": "GET"
}
},
"Api2": {
"Type": "Api",
"Properties": {
"Path": "/foo",
"Method": "POST"
}
}
}
template = Mock()
function_events_mock = Mock()
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": function_events_mock
}
})
function_events_mock.update = Mock()
self.plugin._process_api_events(function, api_events, template)
self.plugin._add_implicit_api_id_if_necessary.assert_has_calls([
call({
"Path": "/",
"Method": "GET"
}),
call({
"Path": "/foo",
"Method": "POST"
}),
])
self.plugin._add_api_to_swagger.assert_has_calls([
call("Api1", {
"Path": "/",
"Method": "GET"
}, template),
call("Api2", {
"Path": "/foo",
"Method": "POST"
}, template),
])
function_events_mock.update.assert_called_with(api_events)
def test_must_verify_expected_keys_exist(self):
api_events = {
"Api1": {
"Type": "Api",
"Properties": {
"Path": "/",
"Methid": "POST"
}
}
}
template = Mock()
function_events_mock = Mock()
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": function_events_mock
}
})
function_events_mock.update = Mock()
with self.assertRaises(InvalidEventException) as context:
self.plugin._process_api_events(function, api_events, template)
def test_must_verify_method_is_string(self):
api_events = {
"Api1": {
"Type": "Api",
"Properties": {
"Path": "/",
"Method": ["POST"]
}
}
}
template = Mock()
function_events_mock = Mock()
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": function_events_mock
}
})
function_events_mock.update = Mock()
with self.assertRaises(InvalidEventException) as context:
self.plugin._process_api_events(function, api_events, template)
def test_must_verify_path_is_string(self):
api_events = {
"Api1": {
"Type": "Api",
"Properties": {
"Path": ["/"],
"Method": "POST"
}
}
}
template = Mock()
function_events_mock = Mock()
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": function_events_mock
}
})
function_events_mock.update = Mock()
with self.assertRaises(InvalidEventException) as context:
self.plugin._process_api_events(function, api_events, template)
def test_must_skip_events_without_properties(self):
api_events = {
"Api1": {
"Type": "Api"
},
"Api2": {
"Type": "Api",
"Properties": {
"Path": "/",
"Method": "GET"
}
}
}
template = Mock()
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": api_events
}
})
self.plugin._process_api_events(function, api_events, template)
self.plugin._add_implicit_api_id_if_necessary.assert_has_calls([
call({
"Path": "/",
"Method": "GET"
}),
])
self.plugin._add_api_to_swagger.assert_has_calls([
call("Api2", {
"Path": "/",
"Method": "GET"
}, template),
])
def test_must_retain_side_effect_of_modifying_events(self):
"""
It must retain any changes made to the Event dictionary by helper methods
"""
api_events = {
"Api1": {
"Type": "Api",
"Properties": {
"Path": "/",
"Method": "get"
}
},
"Api2": {
"Type": "Api",
"Properties": {
"Path": "/foo",
"Method": "post"
}
}
}
template = Mock()
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": {
"Api1":
"Intentionally setting this value to a string for testing. "
"This should be replaced by API Event after processing",
"Api2":
"must be replaced"
}
}
})
def add_key_to_event(event_properties):
event_properties["Key"] = "Value"
# Apply the side effect of adding a key to events dict
self.plugin._add_implicit_api_id_if_necessary.side_effect = add_key_to_event
self.plugin._process_api_events(function, api_events, template)
# Side effect must be visible after call returns on the input object
self.assertEqual(api_events["Api1"]["Properties"], {
"Path": "/",
"Method": "get",
"Key": "Value"
})
self.assertEqual(api_events["Api2"]["Properties"], {
"Path": "/foo",
"Method": "post",
"Key": "Value"
})
# Every Event object inside the SamResource class must be entirely replaced by input api_events with side effect
self.assertEqual(function.properties["Events"]["Api1"]["Properties"], {
"Path": "/",
"Method": "get",
"Key": "Value"
})
self.assertEqual(function.properties["Events"]["Api2"]["Properties"], {
"Path": "/foo",
"Method": "post",
"Key": "Value"
})
# Subsequent calls must be made with the side effect. This is important.
self.plugin._add_api_to_swagger.assert_has_calls([
call(
"Api1",
# Side effects should be visible here
{
"Path": "/",
"Method": "get",
"Key": "Value"
},
template),
call(
"Api2",
# Side effects should be visible here
{
"Path": "/foo",
"Method": "post",
"Key": "Value"
},
template),
])
class TestImplicitRestApiPlugin_get_api_events(TestCase):
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
def test_must_get_all_api_events_in_function(self):
properties = {
"Events": {
"Api1": {
"Type": "Api",
"Properties": {
"a": "b"
}
},
"Api2": {
"Type": "Api",
"Properties": {
"c": "d"
}
},
"Other": {
"Type": "Something",
"Properties": {}
}
}
}
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": properties
})
expected = {
"Api1": {
"Type": "Api",
"Properties": {
"a": "b"
}
},
"Api2": {
"Type": "Api",
"Properties": {
"c": "d"
}
}
}
result = self.plugin._get_api_events(function)
self.assertEqual(expected, result)
def test_must_work_with_no_api_events(self):
properties = {
"Events": {
"Event1": {
"Type": "some",
"Properties": {
"a": "b"
}
},
"EventWithNoType": {
"Properties": {
"c": "d"
}
},
"Event3": {
"Type": "Something",
"Properties": {}
}
}
}
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": properties
})
expected = {}
result = self.plugin._get_api_events(function)
self.assertEqual(expected, result)
def test_must_skip_with_bad_events_structure(self):
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": "must not be string"
}
})
expected = {}
result = self.plugin._get_api_events(function)
self.assertEqual(expected, result)
def test_must_skip_if_no_events_property(self):
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"no": "events"
}
})
expected = {}
result = self.plugin._get_api_events(function)
self.assertEqual(expected, result)
def test_must_skip_if_no_property_dictionary(self):
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": "bad value"
})
expected = {}
result = self.plugin._get_api_events(function)
self.assertEqual(expected, result)
def test_must_return_reference_to_event_dict(self):
function = SamResource({
"Type": SamResourceType.Function.value,
"Properties": {
"Events": {
"Api1": {
"Type": "Api",
"Properties": {
"a": "b"
}
}
}
}
})
result = self.plugin._get_api_events(function)
# Make sure that the result contains a direct reference to Event properties.
# This is an important contract necessary for other parts of the plugin to work.
self.assertTrue(
result["Api1"] is function.properties["Events"]["Api1"])
def test_must_skip_if_function_is_not_valid(self):
function = SamResource({
# NOT a SAM resource
"Type": "AWS::Lambda::Function",
"Properties": {
"Events": {
"Api1": {
"Type": "Api",
"Properties": {}
}
}
}
})
expected = {}
result = self.plugin._get_api_events(function)
self.assertEqual(expected, result)
def setUp(self):
self.plugin = ImplicitRestApiPlugin()
self.plugin.api_conditions = {}