Skip to content

Automate browser based workflows with AI

Close a crashed browser tab so the next attach reaches a live target (SKY-15735) (#8463)

Andrew Neilson45941d6460f7
diff --git a/skyvern/constants.py b/skyvern/constants.py
index 190396c5c..8b2e13fb1 100644
--- a/skyvern/constants.py
+++ b/skyvern/constants.py
@@ -20,6 +20,9 @@ ERROR_CODE_REASONING_MAX_LENGTH = 2000
INPUT_TEXT_TIMEOUT = 120000 # 2 minutes
PAGE_CONTENT_TIMEOUT = 300 # 5 mins
BROWSER_PAGE_CLOSE_TIMEOUT = 5 # 5 seconds
+# Bounded attempts to close a crashed tab. Anything that waits on that close derives its budget from
+# this and BROWSER_PAGE_CLOSE_TIMEOUT rather than restating the count.
+CRASHED_PAGE_CLOSE_ATTEMPTS = 2
BROWSER_CLOSE_TIMEOUT = 180 # 3 minute
# Independent budget for disabling the download interceptor during close(). Kept well below
# BROWSER_CLOSE_TIMEOUT so a stuck/cancellation-resistant download drain is reclaimed quickly
diff --git a/skyvern/webeye/real_browser_state.py b/skyvern/webeye/real_browser_state.py
index 5c4127869..53c618bc9 100644
--- a/skyvern/webeye/real_browser_state.py
+++ b/skyvern/webeye/real_browser_state.py
@@ -3,6 +3,7 @@ from __future__ import annotations
import asyncio
import random
import time
+import weakref
from collections.abc import Awaitable, Callable
from datetime import UTC, datetime
from typing import Literal
@@ -16,6 +17,7 @@ from skyvern.constants import (
BROWSER_CLOSE_TIMEOUT,
BROWSER_INTERCEPTOR_DISABLE_TIMEOUT,
BROWSER_PAGE_CLOSE_TIMEOUT,
+ CRASHED_PAGE_CLOSE_ATTEMPTS,
NAVIGATION_MAX_RETRY_TIME,
)
from skyvern.exceptions import (
@@ -83,6 +85,10 @@ class RealBrowserState(BrowserState):
# so the pin is dropped.
self.__active_page_known_pages: set[Page] = set()
self.pw = pw
+ self._disconnect_listener_contexts: weakref.WeakSet[BrowserContext] = weakref.WeakSet()
+ self._disconnect_listener_browser: Browser | None = None
+ self._crash_listener_pages: weakref.WeakSet[Page] = weakref.WeakSet()
+ self._crashed_pages: weakref.WeakSet[Page] = weakref.WeakSet()
self.browser_context = browser_context
self.browser_artifacts = browser_artifacts
self.browser_cleanup = browser_cleanup
@@ -110,11 +116,21 @@ class RealBrowserState(BrowserState):
self.last_navigation_status: int | None = None
self._ever_connected = browser_context is not None
self._close_requested = False
- self._disconnect_listener_context: BrowserContext | None = None
- self._disconnect_listener_browser: Browser | None = None
if browser_context is not None:
self._register_disconnect_listeners(browser_context)
+ @property
+ def browser_context(self) -> BrowserContext | None:
+ return self._browser_context
+
+ @browser_context.setter
+ def browser_context(self, context: BrowserContext | None) -> None:
+ # Every attachment must arm crash reaping, including swaps made from outside this class:
+ # an unwatched crashed tab keeps winning get_working_page and strands every later attach.
+ self._browser_context = context
+ if context is not None:
+ self._watch_context_for_crashes(context)
+
def add_on_close(self, callback: Callable[[], Awaitable[None]]) -> None:
self._on_close_callbacks.append(callback)
@@ -181,7 +197,12 @@ class RealBrowserState(BrowserState):
pages = self.browser_context.pages
for page in pages:
if page != cur_page:
- if discard_orphaned_videos:
+ # Every crashed page keeps its recording, not just the working one: a crashed tab can
+ # still be here with its close in flight or timed out, and there is no way to tell
+ # from here which one the run was driving. That keeps a spurious second RECORDING for
+ # a crashed non-working tab, which is the cheaper of the two errors — the other is
+ # deleting the recording of the run that just crashed.
+ if discard_orphaned_videos and page not in self._crashed_pages:
# Tombstone before any await: set_popup_video_listener's registration for
# this same page may still be in flight, and must observe the tombstone
# whenever it resolves rather than re-appending after we remove it below.
@@ -390,7 +411,8 @@ class RealBrowserState(BrowserState):
pages = [
http_page
for http_page in self.browser_context.pages
- if (
+ if http_page not in self._crashed_pages
+ and (
http_page.url == "about:blank"
or http_page.url == ":" # sometimes the page url is ":", which is the blank page
or http_page.url == "chrome-error://chromewebdata/"
@@ -531,20 +553,31 @@ class RealBrowserState(BrowserState):
page = await self.__assert_page()
return page
- def _register_disconnect_listeners(self, context: BrowserContext) -> None:
- if context is not getattr(self, "_disconnect_listener_context", None):
+ def _watch_context_for_crashes(self, context: BrowserContext) -> None:
+ if context not in self._disconnect_listener_contexts:
try:
context.on("close", self._on_browser_context_closed)
- self._disconnect_listener_context = context
+ context.on("page", self._watch_page_for_crash)
+ self._disconnect_listener_contexts.add(context)
except Exception:
LOG.debug("Failed to register browser context disconnect listener", exc_info=True)
+ # The "page" event only fires for tabs opened after registration, and both call sites can
+ # attach to a context that already has pages.
+ try:
+ for existing_page in list(context.pages):
+ self._watch_page_for_crash(existing_page)
+ except Exception:
+ LOG.debug("Failed to sweep existing pages for crash listeners", exc_info=True)
+
+ def _register_disconnect_listeners(self, context: BrowserContext) -> None:
+ self._watch_context_for_crashes(context)
try:
browser = context.browser
except Exception:
LOG.debug("Failed to read browser for disconnect listener registration", exc_info=True)
return
- if browser is None or browser is getattr(self, "_disconnect_listener_browser", None):
+ if browser is None or browser is self._disconnect_listener_browser:
return
try:
browser.on("disconnected", self._on_browser_disconnected)
@@ -552,6 +585,49 @@ class RealBrowserState(BrowserState):
except Exception:
LOG.debug("Failed to register browser disconnect listener", exc_info=True)
+ def _watch_page_for_crash(self, page: Page) -> None:
+ if page in self._crash_listener_pages:
+ return
+ try:
+ page.on("crash", self._on_page_crashed)
+ self._crash_listener_pages.add(page)
+ except Exception:
+ LOG.debug("Failed to register page crash listener", exc_info=True)
+
+ def _on_page_crashed(self, page: Page) -> None:
+ # A crashed tab stays in context.pages and keeps winning get_working_page, so later operations
+ # and CDP attaches land on a dead target. Closing it lets _reopen_lost_working_page recover.
+ LOG.warning("Page crashed; closing the crashed tab so a replacement can be opened", url=page.url)
+ # Recorded before the close is scheduled: the close is a detached task, and until it lands the
+ # crashed page is still in context.pages. Callers in that window must not be handed it.
+ self._crashed_pages.add(page)
+ try:
+ task = asyncio.get_running_loop().create_task(self._close_crashed_page(page))
+ except RuntimeError:
+ LOG.debug("No running event loop to close the crashed page on", exc_info=True)
+ return
+ self._own_detached_task(task, "close_crashed_page")
+
+ async def _close_crashed_page(self, page: Page) -> None:
+ # The crash event fires once. Excluding the page from selection keeps this process healthy, but
+ # only closing the target unblocks later CDP attaches, so a hung close is retried up to
+ # CRASHED_PAGE_CLOSE_ATTEMPTS before the target is reported stranded. Bounded by racing the
+ # close rather than by asyncio.timeout, for the reason _run_bounded_detachable already
+ # documents: a Playwright close can ignore the cancel a timeout delivers, and that would look
+ # like success here and skip the retry. A close that raises has finished, so it is not retried.
+ for _ in range(CRASHED_PAGE_CLOSE_ATTEMPTS):
+ closing = asyncio.ensure_future(page.close())
+ done, _pending = await asyncio.wait({closing}, timeout=BROWSER_PAGE_CLOSE_TIMEOUT)
+ if closing not in done:
+ closing.cancel()
+ self._own_detached_task(closing, "close_crashed_page_attempt")
+ continue
+ error = closing.exception() if not closing.cancelled() else None
+ if error is not None:
+ LOG.warning("Error while closing a crashed page", url=page.url, error_type=type(error).__name__)
+ return
+ LOG.warning("Timeout closing a crashed page; the target stays stranded", url=page.url)
+
def _on_browser_context_closed(self, context: BrowserContext) -> None:
if context is not self.browser_context:
return
@@ -562,7 +638,7 @@ class RealBrowserState(BrowserState):
)
def _on_browser_disconnected(self, browser: Browser) -> None:
- if browser is not getattr(self, "_disconnect_listener_browser", None):
+ if browser is not self._disconnect_listener_browser:
return
self._record_disconnect(
"browser_disconnected_event",
diff --git a/tests/unit/test_browser_effect_sink_enumeration.py b/tests/unit/test_browser_effect_sink_enumeration.py
index 38c6fe698..119211598 100644
--- a/tests/unit/test_browser_effect_sink_enumeration.py
+++ b/tests/unit/test_browser_effect_sink_enumeration.py
@@ -69,7 +69,7 @@ _DISCOVERED_BROWSER_API_CALLS = {
{"clear": 1, "click": 2, "move": 2, "scroll_into_view_if_needed": 1, "type": 3, "wheel": 1}
),
"skyvern/forge/sdk/event/factory.py": Counter({"click": 1, "wheel": 1}),
- "skyvern/webeye/real_browser_state.py": Counter({"close": 5, "evaluate": 1, "goto": 1, "new_page": 3, "reload": 2}),
+ "skyvern/webeye/real_browser_state.py": Counter({"close": 6, "evaluate": 1, "goto": 1, "new_page": 3, "reload": 2}),
}
_EVALUATE_CALLERS = {
@@ -219,14 +219,14 @@ def test_discovered_browser_api_lower_bound_is_stable() -> None:
}
assert observed == _DISCOVERED_BROWSER_API_CALLS
- assert sum(sum(methods.values()) for methods in observed.values()) == 164
+ assert sum(sum(methods.values()) for methods in observed.values()) == 165
handler_candidates = _candidate_signatures("skyvern/webeye/actions/handler.py", _CANDIDATE_METHODS)
classified_non_browser = Counter(
{signature: count for signature, count in handler_candidates.items() if signature in _NON_BROWSER_CANDIDATES}
)
assert classified_non_browser == _NON_BROWSER_CANDIDATES
assert sum(_NON_BROWSER_CANDIDATES.values()) == 5
- assert sum(sum(methods.values()) for methods in observed.values()) - sum(_NON_BROWSER_CANDIDATES.values()) == 159
+ assert sum(sum(methods.values()) for methods in observed.values()) - sum(_NON_BROWSER_CANDIDATES.values()) == 160
def test_every_raw_evaluate_call_is_classified() -> None:
diff --git a/tests/unit/test_copilot_candidate_navigation_guard.py b/tests/unit/test_copilot_candidate_navigation_guard.py
index c1cf75333..f67800507 100644
--- a/tests/unit/test_copilot_candidate_navigation_guard.py
+++ b/tests/unit/test_copilot_candidate_navigation_guard.py
@@ -1,5 +1,6 @@
from __future__ import annotations
+import asyncio
from contextlib import asynccontextmanager
from dataclasses import dataclass
from types import SimpleNamespace
@@ -9,6 +10,7 @@ import pytest
from skyvern.forge.sdk.copilot import mcp_adapter
from skyvern.forge.sdk.copilot.mcp_adapter import SkyvernOverlayMCPServer
+from skyvern.webeye.real_browser_state import RealBrowserState
class _Request:
@@ -35,15 +37,39 @@ class _Route:
self.outcome = reason
+class _FakePage:
+ def __init__(self, url: str = "about:blank") -> None:
+ self.url = url
+ self.handlers: dict[str, list] = {}
+ self.closed = False
+ self.video = None
+
+ def on(self, event: str, handler) -> None:
+ self.handlers.setdefault(event, []).append(handler)
+
+ def is_closed(self) -> bool:
+ return self.closed
+
+ async def close(self) -> None:
+ self.closed = True
+
+ def crash(self) -> None:
+ for handler in self.handlers.get("crash", []):
+ handler(self)
+
+
class _BrowserContext:
def __init__(self, browser: _Browser | None = None) -> None:
self.handler = None
self.unrouted = False
- self.pages = [SimpleNamespace(url="about:blank")]
+ self.pages = [_FakePage()]
self.service_workers = []
self.browser = browser or _Browser()
self.closed = False
+ def on(self, _event: str, _handler) -> None:
+ return None
+
async def route(self, _pattern: str, handler) -> None:
self.handler = handler
@@ -54,8 +80,8 @@ class _BrowserContext:
async def cookies(self) -> list[dict[str, str]]:
return []
- async def new_page(self) -> SimpleNamespace:
- page = SimpleNamespace(url="about:blank")
+ async def new_page(self) -> _FakePage:
+ page = _FakePage()
self.pages.append(page)
return page
@@ -197,8 +223,8 @@ async def test_candidate_guard_isolates_non_pristine_attached_cdp_context(
monkeypatch: pytest.MonkeyPatch,
) -> None:
browser_context = _BrowserContext()
- selected_page = SimpleNamespace(url="https://selected.test/")
- newest_page = SimpleNamespace(url="https://newest.test/")
+ selected_page = _FakePage("https://selected.test/")
+ newest_page = _FakePage("https://newest.test/")
browser_context.pages = [selected_page, newest_page]
browser_state = _BrowserState(
browser_context,
@@ -559,3 +585,39 @@ async def test_real_adapter_internal_call_drains_candidate_network_before_return
assert result["ok"] is True
assert agent_function.idle_waits == 2
+
+
+async def test_candidate_context_swap_arms_crash_reaping_on_the_candidate_context(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setattr(mcp_adapter.app, "AGENT_FUNCTION", _AgentFunction())
+ original = _BrowserContext()
+ original_page = original.pages[0]
+ state = RealBrowserState(pw=SimpleNamespace(), browser_context=original, page=original_page)
+
+ async with mcp_adapter._service_worker_blocked_context(state, organization_id="org") as candidate:
+ candidate_page = candidate.pages[-1]
+ assert candidate_page in state._crash_listener_pages
+ candidate_page.crash()
+ await asyncio.gather(*list(state._detached_teardown_tasks))
+ assert candidate_page.closed is True
+
+
+async def test_candidate_context_restore_keeps_crash_reaping_on_the_original_context(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setattr(mcp_adapter.app, "AGENT_FUNCTION", _AgentFunction())
+ original = _BrowserContext()
+ original_page = original.pages[0]
+ state = RealBrowserState(pw=SimpleNamespace(), browser_context=original, page=original_page)
+
+ async with mcp_adapter._service_worker_blocked_context(state, organization_id="org"):
+ pass
+
+ assert state.browser_context is original
+ assert original_page in state._crash_listener_pages
+ original_page.crash()
+ await asyncio.gather(*list(state._detached_teardown_tasks))
+ assert original_page.closed is True
diff --git a/tests/unit/test_forloop_incremental_persist.py b/tests/unit/test_forloop_incremental_persist.py
index bc40691e8..d9e9cb653 100644
--- a/tests/unit/test_forloop_incremental_persist.py
+++ b/tests/unit/test_forloop_incremental_persist.py
@@ -548,8 +548,7 @@ class TestResetBrowserTabsBetweenIterations:
research_old = MagicMock(url="https://r1", close=AsyncMock())
research_cur = MagicMock(url="https://r2", close=AsyncMock())
- bs = RealBrowserState.__new__(RealBrowserState)
- bs.browser_context = MagicMock()
+ bs = RealBrowserState(pw=MagicMock(), browser_context=MagicMock())
bs.browser_context.pages = [deliverable, pre_ref, research_old, research_cur]
bs.get_working_page = AsyncMock(return_value=research_cur)
diff --git a/tests/unit/test_real_browser_state_discards_orphaned_tab_video.py b/tests/unit/test_real_browser_state_discards_orphaned_tab_video.py
index b5b6850d9..fbbc6c0d9 100644
--- a/tests/unit/test_real_browser_state_discards_orphaned_tab_video.py
+++ b/tests/unit/test_real_browser_state_discards_orphaned_tab_video.py
@@ -166,3 +166,67 @@ async def test_discard_video_artifact_noop_when_page_has_no_video() -> None:
await state._discard_video_artifact(page)
assert [va.video_path for va in state.browser_artifacts.video_artifacts] == ["/tmp/real.webm"]
+
+
+async def test_a_crashed_page_keeps_its_recording() -> None:
+ """The crashed tab is usually the run's own working page, so discarding its video here would
+ delete the recording of the very run that crashed. Closing it must not touch the artifact."""
+ crashed = _make_page("/tmp/crashed.webm")
+ survivor = _make_page("/tmp/real.webm")
+ state = _build_state(
+ pages=[crashed, survivor],
+ working_page=survivor,
+ video_artifacts=[VideoArtifact(video_path="/tmp/crashed.webm"), VideoArtifact(video_path="/tmp/real.webm")],
+ )
+
+ await state._close_crashed_page(crashed)
+
+ crashed.close.assert_awaited_once()
+ assert [va.video_path for va in state.browser_artifacts.video_artifacts] == [
+ "/tmp/crashed.webm",
+ "/tmp/real.webm",
+ ]
+ assert state.browser_artifacts.is_page_video_discarded(crashed) is False
+
+
+async def test_the_orphan_sweep_keeps_a_crashed_page_recording() -> None:
+ """The sibling path: a crashed page whose close is in flight or timed out is still in
+ context.pages, and _close_all_other_pages would otherwise discard the same run's recording."""
+ crashed = _make_page("/tmp/crashed.webm")
+ working = _make_page("/tmp/real.webm")
+ orphan = _make_page("/tmp/orphan.webm")
+ state = _build_state(
+ pages=[crashed, working, orphan],
+ working_page=working,
+ video_artifacts=[
+ VideoArtifact(video_path="/tmp/crashed.webm"),
+ VideoArtifact(video_path="/tmp/real.webm"),
+ VideoArtifact(video_path="/tmp/orphan.webm"),
+ ],
+ )
+ state._crashed_pages.add(crashed)
+
+ await state._close_all_other_pages(discard_orphaned_videos=True)
+
+ assert state.browser_artifacts.is_page_video_discarded(crashed) is False
+ assert state.browser_artifacts.is_page_video_discarded(orphan) is True
+ assert [va.video_path for va in state.browser_artifacts.video_artifacts] == [
+ "/tmp/crashed.webm",
+ "/tmp/real.webm",
+ ]
+
+
+async def test_a_crashed_page_that_refuses_to_close_stays_watchable() -> None:
+ crashed = _make_page(None)
+ crashed.close = AsyncMock(side_effect=RuntimeError("close refused"))
+ state = _build_state(pages=[crashed], working_page=None, video_artifacts=[])
+ state._watch_page_for_crash(crashed)
+
+ await state._close_crashed_page(crashed)
+
+ assert crashed in state._crash_listener_pages
+ state._register_disconnect_listeners(state.browser_context)
+ assert crashed.on.call_count == 1
diff --git a/tests/unit/test_real_browser_state_reload.py b/tests/unit/test_real_browser_state_reload.py
index dde464108..f8d8384f2 100644
--- a/tests/unit/test_real_browser_state_reload.py
+++ b/tests/unit/test_real_browser_state_reload.py
@@ -196,9 +196,7 @@ async def test_scrape_with_type_normal_no_reload_call() -> None:
def _reconnect_state(binding: DownloadBinding) -> RealBrowserState:
- state = RealBrowserState.__new__(RealBrowserState)
- state.pw = AsyncMock()
- state.browser_context = MagicMock()
+ state = RealBrowserState(pw=AsyncMock(), browser_context=MagicMock())
state.engine_selection = MagicMock()
state.engine_selection.start_driver = AsyncMock(return_value=AsyncMock())
state.set_working_page = AsyncMock()
@@ -230,9 +228,7 @@ async def test_reconnect_keeps_run_dir_binding() -> None:
def _reconnect_state_capturing_check(binding: DownloadBinding, captured: dict[str, object]) -> RealBrowserState:
- state = RealBrowserState.__new__(RealBrowserState)
- state.pw = AsyncMock()
- state.browser_context = MagicMock()
+ state = RealBrowserState(pw=AsyncMock(), browser_context=MagicMock())
state.engine_selection = MagicMock()
state.engine_selection.start_driver = AsyncMock(return_value=AsyncMock())
state.set_working_page = AsyncMock()
@@ -268,9 +264,8 @@ async def test_reconnect_threads_run_dir_binding_into_check_and_fix_state() -> N
def _recreation_state(
binding: DownloadBinding, captured: dict[str, object]
) -> tuple[RealBrowserState, Callable[..., Awaitable[tuple[object, BrowserArtifacts, object]]]]:
- state = RealBrowserState.__new__(RealBrowserState)
- state.pw = AsyncMock()
- state.browser_context = None # force the check_and_fix_state recreation branch
+ # No browser context forces the check_and_fix_state recreation branch.
+ state = RealBrowserState(pw=AsyncMock(), browser_context=None)
state.engine_selection = None
state.browser_artifacts = BrowserArtifacts(download_binding=binding)
state.set_working_page = AsyncMock()
@@ -346,9 +341,7 @@ async def test_check_and_fix_state_recreation_stamps_forwarded_binding_on_assign
"""Outer contract: on recreation, check_and_fix_state forwards the derived binding and the factory
stamps it on the fresh artifacts, so the state ends up SESSION_DIR — with no later override that
could mislabel a genuine provider change."""
- state = RealBrowserState.__new__(RealBrowserState)
- state.pw = AsyncMock()
- state.browser_context = None
+ state = RealBrowserState(pw=AsyncMock(), browser_context=None)
state.engine_selection = None
state.browser_artifacts = BrowserArtifacts(download_binding=DownloadBinding.SESSION_DIR)
state.set_working_page = AsyncMock()
diff --git a/tests/unit/workflow/test_block_browser_state_recovery.py b/tests/unit/workflow/test_block_browser_state_recovery.py
index 0796f0522..1ee00698a 100644
--- a/tests/unit/workflow/test_block_browser_state_recovery.py
+++ b/tests/unit/workflow/test_block_browser_state_recovery.py
@@ -9,7 +9,7 @@ import subprocess
import urllib.request
from datetime import datetime, timedelta, timezone
from pathlib import Path
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, call
import pytest
from playwright.async_api import async_playwright
@@ -23,6 +23,7 @@ from skyvern.exceptions import (
from skyvern.forge import app
from skyvern.forge.sdk.workflow.models.block import CodeBlock
from skyvern.forge.sdk.workflow.models.parameter import OutputParameter, ParameterType
+from skyvern.webeye import real_browser_state as real_browser_state_module
from skyvern.webeye.browser_artifacts import BrowserArtifacts
from skyvern.webeye.real_browser_state import RealBrowserState
@@ -445,8 +446,6 @@ async def test_reconnect_stops_fresh_driver_when_state_rebuild_fails(monkeypatch
async def test_requested_close_logs_disconnect_at_info_not_warning(monkeypatch: pytest.MonkeyPatch) -> None:
# The end-of-run teardown closes the context on purpose; observing that close is diagnostic
# context, not a warning. A close nobody requested still warns.
- from skyvern.webeye import real_browser_state as real_browser_state_module
-
log = MagicMock()
monkeypatch.setattr(real_browser_state_module, "LOG", log)
monkeypatch.setattr(real_browser_state_module, "disable_download_interceptor_for_context", AsyncMock())
@@ -479,8 +478,6 @@ async def test_requested_close_logs_disconnect_at_info_not_warning(monkeypatch:
async def test_keep_alive_close_does_not_downgrade_a_later_disconnect(monkeypatch: pytest.MonkeyPatch) -> None:
# close(close_browser_on_completion=False) keeps the browser for reuse, so a disconnect that
# follows it is nobody's request and must still warn.
- from skyvern.webeye import real_browser_state as real_browser_state_module
-
log = MagicMock()
monkeypatch.setattr(real_browser_state_module, "LOG", log)
@@ -493,3 +490,123 @@ async def test_keep_alive_close_does_not_downgrade_a_later_disconnect(monkeypatc
log.warning.assert_called_once()
assert log.warning.call_args.args[0] == "Browser state disconnected"
+
+
+def _crashable_page() -> MagicMock:
+ page = MagicMock()
+ page.close = AsyncMock()
+ return page
+
+
+async def _never_returns() -> None:
+ await asyncio.sleep(3600)
+
+
+def test_crash_listener_registers_once_for_pre_existing_and_later_pages() -> None:
+ existing = _crashable_page()
+ context = MagicMock(pages=[existing])
+ state = RealBrowserState(pw=MagicMock(), browser_context=context)
+
+ assert existing.on.call_args_list == [call("crash", state._on_page_crashed)]
+ assert call("page", state._watch_page_for_crash) in context.on.call_args_list
+
+ later = _crashable_page()
+ state._watch_page_for_crash(later)
+ state._watch_page_for_crash(later)
+ state._register_disconnect_listeners(context)
+
+ assert existing.on.call_count == 1
+ assert later.on.call_count == 1
+
+
+def test_a_context_attached_from_outside_the_class_is_armed_for_crash_reaping() -> None:
+ existing = _crashable_page()
+ state = RealBrowserState(pw=MagicMock(), browser_context=MagicMock(pages=[]))
+ replacement = MagicMock(pages=[existing])
+
+ state.browser_context = replacement
+
+ assert existing.on.call_args_list == [call("crash", state._on_page_crashed)]
+
+
+async def test_a_crashed_page_is_excluded_before_its_close_lands() -> None:
+ crashed = _crashable_page()
+ crashed.url = "https://example.invalid/crashed"
+ crashed.close = AsyncMock(side_effect=_never_returns)
+ survivor = _crashable_page()
+ survivor.url = "https://example.invalid/alive"
+ state = RealBrowserState(pw=MagicMock(), browser_context=MagicMock(pages=[crashed, survivor]))
+
+ state._on_page_crashed(crashed)
+
+ try:
+ assert await state.list_valid_pages() == [survivor]
+ crashed.close.assert_not_awaited()
+ finally:
+ for task in list(state._detached_teardown_tasks):
+ task.cancel()
+
+
+async def test_a_close_that_swallows_cancellation_still_exhausts_its_attempts(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """A cancellation-resistant close must not read as success: asyncio.timeout only cancels, so a
+ close that swallows the cancel would leave the dead target blocking every later attach."""
+ monkeypatch.setattr(real_browser_state_module, "BROWSER_PAGE_CLOSE_TIMEOUT", 0.05)
+ page = _crashable_page()
+
+ async def _swallow_cancellation() -> None:
+ try:
+ await asyncio.sleep(3600)
+ except asyncio.CancelledError:
+ return
+
+ page.close = AsyncMock(side_effect=_swallow_cancellation)
+ state = RealBrowserState(pw=MagicMock(), browser_context=MagicMock(pages=[page]))
+
+ await state._close_crashed_page(page)
+
+ assert page.close.await_count == real_browser_state_module.CRASHED_PAGE_CLOSE_ATTEMPTS
+
+
+async def test_a_timed_out_crashed_page_close_is_retried_once(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr(real_browser_state_module, "BROWSER_PAGE_CLOSE_TIMEOUT", 0.05)
+ page = _crashable_page()
+ attempts: list[int] = []
+
+ async def _hang_once_then_succeed() -> None:
+ attempts.append(1)
+ if len(attempts) == 1:
+ await _never_returns()
+
+ page.close = AsyncMock(side_effect=_hang_once_then_succeed)
+ state = RealBrowserState(pw=MagicMock(), browser_context=MagicMock(pages=[page]))
+
+ await state._close_crashed_page(page)
+
+ assert page.close.await_count == 2
+
+
+async def test_crashed_page_close_is_bounded_and_never_raises(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr(real_browser_state_module, "BROWSER_PAGE_CLOSE_TIMEOUT", 0.05)
+ crashed = _crashable_page()
+ stubborn = _crashable_page()
+ stubborn.close = AsyncMock(side_effect=RuntimeError("close refused"))
+ hanging = _crashable_page()
+ hanging.close = AsyncMock(side_effect=_never_returns)
+ context = MagicMock(pages=[crashed, stubborn, hanging])
+ state = RealBrowserState(pw=MagicMock(), browser_context=context)
+
+ state._on_page_crashed(crashed)
+ state._on_page_crashed(stubborn)
+ state._on_page_crashed(hanging)
+ async with asyncio.timeout(10):
+ await asyncio.gather(*list(state._detached_teardown_tasks))
+
+ crashed.close.assert_awaited_once()
+ stubborn.close.assert_awaited_once()
+ assert state._detached_teardown_tasks == set()