def test_bare_input_restriction_types():
client_unnamed = tests.client_from_wsdl(
tests.wsdl_input(
"""\
<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>""", "Elemento"))
client_named = tests.client_from_wsdl(
tests.wsdl_input(
"""\
<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"/>""", "Elemento"))
assert not _isInputWrapped(client_unnamed, "f")
assert not _isInputWrapped(client_named, "f")
def test_fault_reply_with_unicode_faultstring(monkeypatch):
monkeypatch.delitem(locals(), "e", False)
unicode_string = "€ Jurko Gospodnetić ČĆŽŠĐčćžšđ"
fault_xml = 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>%s</faultstring>
</env:Fault>
</env:Body>
</env:Envelope>
""" % unicode_string)
client = tests.client_from_wsdl(_wsdl__simple, faults=True)
inject = dict(reply=fault_xml, status=http.client.INTERNAL_SERVER_ERROR)
e = pytest.raises(suds.WebFault, client.service.f, __inject=inject).value
assert e.fault.faultstring == unicode_string
assert e.document.__class__ is suds.sax.document.Document
client = tests.client_from_wsdl(_wsdl__simple, faults=False)
status, fault = client.service.f(__inject=dict(reply=fault_xml,
status=http.client.INTERNAL_SERVER_ERROR))
assert status == http.client.INTERNAL_SERVER_ERROR
assert fault.faultstring == unicode_string
def test_restriction_data_types():
client_unnamed = tests.client_from_wsdl(
tests.wsdl_output(
"""\
<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>""", "Elemento"))
client_named = tests.client_from_wsdl(
tests.wsdl_output(
"""\
<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" />""", "Elemento"))
client_twice_restricted = tests.client_from_wsdl(
tests.wsdl_output(
"""\
<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" />""", "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_output(
"""\
<xsd:element name="fResponse" type="xsd:string" />""", "fResponse"))
client_wrapped = tests.client_from_wsdl(
tests.wsdl_output(
"""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="fResponse" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", "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_output("""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", "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_reply_error_with_detail_without_fault():
client = tests.client_from_wsdl(_wsdl__simple, faults=False)
for http_status in (http.client.OK, http.client.INTERNAL_SERVER_ERROR):
status, fault = client.service.f(
__inject=dict(reply=_fault_reply__with_detail, status=http_status))
assert status == http.client.INTERNAL_SERVER_ERROR
_test_fault(fault, True)
status, fault = client.service.f(__inject=dict(
reply=_fault_reply__with_detail, status=http.client.BAD_REQUEST))
assert status == http.client.BAD_REQUEST
assert fault == "injected reply"
status, fault = client.service.f(
__inject=dict(reply=_fault_reply__with_detail,
status=http.client.BAD_REQUEST,
description="haleluja"))
assert status == http.client.BAD_REQUEST
assert fault == "haleluja"
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_output(
"""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="fResponse" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", "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_invalid_fault_namespace(monkeypatch):
monkeypatch.delitem(locals(), "e", False)
fault_xml = suds.byte_str("""\
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:p="x">
<env:Body>
<p:Fault>
<faultcode>env:Client</faultcode>
<faultstring>Dummy error.</faultstring>
<detail>
<errorcode>ultimate</errorcode>
</detail>
</p:Fault>
</env:Body>
</env:Envelope>
""")
client = tests.client_from_wsdl(_wsdl__simple, faults=False)
inject = dict(reply=fault_xml, status=http.client.OK)
e = pytest.raises(Exception, client.service.f, __inject=inject).value
assert e.__class__ is Exception
assert str(e) == "<faultcode/> not mapped to message part"
for http_status in (http.client.INTERNAL_SERVER_ERROR,
http.client.PAYMENT_REQUIRED):
status, reason = client.service.f(__inject=dict(reply=fault_xml,
status=http_status, description="trla baba lan"))
assert status == http_status
assert reason == "trla baba lan"
def test_disabling_automated_simple_interface_unwrapping():
client = tests.client_from_wsdl(tests.wsdl_input(
"""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", "Wrapper"),
nosend=True,
prettyxml=True,
unwrap=False)
assert not _isInputWrapped(client, "f")
wrapper = client.factory.create("Wrapper")
wrapper.Elemento = "Wonderwall"
assert _compare_request(
client.service.f(Wrapper=wrapper), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="my-namespace" 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_twice_wrapped_parameter():
"""
Suds does not recognize 'twice wrapped' data structures and unwraps the
external one but keeps the internal wrapping structure in place.
"""
client = tests.client_from_wsdl(tests.wsdl_input(
"""\
<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>""", "Wrapper1"),
nosend=True,
prettyxml=True)
assert _isInputWrapped(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="my-namespace" 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 = list(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_reply_error_without_detail_with_fault(monkeypatch):
monkeypatch.delitem(locals(), "e", False)
client = tests.client_from_wsdl(_wsdl__simple, faults=True)
for http_status in (http.client.OK, http.client.INTERNAL_SERVER_ERROR):
inject = dict(reply=_fault_reply__without_detail, status=http_status)
e = pytest.raises(suds.WebFault, client.service.f, __inject=inject)
e = e.value
_test_fault(e.fault, False)
assert e.document.__class__ is suds.sax.document.Document
assert str(e) == "Server raised fault: 'Dummy error.'"
inject = dict(reply=_fault_reply__with_detail,
status=http.client.BAD_REQUEST,
description="quack-quack")
e = pytest.raises(Exception, client.service.f, __inject=inject).value
assert e.__class__ is Exception
assert e.args[0][0] == http.client.BAD_REQUEST
assert e.args[0][1] == "quack-quack"
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_badly_formed_reply_XML():
for faults in (True, False):
client = tests.client_from_wsdl(_wsdl__simple, faults=faults)
pytest.raises(xml.sax.SAXParseException,
client.service.f,
__inject={"reply": suds.byte_str("bad food")})
def _service_from_wsdl(wsdl):
"""
Construct a suds Client service instance used in tests in this module.
The constructed Client instance only prepares web service operation
invocation requests and does not attempt to actually send them.
"""
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
return client.service
def test_ACCEPTED_and_NO_CONTENT_status_reported_as_None_without_faults():
client = tests.client_from_wsdl(_wsdl__simple, faults=False)
f = lambda r, s : client.service.f(__inject={"reply":suds.byte_str(r),
"status":s})
assert f("", None) is not None
assert f("", http.client.INTERNAL_SERVER_ERROR) is not None
assert f("", http.client.ACCEPTED) is None
assert f("", http.client.NO_CONTENT) is None
assert f("bla-bla", http.client.ACCEPTED) is None
assert f("bla-bla", http.client.NO_CONTENT) is None
def test_binding_uses_argument_parsing(monkeypatch, binding_style):
"""
Calling web service operations should use the generic argument parsing
functionality independent of the operation's specific binding style.
"""
class MyException(Exception):
pass
def raise_exception(*args, **kwargs):
raise MyException
monkeypatch.setattr(suds.argparser._ArgParser, "__init__", raise_exception)
wsdl = suds.byte_str("""\
<?xml version='1.0' encoding='UTF-8'?>
<wsdl:definitions targetNamespace="my-namespace"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:ns="my-namespace"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xsd:schema targetNamespace="my-namespace"
elementFormDefault="qualified"
attributeFormDefault="unqualified"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="Bongo" type="xsd:string" />
</xsd:schema>
</wsdl:types>
<wsdl:message name="fRequestMessage">"
<wsdl:part name="parameters" element="ns:Bongo" />
</wsdl:message>
<wsdl:portType name="dummyPortType">
<wsdl:operation name="f">
<wsdl:input message="ns:fRequestMessage" />
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="dummy" type="ns:dummyPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="f">
<soap:operation soapAction="my-soap-action" style="%s" />
<wsdl:input><soap:body use="literal" /></wsdl:input>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="dummy">
<wsdl:port name="dummy" binding="ns:dummy">
<soap:address location="unga-bunga-location" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
""" % (binding_style, ))
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
pytest.raises(MyException, client.service.f)
pytest.raises(MyException, client.service.f, "x")
pytest.raises(MyException, client.service.f, "x", "y")
def test_document_literal_request_for_single_element_input(xsd,
external_element_name, args, request_body):
wsdl = tests.wsdl_input(xsd, external_element_name)
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="my-namespace" 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_builtin_typed_element_parameter(part_name):
"""
Test correctly recognizing web service operation input structure defined by
a built-in typed element.
"""
wsdl = suds.byte_str("""\
<?xml version='1.0' encoding='UTF-8'?>
<wsdl:definitions targetNamespace="my-namespace"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:ns="my-namespace"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xsd:schema targetNamespace="my-namespace"
elementFormDefault="qualified"
attributeFormDefault="unqualified"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="MyElement" type="xsd:integer" />
</xsd:schema>
</wsdl:types>
<wsdl:message name="fRequestMessage">
<wsdl:part name="%s" element="ns:MyElement" />
</wsdl:message>
<wsdl:portType name="dummyPortType">
<wsdl:operation name="f">
<wsdl:input message="ns:fRequestMessage" />
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="dummy" type="ns:dummyPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="f">
<soap:operation soapAction="my-soap-action" style="document" />
<wsdl:input><soap:body use="literal" /></wsdl:input>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="dummy">
<wsdl:port name="dummy" binding="ns:dummy">
<soap:address location="unga-bunga-location" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>""" % (part_name, ))
client = tests.client_from_wsdl(wsdl, nosend=True)
# Collect references to required WSDL model content.
method = client.wsdl.services[0].ports[0].methods["f"]
assert not method.soap.input.body.wrapped
binding = method.binding.input
assert binding.__class__ is suds.bindings.document.Document
my_element = client.wsdl.schema.elements["MyElement", "my-namespace"]
param_defs = binding.param_defs(method)
_expect_params(param_defs, [("MyElement", my_element)])
def test_ACCEPTED_and_NO_CONTENT_status_reported_as_None_with_faults():
client = tests.client_from_wsdl(_wsdl__simple, faults=True)
f = lambda r, s: client.service.f(__inject={
"reply": suds.byte_str(r),
"status": s
})
assert f("", None) is None
pytest.raises(Exception, f, "", httplib.INTERNAL_SERVER_ERROR)
assert f("", httplib.ACCEPTED) is None
assert f("", httplib.NO_CONTENT) is None
assert f("bla-bla", httplib.ACCEPTED) is None
assert f("bla-bla", httplib.NO_CONTENT) is None
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_unwrapped_parameter(xsd_type):
"""Test recognizing unwrapped web service operation input structures."""
input_schema = sequence_choice_with_element_and_two_element_sequence.xsd
wsdl = _unwrappable_wsdl("part_name", input_schema)
client = tests.client_from_wsdl(wsdl, nosend=True)
# Collect references to required WSDL model content.
method = client.wsdl.services[0].ports[0].methods["f"]
assert method.soap.input.body.wrapped
binding = method.binding.input
assert binding.__class__ is suds.bindings.document.Document
wrapper = client.wsdl.schema.elements["Wrapper", "my-namespace"]
# Construct expected parameter definitions.
xsd_map = sequence_choice_with_element_and_two_element_sequence.xsd_map
expected_param_defs = _parse_schema_model(wrapper, xsd_map)
param_defs = binding.param_defs(method)
_expect_params(param_defs, expected_param_defs)
def test_explicitly_wrapped_parameter(part_name):
"""
Test correctly recognizing explicitly wrapped web service operation input
structure which would otherwise be automatically unwrapped.
"""
input_schema = sequence_choice_with_element_and_two_element_sequence.xsd
wsdl = _unwrappable_wsdl(part_name, input_schema)
client = tests.client_from_wsdl(wsdl, nosend=True, unwrap=False)
# Collect references to required WSDL model content.
method = client.wsdl.services[0].ports[0].methods["f"]
assert not method.soap.input.body.wrapped
binding = method.binding.input
assert binding.__class__ is suds.bindings.document.Document
wrapper = client.wsdl.schema.elements["Wrapper", "my-namespace"]
param_defs = binding.param_defs(method)
_expect_params(param_defs, [("Wrapper", wrapper)])
def test_empty_reply():
client = tests.client_from_wsdl(_wsdl__simple, faults=False)
f = lambda status=None, description=None : client.service.f(__inject=dict(
reply=suds.byte_str(), status=status, description=description))
status, reason = f()
assert status == http.client.OK
assert reason is None
status, reason = f(http.client.OK)
assert status == http.client.OK
assert reason is None
status, reason = f(http.client.INTERNAL_SERVER_ERROR)
assert status == http.client.INTERNAL_SERVER_ERROR
assert reason == 'injected reply'
status, reason = f(http.client.FORBIDDEN)
assert status == http.client.FORBIDDEN
assert reason == 'injected reply'
status, reason = f(http.client.FORBIDDEN, "kwack")
assert status == http.client.FORBIDDEN
assert reason == 'kwack'
def test_binding_for_an_operation_with_no_input_uses_argument_parsing(
monkeypatch, binding_style):
"""
Calling web service operations should use the generic argument parsing
functionality independent of the operation's specific binding style.
"""
class MyException(Exception):
pass
def raise_exception(*args, **kwargs):
raise MyException
monkeypatch.setattr(suds.argparser._ArgParser, "__init__", raise_exception)
wsdl = suds.byte_str("""\
<?xml version='1.0' encoding='UTF-8'?>
<wsdl:definitions targetNamespace="my-namespace"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:ns="my-namespace"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:portType name="dummyPortType">
<wsdl:operation name="f" />
</wsdl:portType>
<wsdl:binding name="dummy" type="ns:dummyPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="f">
<soap:operation soapAction="my-soap-action" style="%s" />
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="dummy">
<wsdl:port name="dummy" binding="ns:dummy">
<soap:address location="unga-bunga-location" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
""" % (binding_style, ))
client = tests.client_from_wsdl(wsdl, nosend=True, prettyxml=True)
pytest.raises(MyException, client.service.f)
pytest.raises(MyException, client.service.f, "x")
pytest.raises(MyException, client.service.f, "x", "y")
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_output(
"""\
<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>""", "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_typed_parameters(param_names):
"""
Test correctly recognizing web service operation input structure defined
with 0 or more typed input message part parameters.
"""
wsdl = [
"""\
<?xml version='1.0' encoding='UTF-8'?>
<wsdl:definitions targetNamespace="my-namespace"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:ns="my-namespace"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xsd:schema targetNamespace="my-namespace"
elementFormDefault="qualified"
attributeFormDefault="unqualified"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:complexType name="MyType">
<xsd:sequence>
<xsd:element name="a" type="xsd:integer" />
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
</wsdl:types>
<wsdl:message name="fRequestMessage">"""
]
for x in param_names:
part_def = '\n <wsdl:part name="%s" type="ns:MyType" />' % (x, )
wsdl.append(part_def)
wsdl.append("""
</wsdl:message>
<wsdl:portType name="dummyPortType">
<wsdl:operation name="f">
<wsdl:input message="ns:fRequestMessage" />
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="dummy" type="ns:dummyPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="f">
<soap:operation soapAction="my-soap-action" style="document" />
<wsdl:input><soap:body use="literal" /></wsdl:input>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="dummy">
<wsdl:port name="dummy" binding="ns:dummy">
<soap:address location="unga-bunga-location" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>""")
wsdl = suds.byte_str("".join(wsdl))
client = tests.client_from_wsdl(wsdl, nosend=True)
# Collect references to required WSDL model content.
method = client.wsdl.services[0].ports[0].methods["f"]
assert not method.soap.input.body.wrapped
binding = method.binding.input
assert binding.__class__ is suds.bindings.document.Document
my_type = client.wsdl.schema.types["MyType", "my-namespace"]
# Construct expected parameter definitions.
expected_param_defs = [
(param_name, [suds.bindings.binding.PartElement, param_name, my_type])
for param_name in param_names
]
param_defs = binding.param_defs(method)
_expect_params(param_defs, expected_param_defs)
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_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_wrapped_parameter(monkeypatch):
monkeypatch.delitem(locals(), "e", False)
# Prepare web service proxies.
client = lambda *args: tests.client_from_wsdl(
tests.wsdl_input(*args), nosend=True, prettyxml=True)
client_bare_single = client(
"""\
<xsd:element name="Elemento" type="xsd:string"/>""", "Elemento")
client_bare_multiple_simple = client(
"""\
<xsd:element name="Elemento1" type="xsd:string"/>
<xsd:element name="Elemento2" type="xsd:string"/>""", "Elemento1",
"Elemento2")
client_bare_multiple_wrapped = client(
"""\
<xsd:complexType name="Wrapper">
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="Elemento1" type="ns:Wrapper"/>
<xsd:element name="Elemento2" type="ns:Wrapper"/>""", "Elemento1",
"Elemento2")
client_wrapped_unnamed = client(
"""\
<xsd:element name="Wrapper">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>""", "Wrapper")
client_wrapped_named = client(
"""\
<xsd:complexType name="WrapperType">
<xsd:sequence>
<xsd:element name="Elemento" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="Wrapper" type="ns:WrapperType"/>""", "Wrapper")
# Make sure suds library interprets our WSDL definitions as wrapped or
# bare input interfaces as expected.
assert not _isInputWrapped(client_bare_single, "f")
assert not _isInputWrapped(client_bare_multiple_simple, "f")
assert not _isInputWrapped(client_bare_multiple_wrapped, "f")
assert _isInputWrapped(client_wrapped_unnamed, "f")
assert _isInputWrapped(client_wrapped_named, "f")
# Both bare & wrapped single parameter input web service operations get
# called the same way even though the wrapped one actually has an extra
# wrapper element around its input data.
data = "Maestro"
call_single = lambda c: c.service.f(data)
assert _compare_request(
call_single(client_bare_single), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="my-namespace" 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:Elemento>%s</ns0:Elemento>
</ns1:Body>
</SOAP-ENV:Envelope>""" % data)
expected_xml = """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="my-namespace" 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>%s</ns0:Elemento>
</ns0:Wrapper>
</ns1:Body>
</SOAP-ENV:Envelope>""" % data
assert _compare_request(call_single(client_wrapped_unnamed), expected_xml)
assert _compare_request(call_single(client_wrapped_named), expected_xml)
# Suds library's automatic structure unwrapping prevents us from
# specifying the external wrapper structure directly.
e = pytest.raises(TypeError, client_wrapped_unnamed.service.f, Wrapper="A")
assert str(e.value) == "f() got an unexpected keyword argument 'Wrapper'"
# Multiple parameter web service operations are never automatically
# unwrapped.
data = ("Unga", "Bunga")
call_multiple = lambda c: c.service.f(*data)
assert _compare_request(
call_multiple(client_bare_multiple_simple), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="my-namespace" 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:Elemento1>%s</ns0:Elemento1>
<ns0:Elemento2>%s</ns0:Elemento2>
</ns1:Body>
</SOAP-ENV:Envelope>""" % data)
assert _compare_request(
call_multiple(client_bare_multiple_wrapped), """\
<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope xmlns:ns0="my-namespace" 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:Elemento1>%s</ns0:Elemento1>
<ns0:Elemento2>%s</ns0:Elemento2>
</ns1:Body>
</SOAP-ENV:Envelope>""" % data)