def test_lambda_handler_with_data(context, dict_data):
event = utils.build_event(dict_data)
uuid_obj = uuid.uuid4()
date_obj = date(2018, 1, 1)
datetime_obj = datetime(
2018,
1,
1,
hour=1,
minute=2,
second=3,
microsecond=45678,
)
@lambda_handler
def handler(req):
payload = {
'req_data': req.data,
'uuid': uuid_obj,
'date': date_obj,
'datetime': datetime_obj
}
return Response(payload)
lambda_output = handler(event, context)
result = utils.parse_lambda_output(lambda_output)
assert result.status_code == 200
assert result.data['req_data'] == dict_data
assert uuid.UUID(result.data['uuid']) == uuid_obj
assert result.data['date'] == '2018-01-01'
assert result.data['datetime'] == '2018-01-01T01:02:03.045678'
def test_pass_no_message_when_no_verbose(setter, fname):
queue = u.setup_aws_mocks()
bucket = u.create_bucket()
# given that verbose is not set
setter()
# when a good file is processed
bucket_name, key_name = u.upload_file(bucket, fname)
event = u.build_event(bucket_name, key_name)
response = lambda_handler(event, u.dummy_context)
# THEN there should be no message
count, msg_json = u.get_one_message(queue)
try:
msg_dict = json.loads(msg_json)
msg = msg_dict['Message']
except ValueError:
msg = ""
# print things that will be useful to debug
print("response:", response)
print("message:", msg)
print("count:", count)
# actual criteria to pass
assert "pass" in response['results'][0]['status']
assert count is 0 and msg is ""
def test_request(self, context):
event = utils.build_event(None)
req = Request(event, context)
assert req.event == event
assert req.context == context
assert req.data == dict()
assert req.query == dict()
def test_request_with_path_params(self, dict_data, context):
event = utils.build_event(None, path_params=dict_data)
req = Request(event, context)
assert req.event == event
assert req.context == context
assert req.data == dict()
assert req.params == dict_data
def test_request_with_data(self, dict_data, context):
event = utils.build_event(dict_data)
req = Request(event, context)
assert req.event == event
assert req.context == context
assert req.data == dict_data
assert req.query == dict()
def test_lambda_handler_invalid_return_value(context):
event = utils.build_event(None)
@lambda_handler
def handler(req):
return None
lambda_output = handler(event, context)
result = utils.parse_lambda_output(lambda_output)
assert result.status_code == 500
def test_lambda_handler_exception(context):
event = utils.build_event(None)
@lambda_handler
def handler(req):
raise Exception('unknown exception')
lambda_output = handler(event, context)
result = utils.parse_lambda_output(lambda_output)
assert result.status_code == 500
assert 'message' in result.data
assert 'errors' in result.data
def test_lambda_handler_with_status_code(context):
expected_status_code = 999
event = utils.build_event(None)
@lambda_handler
def handler(req):
return Response(None, expected_status_code)
lambda_output = handler(event, context)
result = utils.parse_lambda_output(lambda_output)
assert result.status_code == expected_status_code
assert not result.data
def test_exclude_message_when_production(set_production_true, fname, key):
u.setup_aws_mocks()
bucket = u.create_bucket()
# Given that PRODUCTION is missing or true
set_production_true()
# WHEN a bad file is processed:
u.upload_file(bucket, fname, key)
event = u.build_event(bucket.name, key)
response = lambda_handler(event, u.dummy_context)
print("response:", response)
# THEN it should pass & be marked as excluded
assert "pass" in response['results'][0]['status']
assert u.is_in("Excluded from validation", response['results'], 'results')
def test_lambda_handler_bad_request(context):
event = utils.build_event(None)
@lambda_handler
def handler(req):
raise BadRequest('invalid request')
lambda_output = handler(event, context)
result = utils.parse_lambda_output(lambda_output)
assert result.status_code == BadRequest.status_code
assert 'message' in result.data
assert 'errors' in result.data
def test_raise_exception_on_S3_error():
# GIVEN we're running in lambda
# mock the queue, but we won't examine it
u.setup_aws_mocks()
u.create_bucket()
# WHEN a non existant file is processed
# (S3 only guarantees eventual consistancy)
bucket_name, key_name = 'bogus_bucket', 'firefox-bogus.exe'
event = u.build_event(bucket_name, key_name)
# THEN we raise an error (so AWS will retry)
with pytest.raises(IOError):
results = lambda_handler(event, u.dummy_context)
# and function should not have returned
assert 'results' not in locals().keys()
def test_lambda_handler_with_query(context, dict_data):
event = utils.build_event(None, query_params=dict_data)
@lambda_handler
def handler(req):
payload = {'req_query': req.query}
return Response(payload)
lambda_output = handler(event, context)
result = utils.parse_lambda_output(lambda_output)
assert result.status_code == 200
assert result.data['req_query'] == dict_data
def test_lambda_handler(context):
event = utils.build_event(None)
@lambda_handler
def handler(req):
payload = {'event': req.event, 'context': req.context}
return Response(payload)
lambda_output = handler(event, context)
result = utils.parse_lambda_output(lambda_output)
assert result.status_code == 200
assert result.data['event'] == event
assert result.data['context'] == context
def test_always_log_output_issue_17(setter, fname, capsys):
# mock the queue, but we won't examine it
u.setup_aws_mocks()
bucket = u.create_bucket()
# Given that VERBOSE is in any state
setter()
# WHEN any file is processed
bucket_name, key_name = u.upload_file(bucket, fname)
event = u.build_event(bucket_name, key_name)
results = lambda_handler(event, u.dummy_context)
# THEN there should always be a message on stdout
out, err = capsys.readouterr()
# put useful information in failure output
print("response: '{}'".format(results))
assert out != ''
assert err == ''
def test_pass_message_when_verbose(setter, fname):
queue = u.setup_aws_mocks()
bucket = u.create_bucket()
# Given that VERBOSE is set
setter()
# WHEN a good file is processed
bucket_name, key_name = u.upload_file(bucket, fname)
event = u.build_event(bucket_name, key_name)
response = lambda_handler(event, u.dummy_context)
print("response:", response)
# THEN there should be no message
count, msg_json = u.get_one_message(queue)
msg_dict = json.loads(msg_json)
msg = msg_dict['Message']
print("message:", msg)
assert "pass" in response['results'][0]['status']
assert count is 1 and msg.startswith('pass for')
def test_no_exclude_message_when_not_production(set_production_false, fname):
u.setup_aws_mocks()
bucket = u.create_bucket()
# Given that PRODUCTION is set to False
set_production_false()
# WHEN any file is processed
u.upload_file(bucket, fname)
event = u.build_event(bucket.name, fname)
response = lambda_handler(event, u.dummy_context)
# THEN there should be no mentions of skipping
# count, msg = get_one_message(queue)
# print things that will be useful to debug
print("response:", response)
# actual criteria to pass
assert u.not_in("Excluded from validation",
response['results'][0]['results'])
def test_fail_message_when_not_verbose(set_verbose_false, fname):
queue = u.setup_aws_mocks()
bucket = u.create_bucket()
# Given that VERBOSE is not set
set_verbose_false()
# WHEN a bad file is processed
u.upload_file(bucket, fname)
event = u.build_event(bucket.name, fname)
response = lambda_handler(event, u.dummy_context)
# THEN there should be a message
count, msg_json = u.get_one_message(queue)
msg_dict = json.loads(msg_json)
msg = msg_dict['Message']
# print things that will be useful to debug
print("response:", response)
print("message:", msg)
print("count:", count)
# actual criteria to pass
assert "fail" in response['results'][0]['status']
assert count is 1 and msg.startswith('fail for')
