make HookCatcher/StaticEventHandlers testing utils

also fixes mypy typing issues

Author: rmorshea

src/idom/core/layout.py

@@ -379,6 +379,9 @@ class _ModelState:
     )
 
     model: _ModelVdom
+    life_cycle_hook: LifeCycleHook
+    patch_path: str
+    component: AbstractComponent
 
     def __init__(
         self,
@@ -418,12 +421,15 @@ def new(
     ) -> _ModelState:
         if new_parent is None:
             new_parent = getattr(self, "parent", None)
+
+        life_cycle_hook: Optional[LifeCycleHook]
         if hasattr(self, "life_cycle_hook"):
             assert component is not None
             life_cycle_hook = self.life_cycle_hook
             life_cycle_hook.component = component
         else:
             life_cycle_hook = None
+
         return _ModelState(new_parent, self.index, self.key, life_cycle_hook)
 
     def iter_children(self, include_self: bool = True) -> Iterator[_ModelState]:

src/idom/testing.py

@@ -1,5 +1,6 @@
 import logging
 import re
+from functools import wraps
 from types import TracebackType
 from typing import (
     Any,
@@ -12,12 +13,18 @@
     Type,
     TypeVar,
     Union,
+    overload,
 )
 from urllib.parse import urlencode, urlunparse
+from weakref import ref
 
 from selenium.webdriver import Chrome
 from selenium.webdriver.remote.webdriver import WebDriver
+from typing_extensions import Literal
 
+from idom.core.events import EventHandler
+from idom.core.hooks import LifeCycleHook, current_hook
+from idom.core.utils import hex_id
 from idom.server.base import AbstractRenderServer
 from idom.server.prefab import hotswap_server
 from idom.server.utils import find_available_port, find_builtin_server_type
@@ -167,3 +174,107 @@ def __init__(self) -> None:
 
     def handle(self, record: logging.LogRecord) -> None:
         self.records.append(record)
+
+
+class HookCatcher:
+    """Utility for capturing a LifeCycleHook from a component
+
+    Example:
+        .. code-block::
+
+            hooks = HookCatcher(index_by_kwarg="key")
+
+            @idom.component
+            @hooks.capture
+            def MyComponent(key):
+                ...
+
+            ... # render the component
+
+            # grab the last render of where MyComponent(key='some_key')
+            hooks.index["some_key"]
+            # or grab the hook from the component's last render
+            hooks.latest
+
+        After the first render of ``MyComponent`` the ``HookCatcher`` will have
+        captured the component's ``LifeCycleHook``.
+    """
+
+    latest: LifeCycleHook
+
+    def __init__(self, index_by_kwarg: Optional[str] = None):
+        self.index_by_kwarg = index_by_kwarg
+        self.index: Dict[Any, LifeCycleHook] = {}
+
+    def capture(self, render_function: Callable[..., Any]) -> Callable[..., Any]:
+        """Decorator for capturing a ``LifeCycleHook`` on each render of a component"""
+
+        # The render function holds a reference to `self` and, via the `LifeCycleHook`,
+        # the component. Some tests check whether components are garbage collected, thus
+        # we must use a `ref` here to ensure these checks pass once the catcher itself
+        # has been collected.
+        self_ref = ref(self)
+
+        @wraps(render_function)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            self = self_ref()
+            assert self is not None, "Hook catcher has been garbage collected"
+
+            hook = current_hook()
+            if self.index_by_kwarg is not None:
+                self.index[kwargs[self.index_by_kwarg]] = hook
+            self.latest = hook
+            return render_function(*args, **kwargs)
+
+        return wrapper
+
+
+class StaticEventHandlers:
+    """Utility for capturing the target of a static set of event handlers
+
+    Example:
+        .. code-block::
+
+            static_handlers = StaticEventHandlers("first", "second")
+
+            @idom.component
+            def MyComponent(key):
+                state, set_state = idom.hooks.use_state(0)
+                handler = static_handlers.use(key, lambda event: set_state(state + 1))
+                return idom.html.button({"onClick": handler}, "Click me!")
+
+            # gives the target ID for onClick where MyComponent(key="first")
+            first_target = static_handlers.targets["first"]
+    """
+
+    def __init__(self, *index: Any) -> None:
+        if not index:
+            raise ValueError("Static set of index keys are required")
+        self._handlers: Dict[Any, EventHandler] = {i: EventHandler() for i in index}
+        self.targets: Dict[Any, str] = {i: hex_id(h) for i, h in self._handlers.items()}
+
+    @overload
+    def use(
+        self,
+        index: Any,
+        function: Literal[None] = ...,
+    ) -> Callable[[Callable[..., Any]], EventHandler]:
+        ...
+
+    @overload
+    def use(self, index: Any, function: Callable[..., Any]) -> EventHandler:
+        ...
+
+    def use(self, index: Any, function: Optional[Callable[..., Any]] = None) -> Any:
+        """Decorator for capturing an event handler function"""
+
+        def setup(function: Callable[..., Any]) -> EventHandler:
+            handler = self._handlers[index]
+            handler.clear()
+            handler.add(function)
+            return handler
+
+        if function is not None:
+            return setup(function)
+        else:
+            return setup

tests/general_utils.py

@@ -1,12 +1,6 @@
 # dialect=pytest
 
 from contextlib import contextmanager
-from functools import wraps
-from weakref import ref
-
-import idom
-from idom.core.events import EventHandler
-from idom.core.utils import hex_id
 
 
 @contextmanager
@@ -21,74 +15,6 @@ def patch_slots_object(obj, attr, new_value):
         setattr(obj, attr, old_value)
 
 
-class EventCatcher:
-    """Utility for capturing the target of an event handler
-
-    Example:
-        .. code-block::
-
-            event_catcher = EventCatcher()
-
-            @idom.component
-            def MyComponent():
-                state, set_state = idom.hooks.use_state(0)
-                handler = event_catcher.capture(lambda event: set_state(state + 1))
-                return idom.html.button({"onClick": handler}, "Click me!")
-    """
-
-    def __init__(self):
-        self._event_handler = EventHandler()
-
-    @property
-    def target(self) -> str:
-        return hex_id(self._event_handler)
-
-    def capture(self, function) -> EventHandler:
-        """Called within the body of a component to create a captured event handler"""
-        self._event_handler.clear()
-        self._event_handler.add(function)
-        return self._event_handler
-
-
-class HookCatcher:
-    """Utility for capturing a LifeCycleHook from a component
-
-    Example:
-        .. code-block::
-
-            component_hook = HookCatcher()
-
-            @idom.component
-            @component_hook.capture
-            def MyComponent():
-                ...
-
-        After the first render of ``MyComponent`` the ``HookCatcher`` will have
-        captured the component's ``LifeCycleHook``.
-    """
-
-    current: idom.hooks.LifeCycleHook
-
-    def capture(self, render_function):
-        """Decorator for capturing a ``LifeCycleHook`` on the first render of a component"""
-
-        # The render function holds a reference to `self` and, via the `LifeCycleHook`,
-        # the component. Some tests check whether components are garbage collected, thus we
-        # must use a `ref` here to ensure these checks pass.
-        self_ref = ref(self)
-
-        @wraps(render_function)
-        def wrapper(*args, **kwargs):
-            self_ref().current = idom.hooks.current_hook()
-            return render_function(*args, **kwargs)
-
-        return wrapper
-
-    def schedule_render(self) -> None:
-        """Useful alias of ``HookCatcher.current.schedule_render``"""
-        self.current.schedule_render()
-
-
 def assert_same_items(left, right):
     """Check that two unordered sequences are equal (only works if reprs are equal)"""
     sorted_left = list(sorted(left, key=repr))

tests/test_core/test_dispatcher.py

@@ -10,7 +10,8 @@
     SingleViewDispatcher,
 )
 from idom.core.layout import Layout, LayoutEvent
-from tests.general_utils import EventCatcher, assert_same_items
+from idom.testing import StaticEventHandlers
+from tests.general_utils import assert_same_items
 
 
 async def test_shared_state_dispatcher():
@@ -19,9 +20,9 @@ async def test_shared_state_dispatcher():
     changes_2 = []
 
     event_name = "onEvent"
-    event_catcher = EventCatcher()
+    event_handlers = StaticEventHandlers(event_name)
 
-    events_to_inject = [LayoutEvent(target=event_catcher.target, data=[])] * 4
+    events_to_inject = [LayoutEvent(event_handlers.targets[event_name], [])] * 4
 
     async def send_1(patch):
         changes_1.append(patch.changes)
@@ -47,7 +48,7 @@ async def recv_2():
     @idom.component
     def Clickable():
         count, set_count = idom.hooks.use_state(0)
-        handler = event_catcher.capture(lambda: set_count(count + 1))
+        handler = event_handlers.use(event_name, lambda: set_count(count + 1))
         return idom.html.div({event_name: handler, "count": count})
 
     async with SharedViewDispatcher(Layout(Clickable())) as dispatcher:
@@ -61,7 +62,7 @@ def Clickable():
                 "path": "/eventHandlers",
                 "value": {
                     event_name: {
-                        "target": event_catcher.target,
+                        "target": event_handlers.targets[event_name],
                         "preventDefault": False,
                         "stopPropagation": False,
                     }