begin testing layout

Author: rmorshea

idom/core/layout.py

@@ -49,7 +49,7 @@ class ElementState(NamedTuple):
 
 class Layout(HasAsyncResources):
 
-    __slots__ = ["_root", "_event_handlers"]
+    __slots__ = ["root", "_event_handlers"]
 
     if not hasattr(abc.ABC, "__weakref__"):  # pragma: no cover
         __slots__.append("__weakref__")
@@ -60,14 +60,9 @@ def __init__(
         super().__init__()
         if not isinstance(root, AbstractElement):
             raise TypeError("Expected an AbstractElement, not %r" % root)
-        self._root = root
+        self.root = root
         self._event_handlers: Dict[str, EventHandler] = {}
 
-    @property
-    def root(self) -> str:
-        """Id of the root element."""
-        return self._root.id
-
     def update(self, element: "AbstractElement") -> None:
         try:
             self._rendering_queue.put(element)
@@ -92,14 +87,14 @@ async def render(self) -> Dict[str, Any]:
     @async_resource
     async def _rendering_queue(self) -> AsyncIterator["_ElementQueue"]:
         queue = _ElementQueue()
-        queue.put(self._root)
+        queue.put(self.root)
         yield queue
 
     @async_resource
     async def _element_states(self) -> AsyncIterator[ElementState]:
-        root_element_state = self._create_element_state(self._root, "")
+        root_element_state = self._create_element_state(self.root, "")
         try:
-            yield {self._root.id: root_element_state}
+            yield {self.root.id: root_element_state}
         finally:
             self._delete_element_state(root_element_state)
 
@@ -255,6 +250,9 @@ def _iter_element_states_from_root(
                 for i in visited_element_state.child_elements_ids
             )
 
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.root})"
+
 
 @coroutine
 def _render_with_life_cycle_hook(element_state: ElementState) -> Iterator[None]:

tests/test_core/test_hooks.py

@@ -4,6 +4,8 @@
 
 from tests.general_utils import assert_unordered_equal
 
+from .utils import HookCatcher
+
 
 async def test_must_be_rendering_in_layout_to_use_hooks():
     @idom.element
@@ -284,13 +286,13 @@ async def CheckNoEffectYet():
 
 
 async def test_use_effect_cleanup_occurs_on_will_render():
-    element_hook = idom.Ref(None)
+    element_hook = HookCatcher()
     cleanup_triggered = idom.Ref(False)
     cleanup_triggered_before_next_render = idom.Ref(False)
 
     @idom.element
+    @element_hook.capture
     async def ElementWithEffect():
-        element_hook.current = idom.hooks.current_hook()
         if cleanup_triggered.current:
             cleanup_triggered_before_next_render.current = True
 
@@ -308,21 +310,21 @@ def cleanup():
 
         assert not cleanup_triggered.current
 
-        element_hook.current.schedule_render()
+        element_hook.schedule_render()
         await layout.render()
 
         assert cleanup_triggered.current
         assert cleanup_triggered_before_next_render.current
 
 
 async def test_use_effect_cleanup_occurs_on_will_unmount():
-    outer_element_hook = idom.Ref(None)
+    outer_element_hook = HookCatcher()
     cleanup_triggered = idom.Ref(False)
     cleanup_triggered_before_next_render = idom.Ref(False)
 
     @idom.element
+    @outer_element_hook.capture
     async def OuterElement():
-        outer_element_hook.current = idom.hooks.current_hook()
         if cleanup_triggered.current:
             cleanup_triggered_before_next_render.current = True
         return ElementWithEffect()
@@ -343,24 +345,24 @@ def cleanup():
 
         assert not cleanup_triggered.current
 
-        outer_element_hook.current.schedule_render()
+        outer_element_hook.schedule_render()
         await layout.render()
 
         assert cleanup_triggered.current
         assert cleanup_triggered_before_next_render.current
 
 
 async def test_use_effect_memoization():
-    element_hook = idom.Ref(None)
+    element_hook = HookCatcher()
     set_state_callback = idom.Ref(None)
     effect_run_count = idom.Ref(0)
 
     first_value = 1
     second_value = 2
 
     @idom.element
+    @element_hook.capture
     async def ElementWithMemoizedEffect():
-        element_hook.current = idom.hooks.current_hook()
         state, set_state_callback.current = idom.hooks.use_state(first_value)
 
         @idom.hooks.use_effect(args=[state])
@@ -374,7 +376,7 @@ def effect():
 
         assert effect_run_count.current == 1
 
-        element_hook.current.schedule_render()
+        element_hook.schedule_render()
         await layout.render()
 
         assert effect_run_count.current == 1
@@ -384,7 +386,7 @@ def effect():
 
         assert effect_run_count.current == 2
 
-        element_hook.current.schedule_render()
+        element_hook.schedule_render()
         await layout.render()
 
         assert effect_run_count.current == 2

tests/test_core/test_layout.py

@@ -1,13 +1,14 @@
 import gc
-import asyncio
 from weakref import finalize
 
 import pytest
 
 import idom
 from idom.core.layout import LayoutUpdate
 
-from .utils import RenderHistory
+from tests.general_utils import assert_unordered_equal
+
+from .utils import HookCatcher
 
 
 def test_layout_repr():
@@ -27,104 +28,79 @@ def test_layout_expects_abstract_element():
         idom.Layout(idom.html.div())
 
 
-async def test_layout_has_event_loop(event_loop):
-    @idom.element
-    async def MyElement():
-        return idom.html.div()
-
-    async with idom.Layout(MyElement()) as layout:
-        assert layout.loop is event_loop
-        # await the render since creating the layout schedules a render task
-        await layout.render()
-
-
-async def test_layout_cancels_renders_on_close():
-    event_that_is_never_set = asyncio.Event()
-    render_is_cancelled = asyncio.Event()
-
-    @idom.element
-    async def MyElement():
-        try:
-            await event_that_is_never_set.wait()
-        finally:
-            render_is_cancelled.set()
-
-    async with idom.Layout(MyElement()):
-        await asyncio.sleep(0.1)
-
-    await render_is_cancelled.wait()
-
-
 async def test_simple_layout():
     set_state_hook = idom.Ref(None)
 
     @idom.element
-    async def SimpleElement(tag):
-        tag, set_tag = idom.hooks.use_state(tag)
-        set_state_hook.current = set_tag
+    async def SimpleElement():
+        tag, set_state_hook.current = idom.hooks.use_state("div")
         return idom.vdom(tag)
 
-    element = SimpleElement("div")
-    async with idom.Layout(element) as layout:
+    async with idom.Layout(SimpleElement()) as layout:
+        path, changes = await layout.render()
 
-        src, new, old, errors = await layout.render()
-        assert src == element.id
-        assert new == {element.id: {"tagName": "div"}}
-        assert old == []
-        assert errors == []
+        assert path == ""
+        assert_unordered_equal(
+            changes,
+            [
+                {"op": "add", "path": "/eventHandlers", "value": {}},
+                {"op": "add", "path": "/tagName", "value": "div"},
+            ],
+        )
 
         set_state_hook.current("table")
+        path, changes = await layout.render()
 
-        src, new, old, errors = await layout.render()
-        assert src == element.id
-        assert new == {element.id: {"tagName": "table"}}
-        assert old == []
-        assert errors == []
+        assert path == ""
+        assert changes == [{"op": "replace", "path": "/tagName", "value": "table"}]
 
 
 async def test_nested_element_layout():
+    parent_set_state = idom.Ref(None)
+    child_set_state = idom.Ref(None)
 
-    history = RenderHistory()
-
-    @history.track("parent")
     @idom.element
     async def Parent():
-        return idom.html.div([Child()])
+        state, parent_set_state.current = idom.hooks.use_state(0)
+        return idom.html.div(state, Child())
 
-    @history.track("child")
     @idom.element
     async def Child():
-        return idom.html.div()
+        state, child_set_state.current = idom.hooks.use_state(0)
+        return idom.html.div(state)
 
     async with idom.Layout(Parent()) as layout:
 
-        src, new, old, errors = await layout.render()
+        path, changes = await layout.render()
 
-        assert src == history.parent_1.id
-        assert new == {
-            history.parent_1.id: {
-                "tagName": "div",
-                "children": [{"data": history.child_1.id, "type": "ref"}],
-            },
-            history.child_1.id: {"tagName": "div"},
-        }
-        assert old == []
-        assert errors == []
+        assert path == ""
+        assert_unordered_equal(
+            changes,
+            [
+                {"op": "add", "path": "/tagName", "value": "div"},
+                {
+                    "op": "add",
+                    "path": "/children",
+                    "value": [
+                        "0",
+                        {"children": ["0"], "eventHandlers": {}, "tagName": "div"},
+                    ],
+                },
+                {"op": "add", "path": "/eventHandlers", "value": {}},
+            ],
+        )
 
-        layout.update(history.parent_1)
+        parent_set_state.current(1)
+        path, changes = await layout.render()
 
-        src, new, old, errors = await layout.render()
+        assert path == ""
+        assert changes == [{"op": "replace", "path": "/children/0", "value": "1"}]
 
-        assert src == history.parent_1.id
-        assert new == {
-            history.parent_1.id: {
-                "tagName": "div",
-                "children": [{"data": history.child_2.id, "type": "ref"}],
-            },
-            history.child_2.id: {"tagName": "div"},
-        }
-        assert old == [history.child_1.id]
-        assert errors == []
+        child_set_state.current(1)
+        path, changes = await layout.render()
+
+        assert path == "/children/1"
+        assert changes == [{"op": "replace", "path": "/children/0", "value": "1"}]
 
 
 async def test_layout_render_error_has_partial_update():
@@ -220,11 +196,11 @@ async def Outer():
         live_elements.add(element.id)
         finalize(element, live_elements.remove, element.id)
 
-        update = idom.hooks.use_update()
+        hook = idom.hooks.current_hook()
 
         @idom.event(target_id="force-update")
         async def force_update():
-            update()
+            hook.schedule_render()
 
         return idom.html.div({"onEvent": force_update}, Inner())
 

tests/test_core/test_render.py

@@ -94,11 +94,11 @@ async def recv():
 
     @idom.element
     async def Outer():
-        update = idom.hooks.current_hook().use_update()
+        hook = idom.hooks.current_hook()
 
         @idom.event(target_id=target_id)
         async def an_event():
-            update()
+            hook.schedule_render()
 
         return idom.html.div({"onEvent": an_event}, Inner())
 

tests/test_core/utils.py

@@ -1,32 +1,20 @@
 from functools import wraps
 
 
-class RenderHistory:
-    def __init__(self):
-        self.__counters = {}
-        self.__elements = set()
-
-    def clear(self):
-        for k in self.__dict__.items():
-            if not k.startswith("_"):
-                del self.__dict__[k]
-
-    def track(self, name):
-        if name.startswith("_"):
-            raise ValueError(f"Name {name!r} startswith '_'.")
-
-        self.__counters[name] = 0
-
-        def setup(element_function):
-            @wraps(element_function)
-            def wrapper(*args, **kwargs):
-                elmt = element_function(*args, **kwargs)
-                if elmt.id not in self.__elements:
-                    self.__elements.add(elmt.id)
-                    self.__counters[name] += 1
-                    setattr(self, f"{name}_{self.__counters[name]}", elmt)
-                return elmt
-
-            return wrapper
-
-        return setup
+import idom
+
+
+class HookCatcher:
+
+    current: idom.hooks.LifeCycleHook
+
+    def capture(self, render_function):
+        @wraps(render_function)
+        async def wrapper(*args, **kwargs):
+            self.current = idom.hooks.current_hook()
+            return await render_function(*args, **kwargs)
+
+        return wrapper
+
+    def schedule_render(self) -> None:
+        self.current.schedule_render()