def test_wrong_format_event(self):
logger.info("TEST: test_wrong_format_event")
event = {'awslogs': {}}
data_body = {'logStream': 'TestStream', 'messageType': 'DATA_MESSAGE', 'logEvents': []}
# Adding wrong format log
log = "{'timestamp' : '10', 'message' : 'wrong_format', 'id' : '10'}"
data_body['logEvents'].append(log)
data_body['owner'] = 'Test'
data_body['subscriptionFilters'] = ['TestFilters']
data_body['logGroup'] = 'TestlogGroup'
zip_text_file = StringIO()
zipper = gzip.GzipFile(mode='wb', fileobj=zip_text_file)
zipper.write(json.dumps(data_body))
zipper.close()
enc_data = base64.b64encode(zip_text_file.getvalue())
event['awslogs']['data'] = enc_data
httpretty.register_uri(httpretty.POST, self._logzioUrl, status=200, content_type="application/json")
class Context(object):
function_version = 1
invoked_function_arn = 1
memory_limit_in_mb = 128
with self.assertRaises(TypeError):
worker.lambda_handler(event, Context)
logger.info("Catched the correct exception, wrong format message")
def test_should_not_send_activity_message(monkeypatch):
prepare_env(monkeypatch)
monkeypatch.setenv('SEND_BULK_ACTIVITY_MESSAGE', 'FALSE')
s3 = boto3.client('s3', region_name=_region)
s3_key = 'test/create-users/dce.test/users.csv'
meta = {
'requester-exid': 'admin|exid',
'requester-ip': '1.2.3.4',
'requester-city': 'Minas Tirith',
'requester-countrycode': 'Gondor'
}
s3.put_object(
Bucket=_bucket,
Key=s3_key,
Body='email, name\[email protected],User1\[email protected],User2',
Metadata=meta)
# When
lambda_function.lambda_handler(_event, {})
# What
sqs = boto3.client('sqs', region_name=_region)
mes1 = sqs.receive_message(QueueUrl='CREATE_USERS_SQS_QUEUE',
MaxNumberOfMessages=2)
assert len(mes1.get('Messages')) == 2
mes2 = sqs.receive_message(QueueUrl='BULK_ACTIVITY_SQS_QUEUE',
MaxNumberOfMessages=2)
assert 'Messages' not in mes2
def test_retry_request(self):
logger.info("TEST: test_retry_request")
event = self._generate_aws_logs_event(_random_string_builder)
httpretty.register_uri(httpretty.POST,
self._logzioUrl,
responses=[
httpretty.Response(body="1st Fail",
status=500),
httpretty.Response(body="2nd Fail",
status=500),
httpretty.Response(body="3rd Success",
status=200)
])
class Context(object):
function_version = 1
invoked_function_arn = 1
memory_limit_in_mb = 128
try:
worker.lambda_handler(event['enc'], Context)
except Exception:
assert True, "Should have succeeded on last try"
request = httpretty.HTTPretty.last_request
self._check_data(request, event['dec'], Context)
def test_wrong_compression_format(self):
event_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
curr_month, prev_month = utils.get_months_range()
key = "{0}/{1}/12345678-1234-1234-1234-123456789123/{2}".format(
os.environ['REPORT_PATH'], curr_month, os.environ['REPORT_NAME'])
manifest_content = {"reportKeys": ["{}-1.csv.zip".format(key)]}
utils.put_object(
s3client, os.environ['S3_BUCKET_NAME'],
"{0}/{1}/{2}-Manifest.json".format(os.environ['REPORT_PATH'],
curr_month,
os.environ['REPORT_NAME']),
json.dumps(manifest_content))
s3res = boto3.resource('s3')
utils.upload_gzipped(s3res, os.environ['S3_BUCKET_NAME'],
manifest_content["reportKeys"][0],
SAMPLE_CSV_ZIP_1)
event = {
"detail-type": "Scheduled Event",
"source": "aws.events",
"time": event_time
}
# TODO - catch exact string in the error
try:
worker.lambda_handler(event, {})
except zlib_error:
return
assert True, "wrong compression - {}".format(zlib_error)
def test_bad_url(self):
logger.info("TEST: test_retry_request")
event = self._generate_aws_logs_event(_random_string_builder)
httpretty.register_uri(httpretty.POST, self._logzioUrl, status=404)
class Context(object):
function_version = 1
invoked_function_arn = 1
memory_limit_in_mb = 128
with self.assertRaises(UnknownURL):
worker.lambda_handler(event['enc'], Context)
def test_should_get_file_from_s3(monkeypatch):
prepare_env(monkeypatch)
s3 = boto3.client('s3', region_name=_region)
s3_key = 'test/create-users/dce.test/users.csv'
meta = {
'requester-exid': 'admin|exid',
'requester-ip': '1.2.3.4',
'requester-city': 'Minas Tirith',
'requester-countrycode': 'Gondor'
}
s3.put_object(
Bucket=_bucket,
Key=s3_key,
Body='email, name\[email protected],User1\[email protected],User2',
Metadata=meta)
# When
lambda_function.lambda_handler(_event, {})
# What
sqs = boto3.client('sqs', region_name=_region)
mes1 = sqs.receive_message(QueueUrl='CREATE_USERS_SQS_QUEUE',
MaxNumberOfMessages=2)
payload = mes1.get('Messages')[0].get('Body')
assert payload == '{"payload": {"requester": {"exid": "admin|exid", "ip": "1.2.3.4", "city": "Minas Tirith", ' \
'"countrycode": "Gondor"}, ' \
'"realm": "dce.test", "taskId": "1325419200000-users.csv", "user": {"email": ' \
'"*****@*****.**", "name": "User1"}}, "headers": {}, "properties": {}}'
payload = mes1.get('Messages')[1].get('Body')
assert payload == '{"payload": {"requester": {"exid": "admin|exid", "ip": "1.2.3.4", "city": "Minas Tirith", ' \
'"countrycode": "Gondor"}, ' \
'"realm": "dce.test", "taskId": "1325419200000-users.csv", "user": {"email": ' \
'"*****@*****.**", "name": "User2"}}, "headers": {}, "properties": {}}'
mes1 = sqs.receive_message(QueueUrl='BULK_ACTIVITY_SQS_QUEUE',
MaxNumberOfMessages=2)
payload = mes1.get('Messages')[0].get('Body')
assert payload == '{"payload": {"requester": {"exid": "admin|exid", "ip": "1.2.3.4", "city": "Minas Tirith", ' \
'"countrycode": "Gondor"}, ' \
'"realm": "dce.test", "taskId": "1325419200000-users.csv", "taskType": ' \
'"CREATE_USER", "task": {"fileName": "users.csv", "uploadedTime": "2012-01-01T12:00:00.000000Z", ' \
'"expected": 0}}, "headers": {}, "properties": {}}'
payload = mes1.get('Messages')[1].get('Body')
assert payload == '{"payload": {"requester": {"exid": "admin|exid", "ip": "1.2.3.4", "city": "Minas Tirith", ' \
'"countrycode": "Gondor"}, ' \
'"realm": "dce.test", "taskId": "1325419200000-users.csv", "taskType": ' \
'"CREATE_USER", "task": {"fileName": "users.csv", "uploadedTime": "2012-01-01T12:00:00.000000Z", ' \
'"expected": 2}}, "headers": {}, "properties": {}}'
# File been deleted from s3
s3_obj = s3.list_objects(Bucket=_bucket)
assert 'Contents' not in s3_obj
def test_should_fails_if_no_requester_meta(monkeypatch):
prepare_env(monkeypatch)
s3 = boto3.client('s3', region_name=_region)
s3_key = 'test/create-users/dce.test/users.csv'
meta = {}
s3.put_object(
Bucket=_bucket,
Key=s3_key,
Body='email, name\[email protected],User1\[email protected],User2',
Metadata=meta)
# When
with pytest.raises(AttributeError):
lambda_function.lambda_handler(_event, {})
def test_lambda_handler_handles_general_exceptions(mock_get_random_text,
mock_get_table_resource):
mock_get_random_text.side_effect = AttributeError
assert lambda_handler(None, None) == {
'functionError': 'Service failed unexpectedly',
'statusCode': 500
}
def test_lambda_handler(self):
"""Test test_lambda_handler(self)."""
eq_(None, l.lambda_handler(self.event, self.context))
l.LOGS_CLIENT.describe_log_groups.side_effect = Exception("test")
eq_(None, l.lambda_handler(self.event, self.context))
l.LOGS_CLIENT.describe_log_groups.side_effect = l.ClientError(
{
'Error': {
'Code': 404,
'Message': 'NotFound',
},
},
'NotoFound',
)
eq_(None, l.lambda_handler(self.event, self.context))
def test_lambda_handler_handles_lambda_exception(mock_get_random_text,
mock_get_table_resource):
mock_get_random_text.side_effect = LambdaException('asdf', 404)
assert lambda_handler(None, None) == {
'functionError': 'asdf',
'statusCode': 404
}
def test_lambda_handler(apigw_event, mocker):
ret = lambda_function.lambda_handler(apigw_event, "")
data = json.loads(ret["body"])
assert ret["statusCode"] == 200
assert "message" in ret["body"]
assert data["message"] == "hello world"
def test_can_return_message(self):
event = {"message": "This is a test message"}
assert lambda_handler(event, None) == {
"return_message": "This is a test message",
"config": {
"foo": "bar"
},
}
def test_ok_request(self):
logger.info("TEST: test_ok_request")
event = self._generate_aws_logs_event(_random_string_builder)
httpretty.register_uri(httpretty.POST, self._logzioUrl, body="first", status=200,
content_type="application/json")
class Context(object):
function_version = 1
invoked_function_arn = 1
memory_limit_in_mb = 128
try:
worker.lambda_handler(event['enc'], Context)
except Exception:
self.fail("Failed on handling a legit event. Expected status_code = 200")
request = httpretty.HTTPretty.last_request
self._check_data(request, event['dec'], Context)
def test_lambda_handler(apigw_event):
"""
test the expected output for a given event
"""
ret = lambda_function.lambda_handler(apigw_event, "")
data = json.loads(ret["body"])
assert ret["statusCode"] == 200
assert "message" in ret["body"]
assert data["message"] == "hello world"
def test_bad_request(self):
logger.info("TEST: test_bad_request")
event = self._generate_aws_logs_event(_random_string_builder)
httpretty.register_uri(httpretty.POST, self._logzioUrl, responses=[
httpretty.Response(body="first", status=400),
httpretty.Response(body="second", status=401),
])
class Context(object):
function_version = 1
invoked_function_arn = 1
memory_limit_in_mb = 128
with self.assertRaises(BadLogsException):
worker.lambda_handler(event['enc'], Context)
logger.info("Catched the correct exception. Status code = 400")
with self.assertRaises(UnauthorizedAccessException):
worker.lambda_handler(event['enc'], Context)
logger.info("Catched the correct exception. Status code = 401")
def test_no_report(self):
event_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
curr_month, prev_month = utils.get_months_range()
key = "{0}/{1}/12345678-1234-1234-1234-123456789123/{2}".format(
os.environ['REPORT_PATH'], curr_month, os.environ['REPORT_NAME'])
manifest_content = {"reportKeys": ["{}-1.csv.gz".format(key)]}
utils.put_object(
s3client, os.environ['S3_BUCKET_NAME'],
"{0}/{1}/{2}-Manifest.json".format(os.environ['REPORT_PATH'],
curr_month,
os.environ['REPORT_NAME']),
json.dumps(manifest_content))
event = {
"detail-type": "Scheduled Event",
"source": "aws.events",
"time": event_time
}
with self.assertRaises(s3client.exceptions.NoSuchKey):
worker.lambda_handler(event, {})
def test_large_body(self):
logger.info("TEST: test_large_body")
body_size = 2000
event = self._generate_aws_logs_event(_random_string_builder, body_size)
httpretty.register_uri(httpretty.POST, self._logzioUrl, body="first", status=200,
content_type="application/json")
class Context(object):
function_version = 1
invoked_function_arn = 1
memory_limit_in_mb = 128
try:
worker.lambda_handler(event['enc'], Context)
except Exception:
self.fail("Failed on handling a legit event. Expected status_code = 200")
request = httpretty.HTTPretty.last_request
last_bulk_length = len(request.body.splitlines())
assert last_bulk_length <= 2000, "Logs were not fragmented"
def test_lambda_cancel_response(self):
mock_intent = {
"name": "AMAZON_CancelIntent",
"slots": {}
}
mock_event = self.get_mock_event(intent=mock_intent)
result = lambda_handler(mock_event)
self.assertTrue(result)
response = result.get("response")
self.assertTrue(response.get("shouldEndSession", False), "The session did not end.")
def test_lambda_gets_berry(self):
mock_intent = {
"name": "GetMember",
}
mock_event = self.get_mock_event(intent=mock_intent)
result = lambda_handler(mock_event, {})
self.assertTrue(result)
response = result.get("response")
attributes = result.get("sessionAttributes")
self.assertFalse(response.get("shouldEndSession", True),
"The session ended.")
self.assertFalse(attributes, "Attributes found")
def test_gzip_typo_request(self):
logger.info("TEST: test_ok_gzip_request")
os.environ['COMPRESS'] = 'fakecompress'
event = self._generate_aws_logs_event(_random_string_builder)
httpretty.register_uri(httpretty.POST, self._logzioUrl, body="first", status=200,
content_type="application/json")
class Context(object):
function_version = 1
invoked_function_arn = 1
memory_limit_in_mb = 128
try:
worker.lambda_handler(event['enc'], Context)
except Exception:
assert "Failed on handling a legit event. Expected status_code = 200"
request = httpretty.HTTPretty.last_request
try:
gzip_header = request.headers["Content-Encoding"]
self.fail("Failed to send uncompressed logs with typo in compress env filed")
except KeyError:
pass
def test_lambda_gets_context_attributes(self):
mock_intent = {
"name": "AMAZON_HelpIntent",
}
mock_event = self.get_mock_event(intent=mock_intent)
result = lambda_handler(mock_event, {})
self.assertTrue(result)
response = result.get("response")
attributes = result.get("sessionAttributes")
context = attributes.get('context')
self.assertFalse(response.get("shouldEndSession", True), "The session ended.")
self.assertFalse(context, "Context found")
def test_lambda_handler_happy_path(mock_get_random_text,
mock_get_table_resource):
mock_get_random_text.return_value = {
'firstLine': line_1,
'secondLine': line_2
}
assert lambda_handler(None, None) == {
'isBase64Encoded': False,
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*'
},
'body': dumps({
'firstLine': line_1,
'secondLine': line_2
})
}
def main():
tests_passed = True
testpath = 'tests'
testfiles = [join(testpath, f)
for f in listdir(testpath) if isfile(join(testpath, f))]
for test in testfiles:
if test.endswith('.md'):
continue
print("Testing:", test)
try:
request_obj = json.load(open(test))
response = lambda_handler(request_obj)
if verbose:
print(json.dumps(request_obj, indent=4))
print("OK")
except Exception as e:
print("Fail because of", e)
tests_passed=False
if not tests_passed:
raise Exception("Tests did not pass")
def test_lambda_sets_berry(self):
mock_intent = {
"name": "SetMember",
"slots": {
"berry": {
"name": "berry",
"value": "star wars"
}
}
}
mock_event = self.get_mock_event(intent=mock_intent)
result = lambda_handler(mock_event, {})
self.assertTrue(result)
response = result.get("response")
attributes = result.get("sessionAttributes")
self.assertFalse(response.get("shouldEndSession", True),
"The session ended.")
self.assertEqual(attributes.get("berry", ""), "star wars",
"I don't memeber")
def test_diagnostic(mocker):
response = lambda_function.lambda_handler(event("US", "/diagnostic"), "")
assert response['status'] == '200'
def test_lambda_handler():
assert lambda_handler({}, None) == 'OK'
import dotenv
from src.lambda_function import lambda_handler
### runs the bot locally ###
dotenv.load_dotenv()
if __name__ == "__main__":
lambda_handler(event=None, context=None)
"""
Local tester class to test lambda function.
"""
from src import lambda_function
EVENT = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
class TestLambdaContext():
"""
Dummy lambda context class for local testing.
"""
function_name = 'lambda-structured-logging'
function_version = 'LATEST'
invoked_function_arn = 'arn:aws:lambda:us-east-1:1234567890:lambda-structured-logging'
aws_request_id = '022660DA-7F3E-4559-A551-B5E96A6D5E93'
log_group_name = '/aws/lambda/lambda-structured-logging'
log_stream_name = '2020/01/20/[$LATEST]/A551B5E96A6D5E93'
if __name__ == '__main__':
lambda_function.lambda_handler(EVENT, TestLambdaContext)
def test_lambda_launch_request(self):
mock_event = self.launch_request()
result = lambda_handler(mock_event, {})
self.assertTrue(result)
import os
from src import lambda_function
event = {
'title': "Test Issue",
'page_url': "/example.html",
'message': "Test Message",
'name': "Joe Bloggs"
}
lambda_function.lambda_handler(event, {})
def test_lambda_handler(self, report_mock, invocation_mock):
response = module.lambda_handler(MagicMock(), MagicMock())
self.assertEqual("byeworld", response)
self.assertEqual(1, invocation_mock.call_count)
