diff --git a/.pylintrc b/.pylintrc index 48c5997..ae5da43 100644 --- a/.pylintrc +++ b/.pylintrc @@ -62,7 +62,8 @@ confidence= # --disable=W". disable=useless-object-inheritance, unused-argument, - too-many-instance-attributes + too-many-instance-attributes, + bad-continuation # Enable the message, report, category or checker with the given id(s). You can # either give multiple identifier separated by comma (,) or put this option diff --git a/serverlessrepo/__version__.py b/serverlessrepo/__version__.py index b13f75f..5948691 100644 --- a/serverlessrepo/__version__.py +++ b/serverlessrepo/__version__.py @@ -1,12 +1,12 @@ """Serverlessrepo version and package meta-data.""" -__title__ = 'serverlessrepo' -__version__ = '0.1.10' -__license__ = 'Apache 2.0' +__title__ = "serverlessrepo" +__version__ = "0.1.10" +__license__ = "Apache 2.0" __description__ = ( - 'A Python library with convenience helpers for working ' - 'with the AWS Serverless Application Repository.' + "A Python library with convenience helpers for working " + "with the AWS Serverless Application Repository." ) -__url__ = 'https://github.com/awslabs/aws-serverlessrepo-python' -__author__ = 'Amazon Web Services' -__author_email__ = 'aws-sam-developer@amazon.com' +__url__ = "https://github.com/awslabs/aws-serverlessrepo-python" +__author__ = "Amazon Web Services" +__author_email__ = "aws-sam-developer@amazon.com" diff --git a/serverlessrepo/exceptions.py b/serverlessrepo/exceptions.py index debe473..4ff80f5 100644 --- a/serverlessrepo/exceptions.py +++ b/serverlessrepo/exceptions.py @@ -4,7 +4,7 @@ class ServerlessRepoError(Exception): """Base exception raised by serverlessrepo library.""" - MESSAGE = '' + MESSAGE = "" def __init__(self, **kwargs): """Init the exception object.""" @@ -32,11 +32,13 @@ class InvalidApplicationPolicyError(ServerlessRepoError): class S3PermissionsRequired(ServerlessRepoError): """Raised when S3 bucket access is denied.""" - MESSAGE = "The AWS Serverless Application Repository does not have read access to bucket '{bucket}', " \ - "key '{key}'. Please update your Amazon S3 bucket policy to grant the service read " \ - "permissions to the application artifacts you have uploaded to your S3 bucket. See " \ - "https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html" \ - " for more details." + MESSAGE = ( + "The AWS Serverless Application Repository does not have read access to bucket '{bucket}', " + "key '{key}'. Please update your Amazon S3 bucket policy to grant the service read " + "permissions to the application artifacts you have uploaded to your S3 bucket. See " + "https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html" + " for more details." + ) class InvalidS3UriError(ServerlessRepoError): @@ -49,3 +51,9 @@ class ServerlessRepoClientError(ServerlessRepoError): """Wrapper for botocore ClientError.""" MESSAGE = "{message}" + + +class MultipleMatchingApplicationsError(ServerlessRepoError): + """Raised when multiple matching applications are found.""" + + MESSAGE = "{message}" diff --git a/serverlessrepo/parser.py b/serverlessrepo/parser.py index 1981818..31345f6 100644 --- a/serverlessrepo/parser.py +++ b/serverlessrepo/parser.py @@ -1,6 +1,5 @@ """Helper to parse JSON/YAML SAM template and dump YAML files.""" -import re import copy import json from collections import OrderedDict @@ -12,9 +11,8 @@ from .application_metadata import ApplicationMetadata from .exceptions import ApplicationMetadataNotFoundError -METADATA = 'Metadata' -SERVERLESS_REPO_APPLICATION = 'AWS::ServerlessRepo::Application' -APPLICATION_ID_PATTERN = r'arn:[\w\-]+:serverlessrepo:[\w\-]+:[0-9]+:applications\/[\S]+' +METADATA = "Metadata" +SERVERLESS_REPO_APPLICATION = "AWS::ServerlessRepo::Application" def intrinsics_multi_constructor(loader, tag_prefix, node): @@ -27,17 +25,17 @@ def intrinsics_multi_constructor(loader, tag_prefix, node): tag = node.tag[1:] # Some intrinsic functions doesn't support prefix "Fn::" - prefix = 'Fn::' - if tag in ['Ref', 'Condition']: - prefix = '' + prefix = "Fn::" + if tag in ["Ref", "Condition"]: + prefix = "" cfntag = prefix + tag - if tag == 'GetAtt' and isinstance(node.value, six.string_types): + if tag == "GetAtt" and isinstance(node.value, six.string_types): # ShortHand notation for !GetAtt accepts Resource.Attribute format # while the standard notation is to use an array # [Resource, Attribute]. Convert shorthand to standard format - value = node.value.split('.', 1) + value = node.value.split(".", 1) elif isinstance(node, ScalarNode): # Value of this node is scalar @@ -90,8 +88,10 @@ def parse_template(template_str): # json parser. return json.loads(template_str, object_pairs_hook=OrderedDict) except ValueError: - yaml.SafeLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _dict_constructor) - yaml.SafeLoader.add_multi_constructor('!', intrinsics_multi_constructor) + yaml.SafeLoader.add_constructor( + yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _dict_constructor + ) + yaml.SafeLoader.add_multi_constructor("!", intrinsics_multi_constructor) return yaml.safe_load(template_str) @@ -110,20 +110,10 @@ def get_app_metadata(template_dict): return ApplicationMetadata(app_metadata_dict) raise ApplicationMetadataNotFoundError( - error_message='missing {} section in template Metadata'.format(SERVERLESS_REPO_APPLICATION)) - - -def parse_application_id(text): - """ - Extract the application id from input text. - - :param text: text to parse - :type text: str - :return: application id if found in the input - :rtype: str - """ - result = re.search(APPLICATION_ID_PATTERN, text) - return result.group(0) if result else None + error_message="missing {} section in template Metadata".format( + SERVERLESS_REPO_APPLICATION + ) + ) def strip_app_metadata(template_dict): @@ -141,7 +131,8 @@ def strip_app_metadata(template_dict): template_dict_copy = copy.deepcopy(template_dict) # strip the whole metadata section if SERVERLESS_REPO_APPLICATION is the only key in it - if not [k for k in template_dict_copy.get(METADATA) if k != SERVERLESS_REPO_APPLICATION]: + metadata = template_dict_copy.get(METADATA) + if not any(k for k in metadata if k != SERVERLESS_REPO_APPLICATION): template_dict_copy.pop(METADATA, None) else: template_dict_copy.get(METADATA).pop(SERVERLESS_REPO_APPLICATION, None) diff --git a/serverlessrepo/publish.py b/serverlessrepo/publish.py index 2ff427e..59f8964 100644 --- a/serverlessrepo/publish.py +++ b/serverlessrepo/publish.py @@ -7,15 +7,17 @@ from botocore.exceptions import ClientError from .application_metadata import ApplicationMetadata -from .parser import ( - yaml_dump, parse_template, get_app_metadata, - parse_application_id, strip_app_metadata +from .parser import yaml_dump, parse_template, get_app_metadata, strip_app_metadata +from .exceptions import ( + MultipleMatchingApplicationsError, + ServerlessRepoClientError, + S3PermissionsRequired, + InvalidS3UriError, ) -from .exceptions import ServerlessRepoClientError, S3PermissionsRequired, InvalidS3UriError -CREATE_APPLICATION = 'CREATE_APPLICATION' -UPDATE_APPLICATION = 'UPDATE_APPLICATION' -CREATE_APPLICATION_VERSION = 'CREATE_APPLICATION_VERSION' +CREATE_APPLICATION = "CREATE_APPLICATION" +UPDATE_APPLICATION = "UPDATE_APPLICATION" +CREATE_APPLICATION_VERSION = "CREATE_APPLICATION_VERSION" def publish_application(template, sar_client=None): @@ -31,10 +33,10 @@ def publish_application(template, sar_client=None): :raises ValueError """ if not template: - raise ValueError('Require SAM template to publish the application') + raise ValueError("Require SAM template to publish the application") if not sar_client: - sar_client = boto3.client('serverlessrepo') + sar_client = boto3.client("serverlessrepo") template_dict = _get_template_dict(template) app_metadata = get_app_metadata(template_dict) @@ -43,15 +45,14 @@ def publish_application(template, sar_client=None): try: request = _create_application_request(app_metadata, stripped_template) response = sar_client.create_application(**request) - application_id = response['ApplicationId'] + application_id = response["ApplicationId"] actions = [CREATE_APPLICATION] except ClientError as e: if not _is_conflict_exception(e): raise _wrap_client_error(e) # Update the application if it already exists - error_message = e.response['Error']['Message'] - application_id = parse_application_id(error_message) + application_id = _get_application_id(sar_client, app_metadata) try: request = _update_application_request(app_metadata, application_id) sar_client.update_application(**request) @@ -62,7 +63,9 @@ def publish_application(template, sar_client=None): # Create application version if semantic version is specified if app_metadata.semantic_version: try: - request = _create_application_version_request(app_metadata, application_id, stripped_template) + request = _create_application_version_request( + app_metadata, application_id, stripped_template + ) sar_client.create_application_version(**request) actions.append(CREATE_APPLICATION_VERSION) except ClientError as e: @@ -70,9 +73,9 @@ def publish_application(template, sar_client=None): raise _wrap_client_error(e) return { - 'application_id': application_id, - 'actions': actions, - 'details': _get_publish_details(actions, app_metadata.template_dict) + "application_id": application_id, + "actions": actions, + "details": _get_publish_details(actions, app_metadata.template_dict), } @@ -89,10 +92,12 @@ def update_application_metadata(template, application_id, sar_client=None): :raises ValueError """ if not template or not application_id: - raise ValueError('Require SAM template and application ID to update application metadata') + raise ValueError( + "Require SAM template and application ID to update application metadata" + ) if not sar_client: - sar_client = boto3.client('serverlessrepo') + sar_client = boto3.client("serverlessrepo") template_dict = _get_template_dict(template) app_metadata = get_app_metadata(template_dict) @@ -116,7 +121,7 @@ def _get_template_dict(template): if isinstance(template, dict): return copy.deepcopy(template) - raise ValueError('Input template should be a string or dictionary') + raise ValueError("Input template should be a string or dictionary") def _create_application_request(app_metadata, template): @@ -130,21 +135,21 @@ def _create_application_request(app_metadata, template): :return: SAR CreateApplication request body :rtype: dict """ - app_metadata.validate(['author', 'description', 'name']) + app_metadata.validate(["author", "description", "name"]) request = { - 'Author': app_metadata.author, - 'Description': app_metadata.description, - 'HomePageUrl': app_metadata.home_page_url, - 'Labels': app_metadata.labels, - 'LicenseBody': app_metadata.license_body, - 'LicenseUrl': app_metadata.license_url, - 'Name': app_metadata.name, - 'ReadmeBody': app_metadata.readme_body, - 'ReadmeUrl': app_metadata.readme_url, - 'SemanticVersion': app_metadata.semantic_version, - 'SourceCodeUrl': app_metadata.source_code_url, - 'SpdxLicenseId': app_metadata.spdx_license_id, - 'TemplateBody': template + "Author": app_metadata.author, + "Description": app_metadata.description, + "HomePageUrl": app_metadata.home_page_url, + "Labels": app_metadata.labels, + "LicenseBody": app_metadata.license_body, + "LicenseUrl": app_metadata.license_url, + "Name": app_metadata.name, + "ReadmeBody": app_metadata.readme_body, + "ReadmeUrl": app_metadata.readme_url, + "SemanticVersion": app_metadata.semantic_version, + "SourceCodeUrl": app_metadata.source_code_url, + "SpdxLicenseId": app_metadata.spdx_license_id, + "TemplateBody": template, } # Remove None values return {k: v for k, v in request.items() if v} @@ -162,13 +167,13 @@ def _update_application_request(app_metadata, application_id): :rtype: dict """ request = { - 'ApplicationId': application_id, - 'Author': app_metadata.author, - 'Description': app_metadata.description, - 'HomePageUrl': app_metadata.home_page_url, - 'Labels': app_metadata.labels, - 'ReadmeBody': app_metadata.readme_body, - 'ReadmeUrl': app_metadata.readme_url + "ApplicationId": application_id, + "Author": app_metadata.author, + "Description": app_metadata.description, + "HomePageUrl": app_metadata.home_page_url, + "Labels": app_metadata.labels, + "ReadmeBody": app_metadata.readme_body, + "ReadmeUrl": app_metadata.readme_url, } return {k: v for k, v in request.items() if v} @@ -186,12 +191,12 @@ def _create_application_version_request(app_metadata, application_id, template): :return: SAR CreateApplicationVersion request body :rtype: dict """ - app_metadata.validate(['semantic_version']) + app_metadata.validate(["semantic_version"]) request = { - 'ApplicationId': application_id, - 'SemanticVersion': app_metadata.semantic_version, - 'SourceCodeUrl': app_metadata.source_code_url, - 'TemplateBody': template + "ApplicationId": application_id, + "SemanticVersion": app_metadata.semantic_version, + "SourceCodeUrl": app_metadata.source_code_url, + "TemplateBody": template, } return {k: v for k, v in request.items() if v} @@ -204,8 +209,8 @@ def _is_conflict_exception(e): :type e: ClientError :return: True if e is ConflictException """ - error_code = e.response['Error']['Code'] - return error_code == 'ConflictException' + error_code = e.response["Error"]["Code"] + return error_code == "ConflictException" def _wrap_client_error(e): @@ -216,12 +221,12 @@ def _wrap_client_error(e): :type e: ClientError :return: S3PermissionsRequired or InvalidS3UriError or general ServerlessRepoClientError """ - error_code = e.response['Error']['Code'] - message = e.response['Error']['Message'] + error_code = e.response["Error"]["Code"] + message = e.response["Error"]["Message"] - if error_code == 'BadRequestException': + if error_code == "BadRequestException": if "Failed to copy S3 object. Access denied:" in message: - match = re.search('bucket=(.+?), key=(.+?)$', message) + match = re.search("bucket=(.+?), key=(.+?)$", message) if match: return S3PermissionsRequired(bucket=match.group(1), key=match.group(2)) if "Invalid S3 URI" in message: @@ -250,11 +255,37 @@ def _get_publish_details(actions, app_metadata_template): ApplicationMetadata.HOME_PAGE_URL, ApplicationMetadata.LABELS, ApplicationMetadata.README_URL, - ApplicationMetadata.README_BODY + ApplicationMetadata.README_BODY, ] if CREATE_APPLICATION_VERSION in actions: # SemanticVersion and SourceCodeUrl can only be updated by creating a new version - additional_keys = [ApplicationMetadata.SEMANTIC_VERSION, ApplicationMetadata.SOURCE_CODE_URL] + additional_keys = [ + ApplicationMetadata.SEMANTIC_VERSION, + ApplicationMetadata.SOURCE_CODE_URL, + ] include_keys.extend(additional_keys) return {k: v for k, v in app_metadata_template.items() if k in include_keys and v} + + +def _get_application_id(sar_client, metadata): + """ + Gets the application ID of rhte matching application name. + + :param sar_client: The boto3 SAR client. + :param metadata: The application meta data. + :return: The matching application ID. + :rtype: str + :raises: MultipleMatchingApplicationsError + """ + application_ids = [] + pager = sar_client.get_paginator("list_applications") + for page in pager.paginate(): + for application in page.get("Applications", []): + if application["Name"] == metadata.name: + application_ids.append(application["ApplicationId"]) + if len(application_ids) > 1: + raise MultipleMatchingApplicationsError( + message='Multiple applications with the name "%s"' % metadata.name + ) + return application_ids[0] if len(application_ids) == 1 else None diff --git a/tests/unit/test_parser.py b/tests/unit/test_parser.py index d041f6f..de05835 100644 --- a/tests/unit/test_parser.py +++ b/tests/unit/test_parser.py @@ -21,29 +21,12 @@ class TestParser(TestCase): parsed_yaml_dict = { "Resource": { - "Key1": { - "Ref": "Something" - }, - "Key2": { - "Fn::GetAtt": ["Another", "Arn"] - }, - "Key3": { - "Fn::FooBar": [ - {"Fn::Baz": "YetAnother"}, - "hello" - ] - }, - "Key4": { - "Fn::SomeTag": { - "a": "1" - } - }, - "Key5": { - "Fn::GetAtt": ["OneMore", "Outputs.Arn"] - }, - "Key6": { - "Condition": "OtherCondition" - } + "Key1": {"Ref": "Something"}, + "Key2": {"Fn::GetAtt": ["Another", "Arn"]}, + "Key3": {"Fn::FooBar": [{"Fn::Baz": "YetAnother"}, "hello"]}, + "Key4": {"Fn::SomeTag": {"a": "1"}}, + "Key5": {"Fn::GetAtt": ["OneMore", "Outputs.Arn"]}, + "Key6": {"Condition": "OtherCondition"}, } } @@ -64,13 +47,7 @@ def test_yaml_getatt(self): Key: !GetAtt ["a", "b"] """ - output_dir = { - "Resource": { - "Key": { - "Fn::GetAtt": ["a", "b"] - } - } - } + output_dir = {"Resource": {"Key": {"Fn::GetAtt": ["a", "b"]}}} actual_output = parser.parse_template(input_str) self.assertEqual(actual_output, output_dir) @@ -78,7 +55,7 @@ def test_yaml_getatt(self): def test_parse_json_with_tabs(self): template = '{\n\t"foo": "bar"\n}' output = parser.parse_template(template) - self.assertEqual(output, {'foo': 'bar'}) + self.assertEqual(output, {"foo": "bar"}) def test_parse_json_preserve_elements_order(self): input_template = """ @@ -101,10 +78,22 @@ def test_parse_json_preserve_elements_order(self): } } """ - expected_dict = OrderedDict([ - ('B_Resource', OrderedDict([('Key2', {'Name': 'name2'}), ('Key1', {'Name': 'name1'})])), - ('A_Resource', OrderedDict([('Key2', {'Name': 'name2'}), ('Key1', {'Name': 'name1'})])) - ]) + expected_dict = OrderedDict( + [ + ( + "B_Resource", + OrderedDict( + [("Key2", {"Name": "name2"}), ("Key1", {"Name": "name1"})] + ), + ), + ( + "A_Resource", + OrderedDict( + [("Key2", {"Name": "name2"}), ("Key1", {"Name": "name1"})] + ), + ), + ] + ) output_dict = parser.parse_template(input_template) self.assertEqual(expected_dict, output_dict) @@ -122,112 +111,86 @@ def test_parse_yaml_preserve_elements_order(self): Name: name1 """ output_dict = parser.parse_template(input_template) - expected_dict = OrderedDict([ - ('B_Resource', OrderedDict([('Key2', {'Name': 'name2'}), ('Key1', {'Name': 'name1'})])), - ('A_Resource', OrderedDict([('Key2', {'Name': 'name2'}), ('Key1', {'Name': 'name1'})])) - ]) + expected_dict = OrderedDict( + [ + ( + "B_Resource", + OrderedDict( + [("Key2", {"Name": "name2"}), ("Key1", {"Name": "name1"})] + ), + ), + ( + "A_Resource", + OrderedDict( + [("Key2", {"Name": "name2"}), ("Key1", {"Name": "name1"})] + ), + ), + ] + ) self.assertEqual(expected_dict, output_dict) output_template = parser.yaml_dump(output_dict) # yaml dump changes indentation, remove spaces and new line characters to just compare the text - self.assertEqual(re.sub(r'\n|\s', '', input_template), - re.sub(r'\n|\s', '', output_template)) + self.assertEqual( + re.sub(r"\n|\s", "", input_template), re.sub(r"\n|\s", "", output_template) + ) def test_get_app_metadata_missing_metadata(self): - template_dict_without_metadata = { - 'RandomKey': { - 'Key1': 'Something' - } - } + template_dict_without_metadata = {"RandomKey": {"Key1": "Something"}} with self.assertRaises(ApplicationMetadataNotFoundError) as context: parser.get_app_metadata(template_dict_without_metadata) message = str(context.exception) - expected = 'missing AWS::ServerlessRepo::Application section in template Metadata' + expected = ( + "missing AWS::ServerlessRepo::Application section in template Metadata" + ) self.assertTrue(expected in message) def test_get_app_metadata_missing_app_metadata(self): - template_dict_without_app_metadata = { - 'Metadata': { - 'Key1': 'Something' - } - } + template_dict_without_app_metadata = {"Metadata": {"Key1": "Something"}} with self.assertRaises(ApplicationMetadataNotFoundError) as context: parser.get_app_metadata(template_dict_without_app_metadata) message = str(context.exception) - expected = 'missing AWS::ServerlessRepo::Application section in template Metadata' + expected = ( + "missing AWS::ServerlessRepo::Application section in template Metadata" + ) self.assertTrue(expected in message) def test_get_app_metadata_return_metadata(self): app_metadata = { - 'Name': 'name', - 'Description': 'description', - 'Author': 'author' + "Name": "name", + "Description": "description", + "Author": "author", } template_dict = { - 'Metadata': { - 'AWS::ServerlessRepo::Application': dict(app_metadata) - } + "Metadata": {"AWS::ServerlessRepo::Application": dict(app_metadata)} } expected = ApplicationMetadata(app_metadata) actual = parser.get_app_metadata(template_dict) self.assertEqual(expected, actual) - def test_parse_application_id_aws_partition(self): - application_id = 'arn:aws:serverlessrepo:us-east-1:123456789012:applications/test-app' - text_with_application_id = 'Application with id {} already exists.'.format(application_id) - result = parser.parse_application_id(text_with_application_id) - self.assertEqual(result, application_id) - - def test_parse_application_id_aws_cn_partition(self): - application_id = 'arn:aws-cn:serverlessrepo:cn-northwest-1:123456789012:applications/test-app' - text_with_application_id = 'Application with id {} already exists.'.format(application_id) - result = parser.parse_application_id(text_with_application_id) - self.assertEqual(result, application_id) - - def test_parse_application_id_aws_us_gov_partition(self): - application_id = 'arn:aws-us-gov:serverlessrepo:us-gov-east-1:123456789012:applications/test-app' - text_with_application_id = 'Application with id {} already exists.'.format(application_id) - result = parser.parse_application_id(text_with_application_id) - self.assertEqual(result, application_id) - - def test_parse_application_id_return_none(self): - text_without_application_id = 'text without application id' - result = parser.parse_application_id(text_without_application_id) - self.assertIsNone(result) - def test_strip_app_metadata_when_input_does_not_contain_metadata(self): - template_dict = {'Resources': {}} + template_dict = {"Resources": {}} actual_output = parser.strip_app_metadata(template_dict) self.assertEqual(actual_output, template_dict) def test_strip_app_metadata_when_metadata_only_contains_app_metadata(self): template_dict = { - 'Metadata': { - 'AWS::ServerlessRepo::Application': {} - }, - 'Resources': {}, + "Metadata": {"AWS::ServerlessRepo::Application": {}}, + "Resources": {}, } - expected_output = {'Resources': {}} + expected_output = {"Resources": {}} actual_output = parser.strip_app_metadata(template_dict) self.assertEqual(actual_output, expected_output) def test_strip_app_metadata_when_metadata_contains_additional_keys(self): template_dict = { - 'Metadata': { - 'AWS::ServerlessRepo::Application': {}, - 'AnotherKey': {} - }, - 'Resources': {} - } - expected_output = { - 'Metadata': { - 'AnotherKey': {} - }, - 'Resources': {} + "Metadata": {"AWS::ServerlessRepo::Application": {}, "AnotherKey": {}}, + "Resources": {}, } + expected_output = {"Metadata": {"AnotherKey": {}}, "Resources": {}} actual_output = parser.strip_app_metadata(template_dict) self.assertEqual(actual_output, expected_output) diff --git a/tests/unit/test_publish.py b/tests/unit/test_publish.py index bd57cc8..c867f7b 100644 --- a/tests/unit/test_publish.py +++ b/tests/unit/test_publish.py @@ -7,22 +7,22 @@ from serverlessrepo import publish_application, update_application_metadata from serverlessrepo.exceptions import ( InvalidApplicationMetadataError, + MultipleMatchingApplicationsError, S3PermissionsRequired, InvalidS3UriError, - ServerlessRepoClientError + ServerlessRepoClientError, ) from serverlessrepo.parser import get_app_metadata, strip_app_metadata, yaml_dump from serverlessrepo.publish import ( CREATE_APPLICATION, UPDATE_APPLICATION, - CREATE_APPLICATION_VERSION + CREATE_APPLICATION_VERSION, ) class TestPublishApplication(TestCase): - def setUp(self): - patcher = patch('serverlessrepo.publish.boto3') + patcher = patch("serverlessrepo.publish.boto3") self.addCleanup(patcher.stop) self.boto3_mock = patcher.start() self.serverlessrepo_mock = Mock() @@ -46,51 +46,52 @@ def setUp(self): } """ self.template_dict = json.loads(self.template) - self.yaml_template_without_metadata = yaml_dump(strip_app_metadata(self.template_dict)) - self.application_id = 'arn:aws:serverlessrepo:us-east-1:123456789012:applications/test-app' + self.yaml_template_without_metadata = yaml_dump( + strip_app_metadata(self.template_dict) + ) + self.application_id = ( + "arn:aws:serverlessrepo:us-east-1:123456789012:applications/test-app" + ) self.application_exists_error = ClientError( { - 'Error': { - 'Code': 'ConflictException', - 'Message': 'Application with id {} already exists'.format(self.application_id) + "Error": { + "Code": "ConflictException", + "Message": "Application with id {} already exists".format( + self.application_id + ), } }, - 'create_application' + "create_application", ) self.not_conflict_exception = ClientError( - { - 'Error': { - 'Code': 'BadRequestException', - 'Message': 'Random message' - } - }, - 'create_application' + {"Error": {"Code": "BadRequestException", "Message": "Random message"}}, + "create_application", ) self.s3_denied_exception = ClientError( { - 'Error': { - 'Code': 'BadRequestException', - 'Message': 'Failed to copy S3 object. Access denied: bucket=test-bucket, key=test-file' + "Error": { + "Code": "BadRequestException", + "Message": "Failed to copy S3 object. Access denied: bucket=test-bucket, key=test-file", } }, - 'create_application' + "create_application", ) self.invalid_s3_uri_exception = ClientError( - { - 'Error': { - 'Code': 'BadRequestException', - 'Message': 'Invalid S3 URI' - } - }, - 'create_application' + {"Error": {"Code": "BadRequestException", "Message": "Invalid S3 URI"}}, + "create_application", ) + self.paginator_mock = Mock() + self.paginator_mock.paginate.return_value = [ + {"ApplicationId": self.application_id, "Name": "test-app"} + ] + self.serverlessrepo_mock.get_paginator.return_value = self.paginator_mock def test_publish_raise_value_error_for_empty_template(self): with self.assertRaises(ValueError) as context: - publish_application('') + publish_application("") message = str(context.exception) - expected = 'Require SAM template to publish the application' + expected = "Require SAM template to publish the application" self.assertEqual(expected, message) self.serverlessrepo_mock.create_application.assert_not_called() @@ -99,23 +100,23 @@ def test_publish_raise_value_error_for_not_dict_or_string_template(self): publish_application(123) message = str(context.exception) - expected = 'Input template should be a string or dictionary' + expected = "Input template should be a string or dictionary" self.assertEqual(expected, message) self.serverlessrepo_mock.create_application.assert_not_called() - @patch('serverlessrepo.publish.parse_template') + @patch("serverlessrepo.publish.parse_template") def test_publish_template_string_should_parse_template(self, parse_template_mock): self.serverlessrepo_mock.create_application.return_value = { - 'ApplicationId': self.application_id + "ApplicationId": self.application_id } parse_template_mock.return_value = self.template_dict publish_application(self.template) parse_template_mock.assert_called_with(self.template) - @patch('serverlessrepo.publish.copy.deepcopy') + @patch("serverlessrepo.publish.copy.deepcopy") def test_publish_template_dict_should_copy_template(self, copy_mock): self.serverlessrepo_mock.create_application.return_value = { - 'ApplicationId': self.application_id + "ApplicationId": self.application_id } copy_mock.return_value = self.template_dict publish_application(self.template_dict) @@ -123,36 +124,45 @@ def test_publish_template_dict_should_copy_template(self, copy_mock): def test_publish_new_application_should_create_application(self): self.serverlessrepo_mock.create_application.return_value = { - 'ApplicationId': self.application_id + "ApplicationId": self.application_id } actual_result = publish_application(self.template) app_metadata_template = get_app_metadata(self.template_dict).template_dict expected_result = { - 'application_id': self.application_id, - 'actions': [CREATE_APPLICATION], - 'details': app_metadata_template + "application_id": self.application_id, + "actions": [CREATE_APPLICATION], + "details": app_metadata_template, } self.assertEqual(expected_result, actual_result) - expected_request = dict({'TemplateBody': self.yaml_template_without_metadata}, **app_metadata_template) - self.serverlessrepo_mock.create_application.assert_called_once_with(**expected_request) + expected_request = dict( + {"TemplateBody": self.yaml_template_without_metadata}, + **app_metadata_template + ) + self.serverlessrepo_mock.create_application.assert_called_once_with( + **expected_request + ) # publish a new application will only call create_application self.serverlessrepo_mock.update_application.assert_not_called() self.serverlessrepo_mock.create_application_version.assert_not_called() def test_publish_raise_metadata_error_for_invalid_create_application_request(self): - template_without_app_name = self.template.replace('"Name": "test-app",', '') + template_without_app_name = self.template.replace('"Name": "test-app",', "") with self.assertRaises(InvalidApplicationMetadataError) as context: publish_application(template_without_app_name) message = str(context.exception) - self.assertEqual("Invalid application metadata: 'name properties not provided'", message) + self.assertEqual( + "Invalid application metadata: 'name properties not provided'", message + ) # create_application shouldn't be called if application metadata is invalid self.serverlessrepo_mock.create_application.assert_not_called() def test_publish_raise_serverlessrepo_client_error_when_create_application(self): - self.serverlessrepo_mock.create_application.side_effect = self.not_conflict_exception + self.serverlessrepo_mock.create_application.side_effect = ( + self.not_conflict_exception + ) # should raise exception if it's not ConflictException with self.assertRaises(ServerlessRepoClientError): @@ -163,78 +173,107 @@ def test_publish_raise_serverlessrepo_client_error_when_create_application(self) self.serverlessrepo_mock.create_application_version.assert_not_called() def test_publish_raise_s3_permission_error_when_create_application(self): - self.serverlessrepo_mock.create_application.side_effect = self.s3_denied_exception + self.serverlessrepo_mock.create_application.side_effect = ( + self.s3_denied_exception + ) with self.assertRaises(S3PermissionsRequired) as context: publish_application(self.template) message = str(context.exception) - self.assertIn("The AWS Serverless Application Repository does not have read access to bucket " - "'test-bucket', key 'test-file'.", message) + self.assertIn( + "The AWS Serverless Application Repository does not have read access to bucket " + "'test-bucket', key 'test-file'.", + message, + ) def test_publish_raise_invalid_s3_uri_when_create_application(self): - self.serverlessrepo_mock.create_application.side_effect = self.invalid_s3_uri_exception + self.serverlessrepo_mock.create_application.side_effect = ( + self.invalid_s3_uri_exception + ) with self.assertRaises(InvalidS3UriError) as context: publish_application(self.template) message = str(context.exception) self.assertIn("Invalid S3 URI", message) - def test_publish_existing_application_should_update_application_if_version_not_specified(self): - self.serverlessrepo_mock.create_application.side_effect = self.application_exists_error - template_without_version = self.template.replace('"SemanticVersion": "1.0.0"', '') + def test_publish_existing_application_should_update_application_if_version_not_specified( + self + ): + self.serverlessrepo_mock.create_application.side_effect = ( + self.application_exists_error + ) + template_without_version = self.template.replace( + '"SemanticVersion": "1.0.0"', "" + ) actual_result = publish_application(template_without_version) expected_result = { - 'application_id': self.application_id, - 'actions': [UPDATE_APPLICATION], - 'details': { + "application_id": self.application_id, + "actions": [UPDATE_APPLICATION], + "details": { # Name, LicenseUrl and SourceCodeUrl shouldn't show up - 'Description': 'hello world', - 'Author': 'abc', - 'ReadmeUrl': 's3://test-bucket/README.md', - 'Labels': ['test1', 'test2'], - 'HomePageUrl': 'https://github.com/abc/def' - } + "Description": "hello world", + "Author": "abc", + "ReadmeUrl": "s3://test-bucket/README.md", + "Labels": ["test1", "test2"], + "HomePageUrl": "https://github.com/abc/def", + }, } self.assertEqual(expected_result, actual_result) self.serverlessrepo_mock.create_application.assert_called_once() # should continue to update application if the exception is application already exists - expected_request = dict({'ApplicationId': self.application_id}, **expected_result['details']) - self.serverlessrepo_mock.update_application.assert_called_once_with(**expected_request) + expected_request = dict( + {"ApplicationId": self.application_id}, **expected_result["details"] + ) + self.serverlessrepo_mock.update_application.assert_called_once_with( + **expected_request + ) # create_application_version shouldn't be called if version is not provided self.serverlessrepo_mock.create_application_version.assert_not_called() - @patch('serverlessrepo.publish._wrap_client_error') - def test_publish_wrap_client_error_when_update_application(self, wrap_client_error_mock): - self.serverlessrepo_mock.create_application.side_effect = self.application_exists_error - self.serverlessrepo_mock.update_application.side_effect = self.not_conflict_exception - wrap_client_error_mock.return_value = ServerlessRepoClientError(message="client error") + @patch("serverlessrepo.publish._wrap_client_error") + def test_publish_wrap_client_error_when_update_application( + self, wrap_client_error_mock + ): + self.serverlessrepo_mock.create_application.side_effect = ( + self.application_exists_error + ) + self.serverlessrepo_mock.update_application.side_effect = ( + self.not_conflict_exception + ) + wrap_client_error_mock.return_value = ServerlessRepoClientError( + message="client error" + ) with self.assertRaises(ServerlessRepoClientError): publish_application(self.template) # create_application_version shouldn't be called if update_application fails self.serverlessrepo_mock.create_application_version.assert_not_called() - def test_publish_existing_application_should_update_application_if_version_exists(self): - self.serverlessrepo_mock.create_application.side_effect = self.application_exists_error + def test_publish_existing_application_should_update_application_if_version_exists( + self + ): + self.serverlessrepo_mock.create_application.side_effect = ( + self.application_exists_error + ) self.serverlessrepo_mock.create_application_version.side_effect = ClientError( - {'Error': {'Code': 'ConflictException', 'Message': 'Random'}}, - 'create_application_version' + {"Error": {"Code": "ConflictException", "Message": "Random"}}, + "create_application_version", ) actual_result = publish_application(self.template) expected_result = { - 'application_id': self.application_id, - 'actions': [UPDATE_APPLICATION], - 'details': { + "application_id": self.application_id, + "actions": [UPDATE_APPLICATION], + "details": { # Name, LicenseUrl and SourceCodeUrl shouldn't show up - 'Description': 'hello world', - 'Author': 'abc', - 'Labels': ['test1', 'test2'], - 'HomePageUrl': 'https://github.com/abc/def', - 'ReadmeUrl': 's3://test-bucket/README.md' - } + "Description": "hello world", + "Author": "abc", + "Labels": ["test1", "test2"], + "HomePageUrl": "https://github.com/abc/def", + "ReadmeUrl": "s3://test-bucket/README.md", + }, } self.assertEqual(expected_result, actual_result) @@ -243,22 +282,24 @@ def test_publish_existing_application_should_update_application_if_version_exist self.serverlessrepo_mock.create_application_version.assert_called_once() def test_publish_new_version_should_create_application_version(self): - self.serverlessrepo_mock.create_application.side_effect = self.application_exists_error + self.serverlessrepo_mock.create_application.side_effect = ( + self.application_exists_error + ) actual_result = publish_application(self.template) expected_result = { - 'application_id': self.application_id, - 'actions': [UPDATE_APPLICATION, CREATE_APPLICATION_VERSION], - 'details': { + "application_id": self.application_id, + "actions": [UPDATE_APPLICATION, CREATE_APPLICATION_VERSION], + "details": { # Name and LicenseUrl shouldn't show up since they can't be updated - 'Description': 'hello world', - 'Author': 'abc', - 'ReadmeUrl': 's3://test-bucket/README.md', - 'Labels': ['test1', 'test2'], - 'HomePageUrl': 'https://github.com/abc/def', - 'SourceCodeUrl': 'https://github.com/abc/def', - 'SemanticVersion': '1.0.0' - } + "Description": "hello world", + "Author": "abc", + "ReadmeUrl": "s3://test-bucket/README.md", + "Labels": ["test1", "test2"], + "HomePageUrl": "https://github.com/abc/def", + "SourceCodeUrl": "https://github.com/abc/def", + "SemanticVersion": "1.0.0", + }, } self.assertEqual(expected_result, actual_result) @@ -266,25 +307,35 @@ def test_publish_new_version_should_create_application_version(self): self.serverlessrepo_mock.update_application.assert_called_once() # should continue to create application version expected_request = { - 'ApplicationId': self.application_id, - 'SourceCodeUrl': 'https://github.com/abc/def', - 'SemanticVersion': '1.0.0', - 'TemplateBody': self.yaml_template_without_metadata + "ApplicationId": self.application_id, + "SourceCodeUrl": "https://github.com/abc/def", + "SemanticVersion": "1.0.0", + "TemplateBody": self.yaml_template_without_metadata, } - self.serverlessrepo_mock.create_application_version.assert_called_once_with(**expected_request) + self.serverlessrepo_mock.create_application_version.assert_called_once_with( + **expected_request + ) - @patch('serverlessrepo.publish._wrap_client_error') - def test_publish_wrap_client_error_when_create_application_version(self, wrap_client_error_mock): - self.serverlessrepo_mock.create_application.side_effect = self.application_exists_error - self.serverlessrepo_mock.create_application_version.side_effect = self.not_conflict_exception - wrap_client_error_mock.return_value = ServerlessRepoClientError(message="client error") + @patch("serverlessrepo.publish._wrap_client_error") + def test_publish_wrap_client_error_when_create_application_version( + self, wrap_client_error_mock + ): + self.serverlessrepo_mock.create_application.side_effect = ( + self.application_exists_error + ) + self.serverlessrepo_mock.create_application_version.side_effect = ( + self.not_conflict_exception + ) + wrap_client_error_mock.return_value = ServerlessRepoClientError( + message="client error" + ) with self.assertRaises(ServerlessRepoClientError): publish_application(self.template) def test_create_application_with_passed_in_sar_client(self): sar_client = Mock() sar_client.create_application.return_value = { - 'ApplicationId': self.application_id + "ApplicationId": self.application_id } publish_application(self.template, sar_client) @@ -299,6 +350,11 @@ def test_create_application_with_passed_in_sar_client(self): def test_update_application_with_passed_in_sar_client(self): sar_client = Mock() + paginator_mock = Mock() + paginator_mock.paginate.return_value = [ + {"ApplicationId": self.application_id, "Name": "test-app"} + ] + sar_client.get_paginator.return_value = paginator_mock sar_client.create_application.side_effect = self.application_exists_error publish_application(self.template, sar_client) @@ -313,51 +369,69 @@ def test_update_application_with_passed_in_sar_client(self): def test_create_application_with_licensebody(self): self.serverlessrepo_mock.create_application.return_value = { - 'ApplicationId': self.application_id + "ApplicationId": self.application_id } - template_with_licensebody = self.template \ - .replace('"LicenseUrl": "s3://test-bucket/LICENSE"', '"LicenseBody": "test test"') + template_with_licensebody = self.template.replace( + '"LicenseUrl": "s3://test-bucket/LICENSE"', '"LicenseBody": "test test"' + ) actual_result = publish_application(template_with_licensebody) expected_result = { - 'application_id': self.application_id, - 'actions': [CREATE_APPLICATION], - 'details': { - 'Author': 'abc', - 'Description': 'hello world', - 'HomePageUrl': 'https://github.com/abc/def', - 'Labels': ['test1', 'test2'], - 'LicenseBody': 'test test', - 'Name': 'test-app', - 'ReadmeUrl': 's3://test-bucket/README.md', - 'SemanticVersion': '1.0.0', - 'SourceCodeUrl': 'https://github.com/abc/def' - } + "application_id": self.application_id, + "actions": [CREATE_APPLICATION], + "details": { + "Author": "abc", + "Description": "hello world", + "HomePageUrl": "https://github.com/abc/def", + "Labels": ["test1", "test2"], + "LicenseBody": "test test", + "Name": "test-app", + "ReadmeUrl": "s3://test-bucket/README.md", + "SemanticVersion": "1.0.0", + "SourceCodeUrl": "https://github.com/abc/def", + }, } self.assertEqual(expected_result, actual_result) def test_update_application_with_readmebody(self): - self.serverlessrepo_mock.create_application.side_effect = self.application_exists_error - template_with_readmebody = self.template \ - .replace('"SemanticVersion": "1.0.0"', '') \ - .replace('"ReadmeUrl": "s3://test-bucket/README.md"', '"ReadmeBody": "test test"') + self.serverlessrepo_mock.create_application.side_effect = ( + self.application_exists_error + ) + template_with_readmebody = self.template.replace( + '"SemanticVersion": "1.0.0"', "" + ).replace( + '"ReadmeUrl": "s3://test-bucket/README.md"', '"ReadmeBody": "test test"' + ) actual_result = publish_application(template_with_readmebody) expected_result = { - 'application_id': self.application_id, - 'actions': [UPDATE_APPLICATION], - 'details': { - 'Description': 'hello world', - 'Author': 'abc', - 'ReadmeBody': 'test test', - 'Labels': ['test1', 'test2'], - 'HomePageUrl': 'https://github.com/abc/def' - } + "application_id": self.application_id, + "actions": [UPDATE_APPLICATION], + "details": { + "Description": "hello world", + "Author": "abc", + "ReadmeBody": "test test", + "Labels": ["test1", "test2"], + "HomePageUrl": "https://github.com/abc/def", + }, } self.assertEqual(expected_result, actual_result) + def test_update_application_with_multiple_matching_applications(self): + sar_client = Mock() + paginator_mock = Mock() + paginator_mock.paginate.return_value = [ + {"ApplicationId": self.application_id, "Name": "test-app"}, + {"ApplicationId": self.application_id, "Name": "test-app"}, + ] + sar_client.get_paginator.return_value = paginator_mock + sar_client.create_application.side_effect = self.application_exists_error + + with self.assertRaises(MultipleMatchingApplicationsError): + publish_application(self.template, sar_client) + class TestUpdateApplicationMetadata(TestCase): def setUp(self): - patcher = patch('serverlessrepo.publish.boto3') + patcher = patch("serverlessrepo.publish.boto3") self.addCleanup(patcher.stop) self.boto3_mock = patcher.start() self.serverlessrepo_mock = Mock() @@ -375,23 +449,29 @@ def setUp(self): } """ self.template_dict = json.loads(self.template) - self.application_id = 'arn:aws:serverlessrepo:us-east-1:123456789012:applications/test-app' + self.application_id = ( + "arn:aws:serverlessrepo:us-east-1:123456789012:applications/test-app" + ) def test_raise_value_error_for_empty_template(self): with self.assertRaises(ValueError) as context: - update_application_metadata('', self.application_id) + update_application_metadata("", self.application_id) message = str(context.exception) - expected = 'Require SAM template and application ID to update application metadata' + expected = ( + "Require SAM template and application ID to update application metadata" + ) self.assertEqual(expected, message) self.serverlessrepo_mock.update_application.assert_not_called() def test_raise_value_error_for_empty_application_id(self): with self.assertRaises(ValueError) as context: - update_application_metadata(self.template, '') + update_application_metadata(self.template, "") message = str(context.exception) - expected = 'Require SAM template and application ID to update application metadata' + expected = ( + "Require SAM template and application ID to update application metadata" + ) self.assertEqual(expected, message) self.serverlessrepo_mock.update_application.assert_not_called() @@ -400,17 +480,19 @@ def test_raise_value_error_for_not_dict_or_string_template(self): update_application_metadata(123, self.application_id) message = str(context.exception) - expected = 'Input template should be a string or dictionary' + expected = "Input template should be a string or dictionary" self.assertEqual(expected, message) self.serverlessrepo_mock.update_application.assert_not_called() - @patch('serverlessrepo.publish.parse_template') - def test_update_application_metadata_with_template_string_should_parse_template(self, parse_template_mock): + @patch("serverlessrepo.publish.parse_template") + def test_update_application_metadata_with_template_string_should_parse_template( + self, parse_template_mock + ): parse_template_mock.return_value = self.template_dict update_application_metadata(self.template, self.application_id) parse_template_mock.assert_called_with(self.template) - @patch('serverlessrepo.publish.copy.deepcopy') + @patch("serverlessrepo.publish.copy.deepcopy") def test_publish_template_dict_should_copy_template(self, copy_mock): copy_mock.return_value = self.template_dict update_application_metadata(self.template_dict, self.application_id) @@ -420,11 +502,13 @@ def test_update_application_metadata_ignore_irrelevant_fields(self): update_application_metadata(self.template, self.application_id) # SemanticVersion in the template should be ignored expected_request = { - 'ApplicationId': self.application_id, - 'Author': 'abc', - 'Description': 'hello world' + "ApplicationId": self.application_id, + "Author": "abc", + "Description": "hello world", } - self.serverlessrepo_mock.update_application.assert_called_once_with(**expected_request) + self.serverlessrepo_mock.update_application.assert_called_once_with( + **expected_request + ) def test_update_application_metadata_with_passed_in_sar_client(self): sar_client = Mock()