further refine test tooling

adds ServerMountPoint object

Author: rmorshea

idom/testing.py

@@ -1,16 +1,15 @@
 from urllib.parse import urlunparse, urlencode
-from contextlib import contextmanager, AbstractContextManager
-from idom.core.element import ElementConstructor
+from contextlib import contextmanager
 from typing import (
     Callable,
-    NamedTuple,
     Tuple,
     Iterator,
     Type,
     Optional,
-    Union,
     Any,
     Dict,
+    Generic,
+    TypeVar,
 )
 
 from selenium.webdriver.remote.webdriver import WebDriver
@@ -24,26 +23,13 @@
 
 
 __all__ = [
-    "server_base_url",
     "find_available_port",
     "create_simple_selenium_web_driver",
-    "create_mount_and_server",
-    "MountAndServer",
+    "ServerMountPoint",
 ]
 
 
-MountType = Union[Callable[[ElementConstructor], None], Any]
-MountContext = Callable[[], "AbstractContextManager[MountType]"]
-AnyAbstractRenderServer = AbstractRenderServer[Any, Any]
-
-
-def server_base_url(host: str, port: int, path: str = "", query: Optional[Any] = None):
-    return urlunparse(["http", f"{host}:{port}", path, "", urlencode(query or ()), ""])
-
-
-class MountAndServer(NamedTuple):
-    mount: MountContext
-    server: AnyAbstractRenderServer
+AnyRenderServer = AbstractRenderServer[Any, Any]
 
 
 def create_simple_selenium_web_driver(
@@ -62,49 +48,68 @@ def create_simple_selenium_web_driver(
     return driver
 
 
-def create_mount_and_server(
-    server_type: Type[AnyAbstractRenderServer] = PerClientStateServer,
-    host: str = "127.0.0.1",
-    port: Optional[int] = None,
-    server_config: Optional[Any] = None,
-    run_kwargs: Optional[Dict[str, Any]] = None,
-    mount_and_server_constructor: Callable[..., Any] = hotswap_server,
-    app: Optional[Any] = None,
-    **other_options: Any,
-) -> MountAndServer:
-    mount, server = mount_and_server_constructor(
-        (
-            server_type
-            if issubclass(server_type, _RenderServerWithLastError)
-            else type(
-                server_type.__name__,
-                (_RenderServerWithLastError, server_type),
-                {"last_server_error_for_idom_testing": Ref(None)},
-            )
-        ),
-        host,
-        port or find_available_port(host),
-        server_config,
-        run_kwargs,
-        app,
-        **other_options,
-    )
-
-    assert isinstance(server, _RenderServerWithLastError)
+_Mount = TypeVar("_Mount")
+_Server = TypeVar("_Server", bound=AnyRenderServer)
+
+
+class ServerMountPoint(Generic[_Mount, _Server]):
+
+    __slots__ = "server", "host", "port", "_mount"
+
+    def __init__(
+        self,
+        server_type: Type[_Server] = PerClientStateServer,
+        host: str = "127.0.0.1",
+        port: Optional[int] = None,
+        server_config: Optional[Any] = None,
+        run_kwargs: Optional[Dict[str, Any]] = None,
+        mount_and_server_constructor: "Callable[..., Tuple[_Mount, _Server]]" = hotswap_server,
+        app: Optional[Any] = None,
+        **other_options: Any,
+    ):
+        self.host = host
+        self.port = port or find_available_port(host)
+        self._mount, self.server = mount_and_server_constructor(
+            (
+                server_type
+                if issubclass(server_type, _RenderServerWithLastError)
+                else type(
+                    server_type.__name__,
+                    (_RenderServerWithLastError, server_type),
+                    {"last_server_error_for_idom_testing": Ref(None)},
+                )
+            ),
+            self.host,
+            self.port,
+            server_config,
+            run_kwargs,
+            app,
+            **other_options,
+        )
+
+    def url(self, path: str = "", query: Optional[Any] = None) -> str:
+        return urlunparse(
+            [
+                "http",
+                f"{self.host}:{self.port}",
+                path,
+                "",
+                urlencode(query or ()),
+                "",
+            ]
+        )
 
     @contextmanager
-    def mount_context() -> Iterator[MountType]:
-        server.last_server_error_for_idom_testing.current = None
+    def open_mount_function(self) -> Iterator[_Mount]:
+        self.server.last_server_error_for_idom_testing.current = None
         try:
-            yield mount
+            yield self._mount
         finally:
-            if server.last_server_error_for_idom_testing.current is not None:
-                raise server.last_server_error_for_idom_testing.current
-
-    return MountAndServer(mount_context, server)
+            if self.server.last_server_error_for_idom_testing.current is not None:
+                raise self.server.last_server_error_for_idom_testing.current
 
 
-class _RenderServerWithLastError(AnyAbstractRenderServer):
+class _RenderServerWithLastError(AnyRenderServer):
     """A server that updates the ``last_server_error`` fixture"""
 
     last_server_error_for_idom_testing: Ref[Optional[Exception]]

tests/conftest.py

@@ -1,6 +1,6 @@
 import logging
 import inspect
-from typing import Callable, Any, Tuple, Iterator, Iterable
+from typing import Any, Iterator, Iterable
 
 from loguru import logger
 import pytest
@@ -14,13 +14,7 @@
 
 import idom
 from idom.client import manage as manage_client
-from idom.server.prefab import AbstractRenderServer
-from idom.server.utils import find_available_port
-from idom.testing import (
-    server_base_url,
-    create_mount_and_server,
-    create_simple_selenium_web_driver,
-)
+from idom.testing import ServerMountPoint, create_simple_selenium_web_driver
 
 
 def pytest_collection_modifyitems(items: Iterable[Any]) -> None:
@@ -46,13 +40,13 @@ def pytest_addoption(parser: Parser) -> None:
 
 
 @pytest.fixture
-def display(driver, host, port, mount):
+def display(driver, server_mount_point, mount):
     display_id = idom.Ref(0)
 
     def mount_and_display(element_constructor, query=None, check_mount=True):
         element_id = f"display-{display_id.set_current(display_id.current + 1)}"
         mount(lambda: idom.html.div({"id": element_id}, element_constructor()))
-        driver.get(server_base_url(host, port, query=query))
+        driver.get(server_mount_point.url(query=query))
         if check_mount:
             driver.find_element_by_id(element_id)
         return element_id
@@ -61,38 +55,30 @@ def mount_and_display(element_constructor, query=None, check_mount=True):
 
 
 @pytest.fixture
-def driver_get(driver, host, port):
-    return lambda query=None: driver.get(server_base_url(host, port, query=query))
-
-
-@pytest.fixture(scope="module")
-def last_server_error(server):
-    return server.last_server_error_for_idom_testing
+def driver_get(driver, server_mount_point):
+    return lambda query=None: driver.get(server_mount_point.url(query=query))
 
 
 @pytest.fixture
-def mount(mount_and_server):
-    with mount_and_server.mount() as mount:
+def mount(server_mount_point):
+    with server_mount_point.open_mount_function() as mount:
         yield mount
 
 
-@pytest.fixture(scope="module")
-def server(mount_and_server):
-    """An IDOM server"""
-    server = mount_and_server.server
-    yield server
-    server.stop()
+@pytest.fixture
+def last_server_error(server_mount_point):
+    return server_mount_point.server.last_server_error_for_idom_testing
 
 
 @pytest.fixture(scope="module")
-def mount_and_server(
-    host: str, port: int
-) -> Tuple[Callable[..., None], AbstractRenderServer]:
+def server_mount_point():
     """An IDOM layout mount function and server as a tuple
 
     The ``mount`` and ``server`` fixtures use this.
     """
-    return create_mount_and_server(host=host, port=port, server_config={"cors": True})
+    mount_point = ServerMountPoint(server_config={"cors": True})
+    yield mount_point
+    mount_point.server.stop()
 
 
 @pytest.fixture(scope="module")
@@ -101,7 +87,7 @@ def driver_wait(driver):
 
 
 @pytest.fixture(scope="module")
-def driver(create_driver: Callable[[], Chrome]) -> Chrome:
+def driver(create_driver) -> Chrome:
     """A Selenium web driver"""
     return create_driver()
 
@@ -124,23 +110,6 @@ def create():
         d.quit()
 
 
-@pytest.fixture(scope="module")
-def server_url(host, port):
-    return server_base_url(host, port)
-
-
-@pytest.fixture(scope="session")
-def host() -> str:
-    """The hostname for the IDOM server setup by ``mount_and_server``"""
-    return "127.0.0.1"
-
-
-@pytest.fixture(scope="module")
-def port(host: str) -> int:
-    """The port for the IDOM server setup by ``mount_and_server``"""
-    return find_available_port(host)
-
-
 @pytest.fixture
 def client_implementation():
     original = idom.client.current

tests/test_server/test_sanic/test_base.py

@@ -5,22 +5,20 @@
 
 import idom
 from idom.server.sanic import PerClientStateServer
-from idom.testing import create_mount_and_server
+from idom.testing import ServerMountPoint
 
 
 @pytest.fixture(scope="module")
-def mount_and_server(host, port):
-    return create_mount_and_server(
+def server_mount_point():
+    return ServerMountPoint(
         PerClientStateServer,
-        host,
-        port,
         # test that we can use a custom app instance
         app=Sanic(),
     )
 
 
-def test_serve_has_loop_attribute(server):
-    assert isinstance(server.loop, asyncio.AbstractEventLoop)
+def test_serve_has_loop_attribute(server_mount_point):
+    assert isinstance(server_mount_point.server.loop, asyncio.AbstractEventLoop)
 
 
 def test_no_application_until_running():

tests/test_server/test_sanic/test_multiview_server.py

@@ -3,19 +3,19 @@
 import idom
 from idom.server.sanic import PerClientStateServer
 from idom.server.prefab import multiview_server
-from idom.testing import create_mount_and_server
+from idom.testing import ServerMountPoint
 
 from tests.driver_utils import no_such_element
 
 
 @pytest.fixture(scope="module")
-def mount_and_server(host, port):
-    return create_mount_and_server(
-        PerClientStateServer, host, port, mount_and_server_constructor=multiview_server
+def server_mount_point():
+    return ServerMountPoint(
+        PerClientStateServer, mount_and_server_constructor=multiview_server
     )
 
 
-def test_multiview_server(driver_get, driver, mount, server):
+def test_multiview_server(driver_get, driver, mount):
     manual_id = mount["manually_set_id"](lambda: idom.html.h1({"id": "e1"}, ["e1"]))
     auto_view_id = mount(lambda: idom.html.h1({"id": "e2"}, ["e2"]))
 

tests/test_server/test_sanic/test_shared_state_client.py

@@ -6,19 +6,19 @@
 
 import idom
 from idom.server.sanic import SharedClientStateServer
-from idom.testing import create_mount_and_server
+from idom.testing import ServerMountPoint
 
 
 @pytest.fixture(scope="module")
-def mount_and_server(host, port):
+def server_mount_point():
     """An IDOM layout mount function and server as a tuple
 
     The ``mount`` and ``server`` fixtures use this.
     """
-    return create_mount_and_server(SharedClientStateServer, host, port, sync_views=True)
+    return ServerMountPoint(SharedClientStateServer, sync_views=True)
 
 
-def test_shared_client_state(create_driver, mount, server_url):
+def test_shared_client_state(create_driver, mount, server_mount_point):
     driver_1 = create_driver()
     driver_2 = create_driver()
     was_garbage_collected = Event()
@@ -45,8 +45,8 @@ def Counter(count):
 
     mount(IncrCounter)
 
-    driver_1.get(server_url)
-    driver_2.get(server_url)
+    driver_1.get(server_mount_point.url())
+    driver_2.get(server_mount_point.url())
 
     client_1_button = driver_1.find_element_by_id("incr-button")
     client_2_button = driver_2.find_element_by_id("incr-button")