test renderer

tests pass but logs show a task is not getting cancelled appropriately
when the loop closes

Author: rmorshea

idom/core/render.py

@@ -11,6 +11,10 @@
 RecvCoroutine = Callable[[], Awaitable[LayoutEvent]]
 
 
+class StopRendering(Exception):
+    """Raised to gracefully stop :meth:`AbstractRenderer.run`"""
+
+
 class AbstractRenderer(abc.ABC):
     """A base class for implementing :class:`~idom.core.layout.Layout` renderers."""
 
@@ -23,10 +27,24 @@ async def run(self, send: SendCoroutine, recv: RecvCoroutine, context: Any) -> N
         This will call :meth:`AbstractLayout.render` and :meth:`AbstractLayout.trigger`
         to render new models and execute events respectively.
         """
+        self._running = True
+        try:
+            await self._run(send, recv, context)
+        except StopRendering:
+            return None
+        finally:
+            await self._stop()
+
+    async def _run(
+        self, send: SendCoroutine, recv: RecvCoroutine, context: Any
+    ) -> None:
         await asyncio.gather(
             self._outgoing_loop(send, context), self._incoming_loop(recv, context)
         )
 
+    async def _stop(self) -> None:
+        pass
+
     async def _outgoing_loop(self, send: SendCoroutine, context: Any) -> None:
         while True:
             await send(await self._outgoing(self._layout, context))
@@ -58,6 +76,7 @@ async def _outgoing(self, layout: AbstractLayout, context: Any) -> Dict[str, Any
         try:
             src, new, old = await layout.render()
         except RenderError as error:
+            raise
             if error.partial_render is None:
                 raise
             logger.exception("Render failed")
@@ -84,10 +103,12 @@ def __init__(self, layout: AbstractLayout) -> None:
         self._updates: Dict[str, asyncio.Queue[LayoutUpdate]] = {}
         self._render_task = asyncio.ensure_future(self._render_loop(), loop=layout.loop)
 
-    async def run(self, send: SendCoroutine, recv: RecvCoroutine, context: str) -> None:
+    async def _run(
+        self, send: SendCoroutine, recv: RecvCoroutine, context: str
+    ) -> None:
         self._updates[context] = asyncio.Queue()
         try:
-            await asyncio.gather(super().run(send, recv, context), self._render_task)
+            await asyncio.gather(super()._run(send, recv, context), self._render_task)
         except Exception:
             del self._updates[context]
             raise
@@ -127,5 +148,5 @@ async def _outgoing(self, layout: AbstractLayout, context: str) -> Dict[str, Any
         src, new, old = await self._updates[context].get()
         return {"root": layout.root, "src": src, "new": new, "old": old}
 
-    def __del__(self) -> None:
+    async def _stop(self) -> None:
         self._render_task.cancel()

requirements/extras.txt

@@ -1,6 +1,6 @@
 # extra=stable,sanic
 sanic <19.12.0
-sanic-cors >=0.9.9, <1.0
+sanic-cors >=0.9.9
 
 # extra=matplotlib
 matplotlib

requirements/prod.txt

@@ -1,3 +1,4 @@
-loguru ==0.3.2
-typing-extensions ==3.7.4
-mypy-extensions ==0.4.3
+loguru >=0.3.2
+typing-extensions >=3.7.4
+mypy-extensions >=0.4.3
+anyio >=1.3.0

tests/conftest.py

@@ -50,13 +50,6 @@ def emit(self, record):
     logger.remove(handler_id)
 
 
-@pytest.fixture(scope="session", autouse=True)
-def fresh_client():
-    idom.client.restore()
-    yield
-    idom.client.restore()
-
-
 @pytest.fixture
 def display(driver_get, server, mount, host, port, last_server_error):
     def display(element, query=""):
@@ -83,7 +76,7 @@ def get(query=""):
 
 
 @pytest.fixture(scope="session")
-def driver(pytestconfig):
+def driver(pytestconfig, fresh_client):
     chrome_options = Options()
 
     if getattr(pytestconfig.option, "headless", False):
@@ -153,3 +146,10 @@ def last_server_error():
 def _clean_last_server_error(last_server_error):
     last_server_error.set(default_error)
     yield
+
+
+@pytest.fixture(scope="session")
+def fresh_client():
+    idom.client.restore()
+    yield
+    idom.client.restore()

tests/test_core/test_render.py

@@ -0,0 +1,78 @@
+import asyncio
+import pytest
+
+import idom
+from idom.core.layout import Layout, RenderError, LayoutEvent
+from idom.core.render import SingleStateRenderer, SharedStateRenderer, StopRendering
+
+
+async def test_render_error_without_partial_render_raises():
+    class LayoutWithBadRenderError(Layout):
+        async def render(self):
+            raise RenderError("no partial render")
+
+    @idom.element
+    async def pass_element(self):
+        return idom.html.div()
+
+    bad_layout = LayoutWithBadRenderError(pass_element())
+    renderer = SingleStateRenderer(bad_layout)
+
+    async def send(data):
+        return None
+
+    async def recv():
+        while True:
+            await asyncio.sleep(1)
+
+    with pytest.raises(RenderError, match="no partial render"):
+        await renderer.run(send, recv, None)
+
+
+async def test_shared_state_renderer():
+    done = asyncio.Event()
+    data_sent_1 = asyncio.Queue()
+    data_sent_2 = []
+
+    async def send_1(data):
+        await data_sent_1.put(data)
+
+    async def recv_1():
+        sent = await data_sent_1.get()
+
+        element_id = sent["root"]
+        element_data = sent["new"][element_id]
+
+        if element_data["attributes"]["count"] == 4:
+            done.set()
+            raise StopRendering()
+
+        target = element_data["eventHandlers"]["anEvent"]["target"]
+        return LayoutEvent(target=target, data=[])
+
+    async def send_2(data):
+        element_id = data["root"]
+        element_data = data["new"][element_id]
+        data_sent_2.append(element_data["attributes"]["count"])
+        if done.is_set():
+            raise ValueError(data_sent_2)
+
+    async def recv_2():
+        await done.wait()
+        raise StopRendering()
+
+    @idom.element
+    async def Clickable(self, count=0):
+        @idom.event
+        async def an_event():
+            self.update(count=count + 1)
+
+        return idom.html.div({"anEvent": an_event, "count": count})
+
+    renderer = SharedStateRenderer(Layout(Clickable()))
+
+    await asyncio.gather(
+        renderer.run(send_1, recv_1, "1"), renderer.run(send_2, recv_2, "2"),
+    )
+
+    assert data_sent_2 == [0, 1, 2, 3, 4]