def test_restriction_data_types():
client_unnamed = tests.client_from_wsdl(
tests.wsdl("""\
<xsd:element name="Elemento">
<xsd:simpleType>
<xsd:restriction base="xsd:int">
<xsd:enumeration value="1" />
<xsd:enumeration value="3" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
</xsd:element>""",
output="Elemento"))
client_named = tests.client_from_wsdl(
tests.wsdl("""\
<xsd:simpleType name="MyType">
<xsd:restriction base="xsd:int">
<xsd:enumeration value="1" />
<xsd:enumeration value="3" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="Elemento" type="ns:MyType" />""",
output="Elemento"))
client_twice_restricted = tests.client_from_wsdl(
tests.wsdl("""\
<xsd:simpleType name="MyTypeGeneric">
<xsd:restriction base="xsd:int">
<xsd:enumeration value="1" />
<xsd:enumeration value="2" />
<xsd:enumeration value="3" />
<xsd:enumeration value="4" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="MyType">
<xsd:restriction base="ns:MyTypeGeneric">
<xsd:enumeration value="1" />
<xsd:enumeration value="3" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="Elemento" type="ns:MyType" />""",
output="Elemento"))
for client in (client_unnamed, client_named, client_twice_restricted):
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Elemento xmlns="my-namespace">5</Elemento>
</env:Body>
</env:Envelope>""")))
assert response.__class__ is int
assert response == 5
def test_restriction_data_types():
client_unnamed = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="Elemento">
<xsd:simpleType>
<xsd:restriction base="xsd:int">
<xsd:enumeration value="1" />
<xsd:enumeration value="3" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
</xsd:element>""", output="Elemento"))
client_named = tests.client_from_wsdl(tests.wsdl("""\
<xsd:simpleType name="MyType">
<xsd:restriction base="xsd:int">
<xsd:enumeration value="1" />
<xsd:enumeration value="3" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="Elemento" type="ns:MyType" />""", output="Elemento"))
client_twice_restricted = tests.client_from_wsdl(tests.wsdl("""\
<xsd:simpleType name="MyTypeGeneric">
<xsd:restriction base="xsd:int">
<xsd:enumeration value="1" />
<xsd:enumeration value="2" />
<xsd:enumeration value="3" />
<xsd:enumeration value="4" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="MyType">
<xsd:restriction base="ns:MyTypeGeneric">
<xsd:enumeration value="1" />
<xsd:enumeration value="3" />
<xsd:enumeration value="5" />
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="Elemento" type="ns:MyType" />""", output="Elemento"))
for client in (client_unnamed, client_named, client_twice_restricted):
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Elemento xmlns="my-namespace">5</Elemento>
</env:Body>
</env:Envelope>""")))
assert response.__class__ is int
assert response == 5
def test_simple_bare_and_wrapped_output():
# Prepare web service proxies.
client_bare = tests.client_from_wsdl(
tests.wsdl("""\
<xsd:element name="fResponse" type="xsd:string" />""",
output="fResponse"))
client_wrapped = tests.client_from_wsdl(
tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="fResponse" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""",
output="Wrapper"))
# Make sure suds library inteprets our WSDL definitions as wrapped or
# bare output interfaces as expected.
assert not _isOutputWrapped(client_bare, "f")
assert _isOutputWrapped(client_wrapped, "f")
# Both bare & wrapped single parameter output web service operation
# results get presented the same way even though the wrapped one actually
# has an extra wrapper element around its received output data.
data = "The meaning of life."
get_response = lambda client, x: client.service.f(__inject=dict(
reply=suds.byte_str(x)))
response_bare = get_response(
client_bare, """<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<fResponse xmlns="my-namespace">%s</fResponse>
</env:Body>
</env:Envelope>""" % data)
assert response_bare.__class__ is suds.sax.text.Text
assert response_bare == data
response_wrapped = get_response(
client_wrapped, """<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Wrapper xmlns="my-namespace">
<fResponse>%s</fResponse>
</Wrapper>
</env:Body>
</env:Envelope>""" % data)
assert response_wrapped.__class__ is suds.sax.text.Text
assert response_wrapped == data
def test_disabling_automated_simple_interface_unwrapping():
client = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""",
output="Wrapper"),
unwrap=False)
assert not _isOutputWrapped(client, "f")
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Wrapper xmlns="my-namespace">
<Elemento>La-di-da-da-da</Elemento>
</Wrapper>
</env:Body>
</env:Envelope>""")))
assert response.__class__.__name__ == "Wrapper"
assert len(response.__class__.__bases__) == 1
assert response.__class__.__bases__[0] is suds.sudsobject.Object
assert response.Elemento.__class__ is suds.sax.text.Text
assert response.Elemento == "La-di-da-da-da"
def test_missing_wrapper_response():
"""
Suds library's automatic structure unwrapping should not be applied to
interpreting received SOAP Response XML.
"""
client = tests.client_from_wsdl(
tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="fResponse" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""",
output="Wrapper"))
assert _isOutputWrapped(client, "f")
response_with_missing_wrapper = client.service.f(__inject=dict(
reply=suds.byte_str("""<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<fResponse xmlns="my-namespace">Anything</fResponse>
</env:Body>
</env:Envelope>""")))
assert response_with_missing_wrapper is None
def test_disabling_automated_simple_interface_unwrapping():
client = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", output="Wrapper"), unwrap=False)
assert not _isOutputWrapped(client, "f")
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Wrapper xmlns="my-namespace">
<Elemento>La-di-da-da-da</Elemento>
</Wrapper>
</env:Body>
</env:Envelope>""")))
assert response.__class__.__name__ == "Wrapper"
assert len(response.__class__.__bases__) == 1
assert response.__class__.__bases__[0] is suds.sudsobject.Object
assert response.Elemento.__class__ is suds.sax.text.Text
assert response.Elemento == "La-di-da-da-da"
def test_avoid_external_XSD_fetching(self):
# Prepare document content.
xsd_target_namespace = "balancana"
wsdl = tests.wsdl("""\
<xsd:import schemaLocation="suds://imported_xsd"/>
<xsd:include schemaLocation="suds://included_xsd"/>""",
xsd_target_namespace=xsd_target_namespace)
external_xsd_format = """\
<?xml version='1.0' encoding='UTF-8'?>
<schema xmlns="http://www.w3.org/2001/XMLSchema">
<element name="external%d" type="string"/>
</schema>"""
external_xsd1 = suds.byte_str(external_xsd_format % (1,))
external_xsd2 = suds.byte_str(external_xsd_format % (2,))
# Add to cache.
cache = MockCache()
store1 = MockDocumentStore(wsdl=wsdl, imported_xsd=external_xsd1,
included_xsd=external_xsd2)
c1 = suds.client.Client("suds://wsdl", cachingpolicy=1,
cache=cache, documentStore=store1, transport=MockTransport())
assert store1.mock_log == ["suds://wsdl", "suds://imported_xsd",
"suds://included_xsd"]
assert len(cache.mock_data) == 1
wsdl_object_id, wsdl_object = cache.mock_data.items()[0]
assert wsdl_object.__class__ is suds.wsdl.Definitions
# Reuse from cache.
cache.mock_operation_log = []
store2 = MockDocumentStore(wsdl=wsdl)
c2 = suds.client.Client("suds://wsdl", cachingpolicy=1,
cache=cache, documentStore=store2, transport=MockTransport())
assert cache.mock_operation_log == [("get", [wsdl_object_id])]
assert store2.mock_log == []
def _create_dummy_schema():
"""Constructs a new dummy XSD schema instance."""
#TODO: Find out how to construct this XSD schema object directly without
# first having to construct a suds.client.Client from a complete WSDL
# schema.
wsdl = tests.wsdl('<xsd:element name="dummy"/>', input="dummy")
client = tests.client_from_wsdl(wsdl)
return client.wsdl.schema
def _create_dummy_schema():
"""Constructs a new dummy XSD schema instance."""
#TODO: Find out how to construct this XSD schema object directly without
# first having to construct a suds.client.Client from a complete WSDL
# schema.
wsdl = tests.wsdl('<xsd:element name="dummy"/>', input="dummy")
client = tests.client_from_wsdl(wsdl)
return client.wsdl.schema
def test_simple_bare_and_wrapped_output():
# Prepare web service proxies.
client_bare = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="fResponse" type="xsd:string" />""",
output="fResponse"))
client_wrapped = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="fResponse" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", output="Wrapper"))
# Make sure suds library inteprets our WSDL definitions as wrapped or
# bare output interfaces as expected.
assert not _isOutputWrapped(client_bare, "f")
assert _isOutputWrapped(client_wrapped, "f")
# Both bare & wrapped single parameter output web service operation
# results get presented the same way even though the wrapped one actually
# has an extra wrapper element around its received output data.
data = "The meaning of life."
get_response = lambda client, x : client.service.f(__inject=dict(
reply=suds.byte_str(x)))
response_bare = get_response(client_bare, """<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<fResponse xmlns="my-namespace">%s</fResponse>
</env:Body>
</env:Envelope>""" % data)
assert response_bare.__class__ is suds.sax.text.Text
assert response_bare == data
response_wrapped = get_response(client_wrapped, """<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Wrapper xmlns="my-namespace">
<fResponse>%s</fResponse>
</Wrapper>
</env:Body>
</env:Envelope>""" % data)
assert response_wrapped.__class__ is suds.sax.text.Text
assert response_wrapped == data
def test_twice_wrapped_parameter():
"""
Suds does not recognize 'twice wrapped' data structures and unwraps the
external one but keeps the internal wrapping structure in place.
"""
wsdl = tests.wsdl("""\
<xsd:element name="Wrapper1">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Wrapper2">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", input="Wrapper1", xsd_target_namespace="spank me")
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
assert _is_input_wrapped(client, "f")
# Web service operation calls made with 'valid' parameters.
#
# These calls are actually illegal and result in incorrectly generated SOAP
# requests not matching the relevant WSDL schema. To make them valid we
# would need to pass a more complex value instead of a simple string, but
# the current simpler solution is good enough for what we want to test
# here.
value = "A B C"
expectedRequest = """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="spank me" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper1>
<ns0:Wrapper2>%s</ns0:Wrapper2>
</ns0:Wrapper1>
</ns1:Body>
</SOAP-ENV:Envelope>""" % (value,)
assert _compare_request(client.service.f(value), expectedRequest)
assert _compare_request(client.service.f(Wrapper2=value), expectedRequest)
# Web service operation calls made with 'invalid' parameters.
def testInvalidParameter(**kwargs):
assert len(kwargs) == 1
element = kwargs.keys()[0]
expected = "f() got an unexpected keyword argument '%s'" % (element,)
e = pytest.raises(TypeError, client.service.f, **kwargs).value
try:
assert str(e) == expected
finally:
del e
testInvalidParameter(Elemento="A B C")
testInvalidParameter(Wrapper1="A B C")
def test_external_XSD_transport(self, url, external_reference_tag):
xsd_content = '<xsd:%(tag)s schemaLocation="%(url)s"/>' % dict(
tag=external_reference_tag, url=url)
store = MockDocumentStore(wsdl=tests.wsdl(xsd_content))
t = MockTransport(open_data=suds.byte_str("""\
<?xml version='1.0' encoding='UTF-8'?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"/>
"""))
suds.client.Client("suds://wsdl", cache=None, documentStore=store,
transport=t)
assert t.mock_operation_log == [("open", url)]
def test_document_literal_request_for_single_element_input(xsd,
external_element_name, args, request_body):
wsdl = tests.wsdl(xsd, input=external_element_name,
xsd_target_namespace="dr. Doolittle")
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
assert _compare_request(client.service.f(*args), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="dr. Doolittle" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>%s</ns1:Body>
</SOAP-ENV:Envelope>""" % (request_body,))
def test_WSDL_import():
wsdl = tests.wsdl("", wsdl_target_namespace="bingo-bongo")
wsdl_wrapper = suds.byte_str("""\
<?xml version='1.0' encoding='UTF-8'?>
<wsdl:definitions
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
targetNamespace="bingo-bongo">
<wsdl:import namespace="bingo-bongo" location="suds://wsdl"/>
</wsdl:definitions>
""")
store = suds.store.DocumentStore(wsdl=wsdl, wsdl_wrapper=wsdl_wrapper)
client = suds.client.Client("suds://wsdl_wrapper", documentStore=store,
cache=None, nosend=True)
client.service.f()
def test_resolving_builtin_types(monkeypatch):
_monkeypatch_builtin_XSD_type_registry(monkeypatch)
class MockXInteger(XInteger):
pass
Factory.maptag("osama", MockXInteger)
wsdl = tests.wsdl('<xsd:element name="wu" type="xsd:osama"/>', input="wu")
client = tests.client_from_wsdl(wsdl)
element, schema_object = client.sd[0].params[0]
assert element.name == "wu"
assert element.type == ("osama", "http://www.w3.org/2001/XMLSchema")
assert schema_object.__class__ is MockXInteger
assert schema_object.name == "osama"
assert schema_object.schema is client.wsdl.schema
def test_bare_input_restriction_types():
client_unnamed = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="Elemento">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="alfa"/>
<xsd:enumeration value="beta"/>
<xsd:enumeration value="gamma"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>""", input="Elemento"))
client_named = tests.client_from_wsdl(tests.wsdl("""\
<xsd:simpleType name="MyType">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="alfa"/>
<xsd:enumeration value="beta"/>
<xsd:enumeration value="gamma"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:element name="Elemento" type="ns:MyType"/>""", input="Elemento"))
assert not _is_input_wrapped(client_unnamed, "f")
assert not _is_input_wrapped(client_named, "f")
def test_resolving_builtin_types(monkeypatch):
_monkeypatch_builtin_XSD_type_registry(monkeypatch)
class MockXInteger(XInteger):
pass
Factory.maptag("osama", MockXInteger)
wsdl = tests.wsdl('<xsd:element name="wu" type="xsd:osama"/>', input="wu")
client = tests.client_from_wsdl(wsdl)
element, schema_object = client.sd[0].params[0]
assert element.name == "wu"
assert element.type == ("osama", "http://www.w3.org/2001/XMLSchema")
assert schema_object.__class__ is MockXInteger
assert schema_object.name == "osama"
assert schema_object.schema is client.wsdl.schema
def test_using_cached_WSDL_avoids_store_avoids_transport(self,
caching_policy):
"""
When a client's WSDL schema is located in the cache, it should be read
from there instead of fetching its data from the client's document
store or using its registered transport.
When it is is not located in the cache but can be found in the client's
document store, it should be fetched from there but not using the
client's registered transport.
"""
# Add to cache, making sure the WSDL schema is read from the document
# store and not fetched using the client's registered transport.
cache = MockCache()
store1 = MockDocumentStore(umpala=tests.wsdl(""))
c1 = suds.client.Client("suds://umpala", cachingpolicy=caching_policy,
cache=cache, documentStore=store1, transport=MockTransport())
assert [x for x, y in cache.mock_operation_log] == ["get", "put"]
id = cache.mock_operation_log[0][1][0]
assert id == cache.mock_operation_log[1][1][0]
assert len(cache.mock_data) == 1
if caching_policy == 0:
# Cache contains SAX XML documents.
wsdl_document = cache.mock_data.values()[0]
assert wsdl_document.__class__ is suds.sax.document.Document
wsdl_cached_root = wsdl_document.root()
else:
# Cache contains complete suds WSDL objects.
wsdl = cache.mock_data.values()[0]
assert wsdl.__class__ is suds.wsdl.Definitions
wsdl_cached_root = wsdl.root
assert c1.wsdl.root is wsdl_cached_root
# Make certain the same WSDL schema is fetched from the cache and not
# using the document store or the transport.
cache.mock_operation_log = []
cache.mock_put_config = MockCache.FAIL
store2 = MockDocumentStore(mock_fail=True)
c2 = suds.client.Client("suds://umpala", cachingpolicy=caching_policy,
cache=cache, documentStore=store2, transport=MockTransport())
assert cache.mock_operation_log == [("get", [id])]
assert c2.wsdl.root is wsdl_cached_root
def init_function_params(self, params, **kwargs):
"""
Initialize a test in this group with the given parameter definition.
Constructs a complete WSDL schema based on the given function parameter
definition (defines a single web service operation named 'f' by
default), and creates a suds Client object to be used for testing
suds's web service operation invocation.
An alternate operation name may be given using the 'operation_name'
keyword argument.
May only be invoked once per test.
"""
input = '<xsd:element name="Wrapper">%s</xsd:element>' % (params,)
assert not hasattr(self, "service")
wsdl = tests.wsdl(input, input="Wrapper", **kwargs)
client = tests.client_from_wsdl(wsdl, nosend=True)
self.service = client.service
def init_function_params(self, params, **kwargs):
"""
Initialize a test in this group with the given parameter definition.
Constructs a complete WSDL schema based on the given function parameter
definition (defines a single web service operation named 'f' by
default), and creates a suds Client object to be used for testing
suds's web service operation invocation.
An alternate operation name may be given using the 'operation_name'
keyword argument.
May only be invoked once per test.
"""
input = '<xsd:element name="Wrapper">%s</xsd:element>' % (params, )
assert not hasattr(self, "service")
wsdl = tests.wsdl(input, input="Wrapper", **kwargs)
client = tests.client_from_wsdl(wsdl, nosend=True)
self.service = client.service
def test_wrapped_sequence_output():
client = tests.client_from_wsdl(
tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="result1" type="xsd:string" />
<xsd:element name="result2" type="xsd:string" />
<xsd:element name="result3" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""",
output="Wrapper"))
assert _isOutputWrapped(client, "f")
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Wrapper xmlns="my-namespace">
<result1>Uno</result1>
<result2>Due</result2>
<result3>Tre</result3>
</Wrapper>
</env:Body>
</env:Envelope>""")))
# Composite replies always get unmarshalled as a dynamically constructed
# class named 'reply'.
assert len(response.__class__.__bases__) == 1
assert response.__class__.__name__ == "reply"
assert response.__class__.__bases__[0] is suds.sudsobject.Object
# Check response content.
assert len(response) == 3
assert response.result1 == "Uno"
assert response.result2 == "Due"
assert response.result3 == "Tre"
assert response.result1.__class__ is suds.sax.text.Text
assert response.result2.__class__ is suds.sax.text.Text
assert response.result3.__class__ is suds.sax.text.Text
def test_wrapped_sequence_output():
client = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="result1" type="xsd:string" />
<xsd:element name="result2" type="xsd:string" />
<xsd:element name="result3" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", output="Wrapper"))
assert _isOutputWrapped(client, "f")
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<Wrapper xmlns="my-namespace">
<result1>Uno</result1>
<result2>Due</result2>
<result3>Tre</result3>
</Wrapper>
</env:Body>
</env:Envelope>""")))
# Composite replies always get unmarshalled as a dynamically constructed
# class named 'reply'.
assert len(response.__class__.__bases__) == 1
assert response.__class__.__name__ == "reply"
assert response.__class__.__bases__[0] is suds.sudsobject.Object
# Check response content.
assert len(response) == 3
assert response.result1 == "Uno"
assert response.result2 == "Due"
assert response.result3 == "Tre"
assert response.result1.__class__ is suds.sax.text.Text
assert response.result2.__class__ is suds.sax.text.Text
assert response.result3.__class__ is suds.sax.text.Text
def test_missing_wrapper_response():
"""
Suds library's automatic structure unwrapping should not be applied to
interpreting received SOAP Response XML.
"""
client = tests.client_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="fResponse" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", output="Wrapper"))
assert _isOutputWrapped(client, "f")
response_with_missing_wrapper = client.service.f(__inject=dict(
reply=suds.byte_str("""<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<fResponse xmlns="my-namespace">Anything</fResponse>
</env:Body>
</env:Envelope>""")))
assert response_with_missing_wrapper is None
def test_disabling_automated_simple_interface_unwrapping():
wsdl = tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", input="Wrapper", xsd_target_namespace="woof")
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True,
unwrap=False)
assert not _is_input_wrapped(client, "f")
wrapper = client.factory.create("my_xsd:Wrapper")
wrapper.Elemento = "Wonderwall"
assert _compare_request(client.service.f(Wrapper=wrapper), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="woof" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:Elemento>Wonderwall</ns0:Elemento>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
def test_invalid_input_parameter_type_handling():
"""
Input parameters of invalid type get silently pushed into the constructed
SOAP request as strings, even though the constructed SOAP request does not
necessarily satisfy requirements set for it in the web service's WSDL
schema. It is then left up to the web service implementation to detect and
report this error.
"""
wsdl = tests.wsdl("""\
<xsd:complexType name="Freakazoid">
<xsd:sequence>
<xsd:element name="freak1" type="xsd:string"/>
<xsd:element name="freak2" type="xsd:string"/>
<xsd:element name="freak3" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="p1" type="xsd:string"/>
<xsd:element name="anInteger" type="xsd:integer"/>
<xsd:element name="p2" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", input="Wrapper", xsd_target_namespace="1234567890")
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
# Passing an unrelated Python type value.
class SomeType:
def __str__(self):
return "Some string representation."
assert _compare_request(client.service.f(anInteger=SomeType()), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="1234567890" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:p1/>
<ns0:anInteger>Some string representation.</ns0:anInteger>
<ns0:p2/>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
# Passing a value of a WSDL schema defined type.
value = client.factory.create("my_xsd:Freakazoid")
value.freak1 = "Tiny"
value.freak2 = "Miny"
value.freak3 = "Mo"
assert _compare_request(client.service.f(anInteger=value), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="1234567890" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:p1/>
<ns0:anInteger>
<ns0:freak1>Tiny</ns0:freak1>
<ns0:freak2>Miny</ns0:freak2>
<ns0:freak3>Mo</ns0:freak3>
</ns0:anInteger>
<ns0:p2/>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
def test_missing_parameters():
"""Missing non-optional parameters should get passed as empty values."""
service = _service_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="aString" type="xsd:string"/>
<xsd:element name="anInteger" type="xsd:integer"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", input="Wrapper", xsd_target_namespace="plonker"))
assert _compare_request(service.f(), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="plonker" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString/>
<ns0:anInteger/>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
assert _compare_request(service.f(u"Pero Ždero"), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="plonker" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString>Pero Ždero</ns0:aString>
<ns0:anInteger/>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
assert _compare_request(service.f(anInteger=666), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="plonker" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString/>
<ns0:anInteger>666</ns0:anInteger>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
# None value is treated the same as undefined.
assert _compare_request(service.f(aString=None, anInteger=666), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="plonker" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString/>
<ns0:anInteger>666</ns0:anInteger>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
assert _compare_request(service.f(aString="Omega", anInteger=None), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="plonker" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString>Omega</ns0:aString>
<ns0:anInteger/>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
def test_nosend_should_avoid_transport_sends(self):
wsdl = tests.wsdl("")
t = MockTransport()
client = tests.client_from_wsdl(wsdl, nosend=True, transport=t)
client.service.f()
def test_WSDL_transport(self, url):
store = MockDocumentStore()
t = MockTransport(open_data=tests.wsdl(""))
suds.client.Client(url, cache=None, documentStore=store, transport=t)
assert t.mock_operation_log == [("open", url)]
def test_using_cached_XSD_schema_avoids_store_avoids_transport(self,
external_reference_tag, main_WSDL_cached):
"""
When an imported or included XSD schema is located in the client's
cache, it should be read from there instead of fetching its data from
the client's document store or using its registered transport.
When it is is not located in the cache but can be found in the client's
document store, it should be fetched from there but not using the
client's registered transport.
Note that this test makes sense only when caching raw XML documents
(cachingpolicy == 0) and not when caching final WSDL objects
(cachingpolicy == 1).
"""
# Prepare document content.
xsd_target_namespace = "my xsd namespace"
wsdl = tests.wsdl('<xsd:%s schemaLocation="suds://external"/>' % (
external_reference_tag,),
xsd_target_namespace=xsd_target_namespace)
external_schema = suds.byte_str("""\
<?xml version='1.0' encoding='UTF-8'?>
<schema xmlns="http://www.w3.org/2001/XMLSchema">
<element name="external" type="string"/>
</schema>
""")
# Imported XSD schema items retain their namespace, while included ones
# get merged into the target namespace.
external_element_namespace = None
if external_reference_tag == "include":
external_element_namespace = xsd_target_namespace
external_element_id = ("external", external_element_namespace)
# Add to cache.
cache = MockCache()
store1 = MockDocumentStore(wsdl=wsdl, external=external_schema)
c1 = suds.client.Client("suds://wsdl", cachingpolicy=0,
cache=cache, documentStore=store1, transport=MockTransport())
assert [x for x, y in cache.mock_operation_log] == ["get", "put"] * 2
id_wsdl = cache.mock_operation_log[0][1][0]
assert id_wsdl == cache.mock_operation_log[1][1][0]
id_xsd = cache.mock_operation_log[2][1][0]
assert id_xsd == cache.mock_operation_log[3][1][0]
assert len(cache.mock_data) == 2
wsdl_document = cache.mock_data[id_wsdl]
assert c1.wsdl.root is wsdl_document.root()
# Making sure id_xsd refers to the actual external XSD is a bit tricky
# due to the fact that the WSDL object merged in the external XSD
# content and lost the reference to the external XSD object itself. As
# a workaround we make sure that the XSD schema XML element read from
# the XSD object cached as id_xsd matches the one read from the WSDL
# object's XSD schema.
xsd_imported_document = cache.mock_data[id_xsd]
cached_external_element = xsd_imported_document.root().children[0]
external_element = c1.wsdl.schema.elements[external_element_id].root
assert cached_external_element is external_element
# Make certain the same external XSD document is fetched from the cache
# and not using the document store or the transport.
cache.mock_operation_log = []
if main_WSDL_cached:
cache.mock_put_config = MockCache.FAIL
store2 = MockDocumentStore(mock_fail=True)
else:
del cache.mock_data[id_wsdl]
assert len(cache.mock_data) == 1
store2 = MockDocumentStore(wsdl=wsdl)
c2 = suds.client.Client("suds://wsdl", cachingpolicy=0, cache=cache,
documentStore=store2, transport=MockTransport())
expected_cache_operations = [("get", id_wsdl)]
if not main_WSDL_cached:
expected_cache_operations.append(("put", id_wsdl))
expected_cache_operations.append(("get", id_xsd))
cache_operations = [(x, y[0]) for x, y in cache.mock_operation_log]
assert cache_operations == expected_cache_operations
if not main_WSDL_cached:
assert store2.mock_log == ["suds://wsdl"]
assert len(cache.mock_data) == 2
assert cache.mock_data[id_xsd] is xsd_imported_document
external_element = c2.wsdl.schema.elements[external_element_id].root
assert cached_external_element is external_element
def test_default_transport(self):
client = tests.client_from_wsdl(tests.wsdl(""))
expected = suds.transport.https.HttpAuthenticated
assert client.options.transport.__class__ is expected
def test_translation(monkeypatch):
"""Python <--> XML representation translation on marshall/unmarshall."""
anObject = _Dummy()
class MockType(XBuiltin):
def __init__(self, *args, **kwargs):
self._mock_translate_log = []
super(MockType, self).__init__(*args, **kwargs)
def translate(self, value, topython=True):
self._mock_translate_log.append((value, topython))
if topython:
return anObject
return "'ollywood"
_monkeypatch_builtin_XSD_type_registry(monkeypatch)
Factory.maptag("woof", MockType)
namespace = "I'm a little tea pot, short and stout..."
wsdl = tests.wsdl("""\
<xsd:element name="wi" type="xsd:woof"/>
<xsd:element name="wo" type="xsd:woof"/>""",
input="wi",
output="wo",
xsd_target_namespace=namespace)
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
# Check suds library's XSD schema input parameter information.
schema = client.wsdl.schema
element_in = schema.elements["wi", namespace]
assert element_in.name == "wi"
element_out = schema.elements["wo", namespace]
assert element_out.name == "wo"
schema_object_in = element_in.resolve()
schema_object_out = element_out.resolve()
assert element_in is client.sd[0].params[0][0]
assert schema_object_in is client.sd[0].params[0][1]
assert schema_object_in.__class__ is MockType
assert schema_object_in._mock_translate_log == []
assert schema_object_out.__class__ is MockType
assert schema_object_out._mock_translate_log == []
# Construct operation invocation request - test marshalling.
request = client.service.f(55)
assert schema_object_in._mock_translate_log == [(55, False)]
assert schema_object_out._mock_translate_log == []
assert tests.compare_xml_string_to_string(
request.envelope, """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="%s"
xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:wi>'ollywood</ns0:wi>
</ns1:Body>
</SOAP-ENV:Envelope>""" % (namespace, ))
# Process operation response - test unmarshalling.
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<wo xmlns="%s">fri-fru</wo>
</env:Body>
</env:Envelope>""" % (namespace, ))))
assert response is anObject
assert schema_object_in._mock_translate_log == [(55, False)]
assert schema_object_out._mock_translate_log == [("fri-fru", True)]
def test_translation(monkeypatch):
"""Python <--> XML representation translation on marshall/unmarshall."""
anObject = _Dummy()
class MockType(XBuiltin):
def __init__(self, *args, **kwargs):
self._mock_translate_log = []
super(MockType, self).__init__(*args, **kwargs)
def translate(self, value, topython=True):
self._mock_translate_log.append((value, topython))
if topython:
return anObject
return "'ollywood"
_monkeypatch_builtin_XSD_type_registry(monkeypatch)
Factory.maptag("woof", MockType)
namespace = "I'm a little tea pot, short and stout..."
wsdl = tests.wsdl("""\
<xsd:element name="wi" type="xsd:woof"/>
<xsd:element name="wo" type="xsd:woof"/>""", input="wi", output="wo",
xsd_target_namespace=namespace)
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
# Check suds library's XSD schema input parameter information.
schema = client.wsdl.schema
element_in = schema.elements["wi", namespace]
assert element_in.name == "wi"
element_out = schema.elements["wo", namespace]
assert element_out.name == "wo"
schema_object_in = element_in.resolve()
schema_object_out = element_out.resolve()
assert element_in is client.sd[0].params[0][0]
assert schema_object_in is client.sd[0].params[0][1]
assert schema_object_in.__class__ is MockType
assert schema_object_in._mock_translate_log == []
assert schema_object_out.__class__ is MockType
assert schema_object_out._mock_translate_log == []
# Construct operation invocation request - test marshalling.
request = client.service.f(55)
assert schema_object_in._mock_translate_log == [(55, False)]
assert schema_object_out._mock_translate_log == []
assert tests.compare_xml_string_to_string(request.envelope, """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="%s"
xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:wi>'ollywood</ns0:wi>
</ns1:Body>
</SOAP-ENV:Envelope>""" % (namespace,))
# Process operation response - test unmarshalling.
response = client.service.f(__inject=dict(reply=suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<wo xmlns="%s">fri-fru</wo>
</env:Body>
</env:Envelope>""" % (namespace,))))
assert response is anObject
assert schema_object_in._mock_translate_log == [(55, False)]
assert schema_object_out._mock_translate_log == [("fri-fru", True)]
<faultstring>Dummy error.</faultstring>
<detail>
<errorcode>ultimate</errorcode>
</detail>
</env:Fault>
</env:Body>
</env:Envelope>
""")
_fault_reply__without_detail = suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<env:Fault>
<faultcode>env:Client</faultcode>
<faultstring>Dummy error.</faultstring>
</env:Fault>
</env:Body>
</env:Envelope>
""")
_wsdl__simple = tests.wsdl("""\
<xsd:element name="fResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="output_i" type="xsd:integer" />
<xsd:element name="output_s" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", output="fResponse")
def test_named_parameter():
class Tester:
def __init__(self, service, expected_xml):
self.service = service
self.expected_xml = expected_xml
def test(self, *args, **kwargs):
request = self.service.f(*args, **kwargs)
assert _compare_request(request, self.expected_xml)
# Test different ways to make the same web service operation call.
service = _service_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="uno" type="xsd:string"/>
<xsd:element name="due" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", input="Wrapper", xsd_target_namespace="qwerty"))
t = Tester(service, """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="qwerty" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:uno>einz</ns0:uno>
<ns0:due>zwei</ns0:due>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
t.test("einz", "zwei")
t.test(uno="einz", due="zwei")
t.test(due="zwei", uno="einz")
t.test("einz", due="zwei")
# The order of parameters in the constructed SOAP request should depend
# only on the initial WSDL schema.
service = _service_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="due" type="xsd:string"/>
<xsd:element name="uno" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", input="Wrapper", xsd_target_namespace="abracadabra"))
t = Tester(service, """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="abracadabra" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:due>zwei</ns0:due>
<ns0:uno>einz</ns0:uno>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
t.test("zwei", "einz")
t.test(uno="einz", due="zwei")
t.test(due="zwei", uno="einz")
t.test("zwei", uno="einz")
def test_optional_parameter_handling():
"""Missing optional parameters should not get passed at all."""
service = _service_from_wsdl(tests.wsdl("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="aString" type="xsd:string" minOccurs="0"/>
<xsd:element name="anInteger" type="xsd:integer" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", input="Wrapper", xsd_target_namespace="RoOfIe"))
assert _compare_request(service.f(), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="RoOfIe" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper/>
</ns1:Body>
</SOAP-ENV:Envelope>""")
# None is treated as an undefined value.
assert _compare_request(service.f(None), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="RoOfIe" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper/>
</ns1:Body>
</SOAP-ENV:Envelope>""")
# Empty string values are treated as well defined values.
assert _compare_request(service.f(""), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="RoOfIe" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString></ns0:aString>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
assert _compare_request(service.f("Kiflica"), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="RoOfIe" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString>Kiflica</ns0:aString>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
assert _compare_request(service.f(anInteger=666), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="RoOfIe" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:anInteger>666</ns0:anInteger>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
assert _compare_request(service.f("Alfa", 9), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="RoOfIe" xmlns:ns1="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Header/>
<ns1:Body>
<ns0:Wrapper>
<ns0:aString>Alfa</ns0:aString>
<ns0:anInteger>9</ns0:anInteger>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""")
def client(xsd, *input):
wsdl = tests.wsdl(xsd, input=input, xsd_target_namespace="toolyan")
return tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
<detail>
<errorcode>ultimate</errorcode>
</detail>
</env:Fault>
</env:Body>
</env:Envelope>
""")
_fault_reply__without_detail = suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
<env:Body>
<env:Fault>
<faultcode>env:Client</faultcode>
<faultstring>Dummy error.</faultstring>
</env:Fault>
</env:Body>
</env:Envelope>
""")
_wsdl__simple = tests.wsdl("""\
<xsd:element name="fResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="output_i" type="xsd:integer" />
<xsd:element name="output_s" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""",
output="fResponse")