def test_element_any_parse():
node = load_xml("""
<xsd:schema
elementFormDefault="qualified"
targetNamespace="https://tests.python-zeep.org"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="container">
<xsd:complexType>
<xsd:sequence>
<xsd:any/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
""")
schema = xsd.Schema(node)
node = load_xml("""
<container xmlns="https://tests.python-zeep.org">
<something>
<contains>text</contains>
</something>
</container>
""")
elm = schema.get_element('ns0:container')
elm.parse(node, schema)
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_xml_empty_xmlns():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<complexType name="empty"/>
<element name="container">
<complexType>
<sequence>
<element ref="schema"/>
<any/>
</sequence>
</complexType>
</element>
</schema>
"""))
container_elm = schema.get_element('{http://tests.python-zeep.org/}container')
node = load_xml("""
<container>
<xs:schema
xmlns=""
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" id="NewDataSet">
<xs:element name="something" type="xs:string" msdata:foo=""/>
</xs:schema>
<something>foo</something>
</container>
""")
item = container_elm.parse(node, schema)
assert item._value_1 == 'foo'
def test_xml_element_ref_missing_namespace():
# For buggy soap servers (#170)
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/">
<element name="foo" type="string"/>
<element name="bar">
<complexType>
<sequence>
<element ref="tns:foo"/>
</sequence>
</complexType>
</element>
</schema>
"""))
custom_type = schema.get_element('{http://tests.python-zeep.org/}bar')
input_xml = load_xml("""
<ns0:bar xmlns:ns0="http://tests.python-zeep.org/">
<foo>bar</foo>
</ns0:bar>
""")
item = custom_type.parse(input_xml, schema)
assert item.foo == 'bar'
def test_choice_optional_values():
schema = load_xml("""
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:complexType name="Transport">
<xsd:sequence>
<xsd:choice minOccurs="0" maxOccurs="1">
<xsd:element name="item" type="xsd:string"/>
</xsd:choice>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
""")
schema = xsd.Schema(schema)
node = load_xml("""
<document>
<Transport>
</Transport>
</document>
""")
elm = schema.get_type('ns0:Transport')
elm.parse_xmlelement(node, schema)
def test_xml_namespace():
xmlns = load_xml("""
<?xml version="1.0"?>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
targetNamespace="http://www.w3.org/XML/1998/namespace"
elementFormDefault="qualified">
<xs:attribute name="lang" type="xs:string"/>
</xs:schema>
""")
transport = DummyTransport()
transport.bind('http://www.w3.org/2001/xml.xsd', xmlns)
xsd.Schema(load_xml("""
<?xml version="1.0"?>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xs:import namespace="http://www.w3.org/XML/1998/namespace"
schemaLocation="http://www.w3.org/2001/xml.xsd"/>
<xs:element name="container">
<xs:complexType>
<xs:sequence/>
<xs:attribute ref="xml:lang"/>
</xs:complexType>
</xs:element>
</xs:schema>
"""), transport=transport)
def test_xml_defaults_parse():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name="container">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="item_1" type="xsd:string" default="hoi" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="attr_1" type="xsd:string" default="hoi"/>
</xsd:complexType>
</xsd:element>
</xsd:schema>
"""))
container_elm = schema.get_element(
'{http://tests.python-zeep.org/}container')
node = load_xml("""
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>hoi</ns0:item_1>
</ns0:container>
""")
item = container_elm.parse(node, schema)
assert item.attr_1 == 'hoi'
def test_xml_unparsed_elements():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<element name="container">
<complexType>
<sequence>
<element minOccurs="0" maxOccurs="1" name="item" type="string" />
</sequence>
</complexType>
</element>
</schema>
"""))
schema.settings.strict = False
schema.set_ns_prefix('tns', 'http://tests.python-zeep.org/')
expected = load_xml("""
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item>bar</ns0:item>
<ns0:idontbelonghere>bar</ns0:idontbelonghere>
</ns0:container>
</document>
""")
container_elm = schema.get_element('tns:container')
obj = container_elm.parse(expected[0], schema)
assert obj.item == 'bar'
assert obj._raw_elements
def test_soap_array_parse_remote_ns():
transport = DummyTransport()
transport.bind(
'http://schemas.xmlsoap.org/soap/encoding/',
load_xml(io.open('tests/wsdl_files/soap-enc.xsd', 'r').read().encode('utf-8')))
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:import namespace="http://schemas.xmlsoap.org/soap/encoding/"/>
<xsd:simpleType name="CountryCodeType">
<xsd:restriction base="xsd:string">
<xsd:length value="2"/>
<xsd:pattern value="[a-zA-Z]{2}"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:complexType name="CountryItemType">
<xsd:sequence>
<xsd:element name="code" type="tns:CountryCodeType"/>
<xsd:element name="name" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="CountriesArrayType">
<xsd:complexContent>
<xsd:restriction base="soapenc:Array">
<xsd:attribute ref="soapenc:arrayType" wsdl:arrayType="tns:CountryItemType[]"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="countries" type="tns:CountriesArrayType"/>
</xsd:schema>
"""), transport)
doc = load_xml("""
<countries
SOAP-ENC:arrayType="ns1:CountryItemType[1]"
xsi:type="ns1:CountriesArrayType"
xmlns:ns1="http://tests.python-zeep.org/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<item xsi:type="ns1:CountryItemType">
<code xsi:type="ns1:CountryCodeType">NL</code>
<name xsi:type="xsd:string">The Netherlands</name>
</item>
</countries>
""")
elm = schema.get_element('ns0:countries')
data = elm.parse(doc, schema)
assert data[0].code == 'NL'
assert data[0].name == 'The Netherlands'
def test_parse_check_mixed():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name="container">
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:sequence>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="item_1" type="xsd:string"/>
<xsd:element name="item_2" type="xsd:string"/>
</xsd:choice>
<xsd:element name="item_3" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
"""))
element = schema.get_element('ns0:container')
expected = load_xml("""
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
<ns0:item_3>foo</ns0:item_3>
</ns0:container>
""")
element.parse(expected, schema)
def test_xml_complex_type_parsexml():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<element name="Address">
<complexType>
<sequence>
<element minOccurs="0" maxOccurs="1" name="foo" type="string" />
</sequence>
</complexType>
</element>
</schema>
"""))
address_type = schema.get_element('{http://tests.python-zeep.org/}Address')
input_node = load_xml("""
<Address xmlns="http://tests.python-zeep.org/">
<foo>bar</foo>
</Address>
""")
obj = address_type.parse(input_node, None)
assert obj.foo == 'bar'
def test_xml_sequence_recover_from_missing_element():
schema = xsd.Schema(load_xml("""
<schema
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<complexType name="container">
<sequence>
<element name="item_1" type="xsd:string"/>
<element name="item_2" type="xsd:string"/>
<element name="item_3" type="xsd:string"/>
<element name="item_4" type="xsd:string"/>
</sequence>
</complexType>
</schema>
"""), settings=Settings(strict=False))
xml = load_xml("""
<tns:container
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tns="http://tests.python-zeep.org/">
<tns:item_1>text-1</tns:item_1>
<tns:item_3>text-3</tns:item_3>
<tns:item_4>text-4</tns:item_4>
</tns:container>
""")
elm_type = schema.get_type('{http://tests.python-zeep.org/}container')
result = elm_type.parse_xmlelement(xml, schema)
assert result.item_1 == 'text-1'
assert result.item_2 is None
assert result.item_3 == 'text-3'
assert result.item_4 == 'text-4'
def test_sequence_parse_anytype_regression_17():
schema_doc = load_xml(b"""
<?xml version="1.0" encoding="utf-8"?>
<schema
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/tst"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/tst">
<complexType name="CustomField">
<sequence>
<element name="parentItemURI" type="xsd:string"/>
<element name="key" type="xsd:string"/>
<element name="value" nillable="true"/>
</sequence>
</complexType>
<complexType name="Text">
<sequence>
<element name="type" type="xsd:string"/>
<element name="content" type="xsd:string"/>
<element name="contentLossy" type="xsd:boolean"/>
</sequence>
</complexType>
<element name="getCustomFieldResponse">
<complexType>
<sequence>
<element name="getCustomFieldReturn" type="tns:CustomField"/>
</sequence>
</complexType>
</element>
</schema>
""")
xml = load_xml(b"""
<?xml version="1.0" encoding="utf-8"?>
<tst:getCustomFieldResponse
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tst="http://tests.python-zeep.org/tst">
<tst:getCustomFieldReturn>
<tst:parentItemURI>blabla</tst:parentItemURI>
<tst:key>solution</tst:key>
<tst:value xsi:type="tst:Text">
<tst:type xsi:type="xsd:string">text/html</tst:type>
<tst:content xsi:type="xsd:string">Test Solution</tst:content>
<tst:contentLossy xsi:type="xsd:boolean">false</tst:contentLossy>
</tst:value>
</tst:getCustomFieldReturn>
</tst:getCustomFieldResponse>
""")
schema = xsd.Schema(schema_doc)
elm = schema.get_element(
'{http://tests.python-zeep.org/tst}getCustomFieldResponse'
)
result = elm.parse(xml, schema)
assert result.getCustomFieldReturn.value.content == 'Test Solution'
def test_mime_content_serialize_text_xml():
wsdl_content = StringIO("""
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://tests.python-zeep.org/tns"
xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://tests.python-zeep.org/tns">
<message name="Input">
<part name="arg1" type="xsd:string"/>
<part name="arg2" type="xsd:string"/>
</message>
<message name="Output">
<part name="Body" type="xsd:string"/>
</message>
<portType name="TestPortType">
<operation name="TestOperation">
<input message="Input"/>
<output message="Output"/>
</operation>
</portType>
<binding name="TestBinding" type="tns:TestPortType">
<http:binding verb="POST"/>
<operation name="TestOperation">
<http:operation location="test-operation"/>
<input>
<mime:content type="text/xml"/>
</input>
<output>
<mime:mimeXml part="Body"/>
</output>
</operation>
</binding>
</definitions>
""".strip())
root = wsdl.Document(wsdl_content, None)
binding = root.bindings['{http://tests.python-zeep.org/tns}TestBinding']
operation = binding.get('TestOperation')
assert operation.input.body.signature(schema=root.types) == 'TestOperation(arg1: xsd:string, arg2: xsd:string)'
assert operation.input.signature(as_output=False) == 'arg1: xsd:string, arg2: xsd:string'
assert operation.output.body.signature(schema=root.types) == 'TestOperation(Body: xsd:string)'
assert operation.output.signature(as_output=True) == 'xsd:string'
serialized = operation.input.serialize(arg1='ah1', arg2='ah2')
assert serialized.headers == {'Content-Type': 'text/xml'}
assert serialized.path == 'test-operation'
assert_nodes_equal(
load_xml(serialized.content),
load_xml("<TestOperation><arg1>ah1</arg1><arg2>ah2</arg2></TestOperation>"))
def test_nested_choice():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<element name="container">
<complexType>
<sequence>
<choice>
<choice minOccurs="2" maxOccurs="unbounded">
<element ref="tns:a" />
</choice>
<element ref="tns:b" />
</choice>
</sequence>
</complexType>
</element>
<element name="a" type="string" />
<element name="b" type="string" />
</schema>
"""))
schema.set_ns_prefix('tns', 'http://tests.python-zeep.org/')
container_type = schema.get_element('tns:container')
item = container_type(_value_1=[{'a': 'item-1'}, {'a': 'item-2'}])
assert item._value_1[0] == {'a': 'item-1'}
assert item._value_1[1] == {'a': 'item-2'}
expected = load_xml("""
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:a>item-1</ns0:a>
<ns0:a>item-2</ns0:a>
</ns0:container>
</document>
""")
node = render_node(container_type, item)
assert_nodes_equal(node, expected)
result = container_type.parse(expected[0], schema)
assert result._value_1[0] == {'a': 'item-1'}
assert result._value_1[1] == {'a': 'item-2'}
expected = load_xml("""
<container xmlns="http://tests.python-zeep.org/">
<b>1</b>
</container>
""")
result = container_type.parse(expected, schema)
assert result.b == '1'
def test_wsdl_array_type():
transport = DummyTransport()
transport.bind(
'http://schemas.xmlsoap.org/soap/encoding/',
load_xml(io.open('tests/wsdl_files/soap-enc.xsd', 'r').read().encode('utf-8')))
schema = xsd.Schema(load_xml("""
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:import namespace="http://schemas.xmlsoap.org/soap/encoding/"/>
<xsd:complexType name="array">
<xsd:complexContent>
<xsd:restriction base="SOAP-ENC:Array">
<xsd:attribute ref="SOAP-ENC:arrayType" wsdl:arrayType="tns:base[]"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="base">
<xsd:sequence>
<xsd:element minOccurs="0" name="item_1" type="xsd:string"/>
<xsd:element minOccurs="0" name="item_2" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:element name="array" type="tns:array"/>
</xsd:schema>
"""), transport)
array_elm = schema.get_element('{http://tests.python-zeep.org/}array')
item_type = schema.get_type('{http://tests.python-zeep.org/}base')
item_1 = item_type(item_1='foo_1', item_2='bar_1')
item_2 = item_type(item_1='foo_2', item_2='bar_2')
array = array_elm([
xsd.AnyObject(item_type, item_1),
xsd.AnyObject(item_type, item_2),
])
node = etree.Element('document')
array_elm.render(node, array)
expected = """
<document>
<ns0:array xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>foo_1</ns0:item_1>
<ns0:item_2>bar_1</ns0:item_2>
<ns0:item_1>foo_2</ns0:item_1>
<ns0:item_2>bar_2</ns0:item_2>
</ns0:array>
</document>
"""
assert_nodes_equal(expected, node)
def test_sequence_parse_choice_sequence_max_occurs():
schema_doc = load_xml(b"""
<?xml version="1.0" encoding="utf-8"?>
<schema
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/tst"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/tst">
<element name="container">
<complexType>
<sequence>
<choice maxOccurs="3">
<sequence>
<element name="item_1" type="xsd:string" />
<element name="item_2" type="xsd:string" />
</sequence>
<element name="item_3" type="xsd:string" />
</choice>
<element name="item_4" type="xsd:string" />
</sequence>
</complexType>
</element>
</schema>
""")
xml = load_xml(b"""
<?xml version="1.0" encoding="utf-8"?>
<tst:container
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tst="http://tests.python-zeep.org/tst">
<tst:item_1>text-1</tst:item_1>
<tst:item_2>text-2</tst:item_2>
<tst:item_1>text-1</tst:item_1>
<tst:item_2>text-2</tst:item_2>
<tst:item_3>text-3</tst:item_3>
<tst:item_4>text-4</tst:item_4>
</tst:container>
""")
schema = xsd.Schema(schema_doc)
elm = schema.get_element('{http://tests.python-zeep.org/tst}container')
result = elm.parse(xml, schema)
assert result._value_1 == [
{'item_1': 'text-1', 'item_2': 'text-2'},
{'item_1': 'text-1', 'item_2': 'text-2'},
{'item_3': 'text-3'},
]
assert result.item_4 == 'text-4'
def test_include_different_form_defaults():
node_a = etree.fromstring("""
<?xml version="1.0"?>
<xs:schema
xmlns="http://tests.python-zeep.org/"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://tests.python-zeep.org/">
<xs:include
schemaLocation="http://tests.python-zeep.org/b.xsd"/>
</xs:schema>
""".strip())
# include without default namespace, other xsd prefix
node_b = load_xml("""
<?xml version="1.0"?>
<xsd:schema
elementFormDefault="qualified"
attributeFormDefault="qualified"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/b">
<xsd:element name="container" type="foo"/>
<xsd:complexType name="foo">
<xsd:sequence>
<xsd:element name="item" type="xsd:string"/>
</xsd:sequence>
<xsd:attribute name="attr" type="xsd:string"/>
</xsd:complexType>
</xsd:schema>
""")
transport = DummyTransport()
transport.bind('http://tests.python-zeep.org/b.xsd', node_b)
schema = xsd.Schema(node_a, transport=transport)
item = schema.get_element('{http://tests.python-zeep.org/}container')
obj = item(item='foo', attr='bar')
node = render_node(item, obj)
expected = load_xml("""
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/" ns0:attr="bar">
<ns0:item>foo</ns0:item>
</ns0:container>
</document>
""")
assert_nodes_equal(expected, node)
def test_password_prepared():
envelope = load_xml("""
<soap-env:Envelope
xmlns:ns0="http://example.com/stockquote.xsd"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
>
<soap-env:Header xmlns:ns0="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">
<ns0:Security>
<ns0:UsernameToken/>
</ns0:Security>
</soap-env:Header>
<soap-env:Body>
<ns0:TradePriceRequest>
<tickerSymbol>foobar</tickerSymbol>
<ns0:country/>
</ns0:TradePriceRequest>
</soap-env:Body>
</soap-env:Envelope>
""")
token = UsernameToken('michael', 'geheim')
envelope, headers = token.sign(envelope, {})
expected = load_xml("""
<soap-env:Envelope
xmlns:ns0="http://example.com/stockquote.xsd"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soap-env:Header xmlns:ns0="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">
<ns0:Security>
<ns0:UsernameToken>
<ns0:Username>michael</ns0:Username>
<ns0:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText">geheim</ns0:Password>
</ns0:UsernameToken>
</ns0:Security>
</soap-env:Header>
<soap-env:Body>
<ns0:TradePriceRequest>
<tickerSymbol>foobar</tickerSymbol>
<ns0:country/>
</ns0:TradePriceRequest>
</soap-env:Body>
</soap-env:Envelope>
""")
assert_nodes_equal(envelope, expected)
def test_union():
schema_doc = load_xml(b"""
<?xml version="1.0" encoding="utf-8"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/tst"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/tst">
<xsd:element name="State" type="tns:StateType"/>
<xsd:complexType name="StateType">
<xsd:simpleContent>
<xsd:extension base="tns:StateBaseType">
<xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<xsd:simpleType name="tns:StateBaseType">
<xsd:union memberTypes="tns:Type1 tns:Type2"/>
</xsd:simpleType>
<xsd:simpleType name="Type1">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:maxLength value="255"/>
<xsd:enumeration value="Idle"/>
<xsd:enumeration value="Processing"/>
<xsd:enumeration value="Stopped"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="Type2">
<xsd:restriction base="xsd:NMTOKEN">
<xsd:maxLength value="255"/>
<xsd:enumeration value="Paused"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
""")
xml = load_xml(b"""
<?xml version="1.0" encoding="utf-8"?>
<tst:State xmlns:tst="http://tests.python-zeep.org/tst">Idle</tst:State>
""")
schema = xsd.Schema(schema_doc)
elm = schema.get_element('{http://tests.python-zeep.org/tst}State')
result = elm.parse(xml, schema)
assert result._value_1 == 'Idle'
def test_element_any_parse_inline_schema():
node = load_xml("""
<xsd:schema
elementFormDefault="qualified"
targetNamespace="https://tests.python-zeep.org"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="container">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="xsd:schema"/>
<xsd:any/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
""")
schema = xsd.Schema(node)
node = load_xml("""
<OstatDepoResult>
<xs:schema id="OD" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xs:element name="OD" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="odr">
<xs:complexType>
<xs:sequence>
<xs:element name="item" msdata:Caption="item" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<diffgr:diffgram xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" xmlns:diffgr="urn:schemas-microsoft-com:xml-diffgram-v1">
<OD xmlns="">
<odr diffgr:id="odr1" msdata:rowOrder="0">
<item>hetwerkt</item>
</odr>
</OD>
</diffgr:diffgram>
</OstatDepoResult>
""")
elm = schema.get_element('ns0:container')
data = elm.parse(node, schema)
assert data._value_1._value_1[0]['odr']['item'] == 'hetwerkt'
def test_password_digest(monkeypatch):
monkeypatch.setattr(os, 'urandom', lambda x: b'mocked-random')
envelope = load_xml("""
<soap-env:Envelope
xmlns:ns0="http://example.com/stockquote.xsd"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
>
<soap-env:Body>
<ns0:TradePriceRequest>
<tickerSymbol>foobar</tickerSymbol>
<ns0:country/>
</ns0:TradePriceRequest>
</soap-env:Body>
</soap-env:Envelope>
""")
token = UsernameToken('michael', 'geheim', use_digest=True)
envelope, headers = token.sign(envelope, {})
expected = load_xml("""
<soap-env:Envelope
xmlns:ns0="http://example.com/stockquote.xsd"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soap-env:Header>
<ns0:Security xmlns:ns0="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">
<ns0:UsernameToken>
<ns0:Username>michael</ns0:Username>
<ns0:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest">hVicspAQSg70JNhe67OHqD9gexc=</ns0:Password>
<ns0:Nonce>bW9ja2VkLXJhbmRvbQ==</ns0:Nonce>
<ns0:Created xmlns:ns0="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">2016-05-08T12:00:00+00:00</ns0:Created>
</ns0:UsernameToken>
</ns0:Security>
</soap-env:Header>
<soap-env:Body>
<ns0:TradePriceRequest>
<tickerSymbol>foobar</tickerSymbol>
<ns0:country/>
</ns0:TradePriceRequest>
</soap-env:Body>
</soap-env:Envelope>
""")
assert_nodes_equal(envelope, expected)
def test_schema_as_payload():
schema = xsd.Schema(
load_xml(
"""
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:element name="container">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="xsd:schema"/>
<xsd:any/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
"""
)
)
elm_class = schema.get_element("{http://tests.python-zeep.org/}container")
node = load_xml(
"""
<ns0:container xmlns:ns0="http://tests.python-zeep.org/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:schema
targetNamespace="http://tests.python-zeep.org/inline-schema"
elementFormDefault="qualified">
<xsd:element name="sub-element">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="item-1" type="xsd:string"/>
<xsd:element name="item-2" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<ns1:sub-element xmlns:ns1="http://tests.python-zeep.org/inline-schema">
<ns1:item-1>value-1</ns1:item-1>
<ns1:item-2>value-2</ns1:item-2>
</ns1:sub-element>
</ns0:container>
"""
)
value = elm_class.parse(node, schema)
assert value._value_1["item-1"] == "value-1"
assert value._value_1["item-2"] == "value-2"
def test_xml_group_methods():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="unqualified">
<xs:group name="Group">
<xs:annotation>
<xs:documentation>blub</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element name="city" type="xs:string" />
<xs:element name="country" type="xs:string" />
</xs:sequence>
</xs:group>
</xs:schema>
"""))
Group = schema.get_group('{http://tests.python-zeep.org/}Group')
assert Group.signature(schema) == (
'ns0:Group(city: xsd:string, country: xsd:string)')
assert str(Group) == (
'{http://tests.python-zeep.org/}Group(city: xsd:string, country: xsd:string)')
assert len(list(Group)) == 2
def test_rpc_message_deserializer(abstract_message_output):
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/rpc"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<result xsi:type="xsd:string">foobar</result>
</mns:Response>
</SOAP-ENV:Body>
""") # noqa
wsdl = stub(schema=stub(_prefix_map={}))
operation = stub(soapaction='my-action')
msg = messages.RpcMessage(
wsdl=wsdl,
name=None,
operation=operation,
nsmap=soap.Soap11Binding.nsmap)
msg._info = {
'body': {'namespace': 'http://test.python-zeep.org/tests/rpc'},
'header': None,
'headerfault': None
}
msg.resolve(wsdl, abstract_message_output)
result = msg.deserialize(response_body)
assert result == 'foobar'
def test_any_in_nested_sequence():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:tns="http://tests.python-zeep.org/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/"
>
<xsd:element name="something" type="xsd:date"/>
<xsd:element name="foobar" type="xsd:boolean"/>
<xsd:element name="container">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="items" minOccurs="0">
<xsd:complexType>
<xsd:sequence>
<xsd:any namespace="##any" processContents="lax"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="version" type="xsd:string"/>
<xsd:any namespace="##any" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
""")) # noqa
container_elm = schema.get_element('{http://tests.python-zeep.org/}container')
assert container_elm.signature() == (
'items: {_value_1: ANY}, version: xsd:string, _value_1: ANY[]')
something = schema.get_element('{http://tests.python-zeep.org/}something')
foobar = schema.get_element('{http://tests.python-zeep.org/}foobar')
any_1 = xsd.AnyObject(something, datetime.date(2016, 7, 4))
any_2 = xsd.AnyObject(foobar, True)
obj = container_elm(
items={'_value_1': any_1}, version='str1234', _value_1=[any_1, any_2])
node = etree.Element('document')
container_elm.render(node, obj)
expected = """
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:items>
<ns0:something>2016-07-04</ns0:something>
</ns0:items>
<ns0:version>str1234</ns0:version>
<ns0:something>2016-07-04</ns0:something>
<ns0:foobar>true</ns0:foobar>
</ns0:container>
</document>
"""
assert_nodes_equal(expected, node)
item = container_elm.parse(node.getchildren()[0], schema)
assert item.items._value_1 == datetime.date(2016, 7, 4)
assert item.version == 'str1234'
assert item._value_1 == [datetime.date(2016, 7, 4), True]
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()
definitions_ = stub(
target_namespace='',
messages={},
wsdl=stub())
msg = messages.RpcMessage.parse(
definitions=definitions_,
xmlelement=xmlelement,
operation=operation,
nsmap={})
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():
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={})
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 test_xml_group_extension():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="unqualified">
<xs:group name="Group">
<xs:sequence>
<xs:element name="item_2" type="xs:string" />
<xs:element name="item_3" type="xs:string" />
</xs:sequence>
</xs:group>
<xs:complexType name="base">
<xs:sequence>
<xs:element name="item_1" type="xs:string" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="SubGroup">
<xs:complexContent>
<xs:extension base="tns:base">
<xs:group ref="tns:Group"/>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
"""))
SubGroup = schema.get_type('{http://tests.python-zeep.org/}SubGroup')
assert SubGroup.signature(schema) == (
'ns0:SubGroup(item_1: xsd:string, item_2: xsd:string, item_3: xsd:string)')
SubGroup(item_1='een', item_2='twee', item_3='drie')
def test_nested_complex_types():
schema = xsd.Schema(load_xml("""
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:element name="container">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="item" type="tns:item"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="item">
<xsd:sequence>
<xsd:element name="item_1" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
"""))
container_elm = schema.get_element('{http://tests.python-zeep.org/}container')
item_type = schema.get_type('{http://tests.python-zeep.org/}item')
instance = container_elm(item=item_type(item_1='foo'))
result = serialize_object(instance)
assert isinstance(result, dict), type(result)
assert isinstance(result['item'], dict), type(result['item'])
assert result['item']['item_1'] == 'foo'
def test_choice_with_sequence_multiple():
node = load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name="container">
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:choice maxOccurs="2">
<xsd:sequence>
<xsd:element name="item_1" type="xsd:string"/>
<xsd:element name="item_2" type="xsd:string"/>
</xsd:sequence>
<xsd:sequence>
<xsd:element name="item_3" type="xsd:string"/>
<xsd:element name="item_4" type="xsd:string"/>
</xsd:sequence>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
""")
schema = xsd.Schema(node)
element = schema.get_element('ns0:container')
assert element.type.signature() == (
'({item_1: xsd:string, item_2: xsd:string} | {item_3: xsd:string, item_4: xsd:string})[]'
)
value = element(_value_1=[
dict(item_1='foo', item_2='bar'),
dict(item_3='foo', item_4='bar'),
])
expected = """
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
<ns0:item_3>foo</ns0:item_3>
<ns0:item_4>bar</ns0:item_4>
</ns0:container>
</document>
"""
node = etree.Element('document')
element.render(node, value)
assert_nodes_equal(expected, node)
def test_complex_content_sequence_extension():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="https://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:complexType name="Address">
<xsd:complexContent>
<xsd:extension base="tns:Name">
<xsd:sequence>
<xsd:element name="country" type="xsd:string"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="Address" type="tns:Address"/>
<xsd:complexType name="Name">
<xsd:sequence>
<xsd:element name="first_name" type="xsd:string"/>
<xsd:element name="last_name" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
"""))
address_type = schema.get_element("{http://tests.python-zeep.org/}Address")
obj = address_type(first_name="foo",
last_name="bar",
country="The Netherlands")
node = etree.Element("document")
address_type.render(node, obj)
expected = """
<document>
<ns0:Address xmlns:ns0="http://tests.python-zeep.org/">
<ns0:first_name>foo</ns0:first_name>
<ns0:last_name>bar</ns0:last_name>
<ns0:country>The Netherlands</ns0:country>
</ns0:Address>
</document>
"""
assert_nodes_equal(expected, node)
def test_group_nested():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
attributeFormDefault="qualified"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:attributeGroup name="groepje">
<xsd:attribute name="id" type="xsd:string" use="required" form="unqualified" />
<xsd:attribute name="pos" type="xsd:string" use="required" />
<xsd:attributeGroup ref="tns:nestje"/>
</xsd:attributeGroup>
<xsd:attributeGroup name="nestje">
<xsd:attribute name="size" type="xsd:string" use="required" />
</xsd:attributeGroup>
<xsd:element name="Address">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="foo" type="xsd:string" form="unqualified" />
</xsd:sequence>
<xsd:attributeGroup ref="tns:groepje"/>
</xsd:complexType>
</xsd:element>
</xsd:schema>
"""))
address_type = schema.get_element("{http://tests.python-zeep.org/}Address")
obj = address_type(foo="bar", id="20", pos="30", size="maat")
expected = """
<document>
<ns0:Address
xmlns:ns0="http://tests.python-zeep.org/" id="20" ns0:pos="30" ns0:size="maat">
<foo>bar</foo>
</ns0:Address>
</document>
"""
node = etree.Element("document")
address_type.render(node, obj)
assert_nodes_equal(expected, node)
def test_complex_content_with_recursive_elements():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:complexType name="Pet">
<xsd:complexContent>
<xsd:extension base="tns:Name">
<xsd:sequence>
<xsd:element name="children" type="tns:Pet"/>
</xsd:sequence>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="Pet" type="tns:Pet"/>
<xsd:complexType name="Name">
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="common_name" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
"""))
pet_type = schema.get_element('{http://tests.python-zeep.org/}Pet')
assert (pet_type.signature() ==
'name: xsd:string, common_name: xsd:string, children: Pet')
obj = pet_type(name='foo', common_name='bar')
node = etree.Element('document')
pet_type.render(node, obj)
expected = """
<document>
<ns0:Pet xmlns:ns0="http://tests.python-zeep.org/">
<ns0:name>foo</ns0:name>
<ns0:common_name>bar</ns0:common_name>
<ns0:children/>
</ns0:Pet>
</document>
"""
assert_nodes_equal(expected, node)
def test_unit_choice_parse_xmlelements_max_2():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name="container">
<xsd:complexType>
<xsd:choice maxOccurs="2">
<xsd:element name="item_1" type="xsd:string" />
<xsd:element name="item_2" type="xsd:string" />
<xsd:element name="item_3" type="xsd:string" />
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
"""))
element = schema.get_element('ns0:container')
def create_elm(name, text):
elm = etree.Element(name)
elm.text = text
return elm
data = deque([
create_elm('item_1', 'item-1'),
create_elm('item_2', 'item-2'),
create_elm('item_1', 'item-3'),
])
result = element.type._element.parse_xmlelements(data,
schema,
name='items')
assert result == {
'items': [
{
'item_1': 'item-1'
},
{
'item_2': 'item-2'
},
]
}
assert len(data) == 1
def test_any_with_ref():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<element name="item" type="string"/>
<element name="container">
<complexType>
<sequence>
<element ref="tns:item"/>
<any/>
<any maxOccurs="unbounded"/>
</sequence>
</complexType>
</element>
</schema>
"""))
item_elm = schema.get_element("{http://tests.python-zeep.org/}item")
assert isinstance(item_elm.type, xsd.String)
container_elm = schema.get_element(
"{http://tests.python-zeep.org/}container")
obj = container_elm(
item="bar",
_value_1=xsd.AnyObject(item_elm, item_elm("argh")),
_value_2=xsd.AnyObject(item_elm, item_elm("ok")),
)
node = etree.Element("document")
container_elm.render(node, obj)
expected = """
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item>bar</ns0:item>
<ns0:item>argh</ns0:item>
<ns0:item>ok</ns0:item>
</ns0:container>
</document>
"""
assert_nodes_equal(expected, node)
item = container_elm.parse(list(node)[0], schema)
assert item.item == "bar"
assert item._value_1 == "argh"
def test_deserialize():
wsdl_content = StringIO("""
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://tests.python-zeep.org/tns"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://tests.python-zeep.org/tns">
<message name="Output">
<part name="result" type="xsd:string"/>
</message>
<portType name="TestPortType">
<operation name="TestOperation">
<output message="Output"/>
</operation>
</portType>
<binding name="TestBinding" type="tns:TestPortType">
<soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="TestOperation">
<soap:operation soapAction=""/>
<output>
<soap:body use="encoded"
namespace="http://test.python-zeep.org/tests/rpc"/>
</output>
</operation>
</binding>
</definitions>
""".strip())
root = wsdl.Document(wsdl_content, None)
binding = root.bindings['{http://tests.python-zeep.org/tns}TestBinding']
operation = binding.get('TestOperation')
document = load_xml("""
<soap-env:Body
xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/">
<ns0:Output xmlns:ns0="http://test.python-zeep.org/tests/rpc">
<result>ah1</result>
</ns0:Output>
</soap-env:Body>
""")
assert operation.output.signature(True) == 'xsd:string'
result = operation.output.deserialize(document)
assert result == 'ah1'
def test_xml_keep_objects_intact():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="https://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
attributeFormDefault="qualified"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name="Address">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
<xsd:element minOccurs="0" name="optional" type="xsd:string"/>
<xsd:element name="container" nillable="true" type="tns:Container"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="Container">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="service"
nillable="true" type="tns:ServiceRequestType"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="ServiceRequestType">
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
"""))
address_type = schema.get_element("{http://tests.python-zeep.org/}Address")
obj = address_type(name="foo", container={"service": [{"name": "foo"}]})
org_obj = copy.deepcopy(obj)
node = etree.Element("document")
address_type.render(node, obj)
print(org_obj)
print(obj)
assert org_obj["container"]["service"] == obj["container"]["service"]
def get_any_schema():
return xsd.Schema(load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<element name="item" type="string"/>
<element name="container">
<complexType>
<sequence>
<any/>
</sequence>
</complexType>
</element>
</schema>
"""))
def test_build_group_min_occurs_2():
custom_type = xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'authentication'),
xsd.ComplexType(
xsd.Group(
etree.QName('http://tests.python-zeep.org/', 'foobar'),
xsd.Sequence([
xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'item_1'),
xsd.String()),
xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'item_2'),
xsd.String()),
]),
min_occurs=2, max_occurs=2)
))
obj = custom_type(_value_1=[
{'item_1': 'foo', 'item_2': 'bar'},
{'item_1': 'foo', 'item_2': 'bar'},
])
assert obj._value_1 == [
{'item_1': 'foo', 'item_2': 'bar'},
{'item_1': 'foo', 'item_2': 'bar'},
]
result = render_node(custom_type, obj)
expected = load_xml("""
<document>
<ns0:authentication xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
</ns0:authentication>
</document>
""")
assert_nodes_equal(result, expected)
obj = custom_type.parse(result[0], None)
assert obj._value_1 == [
{'item_1': 'foo', 'item_2': 'bar'},
{'item_1': 'foo', 'item_2': 'bar'},
]
assert not hasattr(obj, 'foobar')
def test_schema_repr_val():
schema = xsd.Schema(
load_xml(
"""
<?xml version="1.0"?>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
</xs:schema>
"""
)
)
assert (
repr(schema) == "<Schema(location=None, tns='http://tests.python-zeep.org/')>"
)
def test_password_text():
envelope = load_xml(
"""
<soap-env:Envelope
xmlns:ns0="http://example.com/stockquote.xsd"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
>
<soap-env:Body>
<ns0:TradePriceRequest>
<tickerSymbol>foobar</tickerSymbol>
<ns0:country/>
</ns0:TradePriceRequest>
</soap-env:Body>
</soap-env:Envelope>
"""
)
token = UsernameToken("michael", "geheim")
envelope, headers = token.apply(envelope, {})
expected = """
<soap-env:Envelope
xmlns:ns0="http://example.com/stockquote.xsd"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soap-env:Header>
<wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">
<wsse:UsernameToken>
<wsse:Username>michael</wsse:Username>
<wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText">geheim</wsse:Password>
</wsse:UsernameToken>
</wsse:Security>
</soap-env:Header>
<soap-env:Body>
<ns0:TradePriceRequest>
<tickerSymbol>foobar</tickerSymbol>
<ns0:country/>
</ns0:TradePriceRequest>
</soap-env:Body>
</soap-env:Envelope>
""" # noqa
assert_nodes_equal(envelope, expected)
def test_schema_doc_repr_val():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
</xs:schema>
"""))
docs = schema._get_schema_documents('http://tests.python-zeep.org/')
assert len(docs) == 1
doc = docs[0]
assert repr(
doc
) == "<SchemaDocument(location=None, tns='http://tests.python-zeep.org/', is_empty=True)>"
def test_build_min_occurs_2_max_occurs_2():
custom_type = xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'authentication'),
xsd.ComplexType(
xsd.Sequence([
xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'item_1'),
xsd.String()),
xsd.Element(
etree.QName('http://tests.python-zeep.org/', 'item_2'),
xsd.String()),
], min_occurs=2, max_occurs=2)
))
assert custom_type.signature()
elm = custom_type(_value_1=[
{'item_1': 'foo-1', 'item_2': 'bar-1'},
{'item_1': 'foo-2', 'item_2': 'bar-2'},
])
assert elm._value_1 == [
{'item_1': 'foo-1', 'item_2': 'bar-1'},
{'item_1': 'foo-2', 'item_2': 'bar-2'},
]
expected = load_xml("""
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
</ns0:container>
""")
obj = custom_type.parse(expected, None)
assert obj._value_1 == [
{
'item_1': 'foo',
'item_2': 'bar',
},
{
'item_1': 'foo',
'item_2': 'bar',
},
]
def test_simple_content():
node = load_xml("""
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://tests.python-zeep.org/">
<complexType name="container">
<simpleContent>
<extension base="xsd:string">
<attribute name="sizing" type="xsd:string" />
</extension>
</simpleContent>
</complexType>
</schema>
""")
schema = parse_schema_node(node)
xsd_type = schema.get_type('{http://tests.python-zeep.org/}container')
assert xsd_type(10, sizing='qwe')
def test_union_mixed():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<xsd:element name="item" type="tns:Date"/>
<xsd:simpleType name="Date">
<xsd:union memberTypes="xsd:date xsd:gYear xsd:gYearMonth MMYY MMYYYY"/>
</xsd:simpleType>
<xsd:simpleType name="MMYY">
<xsd:restriction base="xsd:string">
<xsd:pattern value="(0[123456789]|1[012]){1}\d{2}"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="MMYYYY">
<xsd:restriction base="xsd:string">
<xsd:pattern value="(0[123456789]|1[012]){1}\d{4}"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
"""))
elm = schema.get_element('ns0:item')
node = render_node(elm, '102018')
expected = """
<document>
<ns0:item xmlns:ns0="http://tests.python-zeep.org/">102018</ns0:item>
</document>
"""
assert_nodes_equal(expected, node)
value = elm.parse(node.getchildren()[0], schema)
assert value == '102018'
node = render_node(elm, '2018')
expected = """
<document>
<ns0:item xmlns:ns0="http://tests.python-zeep.org/">2018</ns0:item>
</document>
"""
assert_nodes_equal(expected, node)
value = elm.parse(node.getchildren()[0], schema)
assert value == '2018'
def test_choice_with_sequence_change():
node = load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name='ElementName'>
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:choice>
<xsd:sequence>
<xsd:element name="UniqueElement-1" type="xsd:string"/>
<xsd:element name="UniqueElement-2" type="xsd:string"/>
</xsd:sequence>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
""")
schema = xsd.Schema(node)
element = schema.get_element('ns0:ElementName')
elm = element(_choice_1={
'UniqueElement-1': 'foo',
'UniqueElement-2': 'bar'
})
assert elm._choice_1['UniqueElement-1'] == 'foo'
assert elm._choice_1['UniqueElement-2'] == 'bar'
elm._choice_1['UniqueElement-1'] = 'bla-1'
elm._choice_1['UniqueElement-2'] = 'bla-2'
expected = """
<document>
<ns0:ElementName xmlns:ns0="http://tests.python-zeep.org/">
<ns0:UniqueElement-1>bla-1</ns0:UniqueElement-1>
<ns0:UniqueElement-2>bla-2</ns0:UniqueElement-2>
</ns0:ElementName>
</document>
"""
node = etree.Element('document')
element.render(node, elm)
assert_nodes_equal(expected, node)
def test_xml_complex_type_array_to_other_complex_object():
schema = xsd.Schema(
load_xml(
"""
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="Address">
<xs:sequence>
<xs:element minOccurs="0" maxOccurs="1" name="foo" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="ArrayOfAddress">
<xs:sequence>
<xs:element minOccurs="0" maxOccurs="unbounded" name="Address" nillable="true" type="Address" />
</xs:sequence>
</xs:complexType>
<xs:element name="ArrayOfAddress" type="ArrayOfAddress"/>
</xs:schema>
"""
)
)
address_array = schema.get_element("ArrayOfAddress")
obj = address_array()
assert obj.Address == []
obj.Address.append(schema.get_type("Address")(foo="foo"))
obj.Address.append(schema.get_type("Address")(foo="bar"))
expected = """
<?xml version="1.0"?>
<document>
<ArrayOfAddress>
<Address>
<foo>foo</foo>
</Address>
<Address>
<foo>bar</foo>
</Address>
</ArrayOfAddress>
</document>
"""
result = render_node(address_array, obj)
assert_nodes_equal(expected, result)
def test_nested_attribute():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<element name="container">
<complexType>
<sequence>
<element name="item">
<complexType>
<sequence>
<element name="x" type="xsd:string"/>
</sequence>
<attribute name="y" type="xsd:string"/>
</complexType>
</element>
</sequence>
</complexType>
</element>
</schema>
"""))
container_elm = schema.get_element(
"{http://tests.python-zeep.org/}container")
assert container_elm.signature(schema) == (
"ns0:container(item: {x: xsd:string, y: xsd:string})")
obj = container_elm(item={"x": "foo", "y": "bar"})
expected = """
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item y="bar">
<ns0:x>foo</ns0:x>
</ns0:item>
</ns0:container>
</document>
"""
node = etree.Element("document")
container_elm.render(node, obj)
assert_nodes_equal(expected, node)
def test_choice_with_sequence_once_extra_data():
node = load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name="container">
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:sequence>
<xsd:element name="item_0" type="xsd:string"/>
<xsd:choice>
<xsd:sequence>
<xsd:element name="item_1" type="xsd:string"/>
<xsd:element name="item_2" type="xsd:string"/>
</xsd:sequence>
</xsd:choice>
<xsd:element name="item_3" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
""")
schema = xsd.Schema(node)
element = schema.get_element('ns0:container')
assert element.type.signature(schema=schema) == (
'ns0:container(item_0: xsd:string, ({item_1: xsd:string, item_2: xsd:string}), item_3: xsd:string)'
)
value = element(item_0='nul', item_1='foo', item_2='bar', item_3='item-3')
expected = """
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_0>nul</ns0:item_0>
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
<ns0:item_3>item-3</ns0:item_3>
</ns0:container>
</document>
"""
node = etree.Element('document')
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
def test_choice_element_with_any_max_occurs():
schema = xsd.Schema(
load_xml("""
<schema targetNamespace="http://tests.python-zeep.org/"
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<element name="item_any" type="string"/>
<element name="container">
<complexType>
<sequence>
<choice minOccurs="0">
<element maxOccurs="999" minOccurs="0" name="item_1" type="string"/>
<sequence>
<element minOccurs="0" name="item_2"/>
<any maxOccurs="unbounded" minOccurs="0"/>
</sequence>
</choice>
</sequence>
</complexType>
</element>
</schema>
"""))
element = schema.get_element('ns0:container')
value = element(item_2="item-2",
_value_1=[
xsd.AnyObject(schema.get_element('ns0:item_any'),
'any-content')
])
expected = """
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_2>item-2</ns0:item_2>
<ns0:item_any>any-content</ns0:item_any>
</ns0:container>
</document>
"""
node = render_node(element, value)
assert_nodes_equal(node, expected)
result = element.parse(node[0], schema)
assert result.item_2 == 'item-2'
assert result._value_1 == ['any-content']
def test_choice_with_sequence_change_named():
node = load_xml("""
<?xml version="1.0"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<xsd:element name='ElementName'>
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:choice>
<xsd:sequence>
<xsd:element name="item_1" type="xsd:string"/>
<xsd:element name="item_2" type="xsd:string"/>
</xsd:sequence>
<xsd:element name="item_3" type="xsd:string"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
""")
schema = xsd.Schema(node)
element = schema.get_element('ns0:ElementName')
elm = element(item_3='foo')
elm = element(item_1='foo', item_2='bar')
assert elm['item_1'] == 'foo'
assert elm['item_2'] == 'bar'
elm['item_1'] = 'bla-1'
elm['item_2'] = 'bla-2'
expected = """
<document>
<ns0:ElementName xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>bla-1</ns0:item_1>
<ns0:item_2>bla-2</ns0:item_2>
</ns0:ElementName>
</document>
"""
node = etree.Element('document')
element.render(node, elm)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
assert value.item_1 == 'bla-1'
assert value.item_2 == 'bla-2'
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={}))
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'
def test_xml_nested_sequence():
schema = xsd.Schema(
load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<element name="container">
<complexType>
<sequence>
<element minOccurs="0" maxOccurs="1" name="item">
<complexType>
<sequence>
<element name="x" type="integer"/>
<element name="y" type="integer"/>
</sequence>
</complexType>
</element>
</sequence>
</complexType>
</element>
</schema>
"""))
schema.set_ns_prefix('tns', 'http://tests.python-zeep.org/')
container_elm = schema.get_element('tns:container')
obj = container_elm(item={'x': 1, 'y': 2})
expected = """
<document>
<ns0:container xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item>
<ns0:x>1</ns0:x>
<ns0:y>2</ns0:y>
</ns0:item>
</ns0:container>
</document>
"""
result = render_node(container_elm, obj)
assert_nodes_equal(result, expected)
obj = container_elm.parse(result[0], schema)
assert obj.item.x == 1
assert obj.item.y == 2
def test_build_group_min_occurs_1():
custom_type = xsd.Element(
etree.QName("http://tests.python-zeep.org/", "authentication"),
xsd.ComplexType(
xsd.Group(
etree.QName("http://tests.python-zeep.org/", "foobar"),
xsd.Sequence(
[
xsd.Element(
etree.QName("http://tests.python-zeep.org/", "item_1"),
xsd.String(),
),
xsd.Element(
etree.QName("http://tests.python-zeep.org/", "item_2"),
xsd.String(),
),
]
),
min_occurs=1,
)
),
)
obj = custom_type(item_1="foo", item_2="bar")
assert obj.item_1 == "foo"
assert obj.item_2 == "bar"
result = render_node(custom_type, obj)
expected = load_xml(
"""
<document>
<ns0:authentication xmlns:ns0="http://tests.python-zeep.org/">
<ns0:item_1>foo</ns0:item_1>
<ns0:item_2>bar</ns0:item_2>
</ns0:authentication>
</document>
"""
)
assert_nodes_equal(result, expected)
obj = custom_type.parse(result[0], None)
assert obj.item_1 == "foo"
assert obj.item_2 == "bar"
assert not hasattr(obj, "foobar")
def test_sign_pw():
envelope = load_xml("""
<soapenv:Envelope
xmlns:tns="http://tests.python-zeep.org/"
xmlns:wsdl="https://schemas.xmlsoap.org/wsdl/"
xmlns:soapenv="https://schemas.xmlsoap.org/soap/envelope/"
xmlns:soap="https://schemas.xmlsoap.org/wsdl/soap/">
<soapenv:Header></soapenv:Header>
<soapenv:Body>
<tns:Function>
<tns:Argument>OK</tns:Argument>
</tns:Function>
</soapenv:Body>
</soapenv:Envelope>
""")
signature.sign_envelope(envelope, KEY_FILE_PW, KEY_FILE_PW, "geheim")
signature.verify_envelope(envelope, KEY_FILE_PW)
def test_restriction_global():
schema = xsd.Schema(load_xml("""
<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
targetNamespace="http://tests.python-zeep.org/"
elementFormDefault="qualified">
<simpleType name="foo">
<restriction base="integer">
<minInclusive value="0"/>
<maxInclusive value="100"/>
</restriction>
</simpleType>
</schema>
"""))
type_cls = schema.get_type('{http://tests.python-zeep.org/}foo')
assert type_cls.qname.text == '{http://tests.python-zeep.org/}foo'
def test_xsd_missing_localname():
schema = xsd.Schema(
load_xml(
b"""
<?xml version="1.0" encoding="utf-8"?>
<schema
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<element name="container" type="xsd:"/>
</schema>
"""
)
)
schema.get_element("{http://tests.python-zeep.org/}container")
def test_simple_content_extension(schema_visitor):
node = load_xml("""
<schema
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<simpleType name="BaseType">
<restriction base="xsd:integer">
<minInclusive value="0"/>
<maxInclusive value="100"/>
</restriction>
</simpleType>
<complexType name="SubType1">
<simpleContent>
<extension base="tns:BaseType">
<attribute name="attr_1" type="xsd:string"/>
<attribute name="attr_2" type="xsd:string"/>
</extension>
</simpleContent>
</complexType>
<complexType name="SubType2">
<simpleContent>
<extension base="tns:BaseType">
<attribute name="attr_a" type="xsd:string"/>
<attribute name="attr_b" type="xsd:string"/>
<attribute name="attr_c" type="xsd:string"/>
</extension>
</simpleContent>
</complexType>
</schema>
""")
schema_visitor.visit_schema(node)
schema = schema_visitor.schema
schema.resolve()
record_type = schema.get_type('{http://tests.python-zeep.org/}SubType1')
assert len(record_type.attributes) == 2
assert len(record_type.elements) == 1
record_type = schema.get_type('{http://tests.python-zeep.org/}SubType2')
assert len(record_type.attributes) == 3
assert len(record_type.elements) == 1
def test_simple_content_extension(schema_visitor):
node = load_xml("""
<schema
xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://tests.python-zeep.org/"
elementFormDefault="qualified"
targetNamespace="http://tests.python-zeep.org/">
<simpleType name="BaseType">
<restriction base="xsd:integer">
<minInclusive value="0"/>
<maxInclusive value="100"/>
</restriction>
</simpleType>
<complexType name="SubType1">
<simpleContent>
<extension base="tns:BaseType">
<attribute name="attr_1" type="xsd:string"/>
<attribute name="attr_2" type="xsd:string"/>
</extension>
</simpleContent>
</complexType>
<complexType name="SubType2">
<simpleContent>
<extension base="tns:BaseType">
<attribute name="attr_a" type="xsd:string"/>
<attribute name="attr_b" type="xsd:string"/>
<attribute name="attr_c" type="xsd:string"/>
</extension>
</simpleContent>
</complexType>
</schema>
""")
schema_visitor.visit_schema(node)
schema = schema_visitor.schema
schema._prefix_map['ns0'] = 'http://tests.python-zeep.org/'
record_type = schema.get_type('ns0:SubType1')
child_attrs = [child.name for child in record_type._children]
assert len(child_attrs) == 3
record_type = schema.get_type('ns0:SubType2')
child_attrs = [child.name for child in record_type._children]
assert len(child_attrs) == 4
