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_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"