def setUp(self):
self.valid_request = ApiClientRequest(method="GET",
url="https://test.com",
body=None,
headers=None)
self.valid_mock_response = MockResponse(json_data="some test data",
status_code=200)
self.test_api_client = DefaultApiClient()
def skill_configuration(self):
# type: () -> SkillConfiguration
"""Create the skill configuration object using the registered
components.
"""
skill_config = super(StandardSkillBuilder, self).skill_configuration
skill_config.api_client = DefaultApiClient()
if self.table_name is not None:
kwargs = {"table_name": self.table_name} # type: Dict[str, Any]
if self.auto_create_table:
kwargs["create_table"] = self.auto_create_table
if self.partition_keygen:
kwargs["partition_keygen"] = self.partition_keygen
if self.dynamodb_client:
kwargs["dynamodb_resource"] = self.dynamodb_client
skill_config.persistence_adapter = DynamoDbAdapter(**kwargs)
return skill_config
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_core.api_client import DefaultApiClient
from ask_sdk_model.ui import SimpleCard
from ask_sdk_model.ui import AskForPermissionsConsentCard
from ask_sdk_model import Response
from ask_sdk_model.permission_status import PermissionStatus
from ask_sdk_model.services.service_exception import ServiceException
from ask_sdk_model.canfulfill import CanFulfillIntent, CanFulfillIntentValues
if getenv("ENVIRONMENT") in (None, "PROD"):
aws_lambda_logging.setup(level="INFO")
else:
logging.basicConfig(level=logging.INFO)
sb = CustomSkillBuilder(api_client=DefaultApiClient())
ERROR_TITLE = "Uh oh"
ERROR = "Looks like something went wrong."
NOTIFY_TITLE = "Permissions needed"
NOTIFY_MISSING_ADDRESS_PERMISSIONS = ("Please enable Address permissions in "
"the Amazon Alexa app.")
NOTIFY_MISSING_LOCATION_PERMISSIONS = ("Please enable Location permissions in "
"the Amazon Alexa app.")
SWEET_TITLE = "Your Air Report"
SWEET_CARD = ("I found an {}air sensor that's {} away. "
"The air quality is {}. "
"Your AQI is {}.")
SWEET_SPEECH = (
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.handler_input import HandlerInput
from metro_api.directions_api import get_train
from metro_api import commands
from ask_sdk_model import Response
from ask_sdk_model.slu.entityresolution import StatusCode
from ask_sdk_model.ui import SimpleCard, AskForPermissionsConsentCard
from ask_sdk_model.services.reminder_management import Trigger, TriggerType, AlertInfo, SpokenInfo, SpokenText, \
PushNotification, PushNotificationStatus, ReminderRequest
from ask_sdk_model.services import ServiceException
import pytz
from datetime import datetime
sb = CustomSkillBuilder(
api_client=DefaultApiClient()) # required to use remiders
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
REQUIRED_PERMISSIONS = [
"alexa::alerts:reminders:skill:readwrite", "read::alexa:device:all:address"
]
# Request Handler classes
class LaunchRequestHandler(AbstractRequestHandler):
"""Handler for skill launch."""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
return is_request_type("LaunchRequest")(handler_input)
class TestDefaultApiClient(unittest.TestCase):
def setUp(self):
self.valid_request = ApiClientRequest(
method="GET", url="https://test.com", body=None, headers=None)
self.valid_mock_response = MockResponse(
json_data="some test data", status_code=200)
self.test_api_client = DefaultApiClient()
def test_convert_null_header_tuples_to_dict(self):
test_headers_list = None
expected_headers_dict = {}
assert self.test_api_client._convert_list_tuples_to_dict(
test_headers_list) == expected_headers_dict, (
"DefaultApiClient failed to convert null headers list to empty "
"dict object")
def test_convert_header_tuples_to_dict(self):
test_headers_list = [
("header_1", "test_1"), ("header_2", "test_2"),
("header_1", "test_3")]
expected_headers_dict = {
"header_1": "test_1, test_3", "header_2": "test_2"}
assert self.test_api_client._convert_list_tuples_to_dict(
test_headers_list) == expected_headers_dict, (
"DefaultApiClient failed to convert header list of tuples to "
"dictionary format needed for http "
"request call")
def test_convert_null_header_dict_to_tuples(self):
test_headers_dict = None
expected_headers_list = []
assert self.test_api_client._convert_dict_to_list_tuples(
test_headers_dict) == expected_headers_list, (
"DefaultApiClient failed to convert null headers dict to empty "
"list object")
def test_convert_header_dict_to_tuples(self):
test_headers_dict = {
"header_1": "test_1, test_3", "header_2": "test_2",
"header_3": "test_4,"}
expected_headers_list = [
("header_1", "test_1"), ("header_1", "test_3"),
("header_2", "test_2"), ("header_3", "test_4")]
assert set(self.test_api_client._convert_dict_to_list_tuples(
test_headers_dict)) == set(
expected_headers_list), (
"DefaultApiClient failed to convert headers dict to list of "
"tuples format for ApiClientResponse")
def test_resolve_valid_http_method(self):
with mock.patch("requests.get",
side_effect=lambda *args, **kwargs:
self.valid_mock_response):
try:
actual_response = self.test_api_client.invoke(
self.valid_request)
except:
# Should never reach here
raise Exception("DefaultApiClient couldn't resolve valid "
"HTTP Method for calling")
def test_resolve_invalid_http_method_throw_exception(self):
test_invalid_method_request = ApiClientRequest(
method="GET_TEST", url="http://test.com", body=None, headers=None)
with mock.patch("requests.get",
side_effect=lambda *args, **kwargs:
self.valid_mock_response):
with self.assertRaises(ApiClientException) as exc:
self.test_api_client.invoke(test_invalid_method_request)
assert "Invalid request method: GET_TEST" in str(exc.exception)
def test_invoke_http_method_throw_exception(self):
with mock.patch("requests.get",
side_effect=Exception("test exception")):
with self.assertRaises(ApiClientException) as exc:
self.test_api_client.invoke(self.valid_request)
assert "Error executing the request: test exception" in str(exc.exception)
def test_api_client_invoke_with_method_headers_processed(self):
self.valid_request.headers = [
("request_header_1", "test_1"), ("request_header_2", "test_2"),
("request_header_1", "test_3")]
self.valid_request.method = "PUT"
test_response = MockResponse(
headers={
"response_header_1": "test_1, test_3",
"response_header_2": "test_2", "response_header_3": "test_4,"},
status_code=400,
json_data="test response body")
with mock.patch("requests.put",
side_effect=lambda *args, **kwargs: test_response):
actual_response = self.test_api_client.invoke(self.valid_request)
assert set(actual_response.headers) == set([
("response_header_1", "test_1"),
("response_header_1", "test_3"),
("response_header_2", "test_2"),
("response_header_3", "test_4")]), (
"Response headers from client doesn't match with the "
"expected headers")
assert actual_response.status_code == 400, (
"Status code from client response doesn't match with the "
"expected response status code")
assert actual_response.body == "test response body", (
"Body from client response doesn't match with the expected "
"response body")
def test_api_client_invoke_with_http_url_throw_error(self):
test_invalid_url_scheme_request = ApiClientRequest(
method="GET", url="http://test.com", body=None, headers=None)
with mock.patch("requests.get",
side_effect=lambda *args, **kwargs:
self.valid_mock_response):
with self.assertRaises(ApiClientException) as exc:
self.test_api_client.invoke(test_invalid_url_scheme_request)
assert "Requests against non-HTTPS endpoints are not allowed." in str(exc.exception)
def test_api_client_invoke_with_http_case_sensitive_url_throw_error(self):
test_invalid_url_scheme_request = ApiClientRequest(
method="GET", url="HTTP://test.com", body=None, headers=None)
with mock.patch("requests.get",
side_effect=lambda *args, **kwargs:
self.valid_mock_response):
with self.assertRaises(ApiClientException) as exc:
self.test_api_client.invoke(test_invalid_url_scheme_request)
assert "Requests against non-HTTPS endpoints are not allowed." in str(exc.exception)
def test_api_client_invoke_with_no_url_schema_throw_error(self):
test_invalid_url_scheme_request = ApiClientRequest(
method="GET", url="test.com", body=None, headers=None)
with mock.patch("requests.get",
side_effect=lambda *args, **kwargs:
self.valid_mock_response):
with self.assertRaises(ApiClientException) as exc:
self.test_api_client.invoke(test_invalid_url_scheme_request)
assert "Requests against non-HTTPS endpoints are not allowed." in str(exc.exception)
def test_api_client_send_request_with_raw_data(self):
test_data = "test\nstring"
self.valid_request.body = "test\nstring"
self.valid_request.method = "POST"
with mock.patch(
"requests.post",
side_effect=lambda *args, **kwargs: self.valid_mock_response
) as mock_put:
actual_response = self.test_api_client.invoke(self.valid_request)
mock_put.assert_called_once_with(
data=json.dumps(test_data), headers={},
url=self.valid_request.url)
logger.debug("Alexa Response: {}".format(response))
class SavePersistenceAttributesResponseInterceptor(AbstractResponseInterceptor):
"""Save persistence attributes before sending response to user."""
def process(self, handler_input, response):
# type: (HandlerInput, Response) -> None
handler_input.attributes_manager.save_persistent_attributes()
# ###################################################################
# The SkillBuilder object acts as the entry point for your skill, routing all request and response
# payloads to the handlers above. Make sure any new handlers or interceptors you've
# defined are included below. The order matters - they're processed top to bottom.
s3_adapter = S3Adapter(bucket_name=os.environ["S3_PERSISTENCE_BUCKET"])
sb = CustomSkillBuilder(persistence_adapter=s3_adapter,api_client=DefaultApiClient())
# ############# REGISTER HANDLERS #####################
# Request Handlers
sb.add_request_handler(CheckAudioInterfaceHandler())
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(ExceptionEncounteredHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(TodayIntentHandler())
sb.add_request_handler(playAudioIntentHandler())
sb.add_request_handler(qayaamIntentHandler())
sb.add_request_handler(rozaNiyatIntentHandler())
sb.add_request_handler(moharramIntentHandler())
sb.add_request_handler(NamaazTimesIntentHandler())
def can_handle(self, handler_input, exception):
# type: (HandlerInput, Exception) -> bool
return True
def handle(self, handler_input, exception):
# type: (HandlerInput, Exception) -> Response
logger.error(exception, exc_info=True)
speak_output = "Sorry, I had trouble doing what you asked. Please try again."
return (handler_input.response_builder.speak(speak_output).ask(
speak_output).response)
sb = CustomSkillBuilder(persistence_adapter=s3_adapter,
api_client=DefaultApiClient())
####### On Launch #########
sb.add_request_handler(LaunchRequestHandler())
####### Search Bars #######
sb.add_request_handler(SearchBarIntentHandler())
sb.add_request_handler(YesHandler())
sb.add_request_handler(NoHandler())
####### User Data #########
sb.add_request_handler(UserProfileHandler())
sb.add_request_handler(DeleteUserIntentHandler())
####### Beer #########
sb.add_request_handler(WhichBeerIntentHandler())
logger.error(exception, exc_info=True)
speak_output = "Sorry, I had trouble doing what you asked. Please try again."
return (
handler_input.response_builder
.speak(speak_output)
.ask(speak_output)
.response
)
# The SkillBuilder object acts as the entry point for your skill, routing all request and response
# payloads to the handlers above. Make sure any new handlers or interceptors you've
# defined are included below. The order matters - they're processed top to bottom.
sb = CustomSkillBuilder(api_client=DefaultApiClient()) # required to use remiders
#sb = SkillBuilder()
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(IAmTakingKuvanIntentHandler())
sb.add_request_handler(CreateReminderIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelOrStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(IntentReflectorHandler()) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers
sb.add_exception_handler(CatchAllExceptionHandler())
#lambda_handler = sb.lambda_handler()
def handler(event, context):
return sb.lambda_handler()(event, context)