def test_list_not_wrapped_basic_types(self): """Test XML list and no wrap, items is basic type and there is no itemsName. """ basic_xml = """<?xml version="1.0"?> <AppleBarrel> <GoodApples>granny</GoodApples> <GoodApples>fuji</GoodApples> </AppleBarrel>""" class AppleBarrel(Model): _attribute_map = { 'good_apples': { 'key': 'GoodApples', 'type': '[str]', 'xml': { 'name': 'GoodApples' } }, } _xml_map = {'name': 'AppleBarrel'} s = Deserializer({"AppleBarrel": AppleBarrel}) result = s(AppleBarrel, basic_xml, "application/xml") assert result.good_apples == ["granny", "fuji"]
def test_basic_namespace(self): """Test an ultra basic XML.""" basic_xml = """<?xml version="1.0"?> <Data xmlns:fictional="http://characters.example.com"> <fictional:Age>37</fictional:Age> </Data>""" class XmlModel(Model): _attribute_map = { 'age': { 'key': 'age', 'type': 'int', 'xml': { 'name': 'Age', 'prefix': 'fictional', 'ns': 'http://characters.example.com' } }, } _xml_map = {'name': 'Data'} s = Deserializer({"XmlModel": XmlModel}) result = s(XmlModel, basic_xml, "application/xml") assert result.age == 37
def test_add_prop(self): """Test addProp as a dict. """ basic_xml = """<?xml version="1.0"?> <Data> <Metadata> <Key1>value1</Key1> <Key2>value2</Key2> </Metadata> </Data>""" class XmlModel(Model): _attribute_map = { 'metadata': { 'key': 'Metadata', 'type': '{str}', 'xml': { 'name': 'Metadata' } }, } _xml_map = {'name': 'Data'} s = Deserializer({"XmlModel": XmlModel}) result = s(XmlModel, basic_xml, "application/xml") assert len(result.metadata) == 2 assert result.metadata['Key1'] == "value1" assert result.metadata['Key2'] == "value2"
def test_basic(self): """Test an ultra basic XML.""" basic_xml = """<?xml version="1.0"?> <Data country="france"> <Long>12</Long> <EmptyLong/> <Age>37</Age> <EmptyAge/> <EmptyString/> </Data>""" class XmlModel(Model): _attribute_map = { 'longnode': {'key': 'longnode', 'type': 'long', 'xml':{'name': 'Long'}}, 'empty_long': {'key': 'empty_long', 'type': 'long', 'xml':{'name': 'EmptyLong'}}, 'age': {'key': 'age', 'type': 'int', 'xml':{'name': 'Age'}}, 'empty_age': {'key': 'empty_age', 'type': 'int', 'xml':{'name': 'EmptyAge'}}, 'empty_string': {'key': 'empty_string', 'type': 'str', 'xml':{'name': 'EmptyString'}}, 'not_set': {'key': 'not_set', 'type': 'str', 'xml':{'name': 'NotSet'}}, 'country': {'key': 'country', 'type': 'str', 'xml':{'name': 'country', 'attr': True}}, } _xml_map = { 'name': 'Data' } s = Deserializer({"XmlModel": XmlModel}) result = s(XmlModel, basic_xml, "application/xml") assert result.longnode == 12 assert result.empty_long is None assert result.age == 37 assert result.empty_age is None assert result.country == "france" assert result.empty_string == "" assert result.not_set is None
def test_basic(self): """Test an ultra basic XML.""" basic_xml = """<?xml version="1.0"?> <Data country="france"> <Age>37</Age> </Data>""" class XmlModel(Model): _attribute_map = { 'age': { 'key': 'age', 'type': 'int', 'xml': { 'name': 'Age' } }, 'country': { 'key': 'country', 'type': 'str', 'xml': { 'name': 'country', 'attr': True } }, } _xml_map = {'name': 'Data'} s = Deserializer({"XmlModel": XmlModel}) result = s(XmlModel, basic_xml, "application/xml") assert result.age == 37 assert result.country == "france"
def test_list_not_wrapped_complex_types(self): """Test XML list and wrap, items is ref and there is no itemsName. """ basic_xml = """<?xml version="1.0"?> <AppleBarrel> <Apple name="granny"/> <Apple name="fuji"/> </AppleBarrel>""" class AppleBarrel(Model): _attribute_map = { # Name is ignored if wrapped is False 'good_apples': {'key': 'GoodApples', 'type': '[Apple]', 'xml': {'name': 'GoodApples'}}, } _xml_map = { 'name': 'AppleBarrel' } class Apple(Model): _attribute_map = { 'name': {'key': 'name', 'type': 'str', 'xml':{'name': 'name', 'attr': True}}, } _xml_map = { 'name': 'Apple' } s = Deserializer({"AppleBarrel": AppleBarrel, "Apple": Apple}) result = s(AppleBarrel, basic_xml, "application/xml") assert [apple.name for apple in result.good_apples] == ["granny", "fuji"]
def test_list_wrapped_items_name_complex_types(self): """Test XML list and wrap, items is ref and there is itemsName. """ basic_xml = """<?xml version="1.0"?> <AppleBarrel> <GoodApples> <Apple name="granny"/> <Apple name="fuji"/> </GoodApples> </AppleBarrel>""" class AppleBarrel(Model): _attribute_map = { 'good_apples': {'key': 'GoodApples', 'type': '[Apple]', 'xml': {'name': 'GoodApples', 'wrapped': True, 'itemsName': 'Apple'}}, } _xml_map = { 'name': 'AppleBarrel' } class Apple(Model): _attribute_map = { 'name': {'key': 'name', 'type': 'str', 'xml':{'name': 'name', 'attr': True}}, } _xml_map = { 'name': 'Pomme' # Should be ignored, since "itemsName" is defined } s = Deserializer({"AppleBarrel": AppleBarrel, "Apple": Apple}) result = s('AppleBarrel', basic_xml, "application/xml") assert [apple.name for apple in result.good_apples] == ["granny", "fuji"]
def __init__(self, response, error=None, *args): deserialize = Deserializer() self.error = None self.message = None self.response = response self.status_code = self.response.status_code self.request_id = None if error: self.message = error self.error = response else: try: data = response.json() except ValueError: data = response else: data = data.get('error', data) try: self.error = deserialize(CloudErrorData(), data) except DeserializationError: self.error = None try: self.message = self.error.message except AttributeError: self.message = None if not self.error or not self.message: try: content = response.json() except ValueError: server_message = "none" else: server_message = content.get('message', "none") try: response.raise_for_status() except RequestException as err: if not self.error: self.error = err if not self.message: if server_message == "none": server_message = str(err) msg = "Operation failed with status: {!r}. Details: {}" self.message = msg.format(response.reason, server_message) else: if not self.error: self.error = response if not self.message: msg = "Operation failed with status: {!r}. Details: {}" self.message = msg.format(response.status_code, server_message) super(CloudError, self).__init__(self.message, self.error, *args)
def test_object_no_text(self): basic_xml = """<?xml version="1.0"?><Data country="france"><Age>37</Age></Data>""" s = Deserializer() result = s('object', basic_xml, "application/xml") # Should be a XML tree assert result.tag == "Data" assert result.get("country") == "france" for child in result: assert child.tag == "Age" assert child.text == "37"
def test_request_exception(self): def raise_for_status(): raise requests.RequestException() deserializer = Deserializer() response = mock.create_autospec(requests.Response) response.raise_for_status = raise_for_status response.reason = "TESTING" excep = HttpOperationError(deserializer, response) self.assertIn("TESTING", str(excep)) self.assertIn("Operation returned an invalid status code", str(excep))
def deserializer_helper(msrest_cls: Type[Model], dict_to_deserialize: dict) -> Model: dependencies = [ schema_cls for key, schema_cls in getmembers(schema) if isinstance(schema_cls, type) and issubclass(schema_cls, (Model, Enum)) ] dependencies += [ schema_cls for key, schema_cls in getmembers(teams_schema) if isinstance(schema_cls, type) and issubclass(schema_cls, (Model, Enum)) ] dependencies_dict = {dependency.__name__: dependency for dependency in dependencies} deserializer = Deserializer(dependencies_dict) return deserializer(msrest_cls.__name__, dict_to_deserialize)
def test_basic_empty_list(self): """Test an basic XML with an empty node.""" basic_xml = """<?xml version="1.0"?> <Data/>""" class XmlModel(Model): _attribute_map = { 'age': {'key': 'age', 'type': 'str', 'xml':{'name': 'Age'}}, } _xml_map = { 'name': 'Data' } s = Deserializer({"XmlModel": XmlModel}) result = s('[XmlModel]', basic_xml, "application/xml") assert result == []
def __init__(self, response, error=None, *args, **kwargs): self.deserializer = Deserializer({'CloudErrorData': CloudErrorData}) self.error = None self.message = None self.response = response self.status_code = self.response.status_code self.request_id = None if error: self.message = error self.error = response else: self._build_error_data(response) if not self.error or not self.message: self._build_error_message(response) super(CloudError, self).__init__(self.message, self.error, *args, **kwargs)
def test_object_from_requests(self): basic_xml = b"""<?xml version="1.0"?> <Data country="france"> <Age>37</Age> </Data>""" response = requests.Response() response.headers["content-type"] = "application/xml; charset=utf-8" response._content = basic_xml response._content_consumed = True s = Deserializer() result = s('object', response) # Should be a XML tree assert result.tag == "Data" assert result.get("country") == "france" for child in result: assert child.tag == "Age" assert child.text == "37"
def test_basic_unicode(self): """Test a XML with unicode.""" basic_xml = u"""<?xml version="1.0" encoding="utf-8"?> <Data language="français"/>""" class XmlModel(Model): _attribute_map = { 'language': { 'key': 'language', 'type': 'str', 'xml': { 'name': 'language', 'attr': True } }, } _xml_map = {'name': 'Data'} s = Deserializer({"XmlModel": XmlModel}) result = s(XmlModel, basic_xml, "application/xml") assert result.language == u"français"
def _get_deserializer(): client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} return Deserializer(client_models)
_attribute_map = { 'next_link': { 'key': 'nextLink', 'type': 'str' }, 'current_page': { 'key': 'value', 'type': '[str]' } } def __init__(self, *args, **kwargs): super(FakePaged, self).__init__(*args, **kwargs) _test_deserializer = Deserializer({}) class TestPaging(unittest.TestCase): def test_basic_paging(self): def internal_paging(next_link=None, raw=False): if not next_link: return {'nextLink': 'page2', 'value': ['value1.0', 'value1.1']} else: return {'nextLink': None, 'value': ['value2.0', 'value2.1']} deserialized = FakePaged(internal_paging, _test_deserializer) result_iterated = list(deserialized) self.assertListEqual(['value1.0', 'value1.1', 'value2.0', 'value2.1'], result_iterated)
def deserializer_helper(msrest_cls: Type[Model], dict_to_deserialize: dict) -> Model: deserializer = Deserializer(DEPENDICIES_DICT) return deserializer(msrest_cls.__name__, dict_to_deserialize)
def test_custom_exception(self): class ErrorResponse(Model): _attribute_map = { 'error': { 'key': 'error', 'type': 'ErrorDetails' }, } def __init__(self, error=None): self.error = error class ErrorResponseException(HttpOperationError): def __init__(self, deserialize, response, *args): super(ErrorResponseException, self).__init__(deserialize, response, 'ErrorResponse', *args) class ErrorDetails(Model): _validation = { 'code': { 'readonly': True }, 'message': { 'readonly': True }, 'target': { 'readonly': True }, } _attribute_map = { 'code': { 'key': 'code', 'type': 'str' }, 'message': { 'key': 'message', 'type': 'str' }, 'target': { 'key': 'target', 'type': 'str' }, } def __init__(self): self.code = None self.message = None self.target = None deserializer = Deserializer({ 'ErrorResponse': ErrorResponse, 'ErrorDetails': ErrorDetails }) response = mock.create_autospec(requests.Response) response.text = json.dumps({ "error": { "code": "NotOptedIn", "message": "You are not allowed to download invoices. Please contact your account administrator to turn on access in the management portal for allowing to download invoices through the API." } }) response.headers = {"content-type": "application/json; charset=utf8"} excep = ErrorResponseException(deserializer, response) self.assertIn("NotOptedIn", str(excep)) self.assertIn("You are not allowed to download invoices", str(excep))