Add support for nested xsd:choice elements (mvantellingen#370)

Author: mvantellingen

CHANGES

@@ -1,3 +1,8 @@
+1.3.0 (unreleased)
+------------------
+ - Add support for nested xsd:choice elements (#370)
+
+
 1.2.0 (2017-03-12)
 ------------------
  - Add flag to disable strict mode in the Client. This allows zeep to better

src/zeep/xsd/elements/indicators.py

@@ -226,6 +226,19 @@ class All(OrderIndicator):
     """
 
     def parse_xmlelements(self, xmlelements, schema, name=None, context=None):
+        """Consume matching xmlelements
+
+        :param xmlelements: Dequeue of XML element objects
+        :type xmlelements: collections.deque of lxml.etree._Element
+        :param schema: The parent XML schema
+        :type schema: zeep.xsd.Schema
+        :param name: The name of the parent element
+        :type name: str
+        :param context: Optional parsing context (for inline schemas)
+        :type context: zeep.xsd.context.XmlParserContext
+        :rtype: dict or None
+
+        """
         result = OrderedDict()
         expected_tags = {element.qname for __, element in self.elements}
         consumed_tags = set()
@@ -261,7 +274,19 @@ def default_value(self):
         return OrderedDict()
 
     def parse_xmlelements(self, xmlelements, schema, name=None, context=None):
-        """Return a dictionary"""
+        """Consume matching xmlelements
+
+        :param xmlelements: Dequeue of XML element objects
+        :type xmlelements: collections.deque of lxml.etree._Element
+        :param schema: The parent XML schema
+        :type schema: zeep.xsd.Schema
+        :param name: The name of the parent element
+        :type name: str
+        :param context: Optional parsing context (for inline schemas)
+        :type context: zeep.xsd.context.XmlParserContext
+        :rtype: dict or None
+
+        """
         result = []
 
         for _unused in max_occurs_iter(self.max_occurs):
@@ -319,7 +344,7 @@ def parse_kwargs(self, kwargs, name, available_kwargs):
         This handles two distinct initialization methods:
 
         1. Passing the choice elements directly to the kwargs (unnested)
-        2. Passing the choice elements into the `name` kwarg (_alue_1) (nested).
+        2. Passing the choice elements into the `name` kwarg (_value_1) (nested).
            This case is required when multiple choice elements are given.
 
         :param name: Name of the choice element (_value_1)
@@ -369,9 +394,9 @@ def parse_kwargs(self, kwargs, name, available_kwargs):
 
             # When choice elements are specified directly in the kwargs
             found = False
-            for i, choice in enumerate(self):
+            for name, choice in self.elements_nested:
                 temp_kwargs = copy.copy(available_kwargs)
-                subresult = choice.parse_kwargs(kwargs, None, temp_kwargs)
+                subresult = choice.parse_kwargs(kwargs, name, temp_kwargs)
 
                 if subresult:
                     if not any(subresult.values()):
@@ -416,8 +441,12 @@ def accept(self, values):
         nums = set()
         for name, element in self.elements_nested:
             if isinstance(element, Element):
-                if name in values and values[name]:
-                    nums.add(1)
+                if self.accepts_multiple:
+                    if all(name in item and item[name] for item in values):
+                        nums.add(1)
+                else:
+                    if name in values and values[name]:
+                        nums.add(1)
             else:
                 num = element.accept(values)
                 nums.add(num)
@@ -473,7 +502,8 @@ class Sequence(OrderIndicator):
 
     """
     def parse_xmlelements(self, xmlelements, schema, name=None, context=None):
-        """
+        """Consume matching xmlelements
+
         :param xmlelements: Dequeue of XML element objects
         :type xmlelements: collections.deque of lxml.etree._Element
         :param schema: The parent XML schema
@@ -482,7 +512,7 @@ def parse_xmlelements(self, xmlelements, schema, name=None, context=None):
         :type name: str
         :param context: Optional parsing context (for inline schemas)
         :type context: zeep.xsd.context.XmlParserContext
-        :return: dict or None
+        :rtype: dict or None
 
         """
         result = []
@@ -585,6 +615,19 @@ def parse_kwargs(self, kwargs, name, available_kwargs):
         return result
 
     def parse_xmlelements(self, xmlelements, schema, name=None, context=None):
+        """Consume matching xmlelements
+
+        :param xmlelements: Dequeue of XML element objects
+        :type xmlelements: collections.deque of lxml.etree._Element
+        :param schema: The parent XML schema
+        :type schema: zeep.xsd.Schema
+        :param name: The name of the parent element
+        :type name: str
+        :param context: Optional parsing context (for inline schemas)
+        :type context: zeep.xsd.context.XmlParserContext
+        :rtype: dict or None
+
+        """
         result = []
 
         for _unused in max_occurs_iter(self.max_occurs):

tests/test_xsd_indicators_choice.py

@@ -1073,3 +1073,59 @@ def test_choice_extend():
     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_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'