def test_mime_content_serialize_xml():
wsdl = stub(schema=stub(_prefix_map={}))
operation = stub(location='my-action', name='foo')
element_1 = xsd.Element('arg1', xsd.ComplexType([
xsd.Element('arg1_1', xsd.String())
]))
element_2 = xsd.Element('arg2', xsd.String())
abstract_message = definitions.AbstractMessage(
etree.QName('{http://test.python-zeep.org/tests/msg}Method'))
abstract_message.parts = OrderedDict([
('xarg1', definitions.MessagePart(element=element_1, type=None)),
('xarg2', definitions.MessagePart(element=element_2, type=None)),
])
msg = messages.MimeContent(
wsdl=wsdl, name=None, operation=operation, content_type='text/xml',
part_name=None)
msg._info = {
'body': {'namespace': 'http://test.python-zeep.org/tests/rpc'},
'header': None,
'headerfault': None
}
msg.resolve(wsdl, abstract_message)
serialized = msg.serialize(xarg1={'arg1_1': 'uh'}, xarg2='bla')
assert serialized.headers == {
'Content-Type': 'text/xml'
}
assert serialized.path == 'my-action'
assert_nodes_equal(
load_xml(serialized.content),
load_xml(
"<foo><xarg1><arg1_1>uh</arg1_1></xarg1><xarg2>bla</xarg2></foo>"))
def test_rpc_message_parse():
xmlelement = load_xml("""
<input
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<soap:body use="encoded" namespace="http://tests.python-zeep.org/rpc"
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
</input>
""")
operation = stub(name='Operation')
definitions_ = stub(
target_namespace='',
messages={},
wsdl=stub())
msg = messages.RpcMessage.parse(
definitions=definitions_,
xmlelement=xmlelement,
operation=operation,
nsmap={},
type='input')
abstract_body = definitions.AbstractMessage(
etree.QName('{http://test.python-zeep.org/tests/msg}Input'))
abstract_body.parts['arg1'] = definitions.MessagePart(
element=None, type=xsd.String())
abstract_body.parts['arg2'] = definitions.MessagePart(
element=None, type=xsd.String())
msg.resolve(definitions_, abstract_body)
assert msg.headerfault is None
assert msg.header is None
assert msg.body is not None
def test_document_message_parse_with_header():
xmlelement = load_xml("""
<input
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:tns="http://tests.python-zeep.org/tns">
<soap:header message="tns:Input" part="authentication" use="literal" />
<soap:body use="literal"/>
</input>
""")
operation = stub()
definitions_ = stub(target_namespace='', messages={}, wsdl=stub())
msg = messages.DocumentMessage.parse(definitions=definitions_,
xmlelement=xmlelement,
operation=operation,
nsmap={})
abstract_message = definitions.AbstractMessage(
etree.QName('{http://tests.python-zeep.org/tns}Input'))
abstract_message.parts['params'] = definitions.MessagePart(
element=xsd.Element(etree.QName('input'), xsd.String()), type=None)
abstract_message.parts['authentication'] = definitions.MessagePart(
element=xsd.Element(etree.QName('authentication'), xsd.String()),
type=None)
definitions_.messages[abstract_message.name.text] = abstract_message
msg.resolve(definitions_, abstract_message)
assert msg.headerfault is None
assert msg.header == abstract_message.parts['authentication'].element
assert msg.body == abstract_message.parts['params'].element
assert len(abstract_message.parts.values()) == 2
def abstract_message_input():
abstract = definitions.AbstractMessage(
etree.QName('{http://test.python-zeep.org/tests/msg}Method'))
abstract.parts = OrderedDict([
('arg1', definitions.MessagePart(element=None, type=xsd.String())),
('arg2', definitions.MessagePart(element=None, type=xsd.String())),
])
return abstract
def parse_abstract_message(wsdl, xmlelement):
"""Create an AbstractMessage object from a xml element.
<definitions .... >
<message name="nmtoken"> *
<part name="nmtoken" element="qname"? type="qname"?/> *
</message>
</definitions>
"""
tns = wsdl.target_namespace
parts = []
for part in xmlelement.findall('wsdl:part', namespaces=NSMAP):
part_name = part.get('name')
part_element = qname_attr(part, 'element', tns)
part_type = qname_attr(part, 'type', tns)
if part_element is not None:
part_element = wsdl.types.get_element(part_element)
if part_type is not None:
part_type = wsdl.types.get_type(part_type)
part = definitions.MessagePart(part_element, part_type)
parts.append((part_name, part))
# Create the object, add the parts and return it
message_name = qname_attr(xmlelement, 'name', tns)
msg = definitions.AbstractMessage(message_name)
for part_name, part in parts:
msg.add_part(part_name, part)
return msg
def test_document_message_parse():
xmlelement = load_xml("""
<input
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<soap:body use="literal"/>
</input>
""")
operation = stub()
definitions_ = stub(
target_namespace='',
messages={},
wsdl=stub())
msg = messages.DocumentMessage.parse(
definitions=definitions_,
xmlelement=xmlelement,
operation=operation,
nsmap={},
type='input')
abstract_body = definitions.AbstractMessage(
etree.QName('{http://test.python-zeep.org/tests/msg}Input'))
abstract_body.parts['params'] = definitions.MessagePart(
element=xsd.Element(etree.QName('input'), xsd.String()),
type=None)
msg.resolve(definitions_, abstract_body)
assert msg.headerfault is None
assert msg.header is None
assert msg.body == abstract_body.parts['params'].element
def abstract_message_output():
abstract = definitions.AbstractMessage(
etree.QName('{http://test.python-zeep.org/tests/msg}Response'))
abstract.parts = OrderedDict([
('result', definitions.MessagePart(element=None, type=xsd.String())),
])
return abstract
def parse_abstract_message(
wsdl, xmlelement: etree._Element) -> definitions.AbstractMessage:
"""Create an AbstractMessage object from a xml element.
Definition::
<definitions .... >
<message name="nmtoken"> *
<part name="nmtoken" element="qname"? type="qname"?/> *
</message>
</definitions>
:param wsdl: The parent definition instance
:type wsdl: zeep.wsdl.wsdl.Definition
:param xmlelement: The XML node
:type xmlelement: lxml.etree._Element
:rtype: zeep.wsdl.definitions.AbstractMessage
"""
tns = wsdl.target_namespace
message_name = qname_attr(xmlelement, "name", tns)
if not message_name:
raise IncompleteMessage(
"Message element is missing required name attribute")
parts = []
for part in xmlelement.findall("wsdl:part", namespaces=NSMAP):
part_name = part.get("name")
part_element = qname_attr(part, "element")
part_type = qname_attr(part, "type")
try:
if part_element is not None:
part_element = wsdl.types.get_element(part_element)
if part_type is not None:
part_type = wsdl.types.get_type(part_type)
except (NamespaceError, LookupError):
raise IncompleteMessage(
("The wsdl:message for %r contains an invalid part (%r): "
"invalid xsd type or elements") %
(message_name.text, part_name))
part = definitions.MessagePart(part_element, part_type)
parts.append((part_name, part))
# Create the object, add the parts and return it
msg = definitions.AbstractMessage(message_name)
for part_name, part in parts:
msg.add_part(part_name, part)
return msg
def test_deserialize_choice():
response_body = load_xml("""
<SOAP-ENV:Body
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<mns:response xmlns:mns="http://test.python-zeep.org/tests/document"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<mns:return type="xsd:string">foobar</mns:return>
</mns:response>
</SOAP-ENV:Body>
""") # noqa
wsdl = stub(types=stub(
_prefix_map={},
_get_schema_document=lambda namespace: None
))
operation = stub(soapaction='my-action', name='something')
msg = messages.DocumentMessage(
wsdl=wsdl,
name=None,
operation=operation,
nsmap=soap.Soap11Binding.nsmap,
type='input')
# Fake resolve()
namespace = 'http://test.python-zeep.org/tests/document'
msg.abstract = definitions.AbstractMessage(
etree.QName(namespace, 'Method1Response'))
msg.abstract.parts = OrderedDict([
('body', definitions.MessagePart(
element=xsd.Element(
etree.QName(namespace, 'response'),
xsd.ComplexType(
xsd.Choice([
xsd.Element(etree.QName(namespace, 'return'), xsd.String()),
])
)
),
type=None))
])
msg.namespace = {
'body': 'http://test.python-zeep.org/tests/document',
'header': None,
'headerfault': None
}
result = msg.deserialize(response_body)
assert result == 'foobar'
