fix layout tests + add HookCatcher utility

Author: rmorshea

idom/core/layout.py

@@ -135,8 +135,9 @@ async def _render_element(self, element_state: ElementState) -> Dict[str, Any]:
             resolved_model = await self._render_model(element_state, raw_model)
             element_state.model.clear()
             element_state.model.update(resolved_model)
-        except Exception:
+        except Exception as error:
             logger.exception(f"Failed to render {element_state.element_obj}")
+            element_state.model.update({"tagName": "div", "__error__": str(error)})
 
         # We need to return the model from the `element_state` so that the model
         # between all `ElementState` objects within a `Layout` are shared.
@@ -147,7 +148,9 @@ async def _render_model(
     ) -> Dict[str, Any]:
         model: Dict[str, Any] = dict(model)
 
-        model["eventHandlers"] = self._render_model_event_handlers(element_state, model)
+        event_handlers = self._render_model_event_handlers(element_state, model)
+        if event_handlers:
+            model["eventHandlers"] = event_handlers
 
         if "children" in model:
             model["children"] = await self._render_model_children(

tests/general_utils.py

@@ -1,9 +1,57 @@
+from functools import wraps
+from weakref import ref
+
+
+import idom
+
+
+class HookCatcher:
+    """Utility for capturing a LifeCycleHook from an element
+
+    Example:
+        .. code-block::
+            element_hook = HookCatcher()
+
+            @idom.element
+            @element_hook.capture
+            async def MyElement():
+                ...
+
+        After the first render of ``MyElement`` the ``HookCatcher`` will have
+        captured the element's ``LifeCycleHook``.
+    """
+
+    current: idom.hooks.LifeCycleHook
+
+    def capture(self, render_function):
+        """Decorator for capturing a ``LifeCycleHook`` on the first render of an element"""
+
+        # The render function holds a reference to `self` and, via the `LifeCycleHook`,
+        # the element. Some tests check whether elements are garbage collected, thus we
+        # must use a `ref` here to ensure these checks pass.
+        self_ref = ref(self)
+
+        @wraps(render_function)
+        async def wrapper(*args, **kwargs):
+            self_ref().current = idom.hooks.current_hook()
+            return await render_function(*args, **kwargs)
+
+        return wrapper
+
+    def schedule_render(self) -> None:
+        """Useful alias of ``HookCatcher.current.schedule_render``"""
+        self.current.schedule_render()
+
+
 def assert_unordered_equal(x, y):
+    """Check that two unordered sequences are equal"""
+
     list_x = list(x)
     list_y = list(y)
 
-    assert len(x) == len(y) and all(
+    assert len(x) == len(y), f"len({x}) != len({y})"
+    assert all(
         # this is not very efficient unfortunately so don't compare anything large
         list_x.count(value) == list_y.count(value)
         for value in list_x
-    )
+    ), f"{x} != {y}"

tests/test_core/test_hooks.py

@@ -2,9 +2,7 @@
 
 import idom
 
-from tests.general_utils import assert_unordered_equal
-
-from .utils import HookCatcher
+from tests.general_utils import assert_unordered_equal, HookCatcher
 
 
 async def test_must_be_rendering_in_layout_to_use_hooks():
@@ -392,6 +390,14 @@ def effect():
         assert effect_run_count.current == 2
 
 
+def test_error_in_effect_is_gracefully_handled():
+    assert False
+
+
+def test_error_in_effect_cleanup_is_gracefully_handled():
+    assert False
+
+
 async def test_use_reducer():
     saved_count = idom.Ref(None)
     saved_dispatch = idom.Ref(None)

tests/test_core/test_layout.py

@@ -1,14 +1,12 @@
+import asyncio
 import gc
 from weakref import finalize
 
 import pytest
 
 import idom
-from idom.core.layout import LayoutUpdate
 
-from tests.general_utils import assert_unordered_equal
-
-from .utils import HookCatcher
+from tests.general_utils import assert_unordered_equal, HookCatcher
 
 
 def test_layout_repr():
@@ -40,13 +38,7 @@ async def SimpleElement():
         path, changes = await layout.render()
 
         assert path == ""
-        assert_unordered_equal(
-            changes,
-            [
-                {"op": "add", "path": "/eventHandlers", "value": {}},
-                {"op": "add", "path": "/tagName", "value": "div"},
-            ],
-        )
+        assert changes == [{"op": "add", "path": "/tagName", "value": "div"}]
 
         set_state_hook.current("table")
         path, changes = await layout.render()
@@ -77,16 +69,12 @@ async def Child():
         assert_unordered_equal(
             changes,
             [
-                {"op": "add", "path": "/tagName", "value": "div"},
                 {
                     "op": "add",
                     "path": "/children",
-                    "value": [
-                        "0",
-                        {"children": ["0"], "eventHandlers": {}, "tagName": "div"},
-                    ],
+                    "value": ["0", {"tagName": "div", "children": ["0"]}],
                 },
-                {"op": "add", "path": "/eventHandlers", "value": {}},
+                {"op": "add", "path": "/tagName", "value": "div"},
             ],
         )
 
@@ -104,93 +92,67 @@ async def Child():
 
 
 async def test_layout_render_error_has_partial_update():
-    history = RenderHistory()
-
-    @history.track("main")
     @idom.element
     async def Main():
         return idom.html.div([OkChild(), BadChild(), OkChild()])
 
-    @history.track("ok_child")
     @idom.element
     async def OkChild():
         return idom.html.div(["hello"])
 
-    @history.track("bad_child")
     @idom.element
     async def BadChild():
         raise ValueError("Something went wrong :(")
 
     async with idom.Layout(Main()) as layout:
-
-        src, new, old, errors = await layout.render()
-
-        assert src == history.main_1.id
-
-        assert new == {
-            history.main_1.id: {
-                "tagName": "div",
-                "children": [
-                    {"type": "ref", "data": history.ok_child_1.id},
-                    {"type": "ref", "data": history.bad_child_1.id},
-                    {"type": "ref", "data": history.ok_child_2.id},
-                ],
-            },
-            history.ok_child_1.id: {
-                "tagName": "div",
-                "children": [{"type": "str", "data": "hello"}],
-            },
-            history.bad_child_1.id: {"tagName": "div"},
-            history.ok_child_2.id: {
-                "tagName": "div",
-                "children": [{"type": "str", "data": "hello"}],
-            },
-        }
-
-        assert old == []
-
-        assert len(errors) == 1
-        assert isinstance(errors[0], ValueError)
-        assert str(errors[0]) == "Something went wrong :("
+        patch = await layout.render()
+        assert_unordered_equal(
+            patch.changes,
+            [
+                {
+                    "op": "add",
+                    "path": "/children",
+                    "value": [
+                        {"tagName": "div", "children": ["hello"]},
+                        {"tagName": "div", "__error__": "Something went wrong :("},
+                        {"tagName": "div", "children": ["hello"]},
+                    ],
+                },
+                {"op": "add", "path": "/tagName", "value": "div"},
+            ],
+        )
 
 
 async def test_render_raw_vdom_dict_with_single_element_object_as_children():
-    history = RenderHistory()
-
-    @history.track("main")
     @idom.element
     async def Main():
         return {"tagName": "div", "children": Child()}
 
-    @history.track("child")
     @idom.element
     async def Child():
         return {"tagName": "div", "children": {"tagName": "h1"}}
 
     async with idom.Layout(Main()) as layout:
-        render = await layout.render()
-
-    assert render == LayoutUpdate(
-        src=history.main_1.id,
-        new={
-            history.child_1.id: {
-                "tagName": "div",
-                "children": [{"type": "obj", "data": {"tagName": "h1"}}],
-            },
-            history.main_1.id: {
-                "tagName": "div",
-                "children": [{"type": "ref", "data": history.child_1.id}],
-            },
-        },
-        old=[],
-        errors=[],
-    )
+        patch = await layout.render()
+        assert_unordered_equal(
+            patch.changes,
+            [
+                {
+                    "op": "add",
+                    "path": "/children",
+                    "value": [{"tagName": "div", "children": [{"tagName": "h1"}]}],
+                },
+                {"op": "add", "path": "/tagName", "value": "div"},
+            ],
+        )
 
 
 async def test_elements_are_garbage_collected():
     live_elements = set()
+    outer_element_hook = HookCatcher()
 
     @idom.element
+    @outer_element_hook.capture
     async def Outer():
         element = idom.hooks.current_hook().element
         live_elements.add(element.id)
@@ -213,22 +175,54 @@ async def Inner():
 
     async with idom.Layout(Outer()) as layout:
         await layout.render()
+
         assert len(live_elements) == 2
+
         last_live_elements = live_elements.copy()
         # The existing `Outer` element rerenders. A new `Inner` element is created and
         # the the old `Inner` element should be deleted. Thus there should be one
         # changed element in the set of `live_elements` the old `Inner` deleted and new
         # `Inner` added.
-        await layout.dispatch(idom.core.layout.LayoutEvent("force-update", []))
+        outer_element_hook.schedule_render()
         await layout.render()
+
         assert len(live_elements - last_live_elements) == 1
 
     # The layout still holds a reference to the root so that's
     # only deleted once we release a reference to it.
     del layout
+    # the hook also contains a reference to the root element
+    del outer_element_hook
+
     gc.collect()
     assert not live_elements
 
 
-def test_double_updated_element_is_not_double_rendered():
-    assert False
+async def test_double_updated_element_is_not_double_rendered():
+    hook = HookCatcher()
+    run_count = idom.Ref(0)
+
+    @idom.element
+    @hook.capture
+    async def AnElement():
+        run_count.current += 1
+        return idom.html.div()
+
+    async with idom.Layout(AnElement()) as layout:
+        await layout.render()
+
+        assert run_count.current == 1
+
+        hook.schedule_render()
+        hook.schedule_render()
+
+        await layout.render()
+        try:
+            asyncio.wait_for(
+                [layout.render()],
+                timeout=0.1,  # this should have been plenty of time
+            )
+        except asyncio.CancelledError:
+            pass  # the render should still be rendering since we only update once
+
+        assert run_count.current == 2