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)