def setUp(self):
log_name = 'component_test'
log_filename = None
log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
logging.basicConfig(format=log_format,
filename=log_filename,
level=logging.DEBUG)
self.logger = logging.getLogger(log_name)
# ignora falso positivos
# https://github.com/boto/boto3/issues/454
warnings.filterwarnings("ignore",
category=ResourceWarning,
message="unclosed.*<ssl.SSLSocket.*>")
# reset config and env
reset()
reset_config()
# load integration
APP_TYPE = os.environ['APP_TYPE']
if APP_TYPE == 'Flask':
load_dot_env()
else:
load_env()
self.config = get_config()
def __init__(self, logger=None, config=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
def test_connection(self):
self.logger.info('Running test: %s', get_function_name(__name__))
config = get_config()
self.logger.info('REDIS_HOST: {}'.format(config.REDIS_HOST))
self.logger.info('REDIS_PORT: {}'.format(config.REDIS_PORT))
connection = get_connection()
self.assertIsNotNone(connection)
def connect():
from flask_app.config import get_config
config = get_config()
endpoint_url = config.SQS_ENDPOINT
session = session_mock
connection = session.resource('sqs',
endpoint_url=endpoint_url,
region_name=config.REGION_NAME)
return connection
def get_connection(config=None, retry=False):
global _CONNECTION, _RETRY_COUNT, _MAX_RETRY_ATTEMPTS
if not _CONNECTION:
connection = None
if config is None:
config = get_config()
try:
host = config.REDIS_HOST
port = config.REDIS_PORT
test = False
try:
connection = redis.Redis(
host=host,
port=port
)
test = connection.set('connection', 'true')
except Exception as err:
logger.error(err)
# docker
if host == 'redis':
# localhost
host = 'localhost'
connection = redis.Redis(
host=host,
port=port
)
test = connection.set('connection', 'true')
if not test:
raise Exception('Redis - Unable to connect')
else:
_CONNECTION = connection
_RETRY_COUNT = 0
logger.info('Redis - Connected')
except Exception as err:
if _RETRY_COUNT == _MAX_RETRY_ATTEMPTS:
_RETRY_COUNT = 0
logger.error(err)
connection = None
return connection
else:
logger.error(err)
logger.info('Redis - Trying to reconnect... {}'.format(_RETRY_COUNT))
sleep(0.1)
# retry
if not retry:
_RETRY_COUNT += 1
return get_connection(config)
else:
connection = _CONNECTION
return connection
def test_connection_error(self):
self.logger.info('Running test: %s', get_function_name(__name__))
config = get_config()
# forca os parametros
config.REDIS_HOST = 'localhost'
config.REDIS_PORT = '1111'
self.logger.info('REDIS_HOST: {}'.format(config.REDIS_HOST))
self.logger.info('REDIS_PORT: {}'.format(config.REDIS_PORT))
connection = get_connection(config)
self.assertIsNone(connection)
def test_list(self, request:ApiRequest):
self.logger.info('Running test: %s', get_function_name(__name__))
event_type = EventType.SALE_EVENT
where = "{}:*".format(event_type)
config = get_config()
connection = get_connection(config)
repository = EventRepository(redis_connection=connection)
result = repository.list(where=where, offset=request.offset, limit=request.limit)
self.assertIsNotNone(result)
self.assertTrue(len(result) > 0)
def test_create(self, event: EventVO):
self.logger.info('Running test: %s', get_function_name(__name__))
event_type = event.type
key = '%s:%s' % (event_type, event.hash)
config = get_config()
connection = get_connection(config)
repository = EventRepository(redis_connection=connection)
result = repository.create(key, event.to_json())
self.assertTrue(result)
with self.assertRaises(DatabaseException):
repository.create(key, event.to_json())
def test_get(self, event: EventVO):
self.logger.info('Running test: %s', get_function_name(__name__))
event_type = event.type
key = '%s:%s' % (event_type, event.hash)
config = get_config()
connection = get_connection(config)
repository = EventRepository(redis_connection=connection)
result = repository.create(key, event.to_json())
response = repository.get(key)
self.assertTrue(result)
self.assertIsNotNone(response)
def setUpClass(cls):
cls.CONFIG = get_config()
if cls.EXECUTE_FIXTURE:
pass
from flask_app import APP_NAME, APP_VERSION
# Create an APISpec
from flask_app.config import get_config
from flask_app.helper import open_vendor_file
from flask_app.logging import get_logger
servers = [{
"url":
os.environ["API_SERVER"] if "API_SERVER" in os.environ else None,
"description":
os.environ["API_SERVER_DESCRIPTION"]
if "API_SERVER_DESCRIPTION" in os.environ else None
}]
if get_config().APP_ENV == "development":
servers.append({
"url": os.environ["LOCAL_API_SERVER"] if "LOCAL_API_SERVER" in os.environ else "http://localhost:5000",
"description": os.environ["LOCAL_API_SERVER_DESCRIPTION"] \
if "LOCAL_API_SERVER_DESCRIPTION" in os.environ \
else "Development server "
})
spec = APISpec(title=APP_NAME,
openapi_version='3.0.2',
version=APP_VERSION,
plugins=[MarshmallowPlugin()],
servers=servers)
def generate_openapi_yml(spec_object, logger, force=False):
from flask_app.enums.messages import MessagesEnum
from flask_app.exceptions import ApiException
from flask_app.http_resources.request import ApiRequest
from flask_app.http_resources.response import ApiResponse
from flask_app.config import get_config
from flask_app.helper import open_vendor_file
from flask_app.http_helper import CUSTOM_DEFAULT_HEADERS
from flask_app.logging import get_logger, get_log_level
from flask_app.openapi import spec, generate_openapi_yml, get_doc
from flask_app.openapi import api_schemas
from flask import Flask
# config
config = get_config()
# debug
debug = helper.debug_mode()
# logger
logger = get_logger()
# chalice app
app = Flask(__name__)
# override the log configs
if not debug:
# override to the level desired
logger.level = get_log_level()
# override the log instance
app.log = logger
# Set the secret key to some random bytes. Keep this really secret!
app.secret_key = config.SECRET_KEY.encode()
app = Flask(__name__)
