def check_type_attribute_qname_in_default_ns(self):
msg = """
<ns1:test xsi:type="int" xmlns:ns1="urn:vim25" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.w3.org/2001/XMLSchema">
100
</ns1:test>"""
ps = ParsedSoap(msg, envelope=False)
pyobj = ps.Parse(TC.Integer(pname=("urn:vim25", "test")))
def check_any_typed_xsd_int(self):
# from zsi developer's guide
value = 12
d = dict(value=value)
d.update(NSDICT)
xml = """<tns:i xsi:type="xsd:int" %(xsi)s %(soap)s %(tns)s %(xsd)s>%(value)d</tns:i>""" % d
ps = ParsedSoap(xml, envelope=False)
self.assertTrue(ps.Parse(TC.Any()) == value)
def check_any_nill(self):
result = ['23', {'a': None, 'b': 5}]
soap = str(SoapWriter().serialize(
result, TC.Any(pname="NilRequest", nillable=True, aslist=True)))
ps = ParsedSoap(soap)
tc = TC.Any(nillable=True)
pyobj = ps.Parse(tc)
def check_empty_struct(self):
"""Empty Struct is None, maybe dict() makes more sense, but this
is fairly hard to determine if not typed (which is the norm).
"""
data = {}
s = str(SoapWriter().serialize(data,TC.Any()))
p = ParsedSoap(s).Parse(TC.Any())
self.assertTrue(p==None, 'expecting "%s", got "%s"' %(None,p))
def check_any_typed_nonNegativeInteger(self):
# from zsi developer's guide
value = 12
d = dict(value=value)
d.update(NSDICT)
xml = """<tns:i xsi:type="xsd:nonNegativeInteger" %(xsi)s %(soap)s %(tns)s %(xsd)s>%(value)d</tns:i>""" % d
ps = ParsedSoap(xml, envelope=False)
self.failUnless(ps.Parse(TC.Any()) == value)
def test_local_anyType(self):
"""rpc/lit, testing if <any/> lax content handling
should get back dicts and strings
"""
ps = ParsedSoap(MSG)
pyobj = ps.Parse(self.client_module.EventApproximatesSoapOut.typecode)
any = {
'PoolTotals': {
'Pool': {
'Total': u'4117.66',
'ENumbers': None,
'JackpotNet': None
}
},
'Approximates': {
'Pool': {
'Win':
u'3.90,0.00,10.40,11.80,4.70,29.50,29.90,2.40,19.80,0.00',
'Place':
u'1.04,0.00,2.80,5.90,2.00,5.20,7.40,1.04,4.00,0.00'
}
}
}
self.failUnless(
pyobj.EventApproximatesResult.Any == any,
'Failed match:\n %s\n\n%s' %
(pyobj.EventApproximatesResult.Any, any))
pyobj.EventApproximatesResult.Any = dict(
pyobj.EventApproximatesResult.Any)
sw = SoapWriter()
sw.serialize(pyobj)
print str(sw)
ps2 = ParsedSoap(str(sw))
pyobj2 = ps.Parse(self.client_module.EventApproximatesSoapOut.typecode)
print "EAR: ", pyobj2.EventApproximatesResult
print "Any: ", pyobj2.EventApproximatesResult.Any
self.failUnless(
pyobj.EventApproximatesResult.Any ==
pyobj2.EventApproximatesResult.Any,
'Failed match:\n %s\n\n%s' % (pyobj.EventApproximatesResult.Any,
pyobj2.EventApproximatesResult.Any))
def check_any_dict_list_rpcenc(self):
sw = SoapWriter()
testObj = [{"a":1,"b":2}, {"d":4,"e":5}, {"f":{"x":9}, "g":[6,7.0]}]
typecode = TC.Any(aslist=True)
sw.serialize(testObj, typecode=typecode)
xml = str(sw)
ps = ParsedSoap(xml)
result = TC.Any().parse(ps.body_root, ps)
self.assertTrue(result == testObj)
def check_type_attribute_qname_in_default_ns(self):
msg = """
<ns1:test xsi:type="ns1:myInt" xmlns:ns1="urn:vim25" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.w3.org/2001/XMLSchema">
100
</ns1:test>"""
ps = ParsedSoap(msg, envelope=False)
pyobj = ps.Parse(TC.AnyType(pname=("urn:vim25","test")))
self.failUnless(pyobj == 100, 'failed to parse type in default ns')
def check_element_in_default_ns(self):
msg = """
<test xsi:type="myInt" xmlns="urn:vim25" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
100
</test>"""
ps = ParsedSoap(msg, envelope=False)
pyobj = ps.Parse(TC.AnyType(pname=("urn:vim25","test")))
self.failUnless(pyobj == 100, 'failed to parse element in default ns')
def check_parse_empty_string(self):
# Empty String
typecodes = list(TC.Any.parsemap.values())
for tc in [c for c in list(TC.Any.parsemap.values()) if isinstance(c, TC.String)]:
sw = SoapWriter()
sw.serialize("", typecode=tc, typed=True)
soap = str(sw)
ps = ParsedSoap(soap)
parsed = ps.Parse(TC.Any())
self.assertEqual("", parsed)
def dispatch(self, req):
path = req.uri[1:]
if (path[-1] == "/"):
path = path[:-1]
if not configs.has_key(path):
if req.method == "POST":
self.send_fault(
Fault(Fault.Client,
"Unknown Database Path %s" % (repr(configs.keys()))),
req)
else:
# Construct simple table of contents page
xml = ['<databases>']
for k in configs:
xml.append("<database><path>%s</path></database>" % k)
xml.append('</databases>')
txt = ''.join(xml)
self.send_xml(txt, req)
else:
xreq = None
config = configs[path]
if (req.method == "POST"):
try:
data = req.read()
dstr = StringIO.StringIO(data)
ps = ParsedSoap(dstr, readerclass=reader)
except Exception, e:
try:
self.send_fault(FaultFromException(e, 0), req)
except Exception, e:
self.send_fault(FaultFromException(e, 0), req)
return
callname = ps.body_root.localName
classname = callname[0].upper() + callname[1:]
try:
try:
mod = SRW.protocolModules[ps.body_root.namespaceURI]
except KeyError:
log("%r -> %r" % (ps.body_root.namespaceURI, data))
self.send_fault(Fault(Fault.Client, 'Bad Namespace'),
req)
return
config = config[ps.body_root.namespaceURI]
objType = getattr(mod, classname)
xreq = ps.Parse(objType)
xreq.configure(config)
xreq.calledAt = path
result = self.call(xreq)
except AttributeError, err:
# result = self.processUnknownOperation(classname, err, config)
self.send_fault(
Fault(Fault.Client,
'Unknown Operation (%s)' % str(err)), req)
return
def check_any_compound(self):
# from zsi developer's guide
xml = """
<tns:foo %(tns)s %(xsi)s %(soap)s>
<tns:i xsi:type="SOAP-ENC:integer">12</tns:i>
<tns:name xsi:type="SOAP-ENC:string">Hello world</tns:name>
</tns:foo>""" % NSDICT
ps = ParsedSoap(xml, envelope=False)
self.assertTrue(ps.Parse(TC.Any()) == {'i': 12, 'name': 'Hello world'})
self.assertTrue(ps.Parse(TC.Any(aslist=True)) == [12, 'Hello world'])
def AsCGI(nsdict={}, typesmodule=None, rpc=False, modules=None):
'''Dispatch within a CGI script.
'''
if os.environ.get('REQUEST_METHOD') != 'POST':
_CGISendFault(Fault(Fault.Client, 'Must use POST'))
return
ct = os.environ['CONTENT_TYPE']
try:
if ct.startswith('multipart/'):
cid = resolvers.MIMEResolver(ct, sys.stdin)
xml = cid.GetSOAPPart()
ps = ParsedSoap(xml, resolver=cid.Resolve)
else:
length = int(os.environ['CONTENT_LENGTH'])
ps = ParsedSoap(sys.stdin.read(length))
except ParseException as e:
_CGISendFault(FaultFromZSIException(e))
return
_Dispatch(ps, modules, _CGISendXML, _CGISendFault, nsdict=nsdict,
typesmodule=typesmodule, rpc=rpc)
def check_parse_empty_all(self):
# None
skip = [TC.FPEnumeration, TC.Enumeration, TC.IEnumeration, TC.List, TC.Integer]
for typeclass in [c for c in list(TC.__dict__.values()) if type(c) in [type,type] and not issubclass(c, TC.String) and issubclass(c, TC.SimpleType)]:
if typeclass in skip: continue
tc = typeclass()
sw = SoapWriter()
sw.serialize(None, typecode=tc, typed=True)
soap = str(sw)
ps = ParsedSoap(soap)
parsed = ps.Parse(TC.Any())
self.assertEqual(None, parsed)
def AsJonPy(request=None, modules=None, **kw):
'''Dispatch within a jonpy CGI/FastCGI script.
'''
kw['request'] = request
if request.environ.get('REQUEST_METHOD') != 'POST':
_JonPySendFault(Fault(Fault.Client, 'Must use POST'), **kw)
return
ct = request.environ['CONTENT_TYPE']
try:
if ct.startswith('multipart/'):
cid = resolvers.MIMEResolver(ct, request.stdin)
xml = cid.GetSOAPPart()
ps = ParsedSoap(xml, resolver=cid.Resolve)
else:
length = int(request.environ['CONTENT_LENGTH'])
ps = ParsedSoap(request.stdin.read(length))
except ParseException as e:
_JonPySendFault(FaultFromZSIException(e), **kw)
return
_Dispatch(ps, modules, _JonPySendXML, _JonPySendFault, **kw)
def soap_parse_ZSI(xml):
''' This function receives an XML SOAP and returns a dictionary. It is
intended to be used inside a Node, this is why it raises a NodeParserError
'''
parsed_obj = None
parsed_dict = dict()
try:
parsed_obj = ParsedSoap(xml)
parsed_dict = parsed_obj.Parse(TC.Any())
except Exception, e:
print e
def do_POST(self):
soapAction = self.headers.getheader('SOAPAction')
post = self.path
if not post:
raise PostNotSpecified('HTTP POST not specified in request')
if soapAction:
soapAction = soapAction.strip('\'"')
#Forzado porque SAP no lo envía bien.
soapAction = "http://PdfUtils.csi.org/merge2Pdfs"
post = post.strip('\'"')
try:
ct = self.headers['content-type']
if ct.startswith('multipart/'):
cid = resolvers.MIMEResolver(ct, self.rfile)
xml = cid.GetSOAPPart()
ps = ParsedSoap(xml, resolver=cid.Resolve)
else:
length = int(self.headers['content-length'])
xml = self.rfile.read(length)
ps = ParsedSoap(xml)
except ParseException, e:
self.send_fault(FaultFromZSIException(e))
def do_POST(self):
'''The POST command.
'''
try:
ct = self.headers['content-type']
if ct.startswith('multipart/'):
cid = resolvers.MIMEResolver(ct, self.rfile)
xml = cid.GetSOAPPart()
ps = ParsedSoap(xml, resolver=cid.Resolve)
else:
length = int(self.headers['content-length'])
ps = ParsedSoap(self.rfile.read(length))
except ParseException as e:
self.send_fault(FaultFromZSIException(e))
return
except Exception as e:
# Faulted while processing; assume it's in the header.
self.send_fault(FaultFromException(e, 1, sys.exc_info()[2]))
return
_Dispatch(ps, self.server.modules, self.send_xml, self.send_fault,
docstyle=self.server.docstyle, nsdict=self.server.nsdict,
typesmodule=self.server.typesmodule, rpc=self.server.rpc)
def ReceiveSOAP(self, readerclass=None, **kw):
'''Get back a SOAP message.
'''
if self.ps: return self.ps
if not self.IsSOAP():
raise TypeError('Response is "%s", not "text/xml"' %
self.reply_headers.type)
if len(self.data) == 0:
raise TypeError('Received empty response')
self.ps = ParsedSoap(self.data,
readerclass=readerclass or self.readerclass,
encodingStyle=kw.get('encodingStyle'))
if self.sig_handler is not None:
self.sig_handler.verify(self.ps)
return self.ps
def test_local_parse_ItemSearch(self):
msg = self.client_module.ItemSearchResponseMsg()
ps = ParsedSoap(ItemSearchResponseMsg)
response = ps.Parse(msg.typecode)
response.OperationRequest.Arguments
for i in response.OperationRequest.Arguments.Argument:
i.get_attribute_Name()
i.get_attribute_Value()
for i in response.OperationRequest.HTTPHeaders.Header or []:
i.get_attribute_Name()
i.get_attribute_Value()
response.OperationRequest.RequestId
response.OperationRequest.RequestProcessingTime
for its in response.Items:
self.assertTrue(its.TotalResults == 55, '')
self.assertTrue(its.TotalPages == 6, '')
for it in its.Item:
it.ASIN
it.Accessories
#it.AlternateVersions;
it.BrowseNodes
#it.Collections;
it.CustomerReviews
it.DetailPageURL
it.EditorialReviews
it.Errors
it.ImageSets
it.ItemAttributes
it.LargeImage
it.ListmaniaLists
it.MediumImage
it.MerchantItemAttributes
it.OfferSummary
it.Offers
#it.ParentASIN;
it.SalesRank
it.SearchInside
it.SimilarProducts
it.SmallImage
it.Subjects
it.Tracks
def test_local_NoMessagePart(self):
## msg = self.client_module.HelloRequest()
msg = None
rsp = self.client_module.HelloResponse()
# Core functionality required
s = SoapWriter()
xml = str(s)
print xml
# Core functionality required
ps = ParsedSoap(xml)
self.failUnless(ps.body.childNodes == 0, "Empty Body expected: " + ps.body.childNodes)
self.failUnless(ps.body_root == None, "Body root should be None: " + ps.body_root)
pyobj = ps.Parse(None)
self.failUnless(pyobj == None, "pyobj should be None: " + pyobj)
def checkt7(self):
ps = ParsedSoap(text)
tcdict = TC.Apache.Map('c-gensym1')
tclist = TC.Apache.Map('c-gensym1', aslist=1)
d = tcdict.parse(ps.body_root, ps)
self.assertEqual(d, {u'a': 123, '\x00\x01': 456})
#print 'as dictionary\n', d
l = tclist.parse(ps.body_root, ps)
self.assertEqual(l, [('\x00\x01', 456), (u'a', 123)])
#print '\n', '=' * 30
#print 'as list\n', l
#print '\n', '=' * 30
sw = SoapWriter()
sw.serialize(d, tcdict)
#print >>sys.stdout, sw
#print '\n', '=' * 30
sw = SoapWriter()
sw.serialize(l, tclist)
def check_builtins(self):
myInt,myLong,myStr,myDate,myFloat = 123,2147483648,\
"hello", time.gmtime(), 1.0001
orig = [myInt, myLong, myStr, myDate, myFloat]
sw = SoapWriter()
sw.serialize(orig, typecode=TC.Any(pname="builtins", aslist=True))
ps = ParsedSoap(str(sw))
parsed = ps.Parse(TC.Any())
self.assertEqual(len(orig), len(parsed))
self.assertEqual(myInt, parsed[0])
self.assertEqual(myLong, parsed[1])
self.assertEqual(myStr, parsed[2])
self.assertEqual(myDate[0:6], parsed[3][0:6])
self.assertEqual(myFloat, parsed[4])
self.assertEqual(type(myInt), type(parsed[0]))
self.assertEqual(type(myLong), type(parsed[1]))
self.assertEqual(type(myStr), type(parsed[2]))
self.assertEqual(tuple, type(parsed[3]))
self.assertEqual(type(myFloat), type(parsed[4]))
def check_soapfault_faultcode(self):
""" Typecode QName when default namespace is not declared, should
specify the empty namespace.
"""
msg = """<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<soapenv:Body>
<soapenv:Fault>
<faultcode>ServerFaultCode</faultcode>
<faultstring>Operation failed since VMware tools are not running in this virtual machine.</faultstring>
<detail>
<ToolsUnavailableFault xmlns="urn:vim2"/>
</detail>
</soapenv:Fault>
</soapenv:Body>
</soapenv:Envelope>"""
ps = ParsedSoap(msg)
fault = FaultFromFaultMessage(ps)
self.failUnless(fault.code == ('', 'ServerFaultCode'),
'faultcode should be (namespace,name) tuple')
def checkt2(self):
try:
ps = ParsedSoap(IN)
except ParseException, e:
print >> OUT, FaultFromZSIException(e).AsSOAP()
self.fail()
def processRequest(cls, input, **kw):
return ParsedSoap(input, readerclass=cls.readerClass)
def rinse(soap, tc):
''' Turn SOAP into a python object.
'''
with LogTime("parse SOAP into %s object", tc):
parse = ParsedSoap(soap).Parse(tc)
return parse
def xml2pyobj(xml, typecode):
return ParsedSoap(xml).Parse(typecode)
def AsHandler(request=None, modules=None, **kw):
'''Dispatch from within ModPython.'''
ps = ParsedSoap(request)
kw['request'] = request
_Dispatch(ps, modules, _ModPythonSendXML, _ModPythonSendFault, **kw)
def _getResults(self, xml):
from ZSI import ParsedSoap
ps = ParsedSoap(xml, envelope=False)
return ps.Parse(self.resultType)