Improve test runner speed

Author: Archmonger

pyproject.toml

@@ -115,7 +115,8 @@ filterwarnings = """
 testpaths = "tests"
 xfail_strict = true
 asyncio_mode = "auto"
-asyncio_default_fixture_loop_scope = "function"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
 log_cli_level = "INFO"
 
 #######################################

src/reactpy/testing/display.py

@@ -4,35 +4,33 @@
 from types import TracebackType
 from typing import Any
 
-from playwright.async_api import (
-    Browser,
-    BrowserContext,
-    Page,
-    async_playwright,
-)
+from playwright.async_api import Browser, Page, async_playwright
 
 from reactpy.config import REACTPY_TESTS_DEFAULT_TIMEOUT
 from reactpy.testing.backend import BackendFixture
+from reactpy.testing.common import GITHUB_ACTIONS
 from reactpy.types import RootComponentConstructor
 
 
 class DisplayFixture:
     """A fixture for running web-based tests using ``playwright``"""
 
-    _exit_stack: AsyncExitStack
+    page: Page
+    browser_is_external: bool = False
+    backend_is_external: bool = False
 
     def __init__(
         self,
         backend: BackendFixture | None = None,
-        driver: Browser | BrowserContext | Page | None = None,
+        browser: Browser | None = None,
     ) -> None:
-        if backend is not None:
+        if backend:
+            self.backend_is_external = True
             self.backend = backend
-        if driver is not None:
-            if isinstance(driver, Page):
-                self.page = driver
-            else:
-                self._browser = driver
+
+        if browser:
+            self.browser_is_external = True
+            self.browser = browser
 
     async def show(
         self,
@@ -42,34 +40,42 @@ async def show(
         await self.goto("/")
 
     async def goto(self, path: str, query: Any | None = None) -> None:
+        await self.configure_page()
         await self.page.goto(self.backend.url(path, query))
 
     async def __aenter__(self) -> DisplayFixture:
-        es = self._exit_stack = AsyncExitStack()
-
-        browser: Browser | BrowserContext
-        if not hasattr(self, "page"):
-            if not hasattr(self, "_browser"):
-                pw = await es.enter_async_context(async_playwright())
-                browser = await pw.chromium.launch()
-            else:
-                browser = self._browser
-            self.page = await browser.new_page()
-
-        self.page.set_default_timeout(REACTPY_TESTS_DEFAULT_TIMEOUT.current * 1000)
-        self.page.on("console", lambda msg: print(f"BROWSER CONSOLE: {msg.text}"))  # noqa: T201
-        self.page.on("pageerror", lambda exc: print(f"BROWSER ERROR: {exc}"))  # noqa: T201
+        self.browser_exit_stack = AsyncExitStack()
+        self.backend_exit_stack = AsyncExitStack()
+
+        if not hasattr(self, "browser"):
+            pw = await self.browser_exit_stack.enter_async_context(async_playwright())
+            self.browser = await pw.chromium.launch(headless=GITHUB_ACTIONS)
+        await self.configure_page()
+
         if not hasattr(self, "backend"):  # nocov
             self.backend = BackendFixture()
-            await es.enter_async_context(self.backend)
+            await self.backend_exit_stack.enter_async_context(self.backend)
 
         return self
 
+    async def configure_page(self) -> None:
+        """Hook for configuring the page before use."""
+        if getattr(self, "page", None) is None:
+            self.page = await self.browser.new_page()
+            self.page.set_default_timeout(REACTPY_TESTS_DEFAULT_TIMEOUT.current * 1000)
+            self.page.on("console", lambda msg: print(f"BROWSER CONSOLE: {msg.text}"))  # noqa: T201
+            self.page.on("pageerror", lambda exc: print(f"BROWSER ERROR: {exc}"))  # noqa: T201
+
     async def __aexit__(
         self,
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
     ) -> None:
         self.backend.mount(None)
-        await self._exit_stack.aclose()
+        if getattr(self, "page", None) is not None:
+            await self.page.close()
+        if not self.browser_is_external:
+            await self.browser_exit_stack.aclose()
+        if not self.backend_is_external:
+            await self.backend_exit_stack.aclose()

tests/conftest.py

@@ -5,13 +5,11 @@
 import subprocess
 
 import pytest
-from _pytest.config import Config
 from _pytest.config.argparsing import Parser
 
 from reactpy.config import (
     REACTPY_ASYNC_RENDERING,
     REACTPY_DEBUG,
-    REACTPY_TESTS_DEFAULT_TIMEOUT,
 )
 from reactpy.testing import (
     BackendFixture,
@@ -54,30 +52,20 @@ def rebuild():
     subprocess.run(["hatch", "build", "-t", "wheel"], check=True, env=env)  # noqa: S607
 
 
-@pytest.fixture
-async def display(server, page):
-    async with DisplayFixture(server, page) as display:
+@pytest.fixture(scope="session")
+async def display(server, browser):
+    async with DisplayFixture(backend=server, browser=browser) as display:
         yield display
 
 
-@pytest.fixture
+@pytest.fixture(scope="session")
 async def server():
     async with BackendFixture() as server:
         yield server
 
 
-@pytest.fixture
-async def page(browser):
-    pg = await browser.new_page()
-    pg.set_default_timeout(REACTPY_TESTS_DEFAULT_TIMEOUT.current * 1000)
-    try:
-        yield pg
-    finally:
-        await pg.close()
-
-
-@pytest.fixture
-async def browser(pytestconfig: Config):
+@pytest.fixture(scope="session")
+async def browser(pytestconfig: pytest.Config):
     from playwright.async_api import async_playwright
 
     async with async_playwright() as pw:

tests/test_asgi/test_middleware.py

@@ -16,8 +16,8 @@
 from reactpy.testing import BackendFixture, DisplayFixture
 
 
-@pytest.fixture()
-async def display(page):
+@pytest.fixture(scope="module")
+async def display(browser):
     """Override for the display fixture that uses ReactPyMiddleware."""
     templates = Jinja2Templates(
         env=JinjaEnvironment(
@@ -32,7 +32,7 @@ async def homepage(request):
     app = Starlette(routes=[Route("/", homepage)])
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server, driver=page) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             yield new_display
 
 
@@ -56,7 +56,7 @@ async def app(scope, receive, send):
         ReactPyMiddleware(app, root_components=["abc"], web_modules_dir=Path("invalid"))
 
 
-async def test_unregistered_root_component():
+async def test_unregistered_root_component(browser):
     templates = Jinja2Templates(
         env=JinjaEnvironment(
             loader=JinjaFileSystemLoader("tests/templates"),
@@ -75,7 +75,7 @@ def Stub():
     app = ReactPyMiddleware(app, root_components=["tests.sample.SampleApp"])
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             await new_display.show(Stub)
 
             # Wait for the log record to be populated
@@ -106,7 +106,7 @@ def Hello():
     await display.page.wait_for_selector("#hello")
 
 
-async def test_static_file_not_found(page):
+async def test_static_file_not_found():
     async def app(scope, receive, send): ...
 
     app = ReactPyMiddleware(app, [])
@@ -119,7 +119,7 @@ async def app(scope, receive, send): ...
         assert response.status_code == 404
 
 
-async def test_templatetag_bad_kwargs(page, caplog):
+async def test_templatetag_bad_kwargs(caplog, browser):
     """Override for the display fixture that uses ReactPyMiddleware."""
     templates = Jinja2Templates(
         env=JinjaEnvironment(
@@ -134,7 +134,7 @@ async def homepage(request):
     app = Starlette(routes=[Route("/", homepage)])
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server, driver=page) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             await new_display.goto("/")
 
             # This test could be improved by actually checking if `bad kwargs` error message is shown in

tests/test_asgi/test_pyscript.py

@@ -13,21 +13,21 @@
 from reactpy.testing import BackendFixture, DisplayFixture
 
 
-@pytest.fixture()
-async def display(page):
+@pytest.fixture(scope="module")
+async def display(browser):
     """Override for the display fixture that uses ReactPyMiddleware."""
     app = ReactPyCsr(
         Path(__file__).parent / "pyscript_components" / "root.py",
         initial=html.div({"id": "loading"}, "Loading..."),
     )
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server, driver=page) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             yield new_display
 
 
-@pytest.fixture()
-async def multi_file_display(page):
+@pytest.fixture(scope="module")
+async def multi_file_display(browser):
     """Override for the display fixture that uses ReactPyMiddleware."""
     app = ReactPyCsr(
         Path(__file__).parent / "pyscript_components" / "load_first.py",
@@ -36,12 +36,12 @@ async def multi_file_display(page):
     )
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server, driver=page) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             yield new_display
 
 
-@pytest.fixture()
-async def jinja_display(page):
+@pytest.fixture(scope="module")
+async def jinja_display(browser):
     """Override for the display fixture that uses ReactPyMiddleware."""
     templates = Jinja2Templates(
         env=JinjaEnvironment(
@@ -56,7 +56,7 @@ async def homepage(request):
     app = Starlette(routes=[Route("/", homepage)])
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server, driver=page) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             yield new_display
 
 

tests/test_asgi/test_standalone.py

@@ -123,7 +123,7 @@ def ShowRoute():
     assert hook_val.current is not None
 
 
-async def test_customized_head(page):
+async def test_customized_head(browser):
     custom_title = "Custom Title for ReactPy"
 
     @reactpy.component
@@ -133,12 +133,12 @@ def sample():
     app = ReactPy(sample, html_head=html.head(html.title(custom_title)))
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server, driver=page) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             await new_display.show(sample)
             assert (await new_display.page.title()) == custom_title
 
 
-async def test_head_request(page):
+async def test_head_request():
     @reactpy.component
     def sample():
         return html.h1("Hello World")

tests/test_client.py

@@ -1,8 +1,6 @@
 import asyncio
 from pathlib import Path
 
-from playwright.async_api import Page
-
 import reactpy
 from reactpy.testing import BackendFixture, DisplayFixture, poll
 from tests.tooling.common import DEFAULT_TYPE_DELAY
@@ -11,9 +9,7 @@
 JS_DIR = Path(__file__).parent / "js"
 
 
-async def test_automatic_reconnect(
-    display: DisplayFixture, page: Page, server: BackendFixture
-):
+async def test_automatic_reconnect(display: DisplayFixture, server: BackendFixture):
     @reactpy.component
     def SomeComponent():
         count, incr_count = use_counter(0)
@@ -26,35 +22,35 @@ def SomeComponent():
 
     async def get_count():
         # need to refetch element because may unmount on reconnect
-        count = await page.wait_for_selector("#count")
+        count = await display.page.wait_for_selector("#count")
         return await count.get_attribute("data-count")
 
     await display.show(SomeComponent)
 
     await poll(get_count).until_equals("0")
-    incr = await page.wait_for_selector("#incr")
+    incr = await display.page.wait_for_selector("#incr")
     await incr.click()
 
     await poll(get_count).until_equals("1")
-    incr = await page.wait_for_selector("#incr")
+    incr = await display.page.wait_for_selector("#incr")
     await incr.click()
 
     await poll(get_count).until_equals("2")
-    incr = await page.wait_for_selector("#incr")
+    incr = await display.page.wait_for_selector("#incr")
     await incr.click()
 
     await server.restart()
 
     await poll(get_count).until_equals("0")
-    incr = await page.wait_for_selector("#incr")
+    incr = await display.page.wait_for_selector("#incr")
     await incr.click()
 
     await poll(get_count).until_equals("1")
-    incr = await page.wait_for_selector("#incr")
+    incr = await display.page.wait_for_selector("#incr")
     await incr.click()
 
     await poll(get_count).until_equals("2")
-    incr = await page.wait_for_selector("#incr")
+    incr = await display.page.wait_for_selector("#incr")
     await incr.click()
 
 

tests/test_pyscript/test_components.py

@@ -9,13 +9,13 @@
 from reactpy.testing.backend import root_hotswap_component
 
 
-@pytest.fixture()
-async def display(page):
+@pytest.fixture(scope="module")
+async def display(browser):
     """Override for the display fixture that uses ReactPyMiddleware."""
     app = ReactPy(root_hotswap_component, pyscript_setup=True)
 
     async with BackendFixture(app) as server:
-        async with DisplayFixture(backend=server, driver=page) as new_display:
+        async with DisplayFixture(backend=server, browser=browser) as new_display:
             yield new_display