Merge pull request #7 from madeiramadeirabr/unit_tests

Adição de testes de unidade e mocks

Author: andersoncontreira

examples/lambda_api/app.py

@@ -70,8 +70,6 @@ def alive():
                         application/json:
                             schema: HealthCheckSchema
         """
-    # body = {"app": "I'm alive!"}
-    # return http_helper.create_response(body=body, status_code=200)
     service = HealthCheckService()
     service.add_check("self", SelfConnectionHealthCheck(logger, config), [])
     service.add_check("mysql", MysqlConnectionHealthCheck(logger, config), ["db"])

examples/lambda_api/env/development.env

@@ -12,7 +12,7 @@ LOCAL_API_SERVER=http://localhost:5000
 LOCAL_API_SERVER_DESCRIPTION=Development server
 REDIS_HOST=redis
 REDIS_PORT=6379
-DB_HOST = mysql
-DB_USER = root
-DB_PASSWORD = store
-DB = store
+DB_HOST=mysql
+DB_USER=root
+DB_PASSWORD=store
+DB=store

examples/lambda_api/lambda_app/database/dynamodb.py

@@ -0,0 +1,60 @@
+import os
+from time import sleep
+
+import boto3
+
+from chalicelib.logging import get_logger
+
+logger = get_logger()
+
+_CONNECTION = False
+_RETRY_COUNT = 0
+_MAX_RETRY_ATTEMPTS = 3
+
+
+def reset():
+    global _CONNECTION
+    _CONNECTION = False
+
+
+def get_connection(connect=True, retry=False):
+    global _CONNECTION, _RETRY_COUNT, _MAX_RETRY_ATTEMPTS
+    if not _CONNECTION:
+        connection = None
+        try:
+            profile = os.environ['AWS_PROFILE'] if 'AWS_PROFILE' in os.environ else None
+            logger.info('profile: {}'.format(profile))
+            if profile:
+                session = boto3.session.Session(profile_name=profile)
+                connection = session.resource(
+                    'dynamodb',
+                    region_name="sa-east-1"
+                )
+            else:
+                connection = boto3.resource(
+                    'dynamodb',
+                    region_name="sa-east-1"
+                )
+
+            _CONNECTION = connection
+            _RETRY_COUNT = 0
+            logger.info('Connected')
+
+        except Exception as err:
+            if _RETRY_COUNT == _MAX_RETRY_ATTEMPTS:
+                _RETRY_COUNT = 0
+                logger.error(err)
+                return connection
+            else:
+                logger.error(err)
+                logger.info('Trying to reconnect... {}'.format(_RETRY_COUNT))
+
+                sleep(0.1)
+                # retry
+                if not retry:
+                    _RETRY_COUNT += 1
+                    return get_connection(True)
+    else:
+        connection = _CONNECTION
+
+    return connection

examples/lambda_api/lambda_app/database/mysql.py

@@ -2,7 +2,7 @@
 
 from lambda_app.config import get_config
 from lambda_app.logging import get_logger
-from vendor import pymysql
+import pymysql
 
 logger = get_logger()
 

examples/lambda_api/lambda_app/events/aws/sqs.py

@@ -9,30 +9,37 @@
 _RETRY_COUNT = 0
 _MAX_RETRY_ATTEMPTS = 3
 
+
 class SQSEvents:
 
-    def __init__(self, logger=None, config=None):
+    def __init__(self, logger=None, config=None, profile=None, session=None):
         # logger
         self.logger = logger if logger is not None else get_logger()
         # configurations
         self.config = config if config is not None else get_config()
         # last_exception
         self.exception = None
+        # profile
+        self.profile = profile if profile is not None else \
+            os.environ['AWS_PROFILE'] if 'AWS_PROFILE' in os.environ else None
+        # session
+        self.session = session if session is not None else \
+            boto3.session.Session(profile_name=self.profile)
 
     def connect(self, retry=False):
         global _RETRY_COUNT, _MAX_RETRY_ATTEMPTS
         connection = None
         try:
             endpoint_url = self.config.SQS_ENDPOINT
-            profile = os.environ['AWS_PROFILE'] if 'AWS_PROFILE' in os.environ else None
+
             queue_name = os.path.basename(os.environ['APP_QUEUE']) if 'APP_QUEUE' in os.environ else None
-            self.logger.info('SQSEvents - profile: {}'.format(profile))
+            self.logger.info('SQSEvents - profile: {}'.format(self.profile))
             self.logger.info('SQSEvents - endpoint_url: {}'.format(endpoint_url))
             self.logger.info('SQSEvents - queue_name: {}'.format(queue_name))
             self.logger.info('SQSEvents - self.config.REGION_NAME: {}'.format(self.config.REGION_NAME))
 
-            if profile:
-                session = boto3.session.Session(profile_name=profile)
+            if self.profile:
+                session = self.session
                 connection = session.resource(
                     'sqs',
                     endpoint_url=endpoint_url,
@@ -70,10 +77,12 @@ def connect(self, retry=False):
                 if not retry:
                     _RETRY_COUNT += 1
                     # Fix para tratar diff entre docker/local
-                    if self.config.SQS_ENDPOINT == 'http://0.0.0.0:4566' or self.config.SQS_ENDPOINT == 'http://localstack:4566':
+                    if self.config.SQS_ENDPOINT == 'http://0.0.0.0:4566' or \
+                            self.config.SQS_ENDPOINT == 'http://localstack:4566':
                         old_value = self.config.SQS_ENDPOINT
                         self.config.SQS_ENDPOINT = 'http://localhost:4566'
-                        self.logger.info('Changing the endpoint from {} to {}'.format(old_value, self.config.SQS_ENDPOINT))
+                        self.logger.info(
+                            'Changing the endpoint from {} to {}'.format(old_value, self.config.SQS_ENDPOINT))
                     connection = self.connect(retry=True)
         return connection
 
@@ -166,7 +175,3 @@ def delete_queue(self, queue_name):
             result = False
 
         return result
-
-
-
-

examples/lambda_api/lambda_app/repositories/mysql/__init__.py

@@ -1,6 +1,6 @@
 from lambda_app.database.mysql import get_connection
 from lambda_app.logging import get_logger
-from vendor import pymysql
+import pymysql
 
 
 class AbstractRepository:
@@ -21,7 +21,9 @@ def _execute(self, sql, params=None):
             self.logger.info("SQL: {}".format(sql))
             self.logger.info("SQL Values: {}".format(params))
 
-        if isinstance(self.connection, pymysql.connections.Connection):
+        # issubclass(connection_mock.__class__, pymysql.connections.Connection)
+        if isinstance(self.connection, pymysql.connections.Connection) \
+                or issubclass(self.connection.__class__, pymysql.connections.Connection):
             # always connect because is treadsafe
             self.connection.connect()
             # with self.connection.cursor() as cursor:
@@ -36,3 +38,5 @@ def _execute(self, sql, params=None):
 
     def _close(self):
         self.connection.close()
+
+

examples/lambda_api/lambda_app/repositories/mysql/product_repository.py

@@ -5,7 +5,7 @@
 from lambda_app.logging import get_logger
 from lambda_app.repositories.mysql import AbstractRepository
 from lambda_app.vos.product import ProductVO
-from vendor import pymysql
+import pymysql
 
 
 class ProductRepository(AbstractRepository):

examples/lambda_api/lambda_app/services/v1/healthcheck/__init__.py

@@ -36,6 +36,18 @@ def unhealthy(description):
     def degraded(description):
         return HealthCheckResult(HealthStatus.DEGRADED, description)
 
+    def __str__(self):
+        return self.to_dict()
+
+    def __repr__(self):
+        return self.to_json()
+
+    def to_dict(self):
+        return {'status': self.status, 'description': self.description}
+
+    def to_json(self):
+        return json.dumps(self.to_dict())
+
 
 class EntrySchema(Schema):
     status = fields.Str(example=HealthStatus.HEALTHY.value)

examples/lambda_api/lambda_app/services/v1/healthcheck/resources.py

@@ -9,20 +9,20 @@
 
 
 class SelfConnectionHealthCheck(AbstractHealthCheck):
-    def __init__(self, logger=None, config=None):
+    def __init__(self, logger=None, config=None, http_client=None):
         super().__init__(logger=logger, config=config)
+        self.http_client = http_client if http_client is not None else requests
 
     def check_health(self):
         result = False
         description = "Unable to connect"
         check_result = HealthCheckResult.unhealthy(description)
-        response = None
         try:
             result = True
             url = os.environ["API_SERVER"] if "API_SERVER" in os.environ else None
             url = url + "/docs"
             self.logger.info("requesting url: {}".format(url))
-            response = requests.get(url)
+            response = self.http_client.get(url)
             if response:
                 if response.status_code == 200:
                     result = True

examples/lambda_api/requirements-tests.txt

@@ -1,3 +1,4 @@
+serverless-wsgi
 unittest-data-provider
 coverage
 coverage2clover