fix handling the setting of both multiple and single selectize elements

Author: schloerke

shiny/playwright/controller/_input_controls.py

@@ -579,7 +579,7 @@ def set(
             The timeout for the action. Defaults to `None`.
         """
         if not isinstance(selected, str):
-            raise TypeError("`selected` must be a string")
+            raise TypeError("`selected=` must be a string")
 
         # Only need to set.
         # The Browser will _unset_ the previously selected radio button
@@ -778,10 +778,10 @@ def set(
         """
         # Having an arr of size 0 is allowed. Will uncheck everything
         if not isinstance(selected, list):
-            raise TypeError("`selected` must be a list or tuple")
+            raise TypeError("`selected=` must be a list or tuple")
         for item in selected:
             if not isinstance(item, str):
-                raise TypeError("`selected` must be a list of strings")
+                raise TypeError("`selected=` must be a list of strings")
 
         # Make sure the selected items exist
         # Similar to `self.expect_choices(choices = selected)`, but with
@@ -1200,62 +1200,126 @@ def set(
         timeout
             The maximum time to wait for the selection to be set. Defaults to `None`.
         """
-        if isinstance(selected, str):
-            selected = [selected]
-        # Open the dropdown
-        self._loc_events.click()
 
-        # Sift through the selected items
-        # From left to right, we will remove ordered items that are not in the ordered `selected`
-        # If any selected items are not in the current selection, we will add them at the end
-        i = 0
-        while i < self._loc_events.locator("> .item").count():
-            item_loc = self._loc_events.locator("> .item").nth(i)
-            item_data_value = item_loc.get_attribute("data-value")
+        def click_item(data_value: str, error_str: str) -> None:
+            """
+            Clicks the item in the dropdown by its `data-value` attribute.
+            """
+            if not isinstance(data_value, str):
+                raise TypeError(error_str)
+
+            # Wait for the item to exist
+            playwright_expect(
+                self._loc_selectize.locator(f"[data-value='{data_value}']")
+            ).to_have_count(1, timeout=timeout)
+            # Click the item
+            self._loc_selectize.locator(f"[data-value='{data_value}']").click(
+                timeout=timeout
+            )
+
+        # Make sure the selectize exists
+        playwright_expect(self._loc_events).to_have_count(1, timeout=timeout)
+
+        if self.loc.get_attribute("multiple") is None:
+            # Single element selectize
+            if isinstance(selected, list):
+                if len(selected) != 1:
+                    raise ValueError(
+                        "Expected a `str` value (or a list of a single `str` value) when setting a single-select input."
+                    )
+                selected = selected[0]
+
+            # Open the dropdown
+            self._loc_events.click(timeout=timeout)
+
+            try:
+                # Click the item (which closes the dropdown)
+                click_item(selected, "`selected=` value must be a `str`")
+            finally:
+                # Be sure to close the dropdown
+                # (While this is not necessary on a sucessful `set()`, it is cleaner
+                # than a catch all except)
+                self._loc_events.press("Escape", timeout=timeout)
+
+        else:
+            # Multiple element selectize
 
             def delete_item(item_loc: Locator) -> None:
                 """
                 Deletes the item by clicking on it and pressing the Delete key.
                 """
+
                 item_loc.click()
                 self.page.keyboard.press("Delete")
 
-            # If the item has no data-value, remove it
-            if item_data_value is None:
-                delete_item(item_loc)
-                continue
-
-            # If there are more items than selected, we need to remove the extra ones
-            if i >= len(selected):
-                delete_item(item_loc)
-                continue
-
-            selected_data_value = selected[i]
-
-            # If the item is not the next `selected` value, remove it
-            if item_data_value != selected_data_value:
-                delete_item(item_loc)
-                continue
-
-            # The item is the next `selected` value
-            # Increment the index!
-            i += 1
-
-        # Add the remaining items
-        if i < len(selected):
-            for data_value in selected[i:]:
-                # Click on the item in the dropdown to select it
-                self._loc_selectize.locator(f"[data-value='{data_value}']").click(
-                    timeout=timeout
+            if isinstance(selected, str):
+                selected = [selected]
+            if not isinstance(selected, list):
+                raise TypeError(
+                    "`selected=` must be a single `str` value or a list of `str` values when setting a multiple-select input"
                 )
 
-        # Close the dropdown
-        self._loc_events.press("Escape")
+            # Open the dropdown
+            self._loc_events.click()
+
+            try:
+                # Sift through the selected items
+                # From left to right, we will remove ordered items that are not in the
+                # ordered `selected`
+                # If any selected items are not in the current selection, we will add
+                # them at the end
+
+                # All state transitions examples have an end goal of
+                # A,B,C,D,E
+                #
+                # Items wrapped in `[]` are the item of interest at position `i`
+                # Ex: `Z`,i=3 in A,B,C,[Z],E
+
+                i = 0
+                while i < self._loc_events.locator("> .item").count():
+                    item_loc = self._loc_events.locator("> .item").nth(i)
+                    item_data_value = item_loc.get_attribute("data-value")
+
+                    # If the item has no data-value, remove it
+                    # Transition: A,B,C,[?],D,E -> A,B,C,[D],E
+                    if item_data_value is None:
+                        delete_item(item_loc)
+                        continue
+
+                    # If there are more items than selected, remove the extras
+                    # Transition: A,B,C,D,E,[Z] -> A,B,C,D,E,[]
+                    if i >= len(selected):
+                        delete_item(item_loc)
+                        continue
+
+                    selected_data_value = selected[i]
+
+                    # If the item is not the next `selected` value, remove it
+                    # Transition: A,B,[Z],C,D,E -> A,B,[C],D,E
+                    if item_data_value != selected_data_value:
+                        delete_item(item_loc)
+                        continue
+
+                    # The item is the next `selected` value
+                    # Increment the index! (No need to remove it and add it back)
+                    # A,B,[C],D,E -> A,B,C,[D],E
+                    i += 1
+
+                # Add the remaining items
+                # A,B,[] -> A,B,C,D,E
+                if i < len(selected):
+                    for data_value in selected[i:]:
+                        click_item(
+                            data_value, f"`selected[{i}]=` value must be a `str`"
+                        )
+
+            finally:
+                # Be sure to close the dropdown
+                self._loc_events.press("Escape", timeout=timeout)
         return
 
     def expect_choices(
         self,
-        # TODO-future; support patterns?
         choices: ListPatternOrStr,
         *,
         timeout: Timeout = None,

tests/playwright/shiny/inputs/input_selectize/test_input_selectize.py

@@ -1,3 +1,4 @@
+import pytest
 from playwright.sync_api import Page, expect
 
 from shiny.playwright import controller
@@ -40,10 +41,18 @@ def test_input_selectize_kitchen(page: Page, local_app: ShinyAppProc) -> None:
 
     state1.expect_multiple(True)
 
-    state1.set(["IA", "CA"])
+    state1.set("CA")
+    state1.expect_selected(["CA"])
 
-    state1.expect_selected(["IA", "CA"])
+    with pytest.raises(TypeError) as err:
+        state1.set({"a": "1"})  # pyright: ignore[reportArgumentType]
+        assert "when setting a multiple-select input" in str(err.value)
+    with pytest.raises(TypeError) as err:
+        state1.set(45)  # pyright: ignore[reportArgumentType]
+        assert "value must be a" in str(err.value)
 
+    state1.set(["IA", "CA"])
+    state1.expect_selected(["IA", "CA"])
     value1.expect_value("('IA', 'CA')")
 
     # -------------------------
@@ -89,7 +98,17 @@ def test_input_selectize_kitchen(page: Page, local_app: ShinyAppProc) -> None:
 
     state3.expect_multiple(False)
 
-    state3.set(["NJ"])
+    state3.set("NJ")
+
+    with pytest.raises(ValueError) as err:
+        state3.set(["NJ", "NY"])
+        assert "when setting a single-select input" in str(err.value)
+    with pytest.raises(ValueError) as err:
+        state3.set([])
+        assert "when setting a single-select input" in str(err.value)
+    with pytest.raises(TypeError) as err:
+        state3.set(45)  # pyright: ignore[reportArgumentType]
+        assert "value must be a" in str(err.value)
 
     state3.expect_selected(["NJ"])
     value3.expect_value("NJ")