from collections import deque
import pytest
from lxml import etree
from tests.utils import assert_nodes_equal, load_xml, render_node
from zeep import xsd
from zeep.exceptions import ValidationError, XMLParseError
from zeep.helpers import serialize_object
def test_choice_element():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
value = element(item_1="foo")
assert value.item_1 == "foo"
assert value.item_2 is None
assert value.item_3 is None
expected = """
foo
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
assert value.item_1 == "foo"
assert value.item_2 is None
assert value.item_3 is None
def test_choice_element_second_elm():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
value = element(item_2="foo")
assert value.item_1 is None
assert value.item_2 == "foo"
assert value.item_3 is None
expected = """
foo
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
assert value.item_1 is None
assert value.item_2 == "foo"
assert value.item_3 is None
def test_choice_element_second_elm_positional():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
child = schema.get_type("ns0:type_2")(child_1="ha", child_2="ho")
element = schema.get_element("ns0:container")
with pytest.raises(TypeError):
value = element(child)
value = element(item_2=child)
element = schema.get_element("ns0:containerArray")
with pytest.raises(TypeError):
value = element(child)
value = element(item_2=child)
element = schema.get_element("ns0:container")
value = element(item_2=child)
assert value.item_1 is None
assert value.item_2 == child
expected = """
ha
ho
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
assert value.item_1 is None
assert value.item_2.child_1 == "ha"
assert value.item_2.child_2 == "ho"
def test_choice_element_multiple():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
value = element(
_value_1=[{"item_1": "foo"}, {"item_2": "bar"}, {"item_1": "three"}]
)
assert value._value_1 == [{"item_1": "foo"}, {"item_2": "bar"}, {"item_1": "three"}]
expected = """
foo
bar
three
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
assert value._value_1 == [{"item_1": "foo"}, {"item_2": "bar"}, {"item_1": "three"}]
def test_choice_element_optional():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
value = element(item_4="foo")
expected = """
foo
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
assert value.item_4 == "foo"
def test_choice_element_with_any():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
value = element(item_1="foo", name="foo", something="bar")
expected = """
foo
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
result = element.parse(node[0], schema)
assert result.name == "foo"
assert result.something is True
assert result.item_1 == "foo"
def test_choice_element_with_only_any():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
item_1 = schema.get_element("ns0:item_1")
any_object = xsd.AnyObject(item_1, item_1("foo"))
value = element(_value_1=[any_object], name="foo", something="bar")
expected = """
foo
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
result = element.parse(node[0], schema)
assert result.name == "foo"
assert result.something is True
assert result._value_1 == ["foo"]
def test_choice_element_with_any_max_occurs():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
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 = """
item-2
any-content
"""
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_optional_values():
schema = load_xml(
"""
"""
)
schema = xsd.Schema(schema)
node = load_xml("")
elm = schema.get_type("ns0:Transport")
elm.parse_xmlelement(node, schema)
def test_choice_in_sequence():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
container_elm = schema.get_element("ns0:container")
assert container_elm.type.signature(schema=schema) == (
"ns0:container(something: xsd:string, ({item_1: xsd:string} | {item_2: xsd:string} | {item_3: xsd:string}))"
)
value = container_elm(something="foobar", item_1="item-1")
expected = """
foobar
item-1
"""
node = etree.Element("document")
container_elm.render(node, value)
assert_nodes_equal(expected, node)
value = container_elm.parse(node[0], schema)
def test_choice_with_sequence():
node = load_xml(
"""
"""
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
assert element.type.signature(schema=schema) == (
"ns0:container(({item_1: xsd:string, item_2: xsd:string} | {item_3: xsd:string, item_4: xsd:string}))"
)
value = element(item_1="foo", item_2="bar")
expected = """
foo
bar
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
def test_choice_with_sequence_once():
node = load_xml(
"""
"""
)
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}))"
)
value = element(item_0="nul", item_1="foo", item_2="bar")
expected = """
nul
foo
bar
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
def test_choice_with_sequence_unbounded():
node = load_xml(
"""
"""
)
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: ns0:obj]}))"
)
value = element(
_value_1=[
{
"item_0": "nul",
"item_1": "foo",
"item_2": {"_value_1": [{"item_2_1": "bar"}]},
}
]
)
expected = """
nul
foo
bar
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
assert value._value_1[0]["item_0"] == "nul"
assert value._value_1[0]["item_1"] == "foo"
assert value._value_1[0]["item_2"]._value_1[0]["item_2_1"] == "bar"
assert not hasattr(value._value_1[0]["item_2"], "item_2_1")
def test_choice_with_sequence_missing_elements():
node = load_xml(
"""
"""
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
assert element.type.signature(schema=schema) == (
"ns0:container(({item_1: xsd:string, item_2: xsd:string})[])"
)
value = element(_value_1={"item_1": "foo"})
with pytest.raises(ValidationError):
render_node(element, value)
def test_choice_with_sequence_once_extra_data():
node = load_xml(
"""
"""
)
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 = """
nul
foo
bar
item-3
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
def test_choice_with_sequence_second():
node = load_xml(
"""
"""
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
assert element.type.signature(schema=schema) == (
"ns0:container(({item_1: xsd:string, item_2: xsd:string} | {item_3: xsd:string, item_4: xsd:string}))"
)
value = element(item_3="foo", item_4="bar")
expected = """
foo
bar
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
def test_choice_with_sequence_invalid():
node = load_xml(
"""
"""
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
assert element.type.signature(schema=schema) == (
"ns0:container(({item_1: xsd:string, item_2: xsd:string} | {item_3: xsd:string, item_4: xsd:string}))"
)
with pytest.raises(TypeError):
element(item_1="foo", item_4="bar")
def test_choice_with_sequence_change():
node = load_xml(
"""
"""
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:ElementName")
elm = element(item_1="foo", item_2="bar")
assert serialize_object(elm) == {
"item_3": None,
"item_2": "bar",
"item_1": "foo",
"item_4": None,
"nee": None,
}
elm.item_1 = "bla-1"
elm.item_2 = "bla-2"
expected = """
bla-1
bla-2
"""
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_choice_with_sequence_change_named():
node = load_xml(
"""
"""
)
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 = """
bla-1
bla-2
"""
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_choice_with_sequence_multiple():
node = load_xml(
"""
"""
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
assert element.type.signature(schema=schema) == (
"ns0:container(({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 = """
foo
bar
foo
bar
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
def test_choice_with_sequence_and_element():
node = load_xml(
"""
"""
)
schema = xsd.Schema(node)
element = schema.get_element("ns0:container")
assert element.type.signature(schema=schema) == (
"ns0:container(({item_1: xsd:string} | {({item_2: xsd:string} | {item_3: xsd:string})}))"
)
value = element(item_2="foo")
expected = """
foo
"""
node = etree.Element("document")
element.render(node, value)
assert_nodes_equal(expected, node)
value = element.parse(node[0], schema)
def test_element_ref_in_choice():
node = etree.fromstring(
"""
""".strip()
)
schema = xsd.Schema(node)
foo_type = schema.get_element("{http://tests.python-zeep.org/}foo")
assert isinstance(foo_type.type, xsd.String)
custom_type = schema.get_element("{http://tests.python-zeep.org/}container")
value = custom_type(foo="bar")
assert value.foo == "bar"
assert value.bar is None
node = etree.Element("document")
custom_type.render(node, value)
expected = """
bar
"""
assert_nodes_equal(expected, node)
def test_parse_dont_loop():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
element = schema.get_element("ns0:container")
expected = load_xml(
"""
foo
bar
foo
bar
"""
)
with pytest.raises(XMLParseError):
element.parse(expected, schema)
def test_parse_check_unexpected():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
element = schema.get_element("ns0:container")
expected = load_xml(
"""
foo
bar
foo
"""
)
with pytest.raises(XMLParseError):
element.parse(expected, schema)
def test_parse_check_mixed():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
element = schema.get_element("ns0:container")
expected = load_xml(
"""
foo
bar
foo
"""
)
element.parse(expected, schema)
def test_parse_check_mixed_choices():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
element = schema.get_element("ns0:container")
# item_1_1
value = element(item_1_1="foo")
assert value.item_1_1 == "foo"
node = etree.Element("document")
element.render(node, value)
expected = """
foo
"""
assert_nodes_equal(expected, node)
# item_1_2a
value = element(item_1_2a="foo")
node = etree.Element("document")
element.render(node, value)
expected = """
foo
"""
assert_nodes_equal(expected, node)
# item_1_2a & item_1_2b
value = element(item_1_2a="foo", item_1_2b="bar")
node = etree.Element("document")
element.render(node, value)
expected = """
foo
bar
"""
assert_nodes_equal(expected, node)
# item_2
value = element(item_2="foo")
assert value.item_2 == "foo"
node = etree.Element("document")
element.render(node, value)
expected = """
foo
"""
assert_nodes_equal(expected, node)
# item_3
value = element(item_3="foo")
assert value.item_3 == "foo"
node = etree.Element("document")
element.render(node, value)
expected = """
foo
"""
assert_nodes_equal(expected, node)
def test_choice_extend():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
element = schema.get_element("ns0:container")
node = load_xml(
"""
foo
bar
"""
)
value = element.parse(node, schema)
node = load_xml(
"""
foo
bar
xafoo
xabar
"""
)
value = element.parse(node, schema)
assert value["item-1-1"] == "foo"
assert value["item-1-2"] == "bar"
assert value["_value_1"][0] == {"item-2-1": "xafoo"}
assert value["_value_1"][1] == {"item-2-2": "xabar"}
def test_choice_extend_base():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
element = schema.get_element("ns0:container")
node = load_xml(
"""
foo
foo
bar
"""
)
value = element.parse(node, schema)
assert value["container-1"] == "foo"
assert value["container-2"] == "bar"
assert value["choice-1"] == "foo"
def test_nested_choice():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
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(
"""
item-1
item-2
"""
)
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(
"""
1
"""
)
result = container_type.parse(expected, schema)
assert result.b == "1"
def test_unit_choice_parse_xmlelements_max_1():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
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)
assert result == {"item_1": "item-1"}
assert len(data) == 2
def test_unit_choice_parse_xmlelements_max_2():
schema = xsd.Schema(
load_xml(
"""
"""
)
)
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