re-organize tests to support testing multiple servers

Author: rmorshea

idom/server/__init__.py

@@ -49,8 +49,7 @@ def multiview_server(
     """
     mount, element = multiview()
     server_instance = server(element)
-    if server_options:
-        server_instance.configure(server_options)
+    server_instance.configure(server_options)
     server_instance.daemon(host, port, **(run_options or {}))
     return mount, server_instance
 
@@ -81,7 +80,6 @@ def hotswap_server(
     """
     mount, element = hotswap(shared=True)
     server_instance = server(element)
-    if server_options:
-        server_instance.configure(server_options)
+    server_instance.configure(server_options)
     server_instance.daemon(host, port, **(run_options or {}))
     return mount, server_instance

idom/server/base.py

@@ -71,11 +71,17 @@ def register(self: _Self, app: _App) -> _Self:
         self._app = app
         return self
 
-    def configure(self: _Self, config: _Config) -> _Self:
+    def configure(self: _Self, config: Optional[_Config] = None) -> _Self:
         """Configure this extension."""
-        self._config = self._update_config(self._config, config)
+        if config is not None:
+            self._config = self._update_config(self._config, config)
         return self
 
+    @abc.abstractmethod
+    def stop(self) -> None:
+        """Stop the running application"""
+        raise NotImplementedError()
+
     @abc.abstractmethod
     def _init_config(self) -> _Config:
         """Return the default configuration options."""

idom/server/sanic.py

@@ -30,6 +30,9 @@ class Config(TypedDict, total=False):
 class SanicRenderServer(AbstractRenderServer[Sanic, Config]):
     """Base ``sanic`` extension."""
 
+    def stop(self) -> None:
+        self.application.stop()
+
     def _init_config(self) -> Config:
         return Config(cors=False, url_prefix="", webpage_route=True)
 

tests/conftest.py

@@ -1,16 +1,34 @@
 import logging
 import inspect
+import time
+from socket import socket
 
 from loguru import logger
 import pytest
 from _pytest.logging import caplog as _caplog  # noqa
+from selenium.webdriver import Chrome
+from selenium.webdriver.chrome.options import Options
+
+import pyalect.builtins.pytest  # noqa
+
+import idom
+from idom.server import hotswap_server
+from idom.server.sanic import PerClientState
+
+
+# Default is an error because we want to know whether we are setting the last
+# error while testing. A refactor could miss the code path that catches serve
+# errors.
+default_error = NotImplementedError()
 
 
 def pytest_collection_modifyitems(items):
     for item in items:
         if isinstance(item, pytest.Function):
             if inspect.iscoroutinefunction(item.function):
                 item.add_marker(pytest.mark.asyncio)
+        if "driver" in item.fixturenames:
+            item.add_marker("slow")
 
 
 def pytest_addoption(parser):
@@ -30,3 +48,100 @@ def emit(self, record):
     handler_id = logger.add(PropogateHandler(), format="{message}")
     yield _caplog
     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, server, mount, host, port, last_server_error):
+    def display(element, query=""):
+        mount(element)
+        driver.get(f"http://{host}:{port}/client/index.html")
+
+    try:
+        yield display
+    finally:
+        last_error = last_server_error.get()
+        if last_error is default_error:
+            msg = f"The server {server} never ran or did not set the 'last_server_error' fixture."
+            raise NotImplementedError(msg)
+        elif last_error is not None:
+            raise last_error
+
+
+@pytest.fixture(scope="session")
+def driver(pytestconfig):
+    chrome_options = Options()
+
+    if getattr(pytestconfig.option, "headless", False):
+        chrome_options.headless = True
+
+    driver = Chrome(options=chrome_options)
+
+    driver.set_window_size(1080, 800)
+    driver.set_page_load_timeout(3)
+    driver.implicitly_wait(3)
+
+    try:
+        yield driver
+    finally:
+        driver.quit()
+
+
+@pytest.fixture(scope="module")
+def mount(mount_and_server):
+    return mount_and_server[0]
+
+
+@pytest.fixture(scope="module")
+def server(mount_and_server):
+    server = mount_and_server[1]
+    time.sleep(1)
+    yield server
+    server.stop()
+
+
+@pytest.fixture(scope="module")
+def mount_and_server(server_type, host, port):
+    return hotswap_server(server_type, host, port, run_options={"debug": True})
+
+
+@pytest.fixture(scope="module")
+def server_type(last_server_error):
+    class ServerWithErrorCatch(PerClientState):
+        async def _stream_route(self, request, socket):
+            last_server_error.set(None)
+            try:
+                await super()._stream_route(request, socket)
+            except Exception as e:
+                last_server_error.set(e)
+
+    return ServerWithErrorCatch
+
+
+@pytest.fixture(scope="session")
+def host():
+    return "127.0.0.1"
+
+
+@pytest.fixture(scope="module")
+def port(host):
+    sock = socket()
+    sock.bind((host, 0))
+    return sock.getsockname()[1]
+
+
+@pytest.fixture(scope="session")
+def last_server_error():
+    return idom.Var(default_error)
+
+
+@pytest.fixture(autouse=True)
+def _clean_last_server_error(last_server_error):
+    last_server_error.set(default_error)
+    yield

tests/test_browser/my_chart.js renamed to tests/my_chart.js

@@ -15,6 +15,7 @@ def victory():
     yield Import("victory", install=True)
 
 
+@pytest.mark.slow
 def test_install(driver, display, victory):
     display(victory.VictoryBar)
 
@@ -29,6 +30,7 @@ def test_raise_on_missing_import_path():
         client.import_path("module/that/does/not/exist")
 
 
+@pytest.mark.slow
 def test_custom_module(driver, display, victory):
     my_chart = define_module("my/chart", HERE / "my_chart.js")
 
@@ -40,6 +42,7 @@ def test_custom_module(driver, display, victory):
     driver.find_element_by_class_name("VictoryContainer")
 
 
+@pytest.mark.slow
 def test_delete_module(victory):
     client.delete_module("victory")
     assert not client.module_exists("victory")