class TestRuntimeSerialized(unittest.TestCase): class TestObj(Model): _validation = {} _attribute_map = { 'attr_a': {'key':'id', 'type':'str'}, 'attr_b': {'key':'AttrB', 'type':'int'}, 'attr_c': {'key':'Key_C', 'type': 'bool'}, 'attr_d': {'key':'AttrD', 'type':'[int]'}, 'attr_e': {'key':'AttrE', 'type': '{float}'} } def __init__(self): self.attr_a = None self.attr_b = None self.attr_c = None self.attr_d = None self.attr_e = None def __str__(self): return "Test_Object" def setUp(self): self.s = Serializer() return super(TestRuntimeSerialized, self).setUp() def test_obj_without_attr_map(self): """ Test serializing an object with no attribute_map. """ test_obj = type("BadTestObj", (), {}) with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_obj_with_malformed_map(self): """ Test serializing an object with a malformed attribute_map. """ test_obj = type("BadTestObj", (Model,), {"_attribute_map":None}) with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj._attribute_map = {"attr":"val"} with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj._attribute_map = {"attr":{"val":1}} with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_obj_with_mismatched_map(self): """ Test serializing an object with mismatching attributes and map. """ test_obj = type("BadTestObj", (Model,), {"_attribute_map":None}) test_obj._attribute_map = {"abc":{"key":"ABC", "type":"str"}} with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_attr_none(self): """ Test serializing an object with None attributes. """ test_obj = self.TestObj() message = self.s._serialize(test_obj) self.assertIsInstance(message, dict) self.assertFalse('id' in message) def test_attr_int(self): """ Test serializing an object with Int attributes. """ test_obj = self.TestObj() self.TestObj._validation = { 'attr_b': {'required': True}, } test_obj.attr_b = None with self.assertRaises(ValidationError): self.s._serialize(test_obj) test_obj.attr_b = 25 message = self.s._serialize(test_obj) self.assertEqual(message['AttrB'], int(test_obj.attr_b)) test_obj.attr_b = "34534" message = self.s._serialize(test_obj) self.assertEqual(message['AttrB'], int(test_obj.attr_b)) test_obj.attr_b = "NotANumber" with self.assertRaises(SerializationError): self.s._serialize(test_obj) self.TestObj._validation = {} def test_attr_str(self): """ Test serializing an object with Str attributes. """ test_obj = self.TestObj() self.TestObj._validation = { 'attr_a': {'required': True}, } test_obj.attr_a = None with self.assertRaises(ValidationError): self.s._serialize(test_obj) self.TestObj._validation = {} test_obj.attr_a = "TestString" message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) test_obj.attr_a = 1234 message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) test_obj.attr_a = list() message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) test_obj.attr_a = [1] message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) def test_attr_bool(self): """ Test serializing an object with bool attributes. """ test_obj = self.TestObj() test_obj.attr_c = True message = self.s._serialize(test_obj) self.assertEqual(message['Key_C'], True) test_obj.attr_c = "" message = self.s._serialize(test_obj) self.assertTrue('Key_C' in message) test_obj.attr_c = None message = self.s._serialize(test_obj) self.assertFalse('Key_C' in message) test_obj.attr_c = "NotEmpty" message = self.s._serialize(test_obj) self.assertEqual(message['Key_C'], True) def test_attr_sequence(self): """ Test serializing a sequence. """ test_obj = ["A", "B", "C"] output = self.s._serialize(test_obj, '[str]', div='|') self.assertEqual(output, "|".join(test_obj)) test_obj = [1,2,3] output = self.s._serialize(test_obj, '[str]', div=',') self.assertEqual(output, ",".join([str(i) for i in test_obj])) def test_attr_list_simple(self): """ Test serializing an object with simple-typed list attributes """ test_obj = self.TestObj() test_obj.attr_d = [] message = self.s._serialize(test_obj) self.assertEqual(message['AttrD'], test_obj.attr_d) test_obj.attr_d = [1,2,3] message = self.s._serialize(test_obj) self.assertEqual(message['AttrD'], test_obj.attr_d) test_obj.attr_d = ["1","2","3"] message = self.s._serialize(test_obj) self.assertEqual(message['AttrD'], [int(i) for i in test_obj.attr_d]) test_obj.attr_d = ["test","test2","test3"] with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj.attr_d = "NotAList" with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_empty_list(self): input = [] output = self.s._serialize(input, '[str]') self.assertEqual(output, input) def test_attr_list_complex(self): """ Test serializing an object with a list of complex objects as an attribute. """ list_obj = type("ListObj", (Model,), {"_attribute_map":None, "_validation":{}, "abc":None}) list_obj._attribute_map = {"abc":{"key":"ABC", "type":"int"}} list_obj.abc = "123" test_obj = type("CmplxTestObj", (Model,), {"_attribute_map":None, "_validation":{}, "test_list":None}) test_obj._attribute_map = {"test_list":{"key":"_list", "type":"[ListObj]"}} test_obj.test_list = [list_obj] message = self.s._serialize(test_obj) self.assertEqual(message, {'_list':[{'ABC':123}]}) list_obj = type("BadListObj", (Model,), {"map":None}) test_obj._attribute_map = {"test_list":{"key":"_list", "type":"[BadListObj]"}} test_obj.test_list = [list_obj] s = self.s._serialize(test_obj) self.assertEqual(s, {'_list':[{}]}) def test_attr_dict_simple(self): """ Test serializing an object with a simple dictionary attribute. """ test_obj = self.TestObj() test_obj.attr_e = {"value": 3.14} message = self.s._serialize(test_obj) self.assertEqual(message['AttrE']['value'], float(test_obj.attr_e["value"])) test_obj.attr_e = {1: "3.14"} message = self.s._serialize(test_obj) self.assertEqual(message['AttrE']['1'], float(test_obj.attr_e[1])) test_obj.attr_e = "NotADict" with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj.attr_e = {"value": "NotAFloat"} with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_serialize_datetime(self): date_obj = isodate.parse_datetime('2015-01-01T00:00:00') date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '2015-01-01T00:00:00.000Z') date_obj = isodate.parse_datetime('1999-12-31T23:59:59-12:00') date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '2000-01-01T11:59:59.000Z') with self.assertRaises(SerializationError): date_obj = isodate.parse_datetime('9999-12-31T23:59:59-12:00') date_str = Serializer.serialize_iso(date_obj) with self.assertRaises(SerializationError): date_obj = isodate.parse_datetime('0001-01-01T00:00:00+23:59') date_str = Serializer.serialize_iso(date_obj) date_obj = isodate.parse_datetime("2015-06-01T16:10:08.0121-07:00") date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '2015-06-01T23:10:08.0121Z') date_obj = datetime.min date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '0001-01-01T00:00:00.000Z') date_obj = datetime.max date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '9999-12-31T23:59:59.999999Z') def test_serialize_primitive_types(self): a = self.s.serialize_data(1, 'int') self.assertEqual(a, 1) b = self.s.serialize_data(True, 'bool') self.assertEqual(b, True) c = self.s.serialize_data('True', 'str') self.assertEqual(c, 'True') d = self.s.serialize_data(100.0123, 'float') self.assertEqual(d, 100.0123) def test_serialize_object(self): a = self.s.body(1, 'object') self.assertEqual(a, 1) b = self.s.body(True, 'object') self.assertEqual(b, True) c = self.s.serialize_data('True', 'object') self.assertEqual(c, 'True') d = self.s.serialize_data(100.0123, 'object') self.assertEqual(d, 100.0123) e = self.s.serialize_data({}, 'object') self.assertEqual(e, {}) f = self.s.body({"test":"data"}, 'object') self.assertEqual(f, {"test":"data"}) g = self.s.body({"test":{"value":"data"}}, 'object') self.assertEqual(g, {"test":{"value":"data"}}) h = self.s.serialize_data({"test":self.TestObj()}, 'object') self.assertEqual(h, {"test":"Test_Object"}) i = self.s.serialize_data({"test":[1,2,3,4,5]}, 'object') self.assertEqual(i, {"test":[1,2,3,4,5]}) def test_serialize_empty_iter(self): a = self.s.serialize_dict({}, 'int') self.assertEqual(a, {}) b = self.s.serialize_iter([], 'int') self.assertEqual(b, []) def test_serialize_json_obj(self): class ComplexId(Model): _validation = {} _attribute_map = {'id':{'key':'id','type':'int'}, 'name':{'key':'name','type':'str'}, 'age':{'key':'age','type':'float'}, 'male':{'key':'male','type':'bool'}, 'birthday':{'key':'birthday','type':'iso-8601'}, 'anniversary':{'key':'anniversary', 'type':'iso-8601'}} id = 1 name = "Joey" age = 23.36 male = True birthday = '1992-01-01T00:00:00.000Z' anniversary = isodate.parse_datetime('2013-12-08T00:00:00') class ComplexJson(Model): _validation = {} _attribute_map = {'p1':{'key':'p1','type':'str'}, 'p2':{'key':'p2','type':'str'}, 'top_date':{'key':'top_date', 'type':'iso-8601'}, 'top_dates':{'key':'top_dates', 'type':'[iso-8601]'}, 'insider':{'key':'insider','type':'{iso-8601}'}, 'top_complex':{'key':'top_complex','type':'ComplexId'}} p1 = 'value1' p2 = 'value2' top_date = isodate.parse_datetime('2014-01-01T00:00:00') top_dates = [isodate.parse_datetime('1900-01-01T00:00:00'), isodate.parse_datetime('1901-01-01T00:00:00')] insider = { 'k1': isodate.parse_datetime('2015-01-01T00:00:00'), 'k2': isodate.parse_datetime('2016-01-01T00:00:00'), 'k3': isodate.parse_datetime('2017-01-01T00:00:00')} top_complex = ComplexId() message =self.s._serialize(ComplexJson()) output = { 'p1': 'value1', 'p2': 'value2', 'top_date': '2014-01-01T00:00:00.000Z', 'top_dates': [ '1900-01-01T00:00:00.000Z', '1901-01-01T00:00:00.000Z' ], 'insider': { 'k1': '2015-01-01T00:00:00.000Z', 'k2': '2016-01-01T00:00:00.000Z', 'k3': '2017-01-01T00:00:00.000Z' }, 'top_complex': { 'id': 1, 'name': 'Joey', 'age': 23.36, 'male': True, 'birthday': '1992-01-01T00:00:00.000Z', 'anniversary': '2013-12-08T00:00:00.000Z', } } self.maxDiff = None self.assertEqual(message, output) def test_polymorphic_serialization(self): self.maxDiff = None class Zoo(Model): _attribute_map = { "animals":{"key":"Animals", "type":"[Animal]"}, } def __init__(self): self.animals = None class Animal(Model): _attribute_map = { "name":{"key":"Name", "type":"str"} } _subtype_map = { 'dType': {"cat":"Cat", "dog":"Dog"} } def __init__(self): self.name = None class Dog(Animal): _attribute_map = { "name":{"key":"Name", "type":"str"}, "likes_dog_food":{"key":"likesDogFood","type":"bool"} } def __init__(self): self.likes_dog_food = None super(Dog, self).__init__() class Cat(Animal): _attribute_map = { "name":{"key":"Name", "type":"str"}, "likes_mice":{"key":"likesMice","type":"bool"}, "dislikes":{"key":"dislikes","type":"Animal"} } _subtype_map = { "dType":{"siamese":"Siamese"} } def __init__(self): self.likes_mice = None self.dislikes = None super(Cat, self).__init__() class Siamese(Cat): _attribute_map = { "name":{"key":"Name", "type":"str"}, "likes_mice":{"key":"likesMice","type":"bool"}, "dislikes":{"key":"dislikes","type":"Animal"}, "color":{"key":"Color", "type":"str"} } def __init__(self): self.color = None super(Siamese, self).__init__() message = { "Animals": [ { "dType": "dog", "likesDogFood": True, "Name": "Fido" }, { "dType": "cat", "likesMice": False, "dislikes": { "dType": "dog", "likesDogFood": True, "Name": "Angry" }, "Name": "Felix" }, { "dType": "siamese", "Color": "grey", "likesMice": True, "Name": "Finch" }]} zoo = Zoo() angry = Dog() angry.name = "Angry" angry.likes_dog_food = True fido = Dog() fido.name = "Fido" fido.likes_dog_food = True felix = Cat() felix.name = "Felix" felix.likes_mice = False felix.dislikes = angry finch = Siamese() finch.name = "Finch" finch.color = "grey" finch.likes_mice = True zoo.animals = [fido, felix, finch] serialized = self.s._serialize(zoo) self.assertEqual(serialized, message)
class TestRuntimeSerialized(unittest.TestCase): class TestObj(Model): _validation = {} _attribute_map = { 'attr_a': { 'key': 'id', 'type': 'str' }, 'attr_b': { 'key': 'AttrB', 'type': 'int' }, 'attr_c': { 'key': 'Key_C', 'type': 'bool' }, 'attr_d': { 'key': 'AttrD', 'type': '[int]' }, 'attr_e': { 'key': 'AttrE', 'type': '{float}' } } def __init__(self): self.attr_a = None self.attr_b = None self.attr_c = None self.attr_d = None self.attr_e = None def __str__(self): return "Test_Object" def setUp(self): self.s = Serializer() return super(TestRuntimeSerialized, self).setUp() def test_validate(self): # Assert not necessary, should not raise exception self.s.validate("simplestring", "StringForLog", pattern="^[a-z]+$") self.s.validate(u"UTF8ééééé", "StringForLog", pattern=r"^[\w]+$") def test_obj_serialize_none(self): """Test that serialize None in object is still None. """ obj = self.s.serialize_object({'test': None}) self.assertIsNone(obj['test']) def test_obj_without_attr_map(self): """ Test serializing an object with no attribute_map. """ test_obj = type("BadTestObj", (), {}) with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_obj_with_malformed_map(self): """ Test serializing an object with a malformed attribute_map. """ test_obj = type("BadTestObj", (Model, ), {"_attribute_map": None}) with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj._attribute_map = {"attr": "val"} with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj._attribute_map = {"attr": {"val": 1}} with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_obj_with_mismatched_map(self): """ Test serializing an object with mismatching attributes and map. """ test_obj = type("BadTestObj", (Model, ), {"_attribute_map": None}) test_obj._attribute_map = {"abc": {"key": "ABC", "type": "str"}} with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_attr_none(self): """ Test serializing an object with None attributes. """ test_obj = self.TestObj() message = self.s._serialize(test_obj) self.assertIsInstance(message, dict) self.assertFalse('id' in message) def test_attr_int(self): """ Test serializing an object with Int attributes. """ test_obj = self.TestObj() self.TestObj._validation = { 'attr_b': { 'required': True }, } test_obj.attr_b = None with self.assertRaises(ValidationError): self.s._serialize(test_obj) test_obj.attr_b = 25 message = self.s._serialize(test_obj) self.assertEqual(message['AttrB'], int(test_obj.attr_b)) test_obj.attr_b = "34534" message = self.s._serialize(test_obj) self.assertEqual(message['AttrB'], int(test_obj.attr_b)) test_obj.attr_b = "NotANumber" with self.assertRaises(SerializationError): self.s._serialize(test_obj) self.TestObj._validation = {} def test_attr_str(self): """ Test serializing an object with Str attributes. """ test_obj = self.TestObj() self.TestObj._validation = { 'attr_a': { 'required': True }, } test_obj.attr_a = None with self.assertRaises(ValidationError): self.s._serialize(test_obj) self.TestObj._validation = {} test_obj.attr_a = "TestString" message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) test_obj.attr_a = 1234 message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) test_obj.attr_a = list() message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) test_obj.attr_a = [1] message = self.s._serialize(test_obj) self.assertEqual(message['id'], str(test_obj.attr_a)) def test_attr_bool(self): """ Test serializing an object with bool attributes. """ test_obj = self.TestObj() test_obj.attr_c = True message = self.s._serialize(test_obj) self.assertEqual(message['Key_C'], True) test_obj.attr_c = "" message = self.s._serialize(test_obj) self.assertTrue('Key_C' in message) test_obj.attr_c = None message = self.s._serialize(test_obj) self.assertFalse('Key_C' in message) test_obj.attr_c = "NotEmpty" message = self.s._serialize(test_obj) self.assertEqual(message['Key_C'], True) def test_attr_sequence(self): """ Test serializing a sequence. """ test_obj = ["A", "B", "C"] output = self.s._serialize(test_obj, '[str]', div='|') self.assertEqual(output, "|".join(test_obj)) test_obj = [1, 2, 3] output = self.s._serialize(test_obj, '[str]', div=',') self.assertEqual(output, ",".join([str(i) for i in test_obj])) def test_attr_list_simple(self): """ Test serializing an object with simple-typed list attributes """ test_obj = self.TestObj() test_obj.attr_d = [] message = self.s._serialize(test_obj) self.assertEqual(message['AttrD'], test_obj.attr_d) test_obj.attr_d = [1, 2, 3] message = self.s._serialize(test_obj) self.assertEqual(message['AttrD'], test_obj.attr_d) test_obj.attr_d = ["1", "2", "3"] message = self.s._serialize(test_obj) self.assertEqual(message['AttrD'], [int(i) for i in test_obj.attr_d]) test_obj.attr_d = ["test", "test2", "test3"] with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj.attr_d = "NotAList" with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_empty_list(self): input = [] output = self.s._serialize(input, '[str]') self.assertEqual(output, input) def test_attr_list_complex(self): """ Test serializing an object with a list of complex objects as an attribute. """ list_obj = type("ListObj", (Model, ), { "_attribute_map": None, "_validation": {}, "abc": None }) list_obj._attribute_map = {"abc": {"key": "ABC", "type": "int"}} list_obj.abc = "123" test_obj = type("CmplxTestObj", (Model, ), { "_attribute_map": None, "_validation": {}, "test_list": None }) test_obj._attribute_map = { "test_list": { "key": "_list", "type": "[ListObj]" } } test_obj.test_list = [list_obj] message = self.s._serialize(test_obj) self.assertEqual(message, {'_list': [{'ABC': 123}]}) list_obj = type("BadListObj", (Model, ), {"map": None}) test_obj._attribute_map = { "test_list": { "key": "_list", "type": "[BadListObj]" } } test_obj.test_list = [list_obj] s = self.s._serialize(test_obj) self.assertEqual(s, {'_list': [{}]}) def test_attr_dict_simple(self): """ Test serializing an object with a simple dictionary attribute. """ test_obj = self.TestObj() test_obj.attr_e = {"value": 3.14} message = self.s._serialize(test_obj) self.assertEqual(message['AttrE']['value'], float(test_obj.attr_e["value"])) test_obj.attr_e = {1: "3.14"} message = self.s._serialize(test_obj) self.assertEqual(message['AttrE']['1'], float(test_obj.attr_e[1])) test_obj.attr_e = "NotADict" with self.assertRaises(SerializationError): self.s._serialize(test_obj) test_obj.attr_e = {"value": "NotAFloat"} with self.assertRaises(SerializationError): self.s._serialize(test_obj) def test_serialize_datetime(self): date_obj = isodate.parse_datetime('2015-01-01T00:00:00') date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '2015-01-01T00:00:00.000Z') date_obj = isodate.parse_datetime('1999-12-31T23:59:59-12:00') date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '2000-01-01T11:59:59.000Z') with self.assertRaises(SerializationError): date_obj = isodate.parse_datetime('9999-12-31T23:59:59-12:00') date_str = Serializer.serialize_iso(date_obj) with self.assertRaises(SerializationError): date_obj = isodate.parse_datetime('0001-01-01T00:00:00+23:59') date_str = Serializer.serialize_iso(date_obj) date_obj = isodate.parse_datetime("2015-06-01T16:10:08.0121-07:00") date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '2015-06-01T23:10:08.0121Z') date_obj = datetime.min date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '0001-01-01T00:00:00.000Z') date_obj = datetime.max date_str = Serializer.serialize_iso(date_obj) self.assertEqual(date_str, '9999-12-31T23:59:59.999999Z') def test_serialize_primitive_types(self): a = self.s.serialize_data(1, 'int') self.assertEqual(a, 1) b = self.s.serialize_data(True, 'bool') self.assertEqual(b, True) c = self.s.serialize_data('True', 'str') self.assertEqual(c, 'True') d = self.s.serialize_data(100.0123, 'float') self.assertEqual(d, 100.0123) def test_serialize_object(self): a = self.s.body(1, 'object') self.assertEqual(a, 1) b = self.s.body(True, 'object') self.assertEqual(b, True) c = self.s.serialize_data('True', 'object') self.assertEqual(c, 'True') d = self.s.serialize_data(100.0123, 'object') self.assertEqual(d, 100.0123) e = self.s.serialize_data({}, 'object') self.assertEqual(e, {}) f = self.s.body({"test": "data"}, 'object') self.assertEqual(f, {"test": "data"}) g = self.s.body({"test": {"value": "data"}}, 'object') self.assertEqual(g, {"test": {"value": "data"}}) h = self.s.serialize_data({"test": self.TestObj()}, 'object') self.assertEqual(h, {"test": "Test_Object"}) i = self.s.serialize_data({"test": [1, 2, 3, 4, 5]}, 'object') self.assertEqual(i, {"test": [1, 2, 3, 4, 5]}) def test_serialize_empty_iter(self): a = self.s.serialize_dict({}, 'int') self.assertEqual(a, {}) b = self.s.serialize_iter([], 'int') self.assertEqual(b, []) def test_serialize_json_obj(self): class ComplexId(Model): _validation = {} _attribute_map = { 'id': { 'key': 'id', 'type': 'int' }, 'name': { 'key': 'name', 'type': 'str' }, 'age': { 'key': 'age', 'type': 'float' }, 'male': { 'key': 'male', 'type': 'bool' }, 'birthday': { 'key': 'birthday', 'type': 'iso-8601' }, 'anniversary': { 'key': 'anniversary', 'type': 'iso-8601' } } id = 1 name = "Joey" age = 23.36 male = True birthday = '1992-01-01T00:00:00.000Z' anniversary = isodate.parse_datetime('2013-12-08T00:00:00') class ComplexJson(Model): _validation = {} _attribute_map = { 'p1': { 'key': 'p1', 'type': 'str' }, 'p2': { 'key': 'p2', 'type': 'str' }, 'top_date': { 'key': 'top_date', 'type': 'iso-8601' }, 'top_dates': { 'key': 'top_dates', 'type': '[iso-8601]' }, 'insider': { 'key': 'insider', 'type': '{iso-8601}' }, 'top_complex': { 'key': 'top_complex', 'type': 'ComplexId' } } p1 = 'value1' p2 = 'value2' top_date = isodate.parse_datetime('2014-01-01T00:00:00') top_dates = [ isodate.parse_datetime('1900-01-01T00:00:00'), isodate.parse_datetime('1901-01-01T00:00:00') ] insider = { 'k1': isodate.parse_datetime('2015-01-01T00:00:00'), 'k2': isodate.parse_datetime('2016-01-01T00:00:00'), 'k3': isodate.parse_datetime('2017-01-01T00:00:00') } top_complex = ComplexId() message = self.s._serialize(ComplexJson()) output = { 'p1': 'value1', 'p2': 'value2', 'top_date': '2014-01-01T00:00:00.000Z', 'top_dates': ['1900-01-01T00:00:00.000Z', '1901-01-01T00:00:00.000Z'], 'insider': { 'k1': '2015-01-01T00:00:00.000Z', 'k2': '2016-01-01T00:00:00.000Z', 'k3': '2017-01-01T00:00:00.000Z' }, 'top_complex': { 'id': 1, 'name': 'Joey', 'age': 23.36, 'male': True, 'birthday': '1992-01-01T00:00:00.000Z', 'anniversary': '2013-12-08T00:00:00.000Z', } } self.maxDiff = None self.assertEqual(message, output) def test_polymorphic_serialization(self): self.maxDiff = None class Zoo(Model): _attribute_map = { "animals": { "key": "Animals", "type": "[Animal]" }, } def __init__(self, animals=None): self.animals = animals class Animal(Model): _attribute_map = { "name": { "key": "Name", "type": "str" }, "d_type": { "key": "dType", "type": "str" } } _subtype_map = {'d_type': {"cat": "Cat", "dog": "Dog"}} def __init__(self, name=None): self.name = name class Dog(Animal): _attribute_map = { "name": { "key": "Name", "type": "str" }, "likes_dog_food": { "key": "likesDogFood", "type": "bool" }, "d_type": { "key": "dType", "type": "str" } } def __init__(self, name=None, likes_dog_food=None): self.likes_dog_food = likes_dog_food super(Dog, self).__init__(name) self.d_type = 'dog' class Cat(Animal): _attribute_map = { "name": { "key": "Name", "type": "str" }, "likes_mice": { "key": "likesMice", "type": "bool" }, "dislikes": { "key": "dislikes", "type": "Animal" }, "d_type": { "key": "dType", "type": "str" } } _subtype_map = {"d_type": {"siamese": "Siamese"}} def __init__(self, name=None, likes_mice=None, dislikes=None): self.likes_mice = likes_mice self.dislikes = dislikes super(Cat, self).__init__(name) self.d_type = 'cat' class Siamese(Cat): _attribute_map = { "name": { "key": "Name", "type": "str" }, "likes_mice": { "key": "likesMice", "type": "bool" }, "dislikes": { "key": "dislikes", "type": "Animal" }, "color": { "key": "Color", "type": "str" }, "d_type": { "key": "dType", "type": "str" } } def __init__(self, name=None, likes_mice=None, dislikes=None, color=None): self.color = color super(Siamese, self).__init__(name, likes_mice, dislikes) self.d_type = 'siamese' message = { "Animals": [{ "dType": "dog", "likesDogFood": True, "Name": "Fido" }, { "dType": "cat", "likesMice": False, "dislikes": { "dType": "dog", "likesDogFood": True, "Name": "Angry" }, "Name": "Felix" }, { "dType": "siamese", "Color": "grey", "likesMice": True, "Name": "Finch" }] } zoo = Zoo() angry = Dog() angry.name = "Angry" angry.likes_dog_food = True fido = Dog() fido.name = "Fido" fido.likes_dog_food = True felix = Cat() felix.name = "Felix" felix.likes_mice = False felix.dislikes = angry finch = Siamese() finch.name = "Finch" finch.color = "grey" finch.likes_mice = True zoo.animals = [fido, felix, finch] serialized = self.s._serialize(zoo) self.assertEqual(serialized, message) old_dependencies = self.s.dependencies self.s.dependencies = { 'Zoo': Zoo, 'Animal': Animal, 'Dog': Dog, 'Cat': Cat, 'Siamese': Siamese } serialized = self.s.body( { "animals": [{ "dType": "dog", "likes_dog_food": True, "name": "Fido" }, { "dType": "cat", "likes_mice": False, "dislikes": { "dType": "dog", "likes_dog_food": True, "name": "Angry" }, "name": "Felix" }, { "dType": "siamese", "color": "grey", "likes_mice": True, "name": "Finch" }] }, "Zoo") self.assertEqual(serialized, message) self.s.dependencies = old_dependencies
class LogAnalyticsAlertClient(object): def __init__(self, credentials, subscription_id, base_url=None): self.config = LogAnalyticsManagementClientConfiguration( credentials, subscription_id, base_url) self._client = ServiceClient(self.config.credentials, self.config) client_models = { k: v for k, v in models.__dict__.items() if isinstance(v, type) } self._serialize = Serializer(client_models) self._serialize.basic_types[unicode] = "unicode" self._serialize.serialize_type["dict"] = self._patched_serialize_dict self._deserialize = Deserializer(client_models) self._deserialize.basic_types[unicode] = "unicode" self._deserialize.deserialize_type[ "dict"] = self._patched_deserialize_dict self._deserialize.deserialize_type[ "list"] = self._patched_deserialize_iter self.alert_services = AlertServicesOperations(self._client, self.config, self._serialize, self._deserialize) def _patched_serialize_dict(self, attr, **kwargs): """Hack for MS Serialization class which can't handle Dictionaries properly """ serialized = {} for key, value in attr.items(): try: if isinstance(value, list): serialized[self._serialize.serialize_unicode( key)] = self._serialize.serialize_iter( value, "str", **kwargs) else: serialized[self._serialize.serialize_unicode( key)] = self._serialize.serialize_data( value, type(value).__name__, **kwargs) except ValueError: serialized[self._serialize.serialize_unicode(key)] = None return serialized def _patched_deserialize_dict(self, attr): if isinstance(attr, list): return { x['key']: self._deserialize.deserialize_data(x['value'], type(x["value"]).__name__) for x in attr } return { k: self._deserialize.deserialize_data(v, type(v).__name__) for k, v in attr.items() } def _patched_deserialize_iter(self, attr): if attr is None: return None if not isinstance(attr, (list, set)): raise DeserializationError( "Cannot deserialize as [{}] an object of type {}".format( type(attr).__name__, type(attr))) return [ self._deserialize.deserialize_data(a, type(a).__name__) for a in attr ]