def test_complex_class(self):
l = Level1()
l.level2 = Level2()
l.level2.arg1 = 'abcd'
l.level2.arg2 = 1.444
l.level3 = []
l.level4 = []
for i in range(0, 100):
a = Level3()
a.arg1 = i
l.level3.append(a)
for i in range(0, 4):
a = Level4()
a.arg1 = str(i)
l.level4.append(a)
element = etree.Element('test')
XmlObject().to_parent_element(Level1, l, ns_test, element)
element = element[0]
l1 = XmlObject().from_element(Level1, element)
self.assertEquals(l1.level2.arg1, l.level2.arg1)
self.assertEquals(l1.level2.arg2, l.level2.arg2)
self.assertEquals(len(l1.level4), len(l.level4))
self.assertEquals(100, len(l.level3))
def test_boolean(self):
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, True, ns_test, b)
b = b[0]
self.assertEquals('true', b.text)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, 0, ns_test, b)
b = b[0]
self.assertEquals('false', b.text)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, 1, ns_test, b)
b = b[0]
self.assertEquals('true', b.text)
b = XmlObject().from_element(Boolean, b)
self.assertEquals(b, True)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, False, ns_test, b)
b = b[0]
self.assertEquals('false', b.text)
b = XmlObject().from_element(Boolean, b)
self.assertEquals(b, False)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, None, ns_test, b)
b = b[0]
self.assertEquals('true', b.get('{%s}nil' % ns.xsi))
b = XmlObject().from_element(Boolean, b)
self.assertEquals(b, None)
def test_simple_class(self):
a = Address()
a.street = '123 happy way'
a.city = 'badtown'
a.zip = 32
a.lattitude = 4.3
a.longitude = 88.0
element = etree.Element('test')
XmlObject().to_parent_element(Address, a, ns_test, element)
element = element[0]
self.assertEquals(5, len(element.getchildren()))
a.since = datetime.datetime(year=2011, month=12, day=31)
element = etree.Element('test')
XmlObject().to_parent_element(Address, a, ns_test, element)
element = element[0]
self.assertEquals(6, len(element.getchildren()))
r = XmlObject().from_element(Address, element)
self.assertEquals(a.street, r.street)
self.assertEquals(a.city, r.city)
self.assertEquals(a.zip, r.zip)
self.assertEquals(a.lattitude, r.lattitude)
self.assertEquals(a.longitude, r.longitude)
self.assertEquals(a.since, r.since)
def test_class_nested_array(self):
peeps = []
names = ['bob', 'jim', 'peabody', 'mumblesleves']
for name in names:
a = Person()
a.name = name
a.birthdate = datetime.datetime(1979, 1, 1)
a.age = 27
a.addresses = []
for i in range(0, 25):
addr = Address()
addr.street = '555 downtown'
addr.city = 'funkytown'
a.addresses.append(addr)
peeps.append(a)
type = Array(Person)
type.resolve_namespace(type, __name__)
element = etree.Element('test')
XmlObject().to_parent_element(type, peeps, ns_test, element)
element = element[0]
self.assertEquals(4, len(element.getchildren()))
peeps2 = XmlObject().from_element(type, element)
for peep in peeps2:
self.assertEquals(27, peep.age)
self.assertEquals(25, len(peep.addresses))
self.assertEquals('funkytown', peep.addresses[18].city)
def test_y_fromxml(self):
x = X()
x.x = [1, 2]
element = etree.Element('test')
XmlObject().to_parent_element(X, x, 'tns', element)
msg = element[0]
r = XmlObject().from_element(Y, msg)
self.assertEqual(r.x, [1, 2])
def test_y_toxml(self):
y = Y()
y.x = [1, 2]
y.y = 38
element = etree.Element('test')
XmlObject().to_parent_element(Y, y, 'tns', element)
msg = element[0]
r = XmlObject().from_element(Y, msg)
def test_unicode(self):
s = u'\x34\x55\x65\x34'
self.assertEquals(4, len(s))
element = etree.Element('test')
XmlObject().to_parent_element(String, s, 'test_ns', element)
element = element[0]
value = XmlObject().from_element(String, element)
self.assertEquals(value, s)
def test_string(self):
s = String()
element = etree.Element('test')
XmlObject().to_parent_element(String, 'value', ns_test, element)
element = element[0]
self.assertEquals(element.text, 'value')
value = XmlObject().from_element(String, element)
self.assertEquals(value, 'value')
def test_null(self):
element = etree.Element('test')
XmlObject().to_parent_element(Null, None, ns_test, element)
print etree.tostring(element)
element = element[0]
self.assertTrue(bool(element.attrib.get('{%s}nil' % ns.xsi)))
value = XmlObject().from_element(Null, element)
self.assertEquals(None, value)
def test_datetime(self):
n = datetime.datetime.now()
element = etree.Element('test')
XmlObject().to_parent_element(DateTime, n, ns_test, element)
element = element[0]
self.assertEquals(element.text, n.isoformat())
dt = XmlObject().from_element(DateTime, element)
self.assertEquals(n, dt)
def test_large_integer(self):
i = 128375873458473
integer = Integer()
element = etree.Element('test')
XmlObject().to_parent_element(Integer, i, ns_test, element)
element = element[0]
self.assertEquals(element.text, '128375873458473')
value = XmlObject().from_element(integer, element)
self.assertEquals(value, i)
def test_float(self):
f = 1.22255645
element = etree.Element('test')
XmlObject().to_parent_element(Float, f, ns_test, element)
element = element[0]
self.assertEquals(element.text, repr(f))
f2 = XmlObject().from_element(Float, element)
self.assertEquals(f2, f)
def get_xml_as_object(elt, cls):
'''Returns a native :class:`rpclib.model.complex.ComplexModel` child from an
ElementTree representation of the same class.
:param value: The class the xml document represents.
:param value: The xml document to be deserialized.
'''
xml_object = XmlObject()
return xml_object.from_element(cls, elt)
def __init__(self, app=None, validator=None, wrapped=True):
"""Soap 1.1 Protocol with validators.
:param app: A rpclib.application.Application instance.
:param validator: The validator to use. Currently the only supported
value is 'lxml'
:param wrapped: Whether the return type should be wrapped in another
object. Default is 'True'.
"""
XmlObject.__init__(self, app, validator)
self.__wrapped = wrapped
def __init__(self, app=None, validator=None, wrapped=True, xml_declaration=True):
"""Soap 1.1 Protocol with validators.
:param app: A rpclib.application.Application instance.
:param validator: The validator to use. Currently the only supported
value is 'lxml'
:param wrapped: Whether the return type should be wrapped in another
object. Default is 'True'.
"""
XmlObject.__init__(self, app, validator, xml_declaration)
self.__wrapped = wrapped
def test_serialize(self):
DaysOfWeekEnum.resolve_namespace(DaysOfWeekEnum, 'punk')
mo = DaysOfWeekEnum.Monday
print((repr(mo)))
elt = etree.Element('test')
XmlObject().to_parent_element(DaysOfWeekEnum, mo, 'test_namespace',
elt)
elt = elt[0]
ret = XmlObject().from_element(DaysOfWeekEnum, elt)
self.assertEquals(mo, ret)
def get_object_as_xml(value):
'''Returns an ElementTree representation of a :class:`rpclib.model.complex.ComplexModel`
child.
:param value: The instance of the class to be serialized.
'''
xml_object = XmlObject()
parent = etree.Element("parent")
xml_object.to_parent_element(value.__class__, value, value.get_namespace(), parent)
return parent[0]
def get_object_as_xml(value):
'''Returns an ElementTree representation of a :class:`rpclib.model.complex.ComplexModel`
child.
:param value: The instance of the class to be serialized.
'''
xml_object = XmlObject()
parent = etree.Element("parent")
xml_object.to_parent_element(value.__class__, value, value.get_namespace(), parent)
return parent[0]
def test_array_empty(self):
type = Array(String)
type.resolve_namespace(type, "zbank")
values = []
element = etree.Element('test')
XmlObject().to_parent_element(type, values, ns_test, element)
element = element[0]
self.assertEquals(len(values), len(element.getchildren()))
values2 = XmlObject().from_element(type, element)
self.assertEquals(len(values2), 0)
def test_bytes_join_attachment(self):
href_id = "http://tempuri.org/1/634133419330914808"
payload = "ANJNSLJNDYBC SFDJNIREMX:CMKSAJN"
envelope = '''
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
<s:Body>
<DownloadPartFileResponse xmlns="http://tempuri.org/">
<DownloadPartFileResult xmlns:a="http://schemas.datacontract.org/2004/07/KlanApi.Common"
xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<a:ErrorCode>0</a:ErrorCode>
<a:ErrorMessage i:nil="true"/>
<a:Data>
<xop:Include href="cid:%s" xmlns:xop="http://www.w3.org/2004/08/xop/include"/>
</a:Data>
</DownloadPartFileResult>
</DownloadPartFileResponse>
</s:Body>
</s:Envelope>
''' % quote_plus(href_id)
(joinedmsg, numreplaces) = join_attachment(href_id, envelope, payload)
soaptree = etree.fromstring(joinedmsg)
body = soaptree.find("{%s}Body" % ns.soap_env)
response = body.getchildren()[0]
result = response.getchildren()[0]
r = XmlObject().from_element(DownloadPartFileResult, result)
self.assertEquals(payload, r.Data)
def __init__(self, app=None, validator=None, wrapped=True,
xml_declaration=True, cleanup_namespaces=False):
"""Soap 1.1 Protocol with validators.
:param app: A rpclib.application.Application instance.
:param validator: The validator to use. Currently the only supported
value is 'lxml'
:param wrapped: Whether the return type should be wrapped in another
object. Default is 'True'.
:param xml_declaration: Whether to add xml_declaration to the responses
Default is 'True'.
:param cleanup_namespaces: Whether to add clean up namespace declarations
in the response document. Default is 'False'.
"""
XmlObject.__init__(self, app, validator, xml_declaration,
cleanup_namespaces)
self.__wrapped = wrapped
def test_nested_class(self): # FIXME: this test is incomplete
p = Person()
element = etree.Element('test')
XmlObject().to_parent_element(Person, p, ns_test, element)
element = element[0]
self.assertEquals(None, p.name)
self.assertEquals(None, p.birthdate)
self.assertEquals(None, p.age)
self.assertEquals(None, p.addresses)
def test_to_parent_element_w_detail(self):
from lxml.etree import Element
element = Element('testing')
detail = Element('something')
fault = Fault(detail=detail)
cls = Fault
XmlObject().to_parent_element(cls, fault, 'urn:ignored', element)
(child,) = element.getchildren()
self.failUnless(child.find('detail').find('something') is detail)
def test_utcdatetime(self):
datestring = '2007-05-15T13:40:44Z'
e = etree.Element('test')
e.text = datestring
dt = XmlObject().from_element(DateTime, e)
self.assertEquals(dt.year, 2007)
self.assertEquals(dt.month, 5)
self.assertEquals(dt.day, 15)
datestring = '2007-05-15T13:40:44.003Z'
e = etree.Element('test')
e.text = datestring
dt = XmlObject().from_element(DateTime, e)
self.assertEquals(dt.year, 2007)
self.assertEquals(dt.month, 5)
self.assertEquals(dt.day, 15)
def get_object_as_xml(value, cls=None, root_tag_name=None, no_namespace=False):
'''Returns an ElementTree representation of a :class:`rpclib.model.complex.ComplexModel`
child.
:param value: The instance of the class to be serialized.
:param value: The root tag string to use. Defaults to the output of
``value.__class__.get_type_name_ns()``.
'''
if cls is None:
cls = value.__class__
xml_object = XmlObject()
parent = etree.Element("parent")
xml_object.to_parent_element(cls, value, cls.get_namespace(),
parent, root_tag_name)
if no_namespace:
_dig(parent)
etree.cleanup_namespaces(parent)
return parent[0]
def test_class_array(self):
peeps = []
names = ['bob', 'jim', 'peabody', 'mumblesleves']
for name in names:
a = Person()
a.name = name
a.birthdate = datetime.datetime(1979, 1, 1)
a.age = 27
peeps.append(a)
type = Array(Person)
type.resolve_namespace(type, __name__)
element = etree.Element('test')
XmlObject().to_parent_element(type, peeps, ns_test, element)
element = element[0]
self.assertEquals(4, len(element.getchildren()))
peeps2 = XmlObject().from_element(type, element)
for i in range(0, 4):
self.assertEquals(peeps2[i].name, names[i])
self.assertEquals(peeps2[i].birthdate,
datetime.datetime(1979, 1, 1))
def test_to_parent_element_wo_detail(self):
from lxml.etree import Element
import rpclib.const.xml_ns
ns_soap_env = rpclib.const.xml_ns.soap_env
element = Element('testing')
fault = Fault()
cls = Fault
XmlObject().to_parent_element(cls, fault, 'urn:ignored', element)
(child,) = element.getchildren()
self.assertEqual(child.tag, '{%s}Fault' % ns_soap_env)
self.assertEqual(child.find('faultcode').text, 'senv:Server')
self.assertEqual(child.find('faultstring').text, 'Fault')
self.assertEqual(child.find('faultactor').text, '')
self.failIf(child.findall('detail'))
def test_from_xml_w_detail(self):
from lxml.etree import Element
from lxml.etree import SubElement
import rpclib.const.xml_ns
ns_soap_env = rpclib.const.xml_ns.soap_env
element = Element('{%s}Fault' % ns_soap_env)
fcode = SubElement(element, 'faultcode')
fcode.text = 'senv:other'
fstr = SubElement(element, 'faultstring')
fstr.text = 'Testing'
actor = SubElement(element, 'faultactor')
actor.text = 'phreddy'
detail = SubElement(element, 'detail')
fault = XmlObject().from_element(Fault, element)
self.failUnless(fault.detail is detail)
def test_from_xml_wo_detail(self):
from lxml.etree import Element
from lxml.etree import SubElement
import rpclib.const.xml_ns
ns_soap_env = rpclib.const.xml_ns.soap_env
element = Element('{%s}Fault' % ns_soap_env)
fcode = SubElement(element, 'faultcode')
fcode.text = 'senv:other'
fstr = SubElement(element, 'faultstring')
fstr.text = 'Testing'
actor = SubElement(element, 'faultactor')
actor.text = 'phreddy'
fault = XmlObject().from_element(Fault, element)
self.assertEqual(fault.faultcode, 'senv:other')
self.assertEqual(fault.faultstring, 'Testing')
self.assertEqual(fault.faultactor, 'phreddy')
self.assertEqual(fault.detail, None)
@param name the name to say hello to
@param the number of times to say hello
@return the completed array
'''
for i in range(times):
yield 'Hello, %s' % name
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print("Error: example server code requires Python >= 2.5")
logging.basicConfig(level=logging.DEBUG)
logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG)
application = Application([HelloWorldService],
'rpclib.examples.hello.http',
interface=Wsdl11(),
in_protocol=HttpRpc(),
out_protocol=XmlObject())
server = make_server('127.0.0.1', 7789, WsgiApplication(application))
print("listening to http://127.0.0.1:7789")
print("wsdl is at: http://localhost:7789/?wsdl")
server.serve_forever()
def test_boolean(self):
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, True, ns_test, b)
b = b[0]
self.assertEquals('true', b.text)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, 0, ns_test, b)
b = b[0]
self.assertEquals('false', b.text)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, 1, ns_test, b)
b = b[0]
self.assertEquals('true', b.text)
b = XmlObject().from_element(Boolean, b)
self.assertEquals(b, True)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, False, ns_test, b)
b = b[0]
self.assertEquals('false', b.text)
b = XmlObject().from_element(Boolean, b)
self.assertEquals(b, False)
b = etree.Element('test')
XmlObject().to_parent_element(Boolean, None, ns_test, b)
b = b[0]
self.assertEquals('true', b.get('{%s}nil' % ns.xsi))
b = XmlObject().from_element(Boolean, b)
self.assertEquals(b, None)
