# -*- coding: utf-8 -*-
# This program is free software; you can redistribute it and/or modify it under
# the terms of the (LGPL) GNU Lesser General Public License as published by the
# Free Software Foundation; either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Library Lesser General Public License
# for more details at ( http://www.gnu.org/licenses/lgpl.html ).
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# written by: Jurko Gospodnetić ( jurko.gospodnetic@pke.hr )
"""
Suds Python library request construction related unit tests.
Suds provides the user with an option to automatically 'hide' wrapper elements
around simple types and allow the user to specify such parameters without
explicitly creating those wrappers. For example: function taking a parameter of
type X, where X is a sequence containing only a single simple data type (e.g.
string or integer) will be callable by directly passing it that internal simple
data type value instead of first wrapping that value in an object of type X and
then passing that wrapper object instead.
"""
if __name__ == "__main__":
from . import __init__
__init__.runUsingPyTest(globals())
import suds
import suds.store
import tests
import pytest
# TODO: Update the current restriction type output parameter handling so such
# parameters get converted to the correct Python data type based on the
# restriction's underlying data type.
@pytest.mark.xfail
def test_bare_input_restriction_types():
client_unnamed = tests.client_from_wsdl(tests.wsdl_input("""\
""", "Elemento"))
client_named = tests.client_from_wsdl(tests.wsdl_input("""\
""", "Elemento"))
assert not _isInputWrapped(client_unnamed, "f")
assert not _isInputWrapped(client_named, "f")
def parametrize_single_element_input_test(param_names, param_values):
"""
Define different parametrized single element input test function calls.
Parameter value input is a tuple containing 2+ parameters:
* 1. element - input XSD element definition
* 2. element - input element name
* 3+ elements - tuples containing the following:
* position argument list for the invoked test web service operation
* expected request body content for the given arguments
* [optional] reason for marking this test case as expected to fail
"""
mark = pytest
expanded_param_values = []
for param_value in param_values:
xsd, external_element_name = param_value[0:2]
for next_value in param_value[2:]:
assert len(next_value) in (2, 3)
args, request_body = next_value[:2]
xfail = len(next_value) == 3
param = (xsd, external_element_name, args, request_body)
if xfail:
param = pytest.mark.xfail(param, reason=next_value[2])
expanded_param_values.append(param)
return (param_names, expanded_param_values), {}
@pytest.mark.indirect_parametrize(parametrize_single_element_input_test,
("xsd", "external_element_name", "args", "request_body"), (
# Bare non-optional element.
('', "a",
([], ""),
([5], "5")),
# Bare optional element.
('', "a",
([], ""),
([5], "5")),
# Choice with a non-empty sub-sequence.
("""\
""", "Wrapper",
([], "",
"non-optional choice handling buggy"),
([5], "5"),
([None, 1], "1",
"non-optional choice handling buggy"),
([None, 1, 2],
"12"),
([None, None, 1],
"1",
"non-optional choice handling buggy")),
# Choice with a non-optional element.
("""\
""", "Wrapper",
([], "",
"non-optional choice handling buggy"),
([5], "5")),
# Choice with an optional element.
("""\
""", "Wrapper",
([], ""),
([5], "5")),
# Choices with multiple elements, at least one of which is optional.
("""\
""", "Wrapper",
([], ""),
([5], "5"),
([None, 5], "5")),
("""\
""", "Wrapper",
([], ""),
([5], "5"),
([None, 5], "5")),
("""\
""", "Wrapper",
([], ""),
([5], "5"),
([None, 5], "5")),
# Choice with multiple non-empty sub-sequences.
("""\
""", "Wrapper",
([], "",
"non-optional choice handling buggy"),
([5], "5",
"non-optional choice handling buggy"),
([5, 9], """\
5
9
"""),
([None, 1], "1",
"non-optional choice handling buggy"),
([None, None, 1],
"1",
"non-optional choice handling buggy"),
([None, None, 1, 2],
"12"),
([None, None, None, 1],
"1",
"non-optional choice handling buggy")),
# Empty choice.
("""\
""", "Wrapper",
([], "")),
# Empty sequence.
("""\
""", "Wrapper",
([], "")),
# Optional choice.
("""\
""", "Wrapper",
([], "",
# This test passes by accident - the following two bugs seem to
# cancel each other out:
# - choice order indicators explicitly marked optional unsupported
# - not constructing correct input parameter values when using no
# input arguments for a choice
#"suds does not yet support minOccurs/maxOccurs attributes on "
#"all/choice/sequence order indicators"
),
([5], "5"),
([None, 1],
"1")),
# Optional sequence.
("""\
""", "Wrapper",
([], "",
"suds does not yet support minOccurs/maxOccurs attributes on all/"
"choice/sequence order indicators"),
([5], "5"),
([None, 1],
"1"),
([1, 2], """\
1
2
""")),
# Sequence with a non-empty sub-sequence.
("""\
""", "Wrapper",
([], ""),
([5], "5"),
([None, 1],
"1"),
([None, 1, 2], """\
1
2
"""),
([None, None, 1],
"1")),
# Sequence with a non-optional element.
("""\
""", "Wrapper",
([], ""),
([5], "5")),
# Sequence with an optional element.
("""\
""", "Wrapper",
([], ""),
([5], "5")),
# Sequence with multiple consecutive choices.
("""\
""", "Wrapper",
([], "",
"non-optional choice handling buggy"),
([5], "5"),
([None, 1, 2], """\
1
2
"""),
([None, 1, None, 2], """\
1
2
""")),
# Sequence with multiple optional elements.
("""\
""", "Wrapper",
([], ""),
([5], "5"),
([None, 1], "1"),
([5, 1],
"51")),
))
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), """\
%s
""" % (request_body,))
def test_disabling_automated_simple_interface_unwrapping():
client = tests.client_from_wsdl(tests.wsdl_input("""\
""", "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), """\
Wonderwall
""")
def test_element_references_to_different_namespaces():
wsdl = suds.byte_str("""\
""")
external_schema = suds.byte_str("""\
""")
store = suds.store.DocumentStore(external_schema=external_schema,
wsdl=wsdl)
client = suds.client.Client("suds://wsdl", cache=None, documentStore=store,
nosend=True, prettyxml=True)
assert _compare_request(client.service.f(local="--L--",
local_referenced="--LR--", external="--E--"), """\
--L--
--LR--
--E--
""")
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.
"""
client = tests.client_from_wsdl(tests.wsdl_input("""\
""", "Wrapper"), 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()), """\
Some string representation.
""")
# Passing a value of a WSDL schema defined type.
value = client.factory.create("Freakazoid")
value.freak1 = "Tiny"
value.freak2 = "Miny"
value.freak3 = "Mo"
assert _compare_request(client.service.f(anInteger=value), """\
Tiny
Miny
Mo
""")
def test_missing_parameters():
"""Missing non-optional parameters should get passed as empty values."""
service = _service_from_wsdl(tests.wsdl_input("""\
""", "Wrapper"))
assert _compare_request(service.f(), """\
""")
assert _compare_request(service.f("Pero Ždero"), """\
Pero Ždero
""")
assert _compare_request(service.f(anInteger=666), """\
666
""")
# None value is treated the same as undefined.
assert _compare_request(service.f(aString=None, anInteger=666), """\
666
""")
assert _compare_request(service.f(aString="Omega", anInteger=None), """\
Omega
""")
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_input("""\
""", "Wrapper"))
t = Tester(service, """\
einz
zwei
""")
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_input("""\
""", "Wrapper"))
t = Tester(service, """\
zwei
einz
""")
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_input("""\
""", "Wrapper"))
assert _compare_request(service.f(), """\
""")
# None is treated as an undefined value.
assert _compare_request(service.f(None), """\
""")
# Empty string values are treated as well defined values.
assert _compare_request(service.f(""), """\
""")
assert _compare_request(service.f("Kiflica"), """\
Kiflica
""")
assert _compare_request(service.f(anInteger=666), """\
666
""")
assert _compare_request(service.f("Alfa", 9), """\
Alfa
9
""")
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("""\
""", "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 = """\
%s
""" % (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_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("""\
""", "Elemento")
client_bare_multiple_simple = client("""\
""", "Elemento1",
"Elemento2")
client_bare_multiple_wrapped = client("""\
""", "Elemento1",
"Elemento2")
client_wrapped_unnamed = client("""\
""", "Wrapper")
client_wrapped_named = client("""\
""", "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), """\
%s
""" % data)
expected_xml = """\
%s
""" % 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), """\
%s
%s
""" % data)
assert _compare_request(call_multiple(client_bare_multiple_wrapped), """\
%s
%s
""" % data)
def _compare_request(request, expected_xml):
return tests.compare_xml_to_string(request.original_envelope, expected_xml)
def _isInputWrapped(client, method_name):
assert len(client.wsdl.bindings) == 1
operation = list(client.wsdl.bindings.values())[0].operations[method_name]
return operation.soap.input.body.wrapped
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