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)