def dict2xml(self, data):
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("root", {})
self._to_xml(xml, data)
xml.endElement("root")
xml.endDocument()
return stream.getvalue()
def test_parse(self):
""" Make sure the `QueryDict` works OK """
parser = FormParser()
stream = StringIO(self.string)
data = parser.parse(stream)
self.assertEqual(Form(data).is_valid(), True)
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
In case a request is called on /api/v1/, we now redirect the call to DRF instead of
Tastypie. The differences between DRF and Tastypie are:
- Different names and values for several fields (see _rename_fields).
On paginated results:
- An additional 'meta' object containing the limit, next, previous and total_count;
- Next and previous links do not show the domain;
- The root tag name is 'response';
- The tag name of the results is 'objects';
- The tag name for each result is 'object'.
On non-paginated results:
- The tag name of the result is 'object'.
"""
request = renderer_context.get('request')
if '/api/v1/' in request.path:
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
if all(k in data.keys() for k in ['count', 'next', 'previous', 'offset', 'results']):
# Paginated result
xml.startElement("response", {})
data = _convert_data_for_tastypie(request, renderer_context['view'], data)
self._to_xml(xml, data)
xml.endElement("response")
else:
# Non-paginated result
xml.startElement("object", {})
self._to_xml(xml, _rename_fields([data])[0])
xml.endElement("object")
xml.endDocument()
return stream.getvalue()
elif isinstance(data, dict) and 'offset' in data.keys():
data.pop('offset')
return XMLRenderer().render(data, accepted_media_type, renderer_context)
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders *obj* into serialized XML.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("root", {})
self._to_xml(xml, data)
xml.endElement("root")
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
self._to_xml(xml, data)
xml.endDocument()
response = stream.getvalue()
if self.strip_declaration:
declaration = '<?xml version="1.0" encoding="utf-8"?>'
if response.startswith(declaration):
response = response[len(declaration):]
return response.strip()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders *obj* into serialized XML.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("root", {})
self._to_xml(xml, data)
xml.endElement("root")
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement("list", {
'last_update': str(date.today()),
'listing': '834'
})
self._to_xml(xml, data)
xml.endElement("list")
xml.endDocument()
return stream.getvalue()
def test_render_and_parse_complex_data(self):
"""
Test XML rendering.
"""
renderer = XMLRenderer()
content = StringIO(renderer.render(self._complex_data, 'application/xml'))
parser = XMLParser()
complex_data_out = parser.parse(content)
error_msg = "complex data differs!IN:\n %s \n\n OUT:\n %s" % (repr(self._complex_data), repr(complex_data_out))
self.assertEqual(self._complex_data, complex_data_out, error_msg)
def setUp(self):
self._input = StringIO(
'<?xml version="1.0" encoding="utf-8"?>'
'<root>'
'<field_a>121.0</field_a>'
'<field_b>dasd</field_b>'
'<field_c></field_c>'
'<field_d>2011-12-25 12:45:00</field_d>'
'</root>'
)
self._data = {
'field_a': 121,
'field_b': 'dasd',
'field_c': None,
'field_d': datetime.datetime(2011, 12, 25, 12, 45, 00)
}
self._complex_data_input = StringIO(
'<?xml version="1.0" encoding="utf-8"?>'
'<root>'
'<creation_date>2011-12-25 12:45:00</creation_date>'
'<sub_data_list>'
'<list-item><sub_id>1</sub_id><sub_name>first</sub_name></list-item>'
'<list-item><sub_id>2</sub_id><sub_name>second</sub_name></list-item>'
'</sub_data_list>'
'<name>name</name>'
'</root>'
)
self._complex_data = {
"creation_date": datetime.datetime(2011, 12, 25, 12, 45, 00),
"name": "name",
"sub_data_list": [
{
"sub_id": 1,
"sub_name": "first"
},
{
"sub_id": 2,
"sub_name": "second"
}
]
}
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders *obj* into serialized XML.
"""
if data is None:
return ''
elif isinstance(data, six.string_types):
return data
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(self.root_node, {'xmlns': self.xmlns})
self._to_xml(xml, data)
xml.endElement(self.root_node)
xml.endDocument()
return stream.getvalue()
def dict2xml(self, data):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("root", {})
self._to_xml(xml, data)
xml.endElement("root")
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders *obj* into serialized XML.
"""
if data is None:
return ''
elif isinstance(data, six.string_types):
return data
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(self.root_node, {'xmlns': self.xmlns})
self._to_xml(xml, data)
xml.endElement(self.root_node)
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders *obj* into serialized XML.
"""
if data is None:
return ''
stream = StringIO()
root_name = renderer_context.get('root_name', 'root')
root_attributes = renderer_context.get('root_attributes', {})
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(root_name, root_attributes)
self._to_xml(xml, data)
xml.endElement(root_name)
xml.endDocument()
return stream.getvalue()
def test_render_and_parse(self):
"""
Test rendering and then parsing returns the original object.
IE obj -> render -> parse -> obj.
"""
obj = {'foo': ['bar', 'baz']}
renderer = YAMLRenderer()
parser = YAMLParser()
content = renderer.render(obj, 'application/yaml')
data = parser.parse(StringIO(content))
self.assertEqual(obj, data)
