Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 190396c5c..8b2e13fb1 100644--- a/skyvern/constants.py+++ b/skyvern/constants.py@@ -20,6 +20,9 @@ ERROR_CODE_REASONING_MAX_LENGTH = 2000INPUT_TEXT_TIMEOUT = 120000 # 2 minutesPAGE_CONTENT_TIMEOUT = 300 # 5 minsBROWSER_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 = 2BROWSER_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 quicklydiff --git a/skyvern/webeye/real_browser_state.py b/skyvern/webeye/real_browser_state.pyindex 5c4127869..53c618bc9 100644--- a/skyvern/webeye/real_browser_state.py+++ b/skyvern/webeye/real_browser_state.py@@ -3,6 +3,7 @@ from __future__ import annotationsimport asyncioimport randomimport time+import weakreffrom collections.abc import Awaitable, Callablefrom datetime import UTC, datetimefrom 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_contextself.browser_artifacts = browser_artifactsself.browser_cleanup = browser_cleanup@@ -110,11 +116,21 @@ class RealBrowserState(BrowserState):self.last_navigation_status: int | None = Noneself._ever_connected = browser_context is not Noneself._close_requested = False- self._disconnect_listener_context: BrowserContext | None = None- self._disconnect_listener_browser: Browser | None = Noneif 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.pagesfor 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_pagefor 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 pageor 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.browserexcept 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:returntry: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:returnself._record_disconnect("browser_disconnected_event",diff --git a/tests/unit/test_browser_effect_sink_enumeration.py b/tests/unit/test_browser_effect_sink_enumeration.pyindex 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()) == 165handler_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_CANDIDATESassert 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()) == 160def 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.pyindex 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 asynciofrom contextlib import asynccontextmanagerfrom dataclasses import dataclassfrom types import SimpleNamespace@@ -9,6 +10,7 @@ import pytestfrom skyvern.forge.sdk.copilot import mcp_adapterfrom skyvern.forge.sdk.copilot.mcp_adapter import SkyvernOverlayMCPServer+from skyvern.webeye.real_browser_state import RealBrowserStateclass _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 = Noneself.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_returnassert result["ok"] is Trueassert 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 Truediff --git a/tests/unit/test_forloop_incremental_persist.py b/tests/unit/test_forloop_incremental_persist.pyindex 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.pyindex 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 == 1diff --git a/tests/unit/test_real_browser_state_reload.py b/tests/unit/test_real_browser_state_reload.pyindex 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() -> Ndef _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 = Nonestate.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 factorystamps it on the fresh artifacts, so the state ends up SESSION_DIR — with no later override thatcould 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 = Nonestate.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.pyindex 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 subprocessimport urllib.requestfrom datetime import datetime, timedelta, timezonefrom pathlib import Path-from unittest.mock import AsyncMock, MagicMock+from unittest.mock import AsyncMock, MagicMock, callimport pytestfrom playwright.async_api import async_playwright@@ -23,6 +23,7 @@ from skyvern.exceptions import (from skyvern.forge import appfrom skyvern.forge.sdk.workflow.models.block import CodeBlockfrom skyvern.forge.sdk.workflow.models.parameter import OutputParameter, ParameterType+from skyvern.webeye import real_browser_state as real_browser_state_modulefrom skyvern.webeye.browser_artifacts import BrowserArtifactsfrom skyvern.webeye.real_browser_state import RealBrowserState@@ -445,8 +446,6 @@ async def test_reconnect_stops_fresh_driver_when_state_rebuild_fails(monkeypatchasync 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(monkeypatclog.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()