always poll async

if we poll sync then the server might not ever
get a hold of the event loop. this was causing
a problem for the sanic server in a test

Author: rmorshea

requirements/pkg-deps.txt

@@ -5,4 +5,3 @@ jsonpatch >=1.32
 fastjsonschema >=2.14.5
 requests >=2
 colorlog >=6
-werkzeug >=2

src/idom/server/tornado.py

@@ -26,7 +26,7 @@
 from .utils import CLIENT_BUILD_DIR, safe_client_build_dir_path
 
 
-ConnectionContext: type[Context[HTTPServerRequest | None]] = create_context(
+ConnectionContext: type[Context[Connection | None]] = create_context(
     None, "ConnectionContext"
 )
 
@@ -207,7 +207,7 @@ class ModelStreamHandler(WebSocketHandler):
     def initialize(self, component_constructor: ComponentConstructor) -> None:
         self._component_constructor = component_constructor
 
-    async def open(self, path: str = "") -> None:
+    async def open(self, path: str = "", *args: Any, **kwargs: Any) -> None:
         message_queue: "AsyncQueue[str]" = AsyncQueue()
 
         async def send(value: VdomJsonPatch) -> None:

src/idom/server/utils.py

@@ -2,14 +2,13 @@
 
 import asyncio
 import logging
+import os
 import socket
 from contextlib import closing
 from importlib import import_module
 from pathlib import Path
 from typing import Any, Iterator
 
-from werkzeug.security import safe_join
-
 import idom
 from idom.config import IDOM_WEB_MODULES_DIR
 from idom.types import RootComponentConstructor
@@ -72,11 +71,16 @@ def safe_web_modules_dir_path(path: str) -> Path:
     return traversal_safe_path(IDOM_WEB_MODULES_DIR.current, *path.split("/"))
 
 
-def traversal_safe_path(root: Path, *unsafe_parts: str | Path) -> Path:
-    """Sanitize user given path using ``werkzeug.security.safe_join``"""
-    path = safe_join(str(root.resolve()), *unsafe_parts)  # type: ignore
-    if path is None:
-        raise ValueError("Unsafe path")  # pragma: no cover
+def traversal_safe_path(root: Path, *unsafe: str | Path) -> Path:
+    """Raise a ``ValueError`` if the ``unsafe`` path resolves outside the root dir."""
+    root = root.resolve()
+    # resolve relative paths and symlinks
+    path = root.joinpath(*unsafe).resolve()
+
+    if os.path.commonprefix([root, path]) != str(root):
+        # If the common prefix is not root directory we resolved outside the root dir
+        raise ValueError("Unsafe path")
+
     return Path(path)
 
 

src/idom/testing/common.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import asyncio
+import inspect
 import shutil
 import time
 from functools import wraps
@@ -26,9 +28,7 @@ def clear_idom_web_modules_dir() -> None:
 _RC = TypeVar("_RC", covariant=True)
 
 
-class _UntilFunc(Protocol[_RC]):
-    def __call__(self, condition: Callable[[_RC], bool], timeout: float = ...) -> Any:
-        ...
+_DEFAULT_POLL_DELAY = 0.1
 
 
 class poll(Generic[_R]):  # noqa: N801
@@ -40,64 +40,54 @@ def __init__(
         *args: _P.args,
         **kwargs: _P.kwargs,
     ) -> None:
-        self.until: _UntilFunc[_R]
-        """Check that the coroutines result meets a condition within the timeout"""
+        coro: Callable[_P, Awaitable[_R]]
+        if not inspect.iscoroutinefunction(function):
+
+            async def coro(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+                return cast(_R, function(*args, **kwargs))
 
-        if iscoroutinefunction(function):
-            coro_function = cast(Callable[_P, Awaitable[_R]], function)
-
-            async def coro_until(
-                condition: Callable[[_R], bool],
-                timeout: float = IDOM_TESTING_DEFAULT_TIMEOUT.current,
-            ) -> None:
-                started_at = time.time()
-                while True:
-                    result = await coro_function(*args, **kwargs)
-                    if condition(result):
-                        break
-                    elif (time.time() - started_at) > timeout:  # pragma: no cover
-                        raise TimeoutError(
-                            f"Condition not met within {timeout} "
-                            f"seconds - last value was {result!r}"
-                        )
-
-            self.until = coro_until
         else:
-            sync_function = cast(Callable[_P, _R], function)
-
-            def sync_until(
-                condition: Callable[[_R], bool] | Any,
-                timeout: float = IDOM_TESTING_DEFAULT_TIMEOUT.current,
-            ) -> None:
-                started_at = time.time()
-                while True:
-                    result = sync_function(*args, **kwargs)
-                    if condition(result):
-                        break
-                    elif (time.time() - started_at) > timeout:  # pragma: no cover
-                        raise TimeoutError(
-                            f"Condition not met within {timeout} "
-                            f"seconds - last value was {result!r}"
-                        )
-
-            self.until = sync_until
-
-    def until_is(
+            coro = cast(Callable[_P, Awaitable[_R]], function)
+        self._func = coro
+        self._args = args
+        self._kwargs = kwargs
+
+    async def until(
         self,
-        right: Any,
+        condition: Callable[[_R], bool],
         timeout: float = IDOM_TESTING_DEFAULT_TIMEOUT.current,
-    ) -> Any:
+        delay: float = _DEFAULT_POLL_DELAY,
+    ) -> None:
+        """Check that the coroutines result meets a condition within the timeout"""
+        started_at = time.time()
+        while True:
+            await asyncio.sleep(delay)
+            result = await self._func(*self._args, **self._kwargs)
+            if condition(result):
+                break
+            elif (time.time() - started_at) > timeout:  # pragma: no cover
+                raise TimeoutError(
+                    f"Condition not met within {timeout} "
+                    f"seconds - last value was {result!r}"
+                )
+
+    async def until_is(
+        self,
+        right: _R,
+        timeout: float = IDOM_TESTING_DEFAULT_TIMEOUT.current,
+        delay: float = _DEFAULT_POLL_DELAY,
+    ) -> None:
         """Wait until the result is identical to the given value"""
-        return self.until(lambda left: left is right, timeout)
+        return await self.until(lambda left: left is right, timeout, delay)
 
-    def until_equals(
+    async def until_equals(
         self,
-        right: Any,
+        right: _R,
         timeout: float = IDOM_TESTING_DEFAULT_TIMEOUT.current,
-    ) -> Any:
+        delay: float = _DEFAULT_POLL_DELAY,
+    ) -> None:
         """Wait until the result is equal to the given value"""
-        # not really sure why I need a type ignore comment here
-        return self.until(lambda left: left == right, timeout)  # type: ignore
+        return await self.until(lambda left: left == right, timeout, delay)
 
 
 class HookCatcher:

tests/test_core/test_events.py

@@ -221,4 +221,4 @@ def outer_click_is_not_triggered(event):
     inner = await display.page.wait_for_selector("#inner")
     await inner.click()
 
-    poll(lambda: clicked.current).until_is(True)
+    await poll(lambda: clicked.current).until_is(True)

tests/test_core/test_hooks.py

@@ -204,18 +204,18 @@ def TestComponent():
 
     await client_r_1_button.click()
 
-    poll_event_count.until_equals(1)
-    poll_render_count.until_equals(1)
+    await poll_event_count.until_equals(1)
+    await poll_render_count.until_equals(1)
 
     await client_r_2_button.click()
 
-    poll_event_count.until_equals(2)
-    poll_render_count.until_equals(2)
+    await poll_event_count.until_equals(2)
+    await poll_render_count.until_equals(2)
 
     await client_r_2_button.click()
 
-    poll_event_count.until_equals(3)
-    poll_render_count.until_equals(2)
+    await poll_event_count.until_equals(3)
+    await poll_render_count.until_equals(2)
 
 
 async def test_simple_input_with_use_state(display: DisplayFixture):

tests/test_server/test_common.py

@@ -80,7 +80,11 @@ def ShowScope():
 
 async def test_use_location(display: DisplayFixture):
     location = idom.Ref()
-    poll_location = poll(lambda: location.current)
+
+    @poll
+    async def poll_location():
+        """This needs to be async to allow the server to respond"""
+        return location.current
 
     @idom.component
     def ShowRoute():
@@ -89,7 +93,7 @@ def ShowRoute():
 
     await display.show(ShowRoute)
 
-    poll_location.until_equals(Location("/", ""))
+    await poll_location.until_equals(Location("/", ""))
 
     for loc in [
         Location("/something"),
@@ -100,4 +104,4 @@ def ShowRoute():
         Location("/another/something/file.txt", "?key1=value1&key2=value2"),
     ]:
         await display.goto(loc.pathname + loc.search)
-        poll_location.until_equals(loc)
+        await poll_location.until_equals(loc)

tests/test_web/test_module.py

@@ -110,7 +110,7 @@ def ShowSimpleButton():
 
     button = await display.page.wait_for_selector("#my-button")
     await button.click()
-    poll(lambda: is_clicked.current).until_is(True)
+    await poll(lambda: is_clicked.current).until_is(True)
 
 
 def test_module_from_file_source_conflict(tmp_path):

tests/test_widgets.py

@@ -118,12 +118,12 @@ def SomeComponent():
 
     poll_value = poll(lambda: value.current)
 
-    poll_value.until_equals("hello")
+    await poll_value.until_equals("hello")
 
     await input_2.focus()
     await input_2.type(" world", delay=20)
 
-    poll_value.until_equals("hello world")
+    await poll_value.until_equals("hello world")
 
 
 async def test_use_linked_inputs_on_change_with_cast(display: DisplayFixture):
@@ -145,12 +145,12 @@ def SomeComponent():
 
     poll_value = poll(lambda: value.current)
 
-    poll_value.until_equals(1)
+    await poll_value.until_equals(1)
 
     await input_2.focus()
     await input_2.type("2")
 
-    poll_value.until_equals(12)
+    await poll_value.until_equals(12)
 
 
 async def test_use_linked_inputs_ignore_empty(display: DisplayFixture):
@@ -174,13 +174,13 @@ def SomeComponent():
 
     poll_value = poll(lambda: value.current)
 
-    poll_value.until_equals("1")
+    await poll_value.until_equals("1")
 
     await input_2.focus()
     await input_2.press("Backspace")
 
-    poll_value.until_equals("1")
+    await poll_value.until_equals("1")
 
     await input_2.type("2")
 
-    poll_value.until_equals("2")
+    await poll_value.until_equals("2")

tests/tooling/loop.py

@@ -1,10 +1,12 @@
 import asyncio
 import sys
 import threading
+import time
 from asyncio import wait_for
 from contextlib import contextmanager
 from typing import Iterator
 
+from idom.config import IDOM_TESTING_DEFAULT_TIMEOUT
 from idom.testing import poll
 
 
@@ -37,7 +39,14 @@ def open_event_loop(as_current: bool = True) -> Iterator[asyncio.AbstractEventLo
         finally:
             if as_current:
                 asyncio.set_event_loop(None)
-            poll(loop.is_running).until_is(False)
+            start = time.time()
+            while loop.is_running():
+                if (time.time() - start) > IDOM_TESTING_DEFAULT_TIMEOUT.current:
+                    raise TimeoutError(
+                        "Failed to stop loop after "
+                        f"{IDOM_TESTING_DEFAULT_TIMEOUT.current} seconds"
+                    )
+                time.sleep(0.1)
             loop.close()