Test input task button and extended task decorator

shiny/api-examples/extended_task/app-core.py

@@ -24,11 +24,18 @@ async def slow_compute(a: int, b: int) -> int:
     return a + b
 
 
+# @ui.bind_task_button(button_id="btn2")
+async def slow_input_compute(a: int, b: int) -> int:
+    await asyncio.sleep(3)
+    return a + b
+
+
 with ui.layout_sidebar():
     with ui.sidebar():
         ui.input_numeric("x", "x", 1)
         ui.input_numeric("y", "y", 2)
         ui.input_task_button("btn", "Compute, slowly")
+        ui.input_task_button("btn2", "Compute 2 slowly")
         ui.input_action_button("btn_cancel", "Cancel")
 
     @reactive.Effect
@@ -37,6 +44,13 @@ def handle_click():
         # slow_compute.cancel()
         slow_compute(input.x(), input.y())
 
+    @reactive.Effect
+    @reactive.event(input.btn2, ignore_none=False)
+    async def handle_click2():
+        # slow_compute.cancel()
+        val = await slow_input_compute(input.x(), input.y())
+        print(val)
+
     @reactive.Effect
     @reactive.event(input.btn_cancel)
     def handle_cancel():

tests/playwright/controls.py

@@ -790,6 +790,45 @@ def __init__(
         )
 
 
+class InputTaskButton(
+    _WidthLocM,
+    _InputActionBase,
+):
+    # id: str,
+    # label: TagChild,
+    # *args: TagChild,
+    # icon: TagChild = None,
+    # label_busy: TagChild = "Processing...",
+    # icon_busy: TagChild | MISSING_TYPE = MISSING,
+    # width: Optional[str] = None,
+    # type: Optional[str] = "primary",
+    # auto_reset: bool = True,
+    # **kwargs: TagAttrValue,
+    def __init__(
+        self,
+        page: Page,
+        id: str,
+    ) -> None:
+        super().__init__(
+            page,
+            id=id,
+            loc=f"button#{id}.bslib-task-button.shiny-bound-input",
+        )
+
+    def expect_state(self, state: str, *, timeout: Timeout = None):
+        expect_attr(
+            self.loc.locator("> bslib-switch-inline"),
+            name="case",
+            value=state,
+            timeout=timeout,
+        )
+
+    def expect_label_text(self, value: list[str], *, timeout: Timeout = None):
+        playwright_expect(
+            self.loc.locator("> bslib-switch-inline > span")
+        ).to_have_text(value, timeout=timeout)
+
+
 class InputActionLink(_InputActionBase):
     # label: TagChild,
     # icon: TagChild = None,
@@ -2169,6 +2208,9 @@ def __init__(
     ) -> None:
         super().__init__(page, id=id, loc=f"#{id}.shiny-text-output")
 
+    def get_value(self, *, timeout: Timeout = None) -> str:
+        return self.loc.inner_text(timeout=timeout)
+
 
 class OutputCode(_OutputTextValue):
     def __init__(self, page: Page, id: str) -> None:

tests/playwright/shiny/inputs/input_task_button/app.py

@@ -0,0 +1,62 @@
+import asyncio
+from datetime import datetime
+
+from shiny import reactive, render
+from shiny.express import input, ui
+
+ui.h5("Current time")
+
+
+@render.text()
+def current_time() -> str:
+    reactive.invalidate_later(0.1)
+    return str(datetime.now().utcnow())
+
+
+with ui.p():
+    "Notice that the time above updates every second, even if you click the button below."
+
+
+@ui.bind_task_button(button_id="btn")
+@reactive.extended_task
+async def slow_compute(a: int, b: int) -> int:
+    await asyncio.sleep(3)
+    return a + b
+
+
+# @ui.bind_task_button(button_id="btn2")
+async def slow_input_compute(a: int, b: int) -> int:
+    await asyncio.sleep(3)
+    return a + b
+
+
+with ui.layout_sidebar():
+    with ui.sidebar():
+        ui.input_numeric("x", "x", 1)
+        ui.input_numeric("y", "y", 2)
+        ui.input_task_button("btn", "Compute, slowly")
+        ui.input_task_button("btn2", "Compute 2 slowly", label_busy="Blocking...")
+        ui.input_action_button("btn_cancel", "Cancel")
+
+    @reactive.Effect
+    @reactive.event(input.btn, ignore_none=False)
+    def handle_click():
+        # slow_compute.cancel()
+        slow_compute(input.x(), input.y())
+
+    @reactive.Effect
+    @reactive.event(input.btn2, ignore_none=False)
+    async def handle_click2():
+        # slow_compute.cancel()
+        await slow_input_compute(input.x(), input.y())
+
+    @reactive.Effect
+    @reactive.event(input.btn_cancel)
+    def handle_cancel():
+        slow_compute.cancel()
+
+    ui.h5("Sum of x and y")
+
+    @render.text
+    def show_result():
+        return str(slow_compute.result())

tests/playwright/shiny/inputs/input_task_button/test_input_task_button.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from conftest import ShinyAppProc
+from controls import InputNumeric, InputTaskButton, OutputText
+from playwright.sync_api import Page
+
+
+def click_extended_task_button(
+    button: InputTaskButton,
+    current_time: OutputText,
+    button_label: list[str],
+) -> str:
+    button.expect_state("ready")
+    button.expect_label_text(button_label)
+    button.click(timeout=0)
+    button.expect_state("busy", timeout=0)
+    return current_time.get_value(timeout=0)
+
+
+def test_input_action_task_button(page: Page, local_app: ShinyAppProc) -> None:
+    page.goto(local_app.url)
+    y = InputNumeric(page, "y")
+    y.set("4")
+    result = OutputText(page, "show_result")
+    current_time = OutputText(page, "current_time")
+    current_time.expect.not_to_be_empty()
+
+    result.expect_value("3")
+
+    # extended task
+    button1 = InputTaskButton(page, "btn")
+    time1 = click_extended_task_button(
+        button1, current_time, button_label=["Compute, slowly", "\n  \n Processing..."]
+    )
+    current_time.expect.not_to_have_text(time1, timeout=500)
+
+    result.expect_value("3", timeout=0)
+    result.expect_value("5", timeout=(3 + 1) * 1000)
+    y.set("15")
+    result.expect_value("5")
+
+    # extended task with blocking
+    button2 = InputTaskButton(page, "btn2")
+    time2 = click_extended_task_button(
+        button2, current_time, button_label=["Compute 2 slowly", "\n  \n Blocking..."]
+    )
+    current_time.expect_value(time2, timeout=0)