603: Always generate secondary instance for selects

pyxform/survey.py

@@ -10,7 +10,9 @@
 from collections import defaultdict
 from datetime import datetime
 from functools import lru_cache
-from typing import List, Iterator, Optional
+from typing import Iterator, List, Optional
+
+import aliases
 
 from pyxform import constants
 from pyxform.constants import EXTERNAL_INSTANCE_EXTENSIONS
@@ -643,12 +645,13 @@ def _setup_choice_translations(name, choice_value, itext_id):
                         )
 
         self._translations = defaultdict(dict)  # pylint: disable=W0201
+        select_types = set(aliases.select.keys())
         for element in self.iter_descendants():
             # Skip creation of translations for choices in filtered selects
             # The creation of these translations is done futher below in this
             # function
             parent = element.get("parent")
-            if parent and not parent.get("choice_filter"):
+            if parent is not None and parent[constants.TYPE] not in select_types:
                 for d in element.get_translations(self.default_language):
                     translation_path = d["path"]
                     form = "long"
@@ -680,7 +683,7 @@ def _setup_choice_translations(name, choice_value, itext_id):
                 and not has_dynamic_label(choice_list, multi_language)
             ):
                 continue
-            for idx, choice in zip(range(len(choice_list)), choice_list):
+            for idx, choice in enumerate(choice_list):
                 for name, choice_value in choice.items():
                     itext_id = "-".join([list_name, str(idx)])
                     if isinstance(choice_value, dict):

pyxform/survey_element.py

@@ -244,6 +244,13 @@ def to_json_dict(self):
         result["children"] = []
         for child in children:
             result["children"].append(child.to_json_dict())
+        # Translation items with "output_context" have circular references.
+        if "_translations" in result:
+            for lang in result["_translations"].values():
+                for item in lang.values():
+                    for form in item.values():
+                        if callable(getattr(form, "pop", None)):
+                            form.pop("output_context", None)
         # remove any keys with empty values
         for k, v in list(result.items()):
             if not v:

tests/pyxform_test_case.py

@@ -300,7 +300,7 @@ def check_content(content, expected):
                         nsmap_subs=final_nsmap_subs,
                         content_str=cstr,
                     )
-                    for i in expected:
+                    for idx, i in enumerate(expected, start=1):
                         if verb == "contains":
                             self.assertContains(cstr, i, msg_prefix=keyword)
                         elif verb == "excludes":
@@ -311,20 +311,23 @@ def check_content(content, expected):
                                 content=content,
                                 xpath=i[0],
                                 expected=i[1],
+                                case_num=idx,
                             )
                         elif verb == "xpath_count":
                             self.assert_xpath_count(
                                 matcher_context=matcher_context,
                                 content=content,
                                 xpath=i[0],
                                 expected=i[1],
+                                case_num=idx,
                             )
                         elif verb == "xpath_match":
                             self.assert_xpath_count(
                                 matcher_context=matcher_context,
                                 content=content,
                                 xpath=i,
                                 expected=1,
+                                case_num=idx,
                             )
 
                 return verb_str, check_content
@@ -442,6 +445,7 @@ def assert_xpath_exact(
         content: "_Element",
         xpath: str,
         expected: "Set[str]",
+        case_num: int,
     ) -> None:
         """
         Process an assertion for xml__xpath_exact.
@@ -454,6 +458,7 @@ def assert_xpath_exact(
         :param content: XML to be examined.
         :param xpath: XPath to execute.
         :param expected: Expected XPath matches, as XML fragments.
+        :param case_num: The list position of the test case in the input.
         """
         if not (isinstance(xpath, str) and isinstance(expected, set)):
             msg = "Each xpath_exact requires: tuple(xpath: str, expected: Set[str])."
@@ -464,14 +469,19 @@ def assert_xpath_exact(
             xpath=xpath,
             for_exact=True,
         )
-        self.assertSetEqual(set(expected), observed, matcher_context.content_str)
+        msg = (
+            f"XPath found no matches (test case {case_num}):\n{xpath}"
+            f"\n\nXForm content:\n{matcher_context.content_str}"
+        )
+        self.assertSetEqual(set(expected), observed, msg=msg)
 
     def assert_xpath_count(
         self,
         matcher_context: "MatcherContext",
         content: "_Element",
         xpath: str,
         expected: int,
+        case_num: int,
     ):
         """
         Process an assertion for xml__xpath_count.
@@ -480,6 +490,7 @@ def assert_xpath_count(
         :param content: XML to be examined.
         :param xpath: XPath to execute.
         :param expected: Expected count of XPath matches.
+        :param case_num: The list position of the test case in the input.
         """
         if not (isinstance(xpath, str) and isinstance(expected, int)):
             msg = "Each xpath_count requires: tuple(xpath: str, count: int)"
@@ -489,7 +500,10 @@ def assert_xpath_count(
             content=content,
             xpath=xpath,
         )
-        msg = f"XPath found no matches:\n{xpath}\n\nXForm content:\n{matcher_context.content_str}"
+        msg = (
+            f"XPath found no matches (test case {case_num}):\n{xpath}"
+            f"\n\nXForm content:\n{matcher_context.content_str}"
+        )
         self.assertEqual(expected, len(observed), msg=msg)
 
 

tests/test_choices_sheet.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 from tests.pyxform_test_case import PyxformTestCase
-from tests.xpath_helpers.choices import xp
+from tests.xpath_helpers.choices import xpc
+from tests.xpath_helpers.questions import xpq
 
 
 class ChoicesSheetTest(PyxformTestCase):
@@ -19,8 +20,8 @@ def test_numeric_choice_names__for_static_selects__allowed(self):
             |          | choices            | 2    | Two   |
             """,
             xml__xpath_match=[
-                xp.model_instance_choices("choices", (("1", "One"), ("2", "Two"))),
-                xp.body_select1_itemset("a"),
+                xpc.model_instance_choices_label("choices", (("1", "One"), ("2", "Two"))),
+                xpq.body_select1_itemset("a"),
             ],
         )
 
@@ -39,8 +40,8 @@ def test_numeric_choice_names__for_dynamic_selects__allowed(self):
             |          | choices            | 2    | Two   |
             """,
             xml__xpath_match=[
-                xp.model_instance_choices("choices", (("1", "One"), ("2", "Two"))),
-                xp.body_select1_itemset("a"),
+                xpc.model_instance_choices_label("choices", (("1", "One"), ("2", "Two"))),
+                xpq.body_select1_itemset("a"),
             ],
         )
 
@@ -59,8 +60,18 @@ def test_choices_without_labels__for_static_selects__allowed(self):
             |          | choices            | 2    |       |
             """,
             xml__xpath_match=[
-                xp.model_instance_choices_nl("choices", (("1", ""), ("2", ""))),
-                xp.body_select1_itemset("a"),
+                xpq.body_select1_itemset("a"),
+                """
+                /h:html/h:head/x:model/x:instance[@id='choices']/x:root[
+                  ./x:item/x:name/text() = '1'
+                    and not(./x:item/x:label)
+                    and not(./x:item/x:itextId)
+                  and 
+                  ./x:item/x:name/text() = '2'
+                    and not(./x:item/x:label)
+                    and not(./x:item/x:itextId)
+                ]
+                """
             ],
         )
 
@@ -80,7 +91,17 @@ def test_choices_without_labels__for_dynamic_selects__allowed_by_pyxform(self):
             """,
             run_odk_validate=False,
             xml__xpath_match=[
-                xp.model_instance_choices_nl("choices", (("1", ""), ("2", ""))),
-                xp.body_select1_itemset("a"),
+                xpq.body_select1_itemset("a"),
+                """
+                /h:html/h:head/x:model/x:instance[@id='choices']/x:root[
+                  ./x:item/x:name/text() = '1'
+                    and not(./x:item/x:label)
+                    and not(./x:item/x:itextId)
+                  and 
+                  ./x:item/x:name/text() = '2'
+                    and not(./x:item/x:label)
+                    and not(./x:item/x:itextId)
+                ]
+                """
             ],
         )

tests/test_dynamic_default.py

@@ -8,12 +8,13 @@
 from time import perf_counter
 from typing import Optional, Tuple
 from unittest.mock import patch
-from tests.xpath_helpers.choices import xp as xpc
 
 import psutil
 
 from pyxform import utils
 from tests.pyxform_test_case import PyxformTestCase
+from tests.xpath_helpers.choices import xpc
+from tests.xpath_helpers.questions import xpq
 
 
 @dataclass()
@@ -577,12 +578,16 @@ def test_dynamic_default_select_choice_name_with_hyphen(self):
                 xp.model(1, Case(False, "select_one", "a-2")),
                 xp.model(2, Case(False, "select_one", "1-1")),
                 xp.model(3, Case(False, "select_one", "a-b")),
-                xpc.model_instance_choices("c1", (("a-1", "C A-1"), ("a-2", "C A-2"))),
-                xpc.model_instance_choices("c2", (("1-1", "C 1-1"), ("2-2", "C 1-2"))),
-                xpc.model_instance_choices("c3", (("a-b", "C A-B"),)),
-                xpc.body_select1_itemset("q1"),
-                xpc.body_select1_itemset("q2"),
-                xpc.body_select1_itemset("q3"),
+                xpc.model_instance_choices_label(
+                    "c1", (("a-1", "C A-1"), ("a-2", "C A-2"))
+                ),
+                xpc.model_instance_choices_label(
+                    "c2", (("1-1", "C 1-1"), ("2-2", "C 1-2"))
+                ),
+                xpc.model_instance_choices_label("c3", (("a-b", "C A-B"),)),
+                xpq.body_select1_itemset("q1"),
+                xpq.body_select1_itemset("q2"),
+                xpq.body_select1_itemset("q3"),
             ],
         )
 

tests/test_external_instances_for_selects.py

@@ -13,7 +13,8 @@
 from tests.pyxform_test_case import PyxformTestCase
 from tests.test_utils.md_table import md_table_to_workbook
 from tests.utils import get_temp_dir
-from tests.xpath_helpers.choices import xp as xpc
+from tests.xpath_helpers.choices import xpc
+from tests.xpath_helpers.questions import xpq
 
 
 @dataclass()
@@ -319,8 +320,10 @@ def test_no_params_with_filters(self):
                 ]
                 """,
                 # select_one generates internal select.
-                xpc.model_instance_choices("state", (("nsw", "NSW"), ("vic", "VIC"))),
-                xpc.body_select1_itemset("state"),
+                xpc.model_instance_choices_label(
+                    "state", (("nsw", "NSW"), ("vic", "VIC"))
+                ),
+                xpq.body_select1_itemset("state"),
                 # select_one_external generates input referencing itemsets.csv
                 """
                 /h:html/h:body[.

tests/test_fields.py

@@ -3,7 +3,8 @@
 Test duplicate survey question field name.
 """
 from tests.pyxform_test_case import PyxformTestCase
-from tests.xpath_helpers.choices import xp as xpc
+from tests.xpath_helpers.choices import xpc
+from tests.xpath_helpers.questions import xpq
 
 
 class FieldsTests(PyxformTestCase):
@@ -118,8 +119,10 @@ def test_duplicate_choices_with_allow_choice_duplicates_setting(self):
         self.assertPyxformXform(
             md=md,
             xml__xpath_match=[
-                xpc.model_instance_choices("list", (("a", "A"), ("b", "B"), ("b", "C"))),
-                xpc.body_select1_itemset("S1"),
+                xpc.model_instance_choices_label(
+                    "list", (("a", "A"), ("b", "B"), ("b", "C"))
+                ),
+                xpq.body_select1_itemset("S1"),
             ],
         )
 
@@ -139,8 +142,8 @@ def test_choice_list_without_duplicates_is_successful(self):
         self.assertPyxformXform(
             md=md,
             xml__xpath_match=[
-                xpc.model_instance_choices("list", (("a", "A"), ("b", "B"))),
-                xpc.body_select1_itemset("S1"),
+                xpc.model_instance_choices_label("list", (("a", "A"), ("b", "B"))),
+                xpq.body_select1_itemset("S1"),
             ],
         )
 

tests/test_rank.py

@@ -3,7 +3,8 @@
 Test rank widget.
 """
 from tests.pyxform_test_case import PyxformTestCase
-from tests.xpath_helpers.choices import xp as xpc
+from tests.xpath_helpers.choices import xpc
+from tests.xpath_helpers.questions import xpq
 
 
 class RangeWidgetTest(PyxformTestCase):
@@ -19,8 +20,8 @@ def test_rank(self):
             |        | mylist       | b        | B     |
             """,
             xml__xpath_match=[
-                xpc.model_instance_choices("mylist", (("a", "A"), ("b", "B"))),
-                xpc.body_odk_rank_itemset("order"),  # also an implicit test for xmlns:odk
+                xpc.model_instance_choices_label("mylist", (("a", "A"), ("b", "B"))),
+                xpq.body_odk_rank_itemset("order"),  # also an implicit test for xmlns:odk
                 "/h:html/h:head/x:model/x:bind[@nodeset='/test_name/order' and @type='odk:rank']",
             ],
         )
@@ -56,6 +57,7 @@ def test_rank_filter(self):
         )
 
     def test_rank_translations(self):
+        """Should find itext/translations for rank, using itemset method."""
         self.assertPyxformXform(
             md="""
             | survey |              |          |       |                    |
@@ -67,35 +69,18 @@ def test_rank_translations(self):
             |        | mylist       | b        | B     |  BB                |
             """,
             xml__xpath_match=[
-                xpc.model_instance_choices("mylist", (("a", "A"), ("b", "B"))),
-                xpc.body_odk_rank_itemset("order"),  # also an implicit test for xmlns:odk
+                xpc.model_instance_choices_itext("mylist", ("a", "b")),
+                xpq.body_odk_rank_itemset("order"),  # also an implicit test for xmlns:odk
                 "/h:html/h:head/x:model/x:bind[@nodeset='/test_name/order' and @type='odk:rank']",
+                # All itemset translations.
+                xpc.model_itext_choice_text_label_by_pos("default", "mylist", ("A", "B")),
+                xpc.model_itext_choice_text_label_by_pos(
+                    "French (fr)", "mylist", ("AA", "BB")
+                ),
+                # No non-itemset translations.
+                xpc.model_itext_no_text_by_id("default", "/test_name/order/a:label"),
+                xpc.model_itext_no_text_by_id("default", "/test_name/order/b:label"),
+                xpc.model_itext_no_text_by_id("French (fr)", "/test_name/order/a:label"),
+                xpc.model_itext_no_text_by_id("French (fr)", "/test_name/order/b:label"),
             ],
-            # TODO: fix this test
-            debug=True,
-            #         xml__contains=[
-            #             'xmlns:odk="http://www.opendatakit.org/xforms"',
-            #             '<translation lang="French (fr)">',
-            #             """<text id="/data/order:label">
-            #         <value>Ranger</value>
-            #       </text>""",
-            #             """<text id="/data/order/a:label">
-            #         <value>AA</value>
-            #       </text>""",
-            #             """<text id="/data/order/b:label">
-            #         <value>BB</value>
-            #       </text>""",
-            #             "</translation>",
-            #             """<odk:rank ref="/data/order">
-            #   <label ref="jr:itext('/data/order:label')"/>
-            #   <item>
-            #     <label ref="jr:itext('/data/order/a:label')"/>
-            #     <value>a</value>
-            #   </item>
-            #   <item>
-            #     <label ref="jr:itext('/data/order/b:label')"/>
-            #     <value>b</value>
-            #   </item>
-            # </odk:rank>""",
-            #         ],
         )