def main():
serializer = DefaultSerializer()
request_envelope = serializer.deserialize(request.data, RequestEnvelope)
response_envelope = SKILL.invoke(request_envelope=request_envelope,
context=None)
return jsonify(serializer.serialize(response_envelope))
def response_from_dict(response_dict) -> ResponseEnvelope:
"""
Deserialize a response dictionary to a Response object
Args:
response_dict(dict): The response dictionary
Returns: The deserialized response
"""
serializer = DefaultSerializer()
response_json = json.dumps(serializer.serialize(response_dict))
return serializer.deserialize(response_json, ResponseEnvelope)
def send_request(endpoint_url: str,
request_envelope: RequestEnvelope) -> ResponseEnvelope:
"""Sends a request to the endpoint and returns the response."""
serializer = DefaultSerializer()
r = requests.post(
endpoint_url,
json=serializer.serialize(request_envelope),
)
response_envelope = serializer.deserialize(payload=r.text,
obj_type=ResponseEnvelope)
return response_envelope
def operator_intent_handler(handler_input: HandlerInput):
op = get_slot_value(handler_input, "operand")
stack = DZ.deserialize(
handler_input.attributes_manager.session_attributes["stack"],
'list[float]')
handler_input.attributes_manager.session_attributes[
"stack"] = DZ.serialize([despatch[op](stack)])
text = f"Operator intent, {op}"
handler_input.response_builder.speak(text).set_card(
SimpleCard("Calculator", text)).set_should_end_session(False)
return handler_input.response_builder.response
def test_primitive_obj_deserialization_raising_type_error(self):
test_serializer = DefaultSerializer()
mocked_primitive_type = mock.Mock(side_effect=TypeError())
test_serializer.PRIMITIVE_TYPES = [mocked_primitive_type]
test_payload = "test"
test_obj_type = mocked_primitive_type
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, \
"Default Serializer deserialized primitive type which raises TypeError incorrectly"
def test_primitive_obj_deserialization_raising_unicode_exception(self):
test_serializer = DefaultSerializer()
mocked_primitive_type = mock.Mock(
side_effect=UnicodeEncodeError('hitchhiker', u"", 42, 43, 'the universe and everything else'))
test_serializer.PRIMITIVE_TYPES = [mocked_primitive_type]
test_payload = u"√"
test_obj_type = mocked_primitive_type
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert test_serializer.deserialize(
test_payload, test_obj_type) == u"\u221a", \
"Default Serializer deserialized primitive type which raises UnicodeEncodeError incorrectly"
def __init__(self, serializer=None, output_type=None):
# type: (Serializer, Union[T, str]) -> None
"""Initializing the default serializer to deserialize rendered content
to skill response output.
If no serializer is specified, default serializer from
:py:class:`ask_sdk_core.serialize.DefaultSerializer` is set also if the
output type is not specified default value of
:py:class:`ask_sdk_model.response.Response` is set.
The ``output_type`` parameter can be a primitive type, a generic
model object or a list / dict of model objects.
:param serializer: Serializer to deserialize template content
:type serializer: :py:class:`ask_sdk_model.services.Serializer`
:param output_type: resolved class name for deserialized object
:type output_type: Union[object, str]
"""
if serializer is None:
serializer = DefaultSerializer()
if output_type is None:
output_type = 'ask_sdk_model.response.Response'
self.serializer = serializer
self.output_type = output_type
def test(self, test_items):
"""
Test the sequence of TestItems against self.validators
Args:
test_items(list of TestItem): the sequence of TestItems
"""
if len(test_items) == 0:
raise AttributeError("test_items must not be empty")
handler = self.handler
session_attributes = {}
session_id = test_items[0].request.session.session_id.format(
uuid.uuid4())
for i, item in enumerate(test_items):
item.request.session.new = i == 0
item.request.session.attributes = session_attributes
item.request.session.session_id = session_id
if item.session_attributes:
for k, v in item.session_attributes.items():
item.request.session.attributes[k] = v
context = item.request.context
if item.user_access_token is not None:
context.system.api_access_token = item.user_access_token
if item.profile_info is not None:
handler = responses.activate(self.handler)
add_profile_mock(context, item.profile_info)
response_dict = handler(
DefaultSerializer().serialize(item.request), context)
response = response_from_dict(response_dict)
for validator in self.validators:
validator.validate(item, response)
session_attributes = response.session_attributes
def handle(self, handler_input):
session_attr = handler_input.attributes_manager.session_attributes
logger.debug("Session Attr: {}".format(session_attr))
# get the last response stored in session_attributes and return it
cached_response_str = json.dumps(session_attr["recent_response"])
cached_response = DefaultSerializer().deserialize(
cached_response_str, Response)
return cached_response
def operand_intent_handler(handler_input: HandlerInput):
val = float(get_slot_value(handler_input, "operand"))
stack = []
try:
stack = DZ.deserialize(
handler_input.attributes_manager.session_attributes['stack'],
'List[float]')
except:
pass
stack.append(val)
handler_input.attributes_manager.session_attributes[
'stack'] = DZ.serialize(stack)
text = f"Operand intent, {val}"
handler_input.response_builder.speak(text).set_card(
SimpleCard("Calculator", text)).set_should_end_session(False)
return handler_input.response_builder.response
def get_recent_response(handler_input):
"""Returns last response object sent."""
attr = handler_input.attributes_manager.session_attributes
cached_response_str = json.dumps(attr['recent_response'])
cached_response = DefaultSerializer().deserialize(
cached_response_str, Response)
return cached_response
def handle(self, handler_input):
obj_serializer = DefaultSerializer()
current_intent = handler_input.request_envelope.request.intent
reprompt = "what is the stop name you looking for?"
speech = "Can you provide me the stop name you are looking for?"
# Receive the slot that was stored when the user uttered the bus number
bus_number = get_slot_value(slot_name=SLOT_ROUTE_NUMBER,
handler_input=handler_input)
current_intent.confirmation_status = IntentConfirmationStatus.NONE
route = validate_route(
bus_number) # Says if the route is a vlid route of UMD or not
if route:
handler_input.attributes_manager.session_attributes[
R.DEFAULT_ROUTE] = obj_serializer.serialize({
R.ROUTE_TITLE:
route.route_title,
R.ROUTE_TAG:
route.route_tag
})
# Confirm the route just for the workflow
current_intent.slots[
SLOT_ROUTE_NUMBER].confirmation_status = SlotConfirmationStatus.CONFIRMED
return handler_input.response_builder.add_directive(
ElicitSlotDirective(
current_intent,
SLOT_STOP_NAME)).speak(speech).ask(reprompt).response
else:
# Set the slot to None so that if Delegation were to be used,
# Alexa can know to ask for this slot automatically
current_intent.slots[SLOT_ROUTE_NUMBER].value = None
wrong_route_speech = "The bus number is incorrect. Please provide me with a valid bus number. What is the " \
"bus number?"
wrong_route_reprompt = "What is the bus number?"
return handler_input.response_builder.add_directive(
ElicitSlotDirective(current_intent, SLOT_ROUTE_NUMBER)).speak(
wrong_route_speech).ask(wrong_route_reprompt).response
def handle(self, handler_input):
current_intent = handler_input.request_envelope.request.intent
obj_serializer = DefaultSerializer()
stop_val = get_slot(slot_name=SLOT_STOP_NAME,
handler_input=handler_input)
default_route = handler_input.attributes_manager.session_attributes.get(
R.DEFAULT_ROUTE)
current_intent.confirmation_status = IntentConfirmationStatus.NONE
matches = stop_val.resolutions.resolutions_per_authority
# If the stop was matched with a valid name
if matches[0].status.code == StatusCode.ER_SUCCESS_MATCH:
matched_stop = matches[0].values[0]
route = RouteConfig.get_data_route_and_agency_tag(
agency_tag="umd", route_tag=default_route[R.ROUTE_TAG])
stop_id = matched_stop.value.id
if route.has_stop(stop_id):
stop = route.get_stop_by_id(stop_id)
handler_input.attributes_manager.session_attributes[
R.DEFAULT_STOP] = obj_serializer.serialize({
R.STOP_ID:
stop.stop_id,
R.DIRECTION:
stop.direction,
R.STOP_TITLE:
stop.stop_title
})
else:
current_intent.slots[SLOT_STOP_NAME].value = None
current_intent.slots[
SLOT_STOP_NAME].confirmation_status = SlotConfirmationStatus.NONE
return handler_input.response_builder.add_directive(
ElicitSlotDirective(current_intent, SLOT_STOP_NAME)
).speak(
"The stop while confirming is not a stop for this route. Please try again with a stop name or stop number "
"that is in this route").ask(
"Provide a stop name or stop number").response
return handler_input.response_builder.add_directive(
ConfirmIntentDirective(current_intent)).speak(
"I am setting these defaults. Is that okay?").response
def handle(self, handler_input):
# type: (HandlerInput) -> Response
logger.info("In RepeatHandler")
attr = handler_input.attributes_manager.session_attributes
response_builder = handler_input.response_builder
if "recent_response" in attr:
cached_response_str = json.dumps(attr["recent_response"])
cached_response = DefaultSerializer().deserialize(
cached_response_str, Response)
return cached_response
else:
response_builder.speak(data.FALLBACK_ANSWER).ask(data.SET_MESSAGE)
return response_builder.response
def main():
cmdline_parser = argparse.ArgumentParser(
description=__doc__
)
cmdline_parser.add_argument(
'--endpoint_url',
default='http://localhost:8080',
help='endpoint_url'
)
cmdline_parser.add_argument(
'--logdir',
required=True,
help='log directory'
)
args = cmdline_parser.parse_args()
serializer = DefaultSerializer()
if not os.path.exists(args.logdir):
os.mkdir(args.logdir)
curr_request = create_launch_request()
curr_session_attributes: Dict[str, Any] = {}
round_index = 1
while True:
request_envelope = create_request_envelope(
curr_session_attributes,
curr_request
)
request_json = os.path.join(
args.logdir,
'request.round_{}.json'.format(round_index)
)
fp = codecs.open(
request_json,
'w',
encoding='utf-8'
)
fp.write(json.dumps(serializer.serialize(request_envelope)))
fp.write('\n')
fp.close()
response_envelope = send_request(
args.endpoint_url,
request_envelope
)
response = response_envelope.response
if response.should_end_session:
print('=' * 8, 'Session Ended', '=' * 8)
print(curr_session_attributes)
break
print('=' * 8, 'Round Index:', round_index, '=' * 8 )
print('Bot Utterance: ',
unescape_ssml(response.output_speech.ssml[7:-8]))
if response.reprompt:
print('Bot Reprompt: ',
unescape_ssml(response.reprompt.output_speech.ssml[7:-8]))
round_index += 1
user_utterance = input('User Utterance: ')
curr_session_attributes = response_envelope.session_attributes
curr_request = create_intent_request(
round_index=round_index,
user_utterance=user_utterance,
)
def parse_handler_input(
handler_input: HandlerInput,
) -> Tuple[UserMessage, Dict[str, Any]]:
"""Parses the ASK-SDK HandlerInput into Slowbro UserMessage.
Returns the UserMessage object and serialized SessionAttributes.
"""
request_envelope = handler_input.request_envelope
text: str
asr_hypos: List[AsrHypothesisUtterance] = []
if is_request_type("LaunchRequest")(handler_input):
# This is a launch request.
text = ''
elif is_request_type("IntentRequest")(handler_input):
slots = request_envelope.request.intent.slots
slot_text = slots.get('Text', None)
if slot_text is not None:
text = slot_text.value
else:
text = ''
if hasattr(request_envelope.request, 'speechRecognition'):
hypotheses = request_envelope.request.speechRecognition.get('hypotheses', [])
asr_hypos.extend([
AsrHypothesisUtterance(
[
AsrHypothesisToken(
token['value'],
token['confidence'],
token['startOffsetInMilliseconds'],
token['endOffsetInMilliseconds']
)
for token in hypo['tokens']
],
hypo['confidence']
)
for hypo in hypotheses
])
elif text:
# NOTE: create a fake ASR hypo using the text field.
asr_hypos.extend([
AsrHypothesisUtterance(
[
AsrHypothesisToken(
token,
-1,
-1,
-1
)
for token in text.split(' ')
],
-1
)
])
if not text:
# Try to recover the text using asr_hypos.
# Otherwise, raise an exception.
if asr_hypos:
text = asr_hypos[0].__str__()
else:
raise Exception('Unable to find "text" from handler input:',
handler_input)
else:
raise Exception('Unable to parse handler input:',
handler_input)
serializer = DefaultSerializer()
user_message = UserMessage(
payload=serializer.serialize(request_envelope),
channel='alexaprize',
request_id=request_envelope.request.request_id,
session_id=request_envelope.session.session_id,
user_id=request_envelope.session.user.user_id,
text=text,
asr_hypos=asr_hypos
)
attributes_manager = handler_input.attributes_manager
ser_session_attributes = attributes_manager.session_attributes
return (user_message, ser_session_attributes)
import logging.handlers
import uuid
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_core.api_client import DefaultApiClient
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_core.serialize import DefaultSerializer
from ask_sdk_model.interfaces.custom_interface_controller import (
StartEventHandlerDirective, EventFilter, Expiration, FilterMatchAction,
StopEventHandlerDirective, SendDirectiveDirective, Header, Endpoint)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
serializer = DefaultSerializer()
skill_builder = CustomSkillBuilder(api_client=DefaultApiClient())
@skill_builder.request_handler(can_handle_func=is_request_type("LaunchRequest")
)
def launch_request_handler(handler_input: HandlerInput):
logger.info("== Launch Intent ==")
response_builder = handler_input.response_builder
system = handler_input.request_envelope.context.system
# Get connected gadget endpoint ID.
endpoints = get_connected_endpoints(handler_input)
logger.debug("Checking endpoint..")
import sys, os
import importlib
from ask_sdk_core.serialize import DefaultSerializer
from ask_sdk_model.request_envelope import RequestEnvelope
from ask_sdk_model.context import Context
sd = DefaultSerializer()
# TODO: I think the smart thing to build a test bench would be to go through all
# the handlers and just look for a file in some predetermined location and a
# file with the name of the function with a json extension.
# e.g., def LaunchRequestHandler: ==> ../sampleEvents/LaunchRequest.json
# Then if someone wanted different names for the files they would have to
# specify a dictionry below. To quickly get the that information I think it
# would be able to come from the generated language model that the online
# creator makes. But there is away to do it by going through the model and
# looking at it's parent class.
samples_path = 'utils/sampleEvents'
sample_events = {
'LaunchRequest': '/LaunchRequestEvent.json',
'HelpIntent': '/helpIntent.json',
'GetNextMatchIntent': '/getNextMatchEvent.json',
'GetNextTeamMatchIntent': '',
'GetTeamRecordIntent': '/getTeamRecordEvent.json',
'GetTodaysMatchesIntent': '/getTodaysMatchesEvent.json',
'GetTomorrowsMatchesIntent': '/getTomorrowsMatchesEvent.json',
'GetStandingsIntent': '/getStandingsEvent.json',
'GetTopTeamIntent': '/getTopTeamEven.json',
'GetNextTeamMatchIntent': '/getNextTeamMatchEvent.json'
def setUp(self):
self.test_serializer = DefaultSerializer()
class TestSerialization(unittest.TestCase):
def setUp(self):
self.test_serializer = DefaultSerializer()
def test_none_obj_serialization(self):
test_obj = None
assert self.test_serializer.serialize(test_obj) is None, \
"Default Serializer serialized None object incorrectly"
def test_primitive_obj_serialization(self):
test_obj = "test"
assert self.test_serializer.serialize(test_obj) == test_obj, \
"Default Serializer serialized str object incorrectly"
test_obj = 123
assert self.test_serializer.serialize(test_obj) == test_obj, \
"Default Serializer serialized int object incorrectly"
test_obj = u"test"
assert self.test_serializer.serialize(test_obj) == test_obj, \
"Default Serializer serialized unicode object incorrectly"
test_obj = b"test"
assert self.test_serializer.serialize(test_obj) == test_obj, \
"Default Serializer serialized bytes object incorrectly"
test_obj = False
assert self.test_serializer.serialize(test_obj) == test_obj, \
"Default Serializer serialized bool object incorrectly"
def test_list_obj_serialization(self):
test_obj_inst = data.ModelTestObject2(int_var=123)
test_list_obj = ["test", 123, test_obj_inst]
expected_list = ["test", 123, {"var4Int": 123}]
assert self.test_serializer.serialize(test_list_obj) == expected_list, \
"Default Serializer serialized list object incorrectly"
def test_tuple_obj_serialization(self):
test_obj_inst = data.ModelTestObject2(int_var=123)
test_tuple_obj = ("test", 123, test_obj_inst)
expected_tuple = ("test", 123, {"var4Int": 123})
assert self.test_serializer.serialize(test_tuple_obj) == expected_tuple, \
"Default Serializer serialized tuple object incorrectly"
def test_datetime_obj_serialization(self):
test_obj = datetime.datetime(2018, 1, 1, 10, 20, 30)
expected_datetime = "2018-01-01T10:20:30"
assert self.test_serializer.serialize(test_obj) == expected_datetime, \
"Default Serializer serialized datetime object incorrectly"
def test_date_obj_serialization(self):
test_obj = datetime.date(2018, 1, 1)
expected_date = "2018-01-01"
assert self.test_serializer.serialize(test_obj) == expected_date, \
"Default Serializer serialized datetime object incorrectly"
def test_dict_obj_serialization(self):
test_obj_inst = data.ModelTestObject2(int_var=123)
test_dict_obj = {
"test_str": "test",
"test_int": 123,
"test_obj": test_obj_inst
}
expected_dict = {
"test_str": "test",
"test_obj": {
"var4Int": 123
},
"test_int": 123,
}
assert self.test_serializer.serialize(test_dict_obj) == expected_dict, \
"Default Serializer serialized dict object incorrectly"
def test_model_obj_serialization(self):
test_model_obj_2 = data.ModelTestObject2(int_var=123)
test_model_obj_1 = data.ModelTestObject1(
str_var="test", datetime_var=datetime.datetime(
2018, 1, 1, 10, 20, 30), obj_var=test_model_obj_2)
expected_serialized_obj = {
"var1": "test",
"var2Time": "2018-01-01T10:20:30",
"var3Object": {
"var4Int": 123
}
}
assert self.test_serializer.serialize(test_model_obj_1) == expected_serialized_obj, \
"Default Serializer serialized model object incorrectly"
def test_enum_obj_serialization(self):
test_model_obj_2 = data.ModelTestObject2(int_var=123)
test_enum_obj = data.ModelEnumObject("ENUM_VAL_1")
test_model_obj_1 = data.ModelTestObject1(
str_var="test", datetime_var=datetime.datetime(
2018, 1, 1, 10, 20, 30), obj_var=test_model_obj_2,
enum_var=test_enum_obj)
expected_serialized_obj = {
"var1": "test",
"var2Time": "2018-01-01T10:20:30",
"var6Enum": "ENUM_VAL_1",
"var3Object": {
"var4Int": 123
}
}
assert self.test_serializer.serialize(test_model_obj_1) == expected_serialized_obj, \
"Default Serializer serialized enum object incorrectly"
def test_decimal_obj_without_decimals_serialization(self):
test_decimal_obj = decimal.Decimal(10)
expected_obj = 10
actual_obj = self.test_serializer.serialize(test_decimal_obj)
assert actual_obj == expected_obj, (
"Default Serializer serialized decimal object containing no "
"decimals incorrectly")
assert type(actual_obj) == int, (
"Default Serializer serialized decimal object containing no "
"decimals to incorrect type")
def test_decimal_obj_with_decimals_serialization(self):
test_decimal_obj = decimal.Decimal(10.5)
expected_obj = 10.5
actual_obj = self.test_serializer.serialize(test_decimal_obj)
assert actual_obj == expected_obj, (
"Default Serializer serialized decimal object containing "
"decimals incorrectly")
assert type(actual_obj) == float, (
"Default Serializer serialized decimal object containing "
"decimals to incorrect type")
class TestDeserialization(unittest.TestCase):
def setUp(self):
self.test_serializer = DefaultSerializer()
def test_none_obj_deserialization(self):
test_payload = None
test_obj_type = str
assert self.test_serializer.deserialize(
test_payload, test_obj_type) is None, \
"Default Serializer deserialized None object incorrectly"
def test_str_obj_deserialization(self):
test_payload = "test"
test_obj_type = str
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, \
"Default Serializer deserialized string object incorrectly"
def test_unicode_obj_deserialization(self):
test_payload = u"√"
test_obj_type = unicode_type
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == u"\u221a", \
"Default Serializer deserialized unicode string object incorrectly"
def test_int_obj_deserialization(self):
test_payload = 123
test_obj_type = int
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, \
"Default Serializer deserialized int object incorrectly"
def test_long_obj_deserialization(self):
test_payload = 123
test_obj_type = long_type
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == long_type(test_payload), \
"Default Serializer deserialized long object incorrectly"
def test_primitive_obj_deserialization_raising_unicode_exception(self):
test_serializer = DefaultSerializer()
mocked_primitive_type = mock.Mock(
side_effect=UnicodeEncodeError('hitchhiker', u"", 42, 43, 'the universe and everything else'))
test_serializer.PRIMITIVE_TYPES = [mocked_primitive_type]
test_payload = u"√"
test_obj_type = mocked_primitive_type
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert test_serializer.deserialize(
test_payload, test_obj_type) == u"\u221a", \
"Default Serializer deserialized primitive type which raises UnicodeEncodeError incorrectly"
def test_primitive_obj_deserialization_raising_type_error(self):
test_serializer = DefaultSerializer()
mocked_primitive_type = mock.Mock(side_effect=TypeError())
test_serializer.PRIMITIVE_TYPES = [mocked_primitive_type]
test_payload = "test"
test_obj_type = mocked_primitive_type
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, \
"Default Serializer deserialized primitive type which raises TypeError incorrectly"
def test_primitive_obj_deserialization_raising_value_error(self):
test_payload = "test"
test_obj_type = int
with self.assertRaises(SerializationException) as exc:
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
self.test_serializer.deserialize(test_payload, test_obj_type)
assert "Failed to parse test into 'int' object" in str(exc.exception), \
"Default Serializer didn't throw SerializationException when invalid primitive type is deserialized"
def test_datetime_obj_serialization(self):
# payload in iso8601 format
test_payload = "2018-01-01T10:20:30"
test_obj_type = datetime.datetime
expected_obj = datetime.datetime(2018, 1, 1, 10, 20, 30)
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(test_payload, test_obj_type) == expected_obj, \
"Default Serializer deserialized datetime object incorrectly"
def test_date_obj_serialization(self):
# payload in iso8601 format
test_payload = "2018-01-01"
test_obj_type = datetime.date
expected_obj = datetime.date(2018, 1, 1)
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(test_payload, test_obj_type) == expected_obj, \
"Default Serializer deserialized date object incorrectly"
def test_datetime_obj_deserialization_raising_value_error(self):
test_payload = "abc-wx-yzT25:80:90"
test_obj_type = datetime.datetime
with self.assertRaises(SerializationException) as exc:
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
self.test_serializer.deserialize(test_payload, test_obj_type)
assert "Failed to parse abc-wx-yzT25:80:90 into 'datetime' object" in str(exc.exception), \
"Default Serializer didn't throw SerializationException when invalid datetime type is deserialized"
def test_datetime_obj_deserialization_raising_import_error(self):
test_payload = "abc-wx-yzT25:80:90"
test_obj_type = datetime.datetime
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
with mock.patch('dateutil.parser.parse') as parse_class:
parse_class.side_effect = ImportError
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, \
"Default Serializer didn't return datetime correctly for import errors"
parse_class.assert_called_once_with(test_payload)
def test_obj_type_deserialization(self):
test_payload = "test"
test_obj_type = object
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, \
"Default Serializer deserialization of object returned other than the object itself"
def test_native_type_mapping_deserialization(self):
test_payload = "test"
test_obj_type = "str"
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, (
"Default Serializer deserialization of object with object_type of string class under native mapping "
"not deserialized correctly")
def test_polymorphic_list_obj_deserialization(self):
test_payload = ["test", 123, "2018-01-01T10:20:30"]
test_obj_type = "list[str, long, datetime]"
deserialized_datetime_obj = datetime.datetime(2018, 1, 1, 10, 20, 30)
expected_obj = ["test", 123, deserialized_datetime_obj]
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == expected_obj, (
"Default Serializer deserialized list containing poly type object incorrectly")
def test_similar_list_obj_deserialization(self):
test_payload = ["test", "test1", "2018-01-01T10:20:30"]
test_obj_type = "list[str]"
expected_obj = ["test", "test1", "2018-01-01T10:20:30"]
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == expected_obj, (
"Default Serializer deserialized list object containing similar type objects incorrectly")
def test_dict_obj_deserialization(self):
test_payload = {
"test_key": ["test_val_1", "test_val_2"],
"test_date_str": ["2018-01-01T10:20:30"]
}
test_obj_type = "dict(str, list[str])"
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, (
"Default Serializer deserialized dict object incorrectly")
def test_model_obj_deserialization(self):
test_payload = {
"var1": "test",
"var2Time": "2018-01-01T10:20:30",
"var3Object": {
"var4Int": 123
},
"var6Enum": "ENUM_VAL_1"
}
test_obj_type = data.ModelTestObject1
expected_datetime_obj = datetime.datetime(2018, 1, 1, 10, 20, 30)
expected_sub_obj = data.ModelTestObject2(int_var=123)
expected_enum_obj = data.ModelEnumObject("ENUM_VAL_1")
expected_obj = data.ModelTestObject1(
str_var="test", datetime_var=expected_datetime_obj, obj_var=expected_sub_obj, enum_var=expected_enum_obj)
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == expected_obj, (
"Default Serializer deserialized model object incorrectly")
def test_model_obj_with_additional_params_in_payload_deserialization(self):
test_payload = {
"var4Int": 123,
"add_param_1": "Test"
}
test_obj_type = data.ModelTestObject2
expected_obj = data.ModelTestObject2(int_var=123)
expected_obj.add_param_1 = "Test"
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == expected_obj, (
"Default Serializer deserialized model object incorrectly when payload has additional parameters")
def test_invalid_model_obj_deserialization(self):
test_payload = {
"var_1": "some value"
}
test_obj_type = data.InvalidModelObject
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == test_payload, (
"Default Serializer didn't provide payload back when an invalid model object type "
"(without attribute map and swagger type dict) is passed")
def test_invalid_model_obj_type_deserialization(self):
test_payload = {
"var_1": "some value"
}
test_obj_type = "InvalidModelObject"
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
with self.assertRaises(SerializationException) as exc:
self.test_serializer.deserialize(test_payload, test_obj_type)
assert "Unable to resolve class {} from installed modules".format(test_obj_type) in str(exc.exception), (
"Default Serializer didn't throw SerializationException when deserialization is called with invalid "
"object type")
def test_invalid_json_deserialization(self):
test_payload = {
"var_1": "some value"
}
test_obj_type = "str"
with patch("json.loads") as mock_json_loader:
mock_json_loader.side_effect = Exception
with self.assertRaises(SerializationException) as exc:
self.test_serializer.deserialize(test_payload, test_obj_type)
assert "Couldn't parse response body" in str(exc.exception), \
"Default Serializer didn't throw SerializationException when invalid json is deserialized"
def test_parent_model_obj_with_discriminator_deserialization(self):
test_payload = {
"ChildType": 'ChildType1',
"var1": "Some string",
"var3Object": {
"var4Int": 123
},
"testVar": "test string"
}
test_obj_type = data.ModelAbstractParentObject
expected_sub_obj = data.ModelTestObject2(int_var=123)
expected_obj = data.ModelChildObject1(
str_var="Some string", obj_var=expected_sub_obj, test_var="test string")
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == expected_obj, (
"Default Serializer deserialized model object incorrectly when object type is parent class "
"with discriminator")
def test_child_discriminator_model_obj_deserialization(self):
test_payload = {
"ChildType": 'ChildType2',
"var1": "Some string",
"var3Object": {
"var4Int": 123
},
"testIntVar": 456
}
test_obj_type = data.ModelChildObject2
expected_sub_obj = data.ModelTestObject2(int_var=123)
expected_obj = data.ModelChildObject2(
str_var="Some string", obj_var=expected_sub_obj, test_int_var=456)
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
assert self.test_serializer.deserialize(
test_payload, test_obj_type) == expected_obj, (
"Default Serializer deserialized model object incorrectly when object type is parent class "
"with discriminator")
def test_parent_model_obj_with_invalid_discriminator_deserialization(self):
test_payload = {
"ChildType": 'InvalidType',
"var1": "Some string",
"var3Object": {
"var4Int": 123
},
"testVar": "test string"
}
test_obj_type = data.ModelAbstractParentObject
with patch("json.loads") as mock_json_loader:
mock_json_loader.return_value = test_payload
with self.assertRaises(SerializationException) as exc:
self.test_serializer.deserialize(test_payload, test_obj_type)
assert "Couldn't resolve object by discriminator type" in str(exc.exception), (
"Default Serializer didn't throw SerializationException when deserialization is called with invalid "
"discriminator type in payload and parent model")
