[Zope-CVS] CVS: Packages/WebService/tests - runtests.py:1.1 testSOAPInterop.py:1.1 testSOAPMessage.py:1.1 testSOAPReader.py:1.1 testSOAPWriter.py:1.1 testSerializer.py:1.1 testServiceProxy.py:1.1 testWSDLTools.py:1.1 testXMLWriter.py:1.1 testcase.py:1.1
Brian Lloyd
brian@digicool.com
Mon, 26 Nov 2001 11:18:24 -0500
Update of /cvs-repository/Packages/WebService/tests
In directory cvs.zope.org:/tmp/cvs-serv23779/WebService/tests
Added Files:
runtests.py testSOAPInterop.py testSOAPMessage.py
testSOAPReader.py testSOAPWriter.py testSerializer.py
testServiceProxy.py testWSDLTools.py testXMLWriter.py
testcase.py
Log Message:
Initial commit of web services package.
=== Added File Packages/WebService/tests/runtests.py ===
"""Run all of the unit tests for this package."""
def main():
import testSOAPMessage
testSOAPMessage.main()
import testXMLWriter
testXMLWriter.main()
import testSOAPReader
testSOAPReader.main()
import testSOAPWriter
testSOAPWriter.main()
import testWSDLTools
testWSDLTools.main()
import testSerializer
testSerializer.main()
import testSOAPInterop
# testSOAPInterop.main()
if __name__ == '__main__':
import testcase
testcase.setup()
main()
=== Added File Packages/WebService/tests/testSOAPInterop.py ===
"""Test client interop with the SOAPBuilders Interop Lab services."""
import sys, os, string, unittest, testcase
class InteropLabTests(testcase.TestCase):
"""Test interop with www.xmethods.net services."""
def testApache21Interop(self):
"""Test Apache 2.1 service interop."""
url = 'http://www.xmethods.net/sd/interop/ApacheInterop11.wsdl'
self.runSuite(url)
def testEasySoapInterop(self):
"""Test EasySoap++ service interop."""
url = 'http://easysoap.sourceforge.net/interop.wsdl'
self.runSuite(url)
def test4S4CInterop(self):
"""Test 4S4C service interop."""
url = 'http://soap.4s4c.com/ilab/soap.asp?WSDL'
self.runSuite(url)
def testGLUEInterop(self):
"""Test GLUE service interop."""
url = 'http://209.61.190.164:8004/glue/http://soapinterop.org/.wsdl'
self.runSuite(url)
def testHPSOAPInterop(self):
"""Test HP SOAP service interop."""
url = 'http://soap.bluestone.com:80/interop/EchoService/EchoService.wsdl'
self.runSuite(url)
def testWASPInterop(self):
"""Test Idoox WASP service interop."""
url = 'http://soap.idoox.net:7080/soap/services/ilab.wsdl'
self.runSuite(url)
def testKafkaInterop(self):
"""Test Kafka service interop."""
url = 'http://www.vbxml.com/soapworkshop/services/kafka10/services/' \
'endpoint.asp?service=ilab&type=wsdl'
self.runSuite(url)
def testMSATLInterop(self):
"""Test MS ATL service interop."""
url = 'http://4.34.185.52/ilab/ilab.wsdl'
self.runSuite(url)
def testMSSOAPToolkit20Interop(self):
"""Test MS SOAP Toolkit 2.0 (typed) service interop."""
url = 'http://131.107.72.13/stk/InteropTyped.wsdl'
self.runSuite(url)
def testMSSOAPToolkit20Interop(self):
"""Test MS SOAP Toolkit 2.0 (untyped) service interop."""
url = 'http://131.107.72.13/stk/Interop.wsdl'
self.runSuite(url)
def runSuite(self, url):
"""Exercise the interop interface of a service."""
from WebService.ServiceProxy import ServiceProxy
service = ServiceProxy(url)
service.debug = 0
result = service.echoString('This is a string')
assert result == 'This is a string'
result = service.echoInteger(42)
assert result == 42
result = service.echoFloat(42.0)
assert result == 42.0
def test_suite():
return unittest.makeSuite(InteropLabTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testSOAPMessage.py ===
import sys, os, string, unittest, testcase
class SOAPMessageTests(testcase.TestCase):
"""Test the SOAPMessage object implementation."""
def testSimpleMessage(self, version='1.1'):
"""Test building and reading a simple SOAP message."""
from WebService.SOAPMessage import SOAPMessage
from WebService.Utility import DOM
message = SOAPMessage()
message.version = version
message.soapAction = 'urn:xmethodsBabelFish#BabelFish'
message.methodName = 'BabelFish'
message.namespace = 'urn:xmethodsBabelFish'
message.addParameter('translationmode', 'en_de',
(DOM.NS_XSD, 'string')
)
message.addParameter('sourcedata', 'This is a test!',
(DOM.NS_XSD, 'string')
)
message.serialize()
xmldata = message.getMessageBody()
message = SOAPMessage(xmldata)
message.deserialize()
self.assertEquals(message.version, version)
params = message.getParameters()
self.assertEquals(params[0].name, 'translationmode')
self.assertEquals(params[0].value, 'en_de')
self.assertEquals(params[1].name, 'sourcedata')
self.assertEquals(params[1].value, 'This is a test!')
def testMessageVersioning(self):
"""Same test with a SOAP 1.2 message."""
return self.testSimpleMessage(version='1.2')
def testHeaderMessage(self):
"""Test building and reading a message with headers."""
from WebService.SOAPMessage import SOAPMessage
from WebService.Utility import DOM
message = SOAPMessage(message_1)
message.deserialize()
self.assertEquals(message.version, '1.1')
self.assertEquals(message.methodName, 'MethodResponse')
self.assertEquals(message.namespace, 'urn:some-uri')
params = message.getParameters()
self.assertEquals(len(params), 2)
self.assertEquals(params[0].name, 'item1')
self.assertEquals(params[0].value, 'Missouri')
self.assertEquals(params[1].name, 'item2')
self.assertEquals(params[1].value, 42)
message_1 = '''<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<SOAP-ENV:Header>
<t:Transaction xmlns:t="urn:some-uri" SOAP-ENV:mustUnderstand="1">
5
</t:Transaction>
<p:OptionalHeader1 xmlns:p="urn:some-uri" SOAP-ENV:mustUnderstand="0">
optional data 1
</p:OptionalHeader1>
<p:OptionalHeader2 xmlns:p="urn:some-uri">
optional data 2
</p:OptionalHeader2>
</SOAP-ENV:Header>
<SOAP-ENV:Body>
<m:MethodResponse xmlns:m="urn:some-uri">
<item1 xsi:type="xsd:string">Missouri</item1>
<item2 xsi:type="xsd:int">42</item2>
</m:MethodResponse>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>'''
message_2 = '''<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<SOAP-ENV:Body>
<SOAP-ENV:Fault>
<faultcode>SOAP-ENV:Client</faultcode>
<faultstring>Bad client, bad!</faultstring>
<faultactor>urn:myserver</faultactor>
<detail xsi:type="c:stacktrace" xmlns:c="urn:some-uri">
<stacktrace>
imaginary stacktrace
</stacktrace>
</detail>
</SOAP-ENV:Fault>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>'''
message_3 = '''<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.microsoft.com/soap/encoding/clr/1.0 http://schemas.xmlsoap.org/soap/encoding/" xmlns:i3="http://soapinterop.org/xsd" xmlns:i2="http://soapinterop.org/">
<SOAP-ENV:Body>
<i2:echoStructArray id="ref-1">
<return href="#ref-4"/>
</i2:echoStructArray>
<SOAP-ENC:Array id="ref-4" SOAP-ENC:arrayType="i3:SOAPStruct[3]">
<item href="#ref-5"/>
<item href="#ref-6"/>
<item href="#ref-7"/>
</SOAP-ENC:Array>
<i3:SOAPStruct id="ref-5">
<varString xsi:type="xsd:string">West Virginia</varString>
<varInt xsi:type="xsd:int">-546</varInt>
<varFloat xsi:type="xsd:float">-5.398</varFloat>
</i3:SOAPStruct>
<i3:SOAPStruct id="ref-6">
<varString xsi:type="xsd:string">New Mexico</varString>
<varInt xsi:type="xsd:int">-641</varInt>
<varFloat xsi:type="xsd:float">-9.351</varFloat>
</i3:SOAPStruct>
<i3:SOAPStruct id="ref-7">
<varString xsi:type="xsd:string">Missouri</varString>
<varInt xsi:type="xsd:int">-819</varInt>
<varFloat xsi:type="xsd:float">1.495</varFloat>
</i3:SOAPStruct>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
'''
def test_suite():
return unittest.makeSuite(SOAPMessageTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testSOAPReader.py ===
__version__='$Revision: 1.1 $'[11:-2]
import sys, os, string, unittest, testcase
class SOAPReaderTests(testcase.TestCase):
"""Test the low-level SOAPReader object interfaces."""
def testSimpleMessage(self):
"""Test reading a simple SOAP message."""
from WebService.SOAPReader import SOAPReader
from WebService.Utility import DOM
from StringIO import StringIO
stream = StringIO(message_1)
reader = SOAPReader(stream)
envelope = reader.getEnvelope()
encoding = reader.getEncodingStyle(envelope)
assert encoding == reader.NS_SOAP_ENC
header_element = reader.getHeader()
assert header_element is not None
header_elements = reader.getHeaderElements()
assert len(header_elements) == 3
header = reader.getHeaderElement('Transaction', 'urn:some-uri')
value = DOM.getElementText(header)
assert value == '5'
header = reader.getHeaderElement('OptionalHeader1', 'urn:some-uri')
value = DOM.getElementText(header)
assert value == 'optional data 1'
header = reader.getHeaderElement('OptionalHeader2', 'urn:some-uri')
value = DOM.getElementText(header)
assert value == 'optional data 2'
musts = reader.getMustUnderstandHeaders()
assert musts[0].localName == 'Transaction'
assert len(musts) == 1
body_element = reader.getBody()
assert body_element is not None
rpc_element = reader.getRPCStruct()
assert rpc_element.localName == 'GetLastTradePriceResponse'
result = reader.getRPCResult()
assert result.localName == 'PriceAndVolume'
def testComplexMessage(self):
"""Test reading a more complex SOAP message with references."""
from WebService.SOAPReader import SOAPReader
from WebService.Utility import DOM
from StringIO import StringIO
stream = StringIO(message_3)
reader = SOAPReader(stream)
result = reader.getRPCResult()
assert result.localName == 'return'
element = reader.derefElement(result)
assert element.localName == 'Array'
for element in DOM.getElements(element, None, None):
assert element.localName == 'item'
value = reader.derefElement(element)
assert value.localName == 'SOAPStruct'
document = reader.document
del reader
assert document.childNodes is None
del document
def testFaultMessage(self):
"""Test reading a SOAP fault message."""
from WebService.SOAPReader import SOAPReader
from WebService.Utility import DOM
from StringIO import StringIO
stream = StringIO(message_2)
reader = SOAPReader(stream)
envelope = reader.getEnvelope()
encoding = reader.getEncodingStyle(envelope)
assert encoding == reader.NS_SOAP_ENC
header_element = reader.getHeader()
assert header_element is None
header_elements = reader.getHeaderElements()
assert len(header_elements) == 0
musts = reader.getMustUnderstandHeaders()
assert len(musts) == 0
body_element = reader.getBody()
assert body_element is not None
fault = reader.getFault()
assert fault is not None
value = reader.getFaultCode()
assert value == 'Client'
value = reader.getFaultCodeNS()
assert value == reader.NS_SOAP_ENV
value = reader.getFaultString()
assert value == 'Bad client, bad!'
value = reader.getFaultActor()
assert value == 'urn:myserver'
element = reader.getFaultDetail()
elements = DOM.getElements(element, None, None)
assert len(elements) == 1
assert elements[0].localName == 'stacktrace'
message_1 = '''<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<SOAP-ENV:Header>
<t:Transaction xmlns:t="urn:some-uri" SOAP-ENV:mustUnderstand="1">
5
</t:Transaction>
<p:OptionalHeader1 xmlns:p="urn:some-uri" SOAP-ENV:mustUnderstand="0">
optional data 1
</p:OptionalHeader1>
<p:OptionalHeader2 xmlns:p="urn:some-uri">
optional data 2
</p:OptionalHeader2>
</SOAP-ENV:Header>
<SOAP-ENV:Body>
<m:GetLastTradePriceResponse xmlns:m="Some-URI">
<PriceAndVolume>
<LastTradePrice>
34.5
</LastTradePrice>
<DayVolume>
10000
</DayVolume>
</PriceAndVolume>
</m:GetLastTradePriceResponse>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>'''
message_2 = '''<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<SOAP-ENV:Body>
<SOAP-ENV:Fault>
<faultcode>SOAP-ENV:Client</faultcode>
<faultstring>Bad client, bad!</faultstring>
<faultactor>urn:myserver</faultactor>
<detail xsi:type="c:stacktrace" xmlns:c="urn:some-uri">
<stacktrace>
imaginary stacktrace
</stacktrace>
</detail>
</SOAP-ENV:Fault>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>'''
message_3 = '''<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.microsoft.com/soap/encoding/clr/1.0 http://schemas.xmlsoap.org/soap/encoding/" xmlns:i3="http://soapinterop.org/xsd" xmlns:i2="http://soapinterop.org/">
<SOAP-ENV:Body>
<i2:echoStructArray id="ref-1">
<return href="#ref-4"/>
</i2:echoStructArray>
<SOAP-ENC:Array id="ref-4" SOAP-ENC:arrayType="i3:SOAPStruct[3]">
<item href="#ref-5"/>
<item href="#ref-6"/>
<item href="#ref-7"/>
</SOAP-ENC:Array>
<i3:SOAPStruct id="ref-5">
<varString xsi:type="xsd:string">West Virginia</varString>
<varInt xsi:type="xsd:int">-546</varInt>
<varFloat xsi:type="xsd:float">-5.398</varFloat>
</i3:SOAPStruct>
<i3:SOAPStruct id="ref-6">
<varString xsi:type="xsd:string">New Mexico</varString>
<varInt xsi:type="xsd:int">-641</varInt>
<varFloat xsi:type="xsd:float">-9.351</varFloat>
</i3:SOAPStruct>
<i3:SOAPStruct id="ref-7">
<varString xsi:type="xsd:string">Missouri</varString>
<varInt xsi:type="xsd:int">-819</varInt>
<varFloat xsi:type="xsd:float">1.495</varFloat>
</i3:SOAPStruct>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
'''
def test_suite():
return unittest.makeSuite(SOAPReaderTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testSOAPWriter.py ===
__version__='$Revision: 1.1 $'[11:-2]
import sys, os, string, unittest, testcase
class SOAPWriterTests(testcase.TestCase):
"""Test the low-level SOAPWriter object interfaces."""
def testSimpleMessage(self):
"""Test writing a simple SOAP message."""
from WebService.SOAPWriter import SOAPWriter
from WebService.SOAPReader import SOAPReader
from WebService.Utility import DOM
address = "http://services.xmethods.net:80/perl/soaplite.cgi"
soapaction = "urn:xmethodsBabelFish#BabelFish"
methodname = "BabelFish"
methodNS = "urn:xmethodsBabelFish"
writer = SOAPWriter()
writer.startEnvelope(encodingStyle=writer.NS_SOAP_ENC)
writer.startBody()
# Write the RPC struct element.
writer.startElement(methodname, methodNS)
# Write the parameter elements.
typeref = (DOM.NS_XSD, 'string')
params = (('translationmode', None, 'en_de', typeref),
('sourcedata', None, 'This is a test!', typeref),
)
for param in params:
name, nsuri, value, typeref = param
writer.startElement(name)
typens, typename = typeref
typestr = writer.makeQName(typens, typename)
writer.writeAttr('type', typestr, DOM.NS_XSI)
writer.writeText(value)
writer.endElement()
writer.endElement()
writer.endBody()
writer.endEnvelope()
strval = writer.toString(1)
self.debug_print(strval)
# Read the message back to sanity check.
reader = SOAPReader(strval)
envelope = reader.getEnvelope()
encoding = reader.getEncodingStyle(envelope)
assert encoding == reader.NS_SOAP_ENC
header = reader.getHeader()
assert header is None
body = reader.getBody()
assert body is not None
rpc_element = reader.getRPCStruct()
assert rpc_element.localName == 'BabelFish'
params = reader.getRPCParams()
assert params[0].localName == 'translationmode'
assert params[1].localName == 'sourcedata'
value = DOM.getElementText(params[0])
assert value == 'en_de'
value = DOM.getElementText(params[1])
assert value == 'This is a test!'
def testMessageWithSimpleRefs(self):
"""Test writing a message with intra-document references."""
from WebService.Transports import HTTPTransport
from WebService.SOAPWriter import SOAPWriter
from WebService.SOAPReader import SOAPReader
from WebService.Utility import DOM
from StringIO import StringIO
address = "http://services.xmethods.net:80/perl/soaplite.cgi"
soapaction = "urn:xmethodsBabelFish#BabelFish"
methodname = "BabelFish"
methodNS = "urn:xmethodsBabelFish"
writer = SOAPWriter()
writer.startEnvelope(encodingStyle=writer.NS_SOAP_ENC)
writer.startBody()
# Write the RPC struct element.
writer.startElement(methodname, methodNS)
# Write the (reference) parameter elements.
typeref = (DOM.NS_XSD, 'string')
params = (('translationmode', None, 'en_de', typeref),
('sourcedata', None, 'This is a test!', typeref),
)
for param in params:
name, nsuri, value, typeref = param
param_id = writer.makeRefId()
writer.startElement(name)
writer.writeAttr('href', '#%s' % param_id)
writer.endElement()
writer.startBodyElement(name, methodNS)
writer.writeAttr('id', param_id)
typens, typename = typeref
typestr = writer.makeQName(typens, typename)
writer.writeAttr('type', typestr, DOM.NS_XSI)
writer.writeText(value)
writer.endBodyElement()
writer.endElement()
writer.endBody()
writer.endEnvelope()
strval = writer.toString(1)
self.debug_print(strval)
reader = SOAPReader(strval)
envelope = reader.getEnvelope()
encoding = reader.getEncodingStyle(envelope)
assert encoding == reader.NS_SOAP_ENC
header = reader.getHeader()
assert header is None
body = reader.getBody()
assert body is not None
rpc_element = reader.getRPCStruct()
assert rpc_element.localName == 'BabelFish'
params = reader.getRPCParams()
assert len(params) == 2
arg1 = reader.derefElement(params[0])
assert arg1.localName == 'translationmode'
value = DOM.getElementText(arg1)
assert value == 'en_de'
arg2 = reader.derefElement(params[1])
assert arg2.localName == 'sourcedata'
value = DOM.getElementText(arg2)
assert value == 'This is a test!'
def testFoo(self):
from WebService.SOAPWriter import SOAPWriter
from WebService.Utility import DOM
writer = SOAPWriter()
writer.startEnvelope(encodingStyle=writer.NS_SOAP_ENC)
writer.startBody()
# Write the RPC struct element.
writer.startElement('BabelFish', 'urn:xmethodsBabelFish')
# Write the parameter elements.
typestr = writer.makeQName(DOM.NS_XSD, 'string')
writer.startElement('translationmode')
writer.writeAttr('type', typestr, DOM.NS_XSI)
writer.writeText('en_de')
writer.endElement()
writer.startElement('sourcedata')
writer.writeAttr('type', typestr, DOM.NS_XSI)
writer.writeText('This is a test!')
writer.endElement()
# End the RPC struct element.
writer.endElement()
writer.endBody()
writer.endEnvelope()
xml = writer.toString(1)
file = open('temp.txt', 'w')
file.write(xml)
file.close()
def test_suite():
return unittest.makeSuite(SOAPWriterTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testSerializer.py ===
import sys, os, string, unittest, testcase
class SerializerTests(testcase.TestCase):
"""Test the Serializer object implementation."""
def testSimpleTypes(self):
"""Test the interfaces of the serializer object. In this test we
build a SOAP message using as many simple types as possible,
then read it back and make sure we get what we expected."""
from WebService.Serializer import Serializer, SerializationContext
from WebService.SOAPWriter import SOAPWriter
from WebService.SOAPReader import SOAPReader
from WebService.Utility import DOM
argbase = (
('test', (DOM.NS_XSD, 'string')),
('http://www.test.com', (DOM.NS_XSD, 'anyURI')),
('foo:bar', (DOM.NS_XSD, 'QName')),
('test', (DOM.NS_XSD, 'NOTATION')),
('test', (DOM.NS_XSD, 'normalizedString')),
('test', (DOM.NS_XSD, 'token')),
('test', (DOM.NS_XSD, 'NMTOKEN')),
('en/us', (DOM.NS_XSD, 'language')),
('test', (DOM.NS_XSD, 'Name')),
('test', (DOM.NS_XSD, 'NCName')),
('test', (DOM.NS_XSD, 'ID')),
('test', (DOM.NS_XSD, 'IDREF')),
('test', (DOM.NS_XSD, 'ENTITY')),
(('testa', 'testb', 'testc'), (DOM.NS_XSD, 'NMTOKENS')),
(('testa', 'testb', 'testc'), (DOM.NS_XSD, 'IDREFS')),
(('testa', 'testb', 'testc'), (DOM.NS_XSD, 'ENTITIES')),
(42.5, (DOM.NS_XSD, 'decimal')),
(3.4028234663852886E+38, (DOM.NS_XSD, 'float')),
(-3.4028234663852886E+38, (DOM.NS_XSD, 'float')),
(1.70E+308, (DOM.NS_XSD, 'double')),
(-1.70E+308, (DOM.NS_XSD, 'double')),
# (1.7976931348623157E+308, (DOM.NS_XSD, 'double')),
# (-1.7976931348623158E+308, (DOM.NS_XSD, 'double')),
(42, (DOM.NS_XSD, 'integer')),
(0, (DOM.NS_XSD, 'nonPositiveInteger')),
(-9223372036854775808L, (DOM.NS_XSD, 'nonPositiveInteger')),
(-1, (DOM.NS_XSD, 'negativeInteger')),
(-9223372036854775808L, (DOM.NS_XSD, 'negativeInteger')),
(9223372036854775807L, (DOM.NS_XSD, 'nonNegativeInteger')),
(0, (DOM.NS_XSD, 'nonNegativeInteger')),
(9223372036854775807L, (DOM.NS_XSD, 'positiveInteger')),
(1, (DOM.NS_XSD, 'positiveInteger')),
(18446744073709551615L, (DOM.NS_XSD, 'unsignedLong')),
(0, (DOM.NS_XSD, 'unsignedLong')),
(4294967295L, (DOM.NS_XSD, 'unsignedInt')),
(0, (DOM.NS_XSD, 'unsignedInt')),
(65535, (DOM.NS_XSD, 'unsignedShort')),
(0, (DOM.NS_XSD, 'unsignedShort')),
(255, (DOM.NS_XSD, 'unsignedByte')),
(0, (DOM.NS_XSD, 'unsignedByte')),
(9223372036854775807L, (DOM.NS_XSD, 'long')),
(-9223372036854775808L, (DOM.NS_XSD, 'long')),
(2147483647L, (DOM.NS_XSD, 'int')),
(-2147483648L, (DOM.NS_XSD, 'int')),
(32767, (DOM.NS_XSD, 'short')),
(-32768, (DOM.NS_XSD, 'short')),
(127, (DOM.NS_XSD, 'byte')),
(-128, (DOM.NS_XSD, 'byte')),
('true', (DOM.NS_XSD, 'boolean'), 1),
(1, (DOM.NS_XSD, 'boolean'), 1),
('false', (DOM.NS_XSD, 'boolean'), 0),
(0, (DOM.NS_XSD, 'boolean'), 0),
('This is a test.', (DOM.NS_XSD, 'base64Binary')),
('This is a test.', (DOM.NS_SOAP_ENC, 'base64')),
('This is a test.', (DOM.NS_XSD, 'hexBinary')),
('This is a test.', (DOM.NS_XSD_99, 'binary')),
)
# Build up an argument list that includes all of the above, plus
# the SOAP-encoding defined aliases for the XSD simple types.
arglist = []
for item in argbase:
arglist.append(item)
argval = item[0]
argtype = item[1]
if len(item) == 3:
outval = item[2]
else:
outval = None
for nsuri in DOM.NS_SOAP_ENC_ALL:
if outval is not None:
argitem = (argval, (nsuri, argtype[1]), outval)
arglist.append(argitem)
else:
argitem = (argval, (nsuri, argtype[1]))
arglist.append(argitem)
# Set up a serializer and build a whopping big SOAP message.
serializer = Serializer()
context = SerializationContext(serializer)
context.writer = SOAPWriter()
writer = context.writer
writer.startEnvelope(encodingStyle=writer.NS_SOAP_ENV)
writer.startBody()
writer.startElement('SerializationTest', 'urn:serialization-test')
for n in range(len(arglist)):
argname = 'arg-%d' % n
argitem = arglist[n]
argtype = argitem[1]
argval = argitem[0]
serializer.serialize(argname, argval, argtype, context)
writer.endElement()
writer.endBody()
writer.endEnvelope()
xml = writer.toString(1)
# Now read it all back and make sure we got what we expected.
context = SerializationContext(serializer)
context.reader = SOAPReader(xml)
reader = context.reader
params = reader.getRPCParams()
for n in range(len(arglist)):
argname = 'arg-%d' % n
argitem = arglist[n]
argtype = argitem[1]
argval = argitem[0]
if len(argitem) == 3:
retval = argitem[2]
else:
retval = argitem[0]
element = params[n]
typeref = DOM.getTypeRef(element)
value = serializer.deserialize(element, context)
self.assertEquals(element.localName, argname)
self.assertEquals(typeref, argtype)
if type(retval) in (type([]), type(())):
for i in range(len(retval)):
self.assertEquals(retval[i], value[i])
else:
self.assertEquals(retval, value)
def testComplexTypes(self):
"""This will test handling of custom and complex types."""
pass
def testArrayTypes(self):
"""This will test handling of various array constructs."""
pass
def testUnionTypes(self):
"""This will test handling of various union constructs."""
pass
def test_suite():
return unittest.makeSuite(SerializerTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testServiceProxy.py ===
__version__='$Revision: 1.1 $'[11:-2]
import sys, os, string, unittest, testcase
class ServiceProxyTests(testcase.TestCase):
"""Test the ServiceProxy class with various services."""
def test(self):
"""Test simple service proxy usage."""
from WebService.ServiceProxy import ServiceProxy
wsdl_url = 'http://www.xmethods.net/sd/BabelFishService.wsdl'
service = ServiceProxy(wsdl_url)
result = service.BabelFish('en_de', 'This is a test!')
self.assertEquals(result, 'ist dieses ein Test!')
def test_suite():
return unittest.makeSuite(ServiceProxyTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testWSDLTools.py ===
__version__='$Revision: 1.1 $'[11:-2]
import sys, os, string, unittest, testcase
class WSDLTests(testcase.TestCase):
"""Test parsing and manipulating WSDL service descriptions."""
def testWSDLReaderMethods(self):
"""Test loading a document using the WSDLReader interfaces."""
from WebService.WSDLTools import WSDLReader
path = self.get_file_url('EchoService.wsdl')
wsdl = WSDLReader().loadFromURL(path)
self.assertEquals(wsdl.location, path)
self.checkWSDL(wsdl)
path = os.path.join(os.getcwd(), 'data', 'EchoService.wsdl')
wsdl = WSDLReader().loadFromFile(path)
self.checkWSDL(wsdl)
file = open(path, 'rb')
wsdl = WSDLReader().loadFromStream(file)
file.close()
self.checkWSDL(wsdl)
file = open(path, 'rb')
data = file.read()
file.close()
wsdl = WSDLReader().loadFromString(data)
self.checkWSDL(wsdl)
def testWSDLWriterMethods(self):
"""Test using the simplified WSDL generation interface."""
from WebService.WSDLTools import WSDLWriter, WSDLReader
from WebService.SOAPCallInfo import SOAPCallInfo
from WebService.Utility import DOM
from StringIO import StringIO
writer = WSDLWriter('http://www.example.com/services/EchoService.wsdl')
writer.startService('EchoService',
'http://www.example.com/services/EchoService.cgi',
'A simple interop testing service.',
)
for item in (
('echoString', 'Echo a string argument.', 'string'),
('echoInteger', 'Echo an integer argument.', 'int'),
('echoFloat', 'Echo a floating point argument.', 'float')
):
name, docs, type = item
callinfo = SOAPCallInfo(name)
callinfo.documentation = docs
callinfo.soapAction = 'urn:EchoService#%s' % name
callinfo.namespace = 'urn:EchoService'
callinfo.addInParameter('data', (DOM.NS_XSD_01, type))
callinfo.setReturnParameter('return', (DOM.NS_XSD_01, type))
writer.writeMethod(callinfo)
writer.endService()
data = writer.toXML()
wsdl = WSDLReader().loadFromString(data)
self.checkWSDL(wsdl)
return data
def testWSDLWithImports(self):
"""Test parsing a wsdl document containing import elements."""
from WebService.WSDLTools import WSDLReader
fileurl = self.get_file_url('ImportTest.wsdl')
wsdl = WSDLReader().loadFromURL(fileurl)
# Make sure we get the right items in the element collections.
self.assertEquals(len(wsdl.services), 1)
self.assertEquals(len(wsdl.messages), 38)
self.assertEquals(len(wsdl.portTypes), 6)
self.assertEquals(len(wsdl.bindings), 6)
self.assertEquals(len(wsdl.imports), 2)
self.assertEquals(len(wsdl.types), 1)
# Check that we get the right thing when we write out the
# document (with imported elements) and read it back in.
data = wsdl.toXML()
wsdl = WSDLReader().loadFromString(data)
self.assertEquals(len(wsdl.services), 1)
self.assertEquals(len(wsdl.messages), 38)
self.assertEquals(len(wsdl.portTypes), 6)
self.assertEquals(len(wsdl.bindings), 6)
self.assertEquals(len(wsdl.imports), 0)
self.assertEquals(len(wsdl.types), 1)
def get_file_url(self, name):
"""Utility to create a file: url for test data."""
path = os.path.join(os.getcwd(), 'data', name)
if os.name == 'nt':
import nturl2path
path = nturl2path.pathname2url(path)
return 'file://%s' % path
def classCheck(self, object, name):
"""Utility to do a quick check of an object's class."""
self.assertEquals(object.__class__.__name__, name)
def checkWSDL(self, wsdl):
"""Utility to check the correctness of wsdl structures."""
from WebService.Utility import DOM
# Check the basic element collections.
self.assertEquals(len(wsdl.services), 1)
self.assertEquals(len(wsdl.messages), 6)
self.assertEquals(len(wsdl.portTypes), 1)
self.assertEquals(len(wsdl.bindings), 1)
self.assertEquals(len(wsdl.imports), 0)
self.assertEquals(len(wsdl.types), 0)
# Check the definitions element.
self.assertEquals(wsdl.targetNamespace,
'http://www.example.com/services/EchoService.wsdl'
)
# Check the wsdl:service element.
service = wsdl.services[0]
self.assertEquals(service.name, 'EchoService')
self.assertEquals(service.documentation,
'A simple interop testing service.')
self.assertEquals(len(service.ports), 1)
# Check the wsdl:port element.
port = service.ports[0]
self.assertEquals(port.name, 'EchoServicePort')
self.assertEquals(port.documentation, '')
self.assertEquals(len(port.extensions), 1)
self.assertEquals(port.getAddressBinding().location,
'http://www.example.com/services/EchoService.cgi'
)
# Check the wsdl:binding element.
binding = port.getBinding()
self.assertEquals(binding.name, 'EchoServiceBinding')
self.assertEquals(binding.documentation, '')
self.assertEquals(len(binding.extensions), 1)
self.assertEquals(len(binding.operations), 3)
# Check the soap:binding element.
p_binding = binding.extensions[0]
self.classCheck(p_binding, 'SoapBinding')
self.assertEquals(p_binding.style, 'rpc')
self.assertEquals(p_binding.transport,
DOM.NS_SOAP_HTTP
)
# Check the wsdl:operation element.
operation = binding.operations[0]
self.assertEquals(operation.name, 'echoString')
self.assertEquals(operation.documentation, '')
self.assertEquals(len(operation.extensions), 1)
# Check the soap:operation element.
op_binding = operation.extensions[0]
self.classCheck(op_binding, 'SoapOperationBinding')
self.assertEquals(op_binding.style, 'rpc')
self.assertEquals(op_binding.soapAction,
'urn:EchoService#echoString'
)
# Check input and output bindings.
for msgrole_binding in (operation.input, operation.output):
self.assertEquals(len(msgrole_binding.extensions), 1)
element = msgrole_binding.extensions[0]
self.classCheck(element, 'SoapBodyBinding')
self.assertEquals(element.namespace, 'urn:EchoService')
self.assertEquals(element.use, 'encoded')
self.assertEquals(element.parts, None)
self.assertEquals(
element.encodingStyle,
DOM.NS_SOAP_ENC
)
# Check the wsdl:portType element.
portType = binding.getPortType()
self.assertEquals(portType.name, 'EchoServicePortType')
self.assertEquals(portType.documentation, '')
self.assertEquals(len(portType.extensions), 0)
self.assertEquals(len(portType.operations), 3)
# Check the operations of the port type.
operation = portType.operations[0]
self.assertEquals(operation.name, 'echoString')
self.assertEquals(operation.documentation, 'Echo a string argument.')
# Check the input and output messages.
msgrole = operation.input
self.assertEquals(msgrole.type, 'input')
self.assertEquals(msgrole.message, 'echoStringRequest')
message = operation.getInputMessage()
self.assertEquals(message.name, 'echoStringRequest')
self.assertEquals(message.documentation, '')
self.assertEquals(len(message.parts), 1)
part = message.parts[0]
self.assertEquals(part.name, 'data')
self.assertEquals(part.type[1], 'string')
msgrole = operation.output
self.assertEquals(msgrole.type, 'output')
self.assertEquals(msgrole.message, 'echoStringResponse')
message = operation.getOutputMessage()
self.assertEquals(message.name, 'echoStringResponse')
self.assertEquals(message.documentation, '')
self.assertEquals(len(message.parts), 1)
part = message.parts[0]
self.assertEquals(part.name, 'return')
self.assertEquals(part.type[1], 'string')
self.assertEquals(len(operation.faults), 0)
def test_suite():
return unittest.makeSuite(WSDLTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testXMLWriter.py ===
__version__='$Revision: 1.1 $'[11:-2]
import sys, os, string, unittest, testcase
class XMLWriterTests(testcase.TestCase):
"""Test simplified XML writer interfaces."""
def testXMLWriterMethods(self):
"""Test xml writer methods."""
pass
def testXMLWriterExample(self):
"""Test documentation example output."""
from WebService.XMLWriter import XMLWriter
writer = XMLWriter()
writer.startElement('numbers')
for n in range(5):
writer.startElement('item')
writer.writeText(str(n))
writer.endElement()
writer.endElement()
xml = writer.toString(1)
#file = open('temp.txt', 'w')
#file.write(xml)
#file.close()
def test_suite():
return unittest.makeSuite(XMLWriterTests)
def main():
unittest.TextTestRunner().run(test_suite())
if __name__ == '__main__':
testcase.setup()
main()
=== Added File Packages/WebService/tests/testcase.py ===
__version__='$Revision: 1.1 $'[11:-2]
import sys, os, getopt, unittest
class TestCase(unittest.TestCase):
"""Common base class for web service test cases."""
def debug_print(self, data):
if getattr(self, '_debug', None) is not None:
print data
def setup():
sys.path.append(os.path.normpath(os.path.join(os.getcwd(), '../..')))
options, args = getopt.getopt(sys.argv[1:], 'd')
for name, value in options:
if name == '-d':
TestCase._debug = 1
return