Fix test runtime warnings

Author: Archmonger

pyproject.toml

@@ -171,6 +171,7 @@ extra-dependencies = [
   "types-requests",
   "types-lxml",
   "jsonpointer",
+  "pytest",
 ]
 
 [tool.hatch.envs.python.scripts]

src/reactpy/testing/display.py

@@ -3,15 +3,17 @@
 import os
 from contextlib import AsyncExitStack
 from types import TracebackType
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from playwright.async_api import Browser, Page, async_playwright, expect
 
-from reactpy.config import REACTPY_TESTS_DEFAULT_TIMEOUT
+from reactpy.config import REACTPY_TESTS_DEFAULT_TIMEOUT as DEFAULT_TIMEOUT
 from reactpy.testing.backend import BackendFixture
-from reactpy.testing.common import GITHUB_ACTIONS
 from reactpy.types import RootComponentConstructor
 
+if TYPE_CHECKING:
+    import pytest
+
 
 class DisplayFixture:
     """A fixture for running web-based tests using ``playwright``"""
@@ -35,9 +37,7 @@ def __init__(
             self.browser_is_external = True
             self.browser = browser
 
-        self.timeout = (
-            timeout if timeout is not None else REACTPY_TESTS_DEFAULT_TIMEOUT.current
-        )
+        self.timeout = DEFAULT_TIMEOUT.current if timeout is None else timeout
         self.headless = headless
 
     async def show(
@@ -52,33 +52,31 @@ async def goto(self, path: str, query: Any | None = None) -> None:
         await self.page.goto(self.backend.url(path, query))
 
     async def __aenter__(self) -> DisplayFixture:
-        self.browser_exit_stack = AsyncExitStack()
-        self.backend_exit_stack = AsyncExitStack()
+        self.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=self.headless
-                or os.environ.get("PLAYWRIGHT_HEADLESS") == "1"
-                or GITHUB_ACTIONS
+            pw = await self.exit_stack.enter_async_context(async_playwright())
+            self.browser = await self.exit_stack.enter_async_context(
+                await pw.chromium.launch(headless=not _playwright_visible())
             )
 
         expect.set_options(timeout=self.timeout * 1000)
         await self.configure_page()
 
         if not hasattr(self, "backend"):  # nocov
             self.backend = BackendFixture()
-            await self.backend_exit_stack.enter_async_context(self.backend)
+            await self.exit_stack.enter_async_context(self.backend)
 
         return self
 
     async def configure_page(self) -> None:
         if getattr(self, "page", None) is None:
             self.page = await self.browser.new_page()
+            self.page = await self.exit_stack.enter_async_context(self.page)
             self.page.set_default_navigation_timeout(self.timeout * 1000)
             self.page.set_default_timeout(self.timeout * 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.page.on("console", lambda x: print(f"BROWSER CONSOLE: {x.text}"))  # noqa: T201
+            self.page.on("pageerror", lambda x: print(f"BROWSER ERROR: {x}"))  # noqa: T201
 
     async def __aexit__(
         self,
@@ -87,9 +85,13 @@ async def __aexit__(
         traceback: TracebackType | None,
     ) -> None:
         self.backend.mount(None)
-        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()
+        await self.exit_stack.aclose()
+
+
+def _playwright_visible(pytestconfig: pytest.Config | None = None) -> bool:
+    if (pytestconfig and pytestconfig.getoption("visible")) or os.environ.get(
+        "PLAYWRIGHT_VISIBLE"
+    ) == "1":
+        os.environ.setdefault("PLAYWRIGHT_VISIBLE", "1")
+        return True
+    return False

tests/conftest.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import os
-
 import pytest
 from _pytest.config.argparsing import Parser
 
@@ -14,18 +12,18 @@
     DisplayFixture,
     capture_reactpy_logs,
 )
-from reactpy.testing.common import GITHUB_ACTIONS
+from reactpy.testing.display import _playwright_visible
 
 REACTPY_ASYNC_RENDERING.set_current(True)
 REACTPY_DEBUG.set_current(True)
 
 
 def pytest_addoption(parser: Parser) -> None:
     parser.addoption(
-        "--headless",
-        dest="headless",
+        "--visible",
+        dest="visible",
         action="store_true",
-        help="Don't open a browser window when running web-based tests",
+        help="Open a browser window when running web-based tests",
     )
 
 
@@ -46,7 +44,10 @@ async def browser(pytestconfig: pytest.Config):
     from playwright.async_api import async_playwright
 
     async with async_playwright() as pw:
-        yield await pw.chromium.launch(headless=_headless_environ(pytestconfig))
+        async with await pw.chromium.launch(
+            headless=not _playwright_visible(pytestconfig)
+        ) as browser:
+            yield browser
 
 
 @pytest.fixture(autouse=True)
@@ -59,14 +60,3 @@ def assert_no_logged_exceptions():
                     raise r.exc_info[1]
         finally:
             records.clear()
-
-
-def _headless_environ(pytestconfig: pytest.Config):
-    if (
-        pytestconfig.getoption("headless")
-        or os.environ.get("PLAYWRIGHT_HEADLESS") == "1"
-        or GITHUB_ACTIONS
-    ):
-        os.environ["PLAYWRIGHT_HEADLESS"] = "1"
-        return True
-    return False

tests/test_testing.py

@@ -237,20 +237,28 @@ async def test_display_fixture_headless_logic():
         mock_context_manager.__aenter__.return_value = mock_playwright_instance
 
         mock_browser = AsyncMock()
+        mock_browser.__aenter__ = AsyncMock(return_value=mock_browser)
         mock_playwright_instance.chromium.launch.return_value = mock_browser
 
         mock_page = AsyncMock()
         # Configure synchronous methods on page
         mock_page.set_default_timeout = MagicMock()
+        mock_page.set_default_navigation_timeout = MagicMock()
         mock_page.on = MagicMock()
+        mock_page.__aenter__ = AsyncMock(return_value=mock_page)
 
         mock_browser.new_page.return_value = mock_page
 
-        # Case: headless=False, PLAYWRIGHT_HEADLESS='1'
-        with patch.dict(os.environ, {"PLAYWRIGHT_HEADLESS": "1"}):
-            async with DisplayFixture(headless=False):
+        # Case: headless=False, PLAYWRIGHT_VISIBLE='1'
+        with patch.dict(os.environ, {"PLAYWRIGHT_VISIBLE": "1"}):
+            async with DisplayFixture():
+                pass
+            mock_playwright_instance.chromium.launch.assert_called_with(headless=False)
+
+        # Case: headless=True, PLAYWRIGHT_VISIBLE='0'
+        with patch.dict(os.environ, {"PLAYWRIGHT_VISIBLE": "0"}):
+            async with DisplayFixture():
                 pass
-            # Check that launch was called with headless=True
             mock_playwright_instance.chromium.launch.assert_called_with(headless=True)
 
 
@@ -265,11 +273,14 @@ async def test_display_fixture_internal_backend():
         mock_context_manager.__aenter__.return_value = mock_playwright_instance
 
         mock_browser = AsyncMock()
+        mock_browser.__aenter__ = AsyncMock(return_value=mock_browser)
         mock_playwright_instance.chromium.launch.return_value = mock_browser
 
         mock_page = AsyncMock()
         mock_page.set_default_timeout = MagicMock()
+        mock_page.set_default_navigation_timeout = MagicMock()
         mock_page.on = MagicMock()
+        mock_page.__aenter__ = AsyncMock(return_value=mock_page)
         mock_browser.new_page.return_value = mock_page
 
         # We also need to mock BackendFixture to avoid starting real server