From 902fb9bca223655e67c1b7638449b850a0a5f060 Mon Sep 17 00:00:00 2001 From: Bert Blommers Date: Fri, 24 Feb 2023 21:05:08 -0100 Subject: [PATCH] Techdebt: MyPy ElasticBeanstalk (#5972) --- moto/elasticbeanstalk/exceptions.py | 4 +- moto/elasticbeanstalk/models.py | 57 +++++++++++++++++++---------- moto/elasticbeanstalk/responses.py | 20 +++++----- moto/elasticbeanstalk/utils.py | 4 +- setup.cfg | 2 +- 5 files changed, 54 insertions(+), 33 deletions(-) diff --git a/moto/elasticbeanstalk/exceptions.py b/moto/elasticbeanstalk/exceptions.py index d880fa001..22e70cb29 100644 --- a/moto/elasticbeanstalk/exceptions.py +++ b/moto/elasticbeanstalk/exceptions.py @@ -2,10 +2,10 @@ from moto.core.exceptions import RESTError class InvalidParameterValueError(RESTError): - def __init__(self, message): + def __init__(self, message: str): super().__init__("InvalidParameterValue", message) class ResourceNotFoundException(RESTError): - def __init__(self, message): + def __init__(self, message: str): super().__init__("ResourceNotFoundException", message) diff --git a/moto/elasticbeanstalk/models.py b/moto/elasticbeanstalk/models.py index f984346a9..e809c8cf6 100644 --- a/moto/elasticbeanstalk/models.py +++ b/moto/elasticbeanstalk/models.py @@ -1,4 +1,5 @@ import weakref +from typing import Dict, List from moto.core import BaseBackend, BackendDict, BaseModel from .exceptions import InvalidParameterValueError, ResourceNotFoundException @@ -6,7 +7,13 @@ from .utils import make_arn class FakeEnvironment(BaseModel): - def __init__(self, application, environment_name, solution_stack_name, tags): + def __init__( + self, + application: "FakeApplication", + environment_name: str, + solution_stack_name: str, + tags: Dict[str, str], + ): self.application = weakref.proxy( application ) # weakref to break circular dependencies @@ -15,39 +22,41 @@ class FakeEnvironment(BaseModel): self.tags = tags @property - def application_name(self): + def application_name(self) -> str: return self.application.application_name @property - def environment_arn(self): + def environment_arn(self) -> str: resource_path = f"{self.application_name}/{self.environment_name}" return make_arn( self.region, self.application.account_id, "environment", resource_path ) @property - def platform_arn(self): + def platform_arn(self) -> str: return "TODO" # TODO @property - def region(self): + def region(self) -> str: return self.application.region class FakeApplication(BaseModel): - def __init__(self, backend, application_name): + def __init__(self, backend: "EBBackend", application_name: str): self.backend = weakref.proxy(backend) # weakref to break cycles self.application_name = application_name - self.environments = dict() + self.environments: Dict[str, FakeEnvironment] = dict() self.account_id = self.backend.account_id self.region = self.backend.region_name self.arn = make_arn( self.region, self.account_id, "application", self.application_name ) - def create_environment(self, environment_name, solution_stack_name, tags): + def create_environment( + self, environment_name: str, solution_stack_name: str, tags: Dict[str, str] + ) -> FakeEnvironment: if environment_name in self.environments: - raise InvalidParameterValueError + raise InvalidParameterValueError(message="") env = FakeEnvironment( application=self, @@ -61,12 +70,14 @@ class FakeApplication(BaseModel): class EBBackend(BaseBackend): - def __init__(self, region_name, account_id): + def __init__(self, region_name: str, account_id: str): super().__init__(region_name, account_id) - self.applications = dict() + self.applications: Dict[str, FakeApplication] = dict() @staticmethod - def default_vpc_endpoint_service(service_region, zones): + def default_vpc_endpoint_service( + service_region: str, zones: List[str] + ) -> List[Dict[str, str]]: """Default VPC endpoint service.""" return BaseBackend.default_vpc_endpoint_service_factory( service_region, zones, "elasticbeanstalk" @@ -74,7 +85,7 @@ class EBBackend(BaseBackend): service_region, zones, "elasticbeanstalk-health" ) - def create_application(self, application_name): + def create_application(self, application_name: str) -> FakeApplication: if application_name in self.applications: raise InvalidParameterValueError( f"Application {application_name} already exists." @@ -83,23 +94,31 @@ class EBBackend(BaseBackend): self.applications[application_name] = new_app return new_app - def create_environment(self, app, environment_name, stack_name, tags): + def create_environment( + self, + app: FakeApplication, + environment_name: str, + stack_name: str, + tags: Dict[str, str], + ) -> FakeEnvironment: return app.create_environment( environment_name=environment_name, solution_stack_name=stack_name, tags=tags ) - def describe_environments(self): + def describe_environments(self) -> List[FakeEnvironment]: envs = [] for app in self.applications.values(): for env in app.environments.values(): envs.append(env) return envs - def list_available_solution_stacks(self): + def list_available_solution_stacks(self) -> None: # Implemented in response.py pass - def update_tags_for_resource(self, resource_arn, tags_to_add, tags_to_remove): + def update_tags_for_resource( + self, resource_arn: str, tags_to_add: Dict[str, str], tags_to_remove: List[str] + ) -> None: try: res = self._find_environment_by_arn(resource_arn) except KeyError: @@ -113,7 +132,7 @@ class EBBackend(BaseBackend): for key in tags_to_remove: del res.tags[key] - def list_tags_for_resource(self, resource_arn): + def list_tags_for_resource(self, resource_arn: str) -> Dict[str, str]: try: res = self._find_environment_by_arn(resource_arn) except KeyError: @@ -122,7 +141,7 @@ class EBBackend(BaseBackend): ) return res.tags - def _find_environment_by_arn(self, arn): + def _find_environment_by_arn(self, arn: str) -> FakeEnvironment: for app in self.applications.keys(): for env in self.applications[app].environments.values(): if env.environment_arn == arn: diff --git a/moto/elasticbeanstalk/responses.py b/moto/elasticbeanstalk/responses.py index 74d345a6c..568ed4c16 100644 --- a/moto/elasticbeanstalk/responses.py +++ b/moto/elasticbeanstalk/responses.py @@ -1,21 +1,21 @@ from moto.core.responses import BaseResponse from moto.core.utils import tags_from_query_string -from .models import eb_backends +from .models import eb_backends, EBBackend from .exceptions import InvalidParameterValueError class EBResponse(BaseResponse): - def __init__(self): + def __init__(self) -> None: super().__init__(service_name="elasticbeanstalk") @property - def backend(self): + def backend(self) -> EBBackend: """ :rtype: EBBackend """ return eb_backends[self.current_account][self.region] - def create_application(self): + def create_application(self) -> str: app = self.backend.create_application( application_name=self._get_param("ApplicationName") ) @@ -23,11 +23,11 @@ class EBResponse(BaseResponse): template = self.response_template(EB_CREATE_APPLICATION) return template.render(region_name=self.backend.region_name, application=app) - def describe_applications(self): + def describe_applications(self) -> str: template = self.response_template(EB_DESCRIBE_APPLICATIONS) return template.render(applications=self.backend.applications.values()) - def create_environment(self): + def create_environment(self) -> str: application_name = self._get_param("ApplicationName") try: app = self.backend.applications[application_name] @@ -47,16 +47,16 @@ class EBResponse(BaseResponse): template = self.response_template(EB_CREATE_ENVIRONMENT) return template.render(environment=env, region=self.backend.region_name) - def describe_environments(self): + def describe_environments(self) -> str: envs = self.backend.describe_environments() template = self.response_template(EB_DESCRIBE_ENVIRONMENTS) return template.render(environments=envs) - def list_available_solution_stacks(self): + def list_available_solution_stacks(self) -> str: return EB_LIST_AVAILABLE_SOLUTION_STACKS - def update_tags_for_resource(self): + def update_tags_for_resource(self) -> str: resource_arn = self._get_param("ResourceArn") tags_to_add = tags_from_query_string( self.querystring, prefix="TagsToAdd.member" @@ -66,7 +66,7 @@ class EBResponse(BaseResponse): return EB_UPDATE_TAGS_FOR_RESOURCE - def list_tags_for_resource(self): + def list_tags_for_resource(self) -> str: resource_arn = self._get_param("ResourceArn") tags = self.backend.list_tags_for_resource(resource_arn) diff --git a/moto/elasticbeanstalk/utils.py b/moto/elasticbeanstalk/utils.py index e3e22a11d..e3e2e0f6b 100644 --- a/moto/elasticbeanstalk/utils.py +++ b/moto/elasticbeanstalk/utils.py @@ -1,4 +1,6 @@ -def make_arn(region, account_id, resource_type, resource_path): +def make_arn( + region: str, account_id: str, resource_type: str, resource_path: str +) -> str: arn_template = ( "arn:aws:elasticbeanstalk:{region}:{account_id}:{resource_type}/{resource_path}" ) diff --git a/setup.cfg b/setup.cfg index 15ba29675..9140bce3f 100644 --- a/setup.cfg +++ b/setup.cfg @@ -229,7 +229,7 @@ disable = W,C,R,E enable = anomalous-backslash-in-string, arguments-renamed, dangerous-default-value, deprecated-module, function-redefined, import-self, redefined-builtin, redefined-outer-name, reimported, pointless-statement, super-with-arguments, unused-argument, unused-import, unused-variable, useless-else-on-loop, wildcard-import [mypy] -files= moto/a*,moto/b*,moto/c*,moto/d*,moto/ebs/,moto/ec2,moto/ec2instanceconnect,moto/ecr,moto/ecs,moto/efs,moto/eks,moto/elasticache,moto/es,moto/moto_api +files= moto/a*,moto/b*,moto/c*,moto/d*,moto/ebs/,moto/ec2,moto/ec2instanceconnect,moto/ecr,moto/ecs,moto/efs,moto/eks,moto/elasticache,moto/elasticbeanstalk,moto/es,moto/moto_api show_column_numbers=True show_error_codes = True disable_error_code=abstract