def test_list(self, request):
self.logger.info('Running test: %s', get_function_name(__name__))
service = ConsultingManagerService(logger=self.logger,
config=self.CONFIG,
connection=get_connection())
data = service.list(request)
self.assertTrue(len(data) == request.limit)
def test_list(self, request):
self.logger.info('Running test: %s', get_function_name(__name__))
service = StandardManagerService(logger=self.logger,
config=self.CONFIG,
connection=get_connection())
data = service.list(request)
self.assertIsNotNone(data)
def test_get_datasource(self):
self.logger.info('Running test: %s', get_function_name(__name__))
# TODO apenas fazer com mocks tá errado
service = UpdateCheckerService(logger=self.logger,
config=self.CONFIG,
connection=get_connection())
datasources = service.get_datasources()
self.assertIsNotNone(datasources)
def test_execute(self):
self.logger.info('Running test: %s', get_function_name(__name__))
service = UpdateSynchronizerService(logger=self.logger,
config=self.CONFIG,
connection=get_connection())
result = service.execute()
self.assertIsNotNone(result)
def test_list(self, request):
self.logger.info('Running test: %s', get_function_name(__name__))
service = StandardUpdatesService(logger=self.logger,
config=self.config,
connection=self.connection)
data = service.list(request)
# print(len(data))
self.assertIsNotNone(data)
def test_index_multiple(self, event):
self.logger.info('Running test: %s', get_function_name(__name__))
self.logger.info('Event: {}'.format(event))
lambda_context = FakeLambdaContext()
response = app.index(event=event, context=lambda_context)
self.assertTrue(response)
def test_get(self):
self.logger.info('Running test: %s', get_function_name(__name__))
api = Api()
url = '{}/{}'.format(self.config.API_URL, 657705)
headers = api.build_headers_from_string(self.config.API_TOKEN)
response = api.get(url, headers=headers)
api.log(response)
self.assertEqual(response.status_code, 200)
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 test_send_message(self, message):
self.logger.info('Running test: %s', get_function_name(__name__))
sqs = SQSEvents()
queue_url = self.CONFIG.APP_QUEUE
response = sqs.send_message(message, queue_url)
self.assertIsNotNone(response)
self.assertIsInstance(response, dict)
self.assertTrue('MD5OfMessageBody' in response)
self.assertTrue('MessageId' in response)
def test_execute(self):
self.logger.info('Running test: %s', get_function_name(__name__))
service = UpdateCheckerService(logger=self.logger,
config=self.CONFIG,
connection=get_connection())
result = service.execute()
self.assertIsNotNone(result)
self.logger.info("Total of updates: {}".format(len(service.updates)))
self.assertGreater(len(service.updates), 0)
def test_count(self, request):
"""
:param (ApiRequest) request:
:return:
"""
self.logger.info('Running test: %s', get_function_name(__name__))
service = StandardUpdatesService(logger=self.logger, config=self.CONFIG, connection=get_connection())
data = service.count(request)
self.assertIsNotNone(data)
self.assertTrue(data > 0)
def test_load_dot_env(self, env, expected):
self.logger.info('Running test: %s - %s', get_function_name(__name__),
env)
APP_TYPE = os.environ['APP_TYPE']
if APP_TYPE == 'Flask':
reset()
load_dot_env(env)
self.assertEqual(is_loaded(), expected)
else:
self.skipTest(
'test_load_dot_env - Ignored because the APP_TYPE {}'.format(
APP_TYPE))
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 test_auth_token(self, event, routes_allowed_is_empty):
self.logger.info('Running test: %s', get_function_name(__name__))
lambda_context = FakeLambdaContext()
auth_response_dict = app.auth_token(event=event,
context=lambda_context)
# print(auth_response_dict)
response_body = auth_response_dict['policyDocument']
# response_body = auth_response_dict
# self.assertIsInstance(response, chalice.app.Response)
# response_dict = response.to_dict()
self.assertTrue("Version" in response_body)
self.assertTrue("Statement" in response_body)
is_empty = len(response_body['Statement'][0]['Resource']) > 0
self.assertEqual(is_empty, routes_allowed_is_empty)
def test_load_dot_env(self, env, expected):
self.logger.info('Running test: %s - %s', get_function_name(__name__),
env)
APP_TYPE = os.environ['APP_TYPE']
self.logger.info("APP_TYPE: {}".format(APP_TYPE))
if APP_TYPE == 'Flask':
# AWS Image condition
if 'ENVIRONMENT_NAME' in os.environ:
if env == os.environ['ENVIRONMENT_NAME']:
expected = True
reset()
load_dot_env(env)
self.assertEqual(is_loaded(), expected)
else:
self.skipTest(
'test_load_dot_env - Ignored because the APP_TYPE {}'.format(
APP_TYPE))
def test_connect(self):
self.logger.info('Running test: %s', get_function_name(__name__))
sqs = SQSEvents()
connection = sqs.connect()
self.assertIsNotNone(connection)
def test_get_datasource(self):
self.logger.info('Running test: %s', get_function_name(__name__))
self.skipTest('Test need review')
service = UpdateCheckerService()
datasources = service.get_datasources()
self.assertIsNotNone(datasources)
def test_execute(self):
self.logger.info('Running test: %s', get_function_name(__name__))
self.skipTest('Test need review')
service = UpdateCheckerService()
result = service.execute()
self.assertIsNotNone(result)
