def invoke(self,
ResourceType,
RequestType="Create",
LogicalResourceId="LogicalResourceId",
**kw):
"""
Invoke a mock lambda function.
"""
sockname = self.server.socket.getsockname()
event = {
"StackId": "stack-1234",
"RequestId": "req-1234",
"LogicalResourceId": LogicalResourceId,
"RequestType": RequestType,
"ResourceType": ResourceType,
"ResponseURL": "http://%s:%s/" % (sockname[0], sockname[1])
}
if "PhysicalResourceId" in kw:
event["PhysicalResourceId"] = kw.pop("PhysicalResourceId")
event["ResourceProperties"] = kw
import handler
handler.lambda_handler(event, None)
return json_loads(ResponseHandler.responses.pop())
def test_character_info(self):
# test correct response
response = handler.lambda_handler(
make_input("GetCharacterInfo", {"character": "Jon Snow"}),
self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("Stark", get_speech_output(response))
# test the card info
self.assertEqual("Jon Snow", response["response"]["card"]["title"])
self.assertIn("Stark", response["response"]["card"]["content"])
# test mangled name
response = handler.lambda_handler(
make_input("GetCharacterInfo", {"character": "John Snow"}),
self.context)
self._assert_normal(response)
self.assertNotIn("Stark", get_speech_output(response))
# missing slot
response = handler.lambda_handler(make_input("GetCharacterInfo", {}),
self.context)
self._assert_normal(response)
self.assertNotIn("Stark", get_speech_output(response))
def test_get_actor(self):
response = handler.lambda_handler(make_input("GetActor", {"character": "Tyrion Lannister"}), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("Peter", get_speech_output(response))
# test the card info
self.assertEqual("Tyrion Lannister", response["response"]["card"]["title"])
self.assertIn("Peter", response["response"]["card"]["content"])
# test a char with multiple actors
response = handler.lambda_handler(make_input("GetActor", {"character": "Tommen"}), self.context)
self._assert_normal(response)
self.assertIn("Dean-Charles Chapman", get_speech_output(response))
self.assertIn("Callum Wharry", get_speech_output(response))
def test_handler(self):
event_bucket = "venkkat-test"
event_key = "input.csv"
output_bucket = "venkkat-output"
output_key = "output.csv"
event = s3_put_event_factory(event_bucket, event_key)
# Execution
lambda_handler(event, {})
input_file = read_s3_file(event_bucket, event_key).split('\n')
bucket_files = get_all_keys(output_bucket, prefix=output_key)
output_file = read_s3_file(output_bucket, bucket_files[0]).split('\n')
assert len(bucket_files) == 1
assert len(input_file) == len(output_file)
def handler(event, context):
log_level = logging.getLevelName(CONFIG['log_level'])
logging.basicConfig(level=log_level)
if is_lex_message(event):
return worker.lex(event, None)
return zappa_handler.lambda_handler(event, context)
def test_character_missing(self):
# test correct response
response = handler.lambda_handler(
make_input("GetCharacterInfo", {"character": "Robert Baratheon"}),
self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("don't know", get_speech_output(response))
def test_actor_other_roles(self):
# test correct response
response = handler.lambda_handler(make_input("GetOtherRoles", {"actor": "Lena Headey"}), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("Dredd", get_speech_output(response))
# test the card info
self.assertEqual("Lena Headey", response["response"]["card"]["title"])
self.assertIn("Dredd", response["response"]["card"]["content"])
def test_entrypoint_ignore_audio():
request = {
'request': {
'type': 'AudioPlayer.PlaybackStarted',
'requestId': 1234
}
}
full_response = lambda_handler(request, {})
resp = full_response['response']
assert not resp, "Should have ignored AudioPlayer request"
def test_get_actor(self):
response = handler.lambda_handler(
make_input("GetActor", {"character": "Tyrion Lannister"}),
self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("Peter", get_speech_output(response))
# test the card info
self.assertEqual("Tyrion Lannister",
response["response"]["card"]["title"])
self.assertIn("Peter", response["response"]["card"]["content"])
# test a char with multiple actors
response = handler.lambda_handler(
make_input("GetActor", {"character": "Tommen"}), self.context)
self._assert_normal(response)
self.assertIn("Dean-Charles Chapman", get_speech_output(response))
self.assertIn("Callum Wharry", get_speech_output(response))
def test_character_info(self):
# test correct response
response = handler.lambda_handler(make_input("GetCharacterInfo", {"character": "Jon Snow"}), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("Stark", get_speech_output(response))
# test the card info
self.assertEqual("Jon Snow", response["response"]["card"]["title"])
self.assertIn("Stark", response["response"]["card"]["content"])
# test mangled name
response = handler.lambda_handler(make_input("GetCharacterInfo", {"character": "John Snow"}), self.context)
self._assert_normal(response)
self.assertNotIn("Stark", get_speech_output(response))
# missing slot
response = handler.lambda_handler(make_input("GetCharacterInfo", {}), self.context)
self._assert_normal(response)
self.assertNotIn("Stark", get_speech_output(response))
def test_entrypoint_launch():
request = {
'request': {
'type': 'LaunchRequest',
'requestId': 1234
},
'session': NO_SESSION
}
full_response = lambda_handler(request, {})
resp = full_response['response']
assert _("Squeezebox is online") in resp['outputSpeech']['text']
def test_house(self):
# test correct response
response = handler.lambda_handler(make_input("GetHouseWords", {"house": "Stark"}), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertEqual("Winter is Coming", get_speech_output(response))
# test the card info
self.assertEqual("Stark", response["response"]["card"]["title"])
self.assertIn("Winter is Coming", response["response"]["card"]["content"])
# test unknown house
response = handler.lambda_handler(make_input("GetHouseWords", {"house": "Starrk"}), self.context)
self._assert_normal(response)
self.assertNotEqual("Winter is Coming", get_speech_output(response))
# test missing house slot
response = handler.lambda_handler(make_input("GetHouseWords", {}), self.context)
self._assert_normal(response)
self.assertNotEqual("Winter is Coming", get_speech_output(response))
def test_actor_other_roles(self):
# test correct response
response = handler.lambda_handler(
make_input("GetOtherRoles", {"actor": "Lena Headey"}),
self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("Dredd", get_speech_output(response))
# test the card info
self.assertEqual("Lena Headey", response["response"]["card"]["title"])
self.assertIn("Dredd", response["response"]["card"]["content"])
def test_http_error(self):
with mock.patch("handler.handler") as m:
m.side_effect = _raise_invalid_argument_exception
resp = handler.lambda_handler({"some": "event"}, None,
{"some": "config"})
m.assert_called_once_with({"some": "event"}, {"some": "config"})
self.assertEqual(
resp, {
'statusCode': '400',
'body': "some error",
"headers": {
'Content-Type': 'application/json',
},
})
def test_http_success(self):
with mock.patch("handler.handler", return_value={"some":
"response"}) as m:
resp = handler.lambda_handler({"some": "event"}, None,
{"some": "config"})
m.assert_called_once_with({"some": "event"}, {"some": "config"})
self.assertEqual(
resp, {
'statusCode': '200',
'body': "{\"some\": \"response\"}",
"headers": {
'Content-Type': 'application/json',
},
})
def test_house(self):
# test correct response
response = handler.lambda_handler(
make_input("GetHouseWords", {"house": "Stark"}), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertEqual("Winter is Coming", get_speech_output(response))
# test the card info
self.assertEqual("Stark", response["response"]["card"]["title"])
self.assertIn("Winter is Coming",
response["response"]["card"]["content"])
# test unknown house
response = handler.lambda_handler(
make_input("GetHouseWords", {"house": "Starrk"}), self.context)
self._assert_normal(response)
self.assertNotEqual("Winter is Coming", get_speech_output(response))
# test missing house slot
response = handler.lambda_handler(make_input("GetHouseWords", {}),
self.context)
self._assert_normal(response)
self.assertNotEqual("Winter is Coming", get_speech_output(response))
def test_lambda_handler_successful_run(mocker):
mocker.patch('handler.logger')
mocker.patch('handler.sns.Topic')
mocker.patch('handler.run')
topic = uuid.uuid4().hex
handler.sns.Topic.return_value = topic
handler.run.return_value = "ok"
result = handler.lambda_handler(fixtures.termination_event, None)
# check return result of run
assert result == "ok"
# check right arguments to run
handler.run.assert_called_with(
fixtures.termination_event['Records'][0]['Sns'], topic)
def test_lambda_handler_run_with_exception(mocker):
mocker.patch('handler.run')
mocker.patch('handler.sns')
mock_topic = mocker.Mock()
handler.sns.Topic.return_value = mock_topic
exc = Exception('foobar')
handler.run.side_effect = exc
result = handler.lambda_handler(fixtures.termination_event, None)
# check republishing of event on exception
mock_topic.publish.assert_called_once()
# check handler returns "error"
assert result == "error"
import handler message = handler.lambda_handler(None, None) print(message)
def test_getsites(self):
"""Test we can click OK."""
response = lambda_handler(None, None)
self.assertTrue(len(json.loads(response['body'])) > 10)
from handler import lambda_handler
if __name__ == "__main__":
lambda_handler({}, {})
def test_character_missing(self):
# test correct response
response = handler.lambda_handler(make_input("GetCharacterInfo", {"character": "Robert Baratheon"}), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
self.assertIn("don't know", get_speech_output(response))
# -*- coding: utf-8 -*-
"""
Return from Lambda
"""
import os
if __name__ == '__main__':
# ensures the cwd is root of project
__WS_DIR__ = os.path.dirname(os.path.realpath(__file__))
os.chdir('{}/..'.format(__WS_DIR__))
# execute lambda_handler
from handler import lambda_handler
lambda_handler(None, None)
def test_echo():
assert handler.lambda_handler(TEST_DATA, None) == 'test'
def test_entrypoint_error():
full_response = lambda_handler(None, {}, server=FakeSqueeze())
assert 'sessionAttributes' in full_response
resp = full_response['response']
assert resp, "Blank response generated"
assert resp['card']['title'] == _("All went wrong")
from handler import lambda_handler
result = lambda_handler(
{
'model_name': 'samplemodel',
'operation': 'list',
'payload': '',
}, {})
print(result)
def test_lambda_handler():
try:
event = {'Number1': 10, 'Number2': 20}
except null:
assert lambda_handler(event, null) == 30
def test_help(self):
response = handler.lambda_handler(make_help_input(), self.context)
self._assert_normal(response)
self.assertIn("Hello", get_speech_output(response))
self.assertFalse(response["response"]["shouldEndSession"])
def test_hello_world_returned(self):
self.assertEquals(lambda_handler({}, {}), 'Hello World')
import json
import handler
request = {
"directive": {
"endpoint": {
"cookie": {},
"endpointId": "bbqberry",
"scope": {
"token":
"Atza|IwEBIIM1Jk0zzEZNvrskXb9ofwhSfx_zO5JPcWvJ6_WLN93ZIHFK9sGDF2xTgU8UxDLmkaWGjL843ggSixnpbbhokriKbCR1rcA1USxWBOvI5BM3THWg7swp4ySawTWJ0EOLsRhIhnj2-KN4xCxFpMKF4FA97yuHLz0wMdieaI1X5cr3y5ASUP4q1qcSXWFCe753cRQOiJPyDdIxW_PKRbzD5pfsIvZ5IVrfwx5qmdo1PsA7cKqSjHq9Gvc9eg93uklHyuOR7s9XJeXo6r1Wn0UMhbQmI4Vl428ve8jbIKZwD16M_N-yUaN9NTBEw3mK2gak5KjvnHp8ENFvtS5s9Yy_Lvw5qd4zKctTptzBTD-RuQuytwB73RxJ8uA4Eqdspf1In30J8rU7Ty795CS8-dhD8Uzaw6eTHdZeIQMPGVGf7J7Z--PIXKENWHjcP4EwTs2npyEJuMXCNqAbpVylC5clgNKxYTJuaF7Gmdh3SSldxc9bVxyqZ8kX_xKXr4Pkwm5Sbwc",
"type": "BearerToken"
}
},
"header": {
"correlationToken":
"AAAAAAAAAADBZt5qTLHppE/m3LrCcUjhBAIAAAAAAAB7MwFlwRP+4Q7XjVaiZ/oznNcsABhUAFG90MpB2k9gHGpKjBVmwMR9wHhaBV79kAeYUN2QTyi6Fy+u41xl/3JT3Md5oPHCL17PMrhoN8PlzvAz78aLUfvdV7VjFjrL9wM/T3MRD/s2KmcGb8MDVAHByNn9HOEo6TouA18b1Yo+WiMxqHcIYlrvnmpSBjJLO+bg4SzanT4gzjB9iAuf1BEPa6Xott8fI/iZ5XzQq2B6B/83wH2ez4Y5AwpotlK4/Z5ALew+QS2oL69RtWha7rfzF2wsvDWbsSiU8KAV6ihHT9tP4Ug0K2/kToYN6PtdYOvk7TUtwV4QitupCxuj4dY0xS96dvXgprWQ5w7QU+SlQxiZhFMZx6G2JgqLtBig7Fr9s8QO1PYFumhGrNLshPh627AHJX/yuJY8md4pjznZAdcPwK7ko94qG1GCbipjewzoaQYXVz8+5dK1jGAmjT4lV3Osc5n/olvySuMMG83hY0wbvzx5jf0lBdrG1jorKIYVmxlbattfszLh0AOddORbOd0pAyk//pU01kSCV38Yw244bzEWCr7+SMqiVanAAQN7mAqE3kxW+mfJTwo0zhttOaKTTUMTUbFbLl0Wq4P7rrYtWM2BBC91zG18o1mz6DEY/Z9p/0La15IK+rhxPpxbxCf0YOOAKJe/DAcAODY3MGZxy/E=",
"messageId": "bb819a53-791f-48a6-8089-c2ef5fafa46b",
"name": "ReportState",
"namespace": "Alexa",
"payloadVersion": "3"
},
"payload": {}
}
}
response = handler.lambda_handler(request, None)
print(json.dumps(response, indent=4))
def test_help(self):
response = handler.lambda_handler(make_help_input(), self.context)
self._assert_normal(response)
self.assertIn("Hello", get_speech_output(response))
self.assertFalse(response["response"]["shouldEndSession"])
def test_stop(self):
response = handler.lambda_handler(make_stop_input(), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
def test_stop(self):
response = handler.lambda_handler(make_stop_input(), self.context)
self._assert_normal(response)
self.assertTrue(response["response"]["shouldEndSession"])
def test_handler(self):
with self.assertRaises(SystemExit): # Check that will exit if error code is incorrect
handler.lambda_handler({"detail": {"errorCode": "random"}}, {})
def test_entrypoint_error_ssml():
full_response = lambda_handler(None, {}, server=FakeSqueeze())
resp = full_response['response']
assert resp['outputSpeech']['type'] == "SSML"
regex = re.compile('<speak>.+</speak>')
assert regex.match(resp['outputSpeech']['ssml'])
"friday":
False,
"startTime":
1730,
"endTime":
1920,
"monday":
False
}],
"isOpen":
True,
"attributes": {
"description": "_Core Science & Technology A",
"isZTCAttribute": False,
"code": "SA",
"class":
"net.hedtech.banner.student.schedule.SectionDegreeProgramAttributeDecorator",
"courseReferenceNumber": "2184",
"termCode": "202036"
},
"courseName":
"KINS-1223",
"title":
"Human Anatomy and Physiology I",
"crn":
2184
}]
}
print(handler.lambda_handler(event, None))
def test_lambda_handler_malformed_event(mocker):
mocker.patch('handler.logger')
mocker.patch('handler.run')
assert handler.lambda_handler({}, None) is "error"
