Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
import asyncio
import json
from collections.abc import AsyncIterator, Callable
from datetime import UTC, timedelta
from pathlib import Path
from types import SimpleNamespace
from typing import Any, cast
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
import pytest_asyncio
from sqlalchemy import update
from structlog.testing import capture_logs
from skyvern.config import settings
from skyvern.exceptions import (
BlockedHost,
BrowserSessionAlreadyOccupiedError,
BrowserSessionClosed,
BrowserSessionExpired,
BrowserSessionNotFound,
BrowserSessionNotRenewable,
BrowserSessionOwnershipConflict,
ExternalBrowserEndpointNotEncrypted,
ExternalBrowserUnavailable,
)
from skyvern.forge import agent as agent_mod
from skyvern.forge.agent import ForgeAgent
from skyvern.forge.sdk.core import skyvern_context
from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
from skyvern.forge.sdk.db.datetime_utils import naive_utc_now
from skyvern.forge.sdk.db.models import PersistentBrowserSessionModel
from skyvern.forge.sdk.encrypt import encryptor
from skyvern.forge.sdk.routes import agent_protocol as agent_protocol_mod
from skyvern.forge.sdk.routes.streaming import verify as verify_mod
from skyvern.forge.sdk.schemas.persistent_browser_sessions import (
PersistentBrowserSession,
lost_external_browser_error,
)
from skyvern.forge.sdk.schemas.tasks import TaskRequest
from skyvern.forge.sdk.workflow import service as service_mod
from skyvern.forge.sdk.workflow.models.block import TaskBlock
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody
from skyvern.forge.sdk.workflow.service import WorkflowService
from skyvern.webeye import default_persistent_sessions_manager as manager_mod
from skyvern.webeye import external_cdp_sessions as external_mod
from skyvern.webeye import real_browser_manager as real_browser_manager_mod
from skyvern.webeye import real_browser_state as real_browser_state_mod
from skyvern.webeye.actions.handler import _adopted_session_download_binding
from skyvern.webeye.browser_factory import BrowserContextFactory, rebind_download_dir
from skyvern.webeye.cdp_discovery import CdpDiscoveryError, resolve_websocket_url
from skyvern.webeye.external_cdp_sessions import close_expired_external_cdp_sessions
from skyvern.webeye.real_browser_manager import RealBrowserManager
from skyvern.webeye.real_browser_state import RealBrowserState
from tests.unit._external_cdp_fakes import (
CDP_URL,
ORG_A,
ORG_B,
TOKEN,
acquire_lease,
backdate_registration,
begin_lease,
external_browser_state,
external_cdp_stack,
install_deadline_clock,
register_external,
release_lease,
release_lease_by,
stall_external_detach,
)
from tests.unit._task_block_fakes import mock_block_execute_deps, output_parameter
from tests.unit.scoped_asyncio import ScopedAsyncio
@pytest_asyncio.fixture
async def stack() -> AsyncIterator[SimpleNamespace]:
async with external_cdp_stack() as built:
yield built
@pytest.mark.asyncio
async def test_registration_is_org_scoped_detach_only_and_never_reveals_the_address(stack: SimpleNamespace) -> None:
client, manager = stack.client, stack.manager
attached, context, pw = external_browser_state()
connect = AsyncMock(return_value=attached)
with capture_logs() as logs, patch.object(manager_mod, "attach_registered_cdp_browser", connect):
registered = await register_external(client)
assert registered.status_code == 200
session_id = registered.json()["browser_session_id"]
assert session_id.startswith("pbs_")
assert registered.json()["status"] == "running"
assert registered.json()["browser_address"] is None
read_a = await client.get(f"/v1/browser_sessions/{session_id}")
assert read_a.status_code == 200
stored = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert stored is not None and stored.upstream_cdp_url and stored.upstream_cdp_url not in repr(stored)
stack.caller.organization_id = ORG_B
assert (await client.get(f"/v1/browser_sessions/{session_id}")).status_code == 404
assert await manager.get_browser_state(session_id, ORG_B) is None
connect.assert_not_awaited()
assert await manager.get_browser_state(session_id, ORG_A) is attached
assert await manager.get_browser_state(session_id, ORG_A) is attached
connect.assert_awaited_once()
assert await manager.get_browser_state(session_id, ORG_B) is None
assert (await client.post(f"/v1/browser_sessions/{session_id}/close")).status_code == 404
assert session_id in manager._browser_sessions
stack.caller.organization_id = ORG_A
assert (await client.post(f"/v1/browser_sessions/{session_id}/close")).status_code == 200
assert session_id not in manager._browser_sessions
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
context.browser.close.assert_not_awaited()
closed = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert closed is not None and closed.completed_at is not None
assert closed.upstream_cdp_url is None
for body in (registered.text, read_a.text):
assert TOKEN not in body and ":9333" not in body
assert any(log.get("event") == "api.raw_request" for log in logs)
assert TOKEN not in repr(logs) and "devtools/browser/b1" not in repr(logs)
@pytest.mark.asyncio
async def test_closing_every_session_leaves_a_registration_open(stack: SimpleNamespace) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
await stack.manager.close_all_sessions(ORG_A)
kept = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert kept is not None and kept.completed_at is None and kept.upstream_cdp_url is not None
@pytest.mark.asyncio
async def test_attach_rechecks_the_host_policy_at_connect_time(stack: SimpleNamespace) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
with patch.object(settings, "ENV", "production"), pytest.raises(BlockedHost):
await stack.manager.get_browser_state(session_id, ORG_A)
assert session_id not in stack.manager._browser_sessions
@pytest.mark.asyncio
@pytest.mark.parametrize("warm", [True, False], ids=["warm_cache", "cold_cache"])
async def test_an_expired_registration_is_refused_and_released(warm: bool, stack: SimpleNamespace) -> None:
manager = stack.manager
attached, context, pw = external_browser_state()
connect = AsyncMock(return_value=attached)
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
with patch.object(manager_mod, "attach_registered_cdp_browser", connect):
if warm:
assert await manager.get_browser_state(session_id, ORG_A) is attached
await backdate_registration(stack, session_id, minutes=6)
with pytest.raises(BrowserSessionExpired):
await begin_lease(stack.manager, session_id, "tsk_before_close")
with pytest.raises(BrowserSessionExpired):
await manager.get_browser_state(session_id, ORG_A)
with pytest.raises(BrowserSessionExpired):
await begin_lease(stack.manager, session_id, "tsk_after_close")
assert connect.await_count == (1 if warm else 0)
assert session_id not in manager._browser_sessions
assert pw.stop.await_count == (1 if warm else 0)
context.close.assert_not_awaited()
closed = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert closed is not None and closed.completed_at is not None and closed.upstream_cdp_url is None
@pytest.mark.asyncio
async def test_renewal_never_moves_a_registration_deadline(stack: SimpleNamespace) -> None:
manager = stack.manager
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
await backdate_registration(stack, session_id, minutes=4)
renewed = await manager.renew_or_close_session(session_id, ORG_A)
assert renewed.timeout_minutes == 5 and renewed.completed_at is None
stored = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert stored is not None and stored.timeout_minutes == 5 and stored.completed_at is None
remaining = await manager.remaining_lifetime_seconds(session_id, ORG_A)
assert remaining is not None and 0 < remaining <= 60
fixed = await manager.seconds_until_fixed_deadline(session_id, ORG_A)
assert fixed is not None and 0 < fixed <= 60
await backdate_registration(stack, session_id, minutes=6)
with pytest.raises(BrowserSessionNotRenewable):
await manager.renew_or_close_session(session_id, ORG_A, close_on_failure=False)
stored = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert stored is not None and stored.completed_at is None
@pytest.mark.asyncio
async def test_a_close_during_an_in_flight_connect_publishes_nothing(stack: SimpleNamespace) -> None:
manager = stack.manager
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state()
connect_started, release_connect = asyncio.Event(), asyncio.Event()
async def slow_connect(_: str) -> RealBrowserState:
connect_started.set()
await release_connect.wait()
return attached
with patch.object(manager_mod, "attach_registered_cdp_browser", slow_connect):
attach = asyncio.create_task(manager.get_browser_state(session_id, ORG_A))
await connect_started.wait()
await manager.close_session(ORG_A, session_id)
release_connect.set()
assert await attach is None
assert session_id not in manager._browser_sessions
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_expiry_closes_a_registration_no_process_holds(stack: SimpleNamespace) -> None:
expired_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
live_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
await backdate_registration(stack, expired_id, minutes=10)
with patch.object(manager_mod, "active_copilot_session_ids", lambda: {expired_id}):
await stack.manager.reap_expired_sessions()
reaped = await stack.repo.get_persistent_browser_session(expired_id, ORG_A)
assert reaped is not None and reaped.completed_at is not None and reaped.upstream_cdp_url is None
await backdate_registration(stack, live_id, minutes=10)
assert await close_expired_external_cdp_sessions(stack.repo) == 1
swept = await stack.repo.get_persistent_browser_session(live_id, ORG_A)
assert swept is not None and swept.completed_at is not None and swept.upstream_cdp_url is None
assert swept.close_reason == "expired"
@pytest.mark.asyncio
async def test_a_restart_leaves_registrations_attachable(stack: SimpleNamespace) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
with patch.object(settings, "BROWSER_STREAMING_MODE", "cdp"):
await stack.manager.cleanup_stale_sessions()
kept = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert kept is not None and kept.completed_at is None and kept.upstream_cdp_url is not None
attached, context, pw = external_browser_state()
with patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=attached)):
assert await stack.manager.get_browser_state(session_id, ORG_A) is attached
await manager_mod.DefaultPersistentSessionsManager.close()
kept = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert kept is not None and kept.completed_at is None and kept.upstream_cdp_url is not None
assert session_id not in stack.manager._browser_sessions
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_a_host_dns_cannot_resolve_is_refused_before_any_dial() -> None:
start = AsyncMock()
with (
patch.object(settings, "ENV", "production"),
patch.object(external_mod, "async_playwright", lambda: SimpleNamespace(start=start)),
pytest.raises(BlockedHost),
):
await external_mod.connect_external_cdp_browser("https://cdp.invalid:9222/?token=T")
start.assert_not_awaited()
async def _serve_discovery(reply: bytes | Callable[[int], bytes], requests: list[bytes]) -> asyncio.Server:
async def handle(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
requests.append(await reader.readuntil(b"\r\n\r\n"))
writer.write(reply(writer.get_extra_info("sockname")[1]) if callable(reply) else reply)
await writer.drain()
writer.close()
return await asyncio.start_server(handle, "127.0.0.1", 0)
def _json_reply(payload: object) -> bytes:
body = json.dumps(payload).encode()
return b"HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s" % (len(body), body)
def _driver() -> tuple[SimpleNamespace, AsyncMock]:
"""A Playwright driver whose connect records the websocket URL it was asked to dial."""
connect = AsyncMock(return_value=SimpleNamespace(contexts=[external_browser_state()[1]]))
pw = SimpleNamespace(stop=AsyncMock(), chromium=SimpleNamespace(connect_over_cdp=connect))
return SimpleNamespace(start=AsyncMock(return_value=pw)), connect
@pytest.mark.asyncio
@pytest.mark.parametrize(
("endpoint", "reported", "request_line", "auth", "dialed"),
[
(
"http://127.0.0.1:{port}/?token=T",
"ws://localhost/devtools/browser/abc",
b"GET /json/version?token=T ",
None,
"ws://127.0.0.1:{port}/devtools/browser/abc?token=T",
),
(
"http://user:p%40s[email protected]:{port}",
"ws://127.0.0.1:{port}/devtools/browser/abc",
b"GET /json/version ",
b"Authorization: Basic dXNlcjpwQHNz",
"ws://user:p%40s[email protected]:{port}/devtools/browser/abc",
),
(
"http://127.0.0.1:{port}/pbs_x?token=T",
"ws://127.0.0.1:{port}/pbs_x/devtools/browser/abc?token=R",
b"GET /pbs_x/json/version?token=T ",
None,
"ws://127.0.0.1:{port}/pbs_x/devtools/browser/abc?token=R",
),
(
"http://127.0.0.1:{port}",
"wss://93.184.216.34:8443/devtools/browser/abc?session=S",
b"GET /json/version ",
None,
"wss://93.184.216.34:8443/devtools/browser/abc?session=S",
),
],
ids=["loopback_answer_keeps_query_token", "same_authority_keeps_userinfo", "reported_query_wins", "separate_host"],
)
async def test_the_dial_keeps_the_callers_credential_or_follows_a_separate_websocket_host(
endpoint: str, reported: str, request_line: bytes, auth: bytes | None, dialed: str
) -> None:
requests: list[bytes] = []
server = await _serve_discovery(
lambda port: _json_reply({"webSocketDebuggerUrl": reported.format(port=port)}), requests
)
port = server.sockets[0].getsockname()[1]
driver, connect = _driver()
try:
with patch.object(settings, "ENV", "local"), patch.object(external_mod, "async_playwright", lambda: driver):
await external_mod.connect_external_cdp_browser(endpoint.format(port=port))
finally:
server.close()
assert requests[0].startswith(request_line)
if auth is not None:
assert auth in requests[0]
assert connect.await_args is not None and connect.await_args.args[0] == dialed.format(port=port)
@pytest.mark.asyncio
@pytest.mark.parametrize(
"reply",
[
_json_reply({"webSocketDebuggerUrl": "ws://93.184.216.34:9222/devtools/browser/abc"}),
b"HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:1/json/version\r\nContent-Length: 0\r\n\r\n",
_json_reply({"webSocketDebuggerUrl": "ws://localhost/devtools/browser/abc", "pad": "x" * 70_000}),
],
ids=["plaintext_websocket_elsewhere", "redirect", "oversized"],
)
async def test_a_discovery_answer_that_breaks_policy_starts_no_driver(reply: bytes) -> None:
requests: list[bytes] = []
server = await _serve_discovery(reply, requests)
driver, connect = _driver()
try:
with (
patch.object(settings, "ENV", "local"),
patch.object(external_mod, "async_playwright", lambda: driver),
pytest.raises((ExternalBrowserEndpointNotEncrypted, ExternalBrowserUnavailable)),
):
await external_mod.connect_external_cdp_browser(f"http://127.0.0.1:{server.sockets[0].getsockname()[1]}")
finally:
server.close()
assert len(requests) == 1
driver.start.assert_not_awaited()
@pytest.mark.asyncio
async def test_a_trickling_discovery_reply_is_cut_off_at_the_deadline() -> None:
handlers: list[asyncio.Task[Any]] = []
async def trickle(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
handlers.append(cast("asyncio.Task[Any]", asyncio.current_task()))
await reader.readuntil(b"\r\n\r\n")
try:
writer.write(b"HTTP/1.1 200 OK\r\n")
for _ in range(50):
writer.write(b"X-Slow: 1\r\n")
await writer.drain()
await asyncio.sleep(0.2)
except ConnectionError:
pass
writer.close()
server = await asyncio.start_server(trickle, "127.0.0.1", 0)
loop = asyncio.get_running_loop()
started = loop.time()
try:
with pytest.raises(CdpDiscoveryError, match="TimeoutError"):
await resolve_websocket_url(f"http://127.0.0.1:{server.sockets[0].getsockname()[1]}", timeout_ms=1_000)
finally:
server.close()
for handler in handlers:
handler.cancel()
await asyncio.gather(*handlers, return_exceptions=True)
assert loop.time() - started < 3
@pytest.mark.asyncio
async def test_the_stored_address_is_ciphertext_that_attach_decrypts(stack: SimpleNamespace) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
stored = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert stored is not None and stored.upstream_cdp_url
assert TOKEN not in stored.upstream_cdp_url and ":9333" not in stored.upstream_cdp_url
attached, _, _ = external_browser_state()
connect = AsyncMock(return_value=attached)
with patch.object(external_mod, "connect_external_cdp_browser", connect):
assert await stack.manager.get_browser_state(session_id, ORG_A) is attached
connect.assert_awaited_once_with(CDP_URL)
@pytest.mark.asyncio
async def test_registration_is_refused_without_encryption_configured(stack: SimpleNamespace) -> None:
with patch.dict(encryptor._methods, clear=True):
response = await register_external(stack.client)
assert response.status_code == 503
assert await stack.repo.get_uncompleted_persistent_browser_sessions() == []
@pytest.mark.asyncio
async def test_an_attach_cancelled_before_publishing_releases_its_driver(stack: SimpleNamespace) -> None:
manager = stack.manager
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state()
read_row = stack.repo.get_persistent_browser_session
attach_done, reading_after_attach = asyncio.Event(), asyncio.Event()
async def attach(_: str) -> RealBrowserState:
attach_done.set()
return attached
async def read(session_id: str, organization_id: str | None = None) -> PersistentBrowserSession | None:
if attach_done.is_set():
reading_after_attach.set()
await asyncio.Event().wait()
return await read_row(session_id, organization_id)
with (
patch.object(manager_mod, "attach_registered_cdp_browser", attach),
patch.object(stack.repo, "get_persistent_browser_session", read),
):
attach_task = asyncio.create_task(manager.get_browser_state(session_id, ORG_A))
await reading_after_attach.wait()
attach_task.cancel()
with pytest.raises(asyncio.CancelledError):
await attach_task
assert session_id not in manager._browser_sessions
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_a_connect_that_lands_mid_close_publishes_nothing(stack: SimpleNamespace) -> None:
manager = stack.manager
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state()
connect_started, release_connect = asyncio.Event(), asyncio.Event()
closing, finish_close = asyncio.Event(), asyncio.Event()
record_close_reason = stack.repo.record_persistent_browser_session_close_reason
async def slow_connect(_: str) -> RealBrowserState:
connect_started.set()
await release_connect.wait()
return attached
async def held_record(*args: object) -> None:
closing.set()
await finish_close.wait()
await record_close_reason(*args)
with (
patch.object(manager_mod, "attach_registered_cdp_browser", slow_connect),
patch.object(stack.repo, "record_persistent_browser_session_close_reason", held_record),
):
attach = asyncio.create_task(manager.get_browser_state(session_id, ORG_A))
await connect_started.wait()
close = asyncio.create_task(manager.close_session(ORG_A, session_id))
await closing.wait()
release_connect.set()
assert await attach is None
finish_close.set()
await close
assert session_id not in manager._browser_sessions
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_every_connect_failure_is_bounded_and_reads_the_same() -> None:
async def hang(*_: object, **__: object) -> None:
await asyncio.Event().wait()
failures = [
hang,
AsyncMock(side_effect=RuntimeError("Unexpected status 401 when connecting")),
AsyncMock(side_effect=ConnectionRefusedError("connect ECONNREFUSED")),
]
messages = set()
for connect in failures:
pw = SimpleNamespace(stop=AsyncMock(), chromium=SimpleNamespace(connect_over_cdp=connect))
with (
patch.object(settings, "ENV", "local"),
patch.object(external_mod, "EXTERNAL_CDP_CONNECT_TIMEOUT_MS", 100),
patch.object(external_mod, "async_playwright", lambda: SimpleNamespace(start=AsyncMock(return_value=pw))),
pytest.raises(ExternalBrowserUnavailable) as raised,
):
async with asyncio.timeout(5):
await external_mod.connect_external_cdp_browser(CDP_URL)
messages.add(str(raised.value))
pw.stop.assert_awaited_once()
assert len(messages) == 1
async def _lease(stack: SimpleNamespace, session_id: str) -> tuple[str | None, str | None]:
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None
return row.runnable_id, row.runnable_generation_id
@pytest.mark.asyncio
async def test_a_run_leases_the_named_registration_and_its_release_only_detaches_its_driver(
stack: SimpleNamespace,
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state(pages=2)
next_run, _, next_pw = external_browser_state()
connect = AsyncMock(side_effect=[attached, next_run])
with capture_logs() as logs, patch.object(manager_mod, "attach_registered_cdp_browser", connect):
generation = await begin_lease(stack.manager, session_id, "tsk_a")
assert await acquire_lease(stack.manager, session_id, "tsk_a", generation) is attached
with pytest.raises(BrowserSessionAlreadyOccupiedError):
await begin_lease(stack.manager, session_id, "tsk_b")
assert await _lease(stack, session_id) == ("tsk_a", generation)
assert await release_lease(stack.manager, session_id, "tsk_a", generation)
assert await _lease(stack, session_id) == (None, None)
pw.stop.assert_awaited_once()
generation_b = await begin_lease(stack.manager, session_id, "tsk_b")
assert await acquire_lease(stack.manager, session_id, "tsk_b", generation_b) is next_run
assert not await release_lease(stack.manager, session_id, "tsk_a", generation)
assert await acquire_lease(stack.manager, session_id, "tsk_b", generation_b) is next_run
assert await _lease(stack, session_id) == ("tsk_b", generation_b)
next_pw.stop.assert_not_awaited()
assert next_run.is_connected()
released = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert released is not None and released.completed_at is None and released.upstream_cdp_url is not None
context.close.assert_not_awaited()
context.browser.close.assert_not_awaited()
for page in context.pages:
page.close.assert_not_awaited()
assert TOKEN not in repr(logs) and ":9333" not in repr(logs)
with patch.object(verify_mod, "app", SimpleNamespace(PERSISTENT_SESSIONS_MANAGER=stack.manager)):
assert await verify_mod.verify_browser_session(session_id, ORG_A) is None
@pytest.mark.asyncio
async def test_a_run_naming_no_session_launches_a_managed_browser_and_leaves_registrations_alone(
stack: SimpleNamespace,
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
managed = MagicMock(get_or_create_page=AsyncMock(), browser_context=None)
browser_manager = RealBrowserManager()
launch = AsyncMock(return_value=managed)
attach = AsyncMock()
task = MagicMock(
task_id="tsk_1",
workflow_run_id=None,
organization_id=ORG_A,
browser_session_id=None,
browser_address=None,
url="https://example.test/",
)
with (
patch.object(real_browser_manager_mod, "app", MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)),
patch.object(manager_mod, "attach_registered_cdp_browser", attach),
patch.object(browser_manager, "_create_browser_state", launch),
):
assert await browser_manager.get_or_create_for_task(task) is managed
assert launch.await_args is not None and launch.await_args.kwargs.get("browser_session_id") is None
attach.assert_not_awaited()
assert await _lease(stack, session_id) == (None, None)
@pytest.mark.asyncio
async def test_a_reused_session_claim_leases_a_registration_without_waiting_for_an_address(
stack: SimpleNamespace,
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None
skyvern_context.set(SkyvernContext())
try:
with patch.object(service_mod, "app", SimpleNamespace(PERSISTENT_SESSIONS_MANAGER=stack.manager)):
claimed = await WorkflowService()._claim_reused_session(
organization_id=ORG_A, workflow_run_id="wr_1", browser_session=row
)
finally:
skyvern_context.reset()
assert claimed == session_id
assert (await _lease(stack, session_id))[0] == "wr_1"
@pytest.mark.asyncio
@pytest.mark.parametrize("run_type", ["task", "workflow_run"])
@pytest.mark.parametrize("state", ["open", "expired", "closed", "foreign"])
async def test_submission_admits_only_an_open_registration_of_the_callers_org(
stack: SimpleNamespace, state: str, run_type: str
) -> None:
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
if state == "expired":
await backdate_registration(stack, session_id, minutes=6)
if state == "closed":
await stack.client.post(f"/v1/browser_sessions/{session_id}/close")
admitted = AsyncMock(side_effect=asyncio.CancelledError)
fake_app = SimpleNamespace(
DATABASE=SimpleNamespace(browser_sessions=stack.repo, tasks=SimpleNamespace(create_task=admitted))
)
expected: dict[str, tuple[type[BaseException], str | None]] = {
"open": (asyncio.CancelledError, None),
"expired": (
BrowserSessionExpired,
r"expired after .* register it again \(POST /v1/browser_sessions/external\)",
),
"closed": (BrowserSessionClosed, r"no longer usable .* register it again"),
"foreign": (BrowserSessionNotFound, None),
}
error_type, message = expected[state]
organization_id = ORG_B if state == "foreign" else ORG_A
service = WorkflowService()
with (
patch.object(agent_mod, "app", fake_app),
patch.object(service_mod, "app", fake_app),
patch.object(service, "get_workflow", admitted),
pytest.raises(error_type, match=message),
):
if run_type == "task":
await ForgeAgent().create_task(
TaskRequest(url="https://example.test/", browser_session_id=session_id), organization_id
)
else:
await service.create_workflow_run(
WorkflowRequestBody(browser_session_id=session_id), "wpid_1", "w_1", organization_id
)
assert admitted.await_count == (1 if state == "open" else 0)
@pytest.mark.asyncio
async def test_an_attach_that_lands_after_its_lease_moved_publishes_nothing(stack: SimpleNamespace) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state()
connect_started, release_connect = asyncio.Event(), asyncio.Event()
async def slow_connect(_: str) -> RealBrowserState:
connect_started.set()
await release_connect.wait()
return attached
with patch.object(manager_mod, "attach_registered_cdp_browser", slow_connect):
generation_a = await begin_lease(stack.manager, session_id, "tsk_a")
attach_a = asyncio.create_task(acquire_lease(stack.manager, session_id, "tsk_a", generation_a))
await connect_started.wait()
assert await release_lease(stack.manager, session_id, "tsk_a", generation_a)
generation_b = await begin_lease(stack.manager, session_id, "tsk_b")
release_connect.set()
with pytest.raises(BrowserSessionOwnershipConflict):
await attach_a
assert session_id not in stack.manager._browser_sessions
assert await _lease(stack, session_id) == ("tsk_b", generation_b)
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_a_run_that_waited_behind_another_attach_while_its_lease_moved_gets_no_browser(
stack: SimpleNamespace,
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, _ = external_browser_state()
connect_started, release_connect = asyncio.Event(), asyncio.Event()
async def slow_connect(_: str) -> RealBrowserState:
connect_started.set()
await release_connect.wait()
return attached
with patch.object(manager_mod, "attach_registered_cdp_browser", slow_connect):
generation_a = await begin_lease(stack.manager, session_id, "tsk_a")
observer = asyncio.create_task(stack.manager.get_browser_state(session_id, ORG_A))
await connect_started.wait()
waiter = asyncio.create_task(acquire_lease(stack.manager, session_id, "tsk_a", generation_a))
async with asyncio.timeout(5):
while not stack.manager._external_connect_locks[session_id]._waiters:
await asyncio.sleep(0)
assert await release_lease(stack.manager, session_id, "tsk_a", generation_a)
generation_b = await begin_lease(stack.manager, session_id, "tsk_b")
release_connect.set()
assert await observer is attached
with pytest.raises(BrowserSessionOwnershipConflict):
await waiter
assert await _lease(stack, session_id) == ("tsk_b", generation_b)
context.close.assert_not_awaited()
@pytest.mark.asyncio
@pytest.mark.parametrize("end", ["deadline", "closed_elsewhere"])
async def test_the_lease_holder_detaches_when_its_registration_expires_or_another_process_closes_it(
stack: SimpleNamespace, monkeypatch: pytest.MonkeyPatch, end: str
) -> None:
clock = install_deadline_clock(monkeypatch)
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
attached, context, pw = external_browser_state(pages=2)
if end == "deadline":
await backdate_registration(stack, session_id, minutes=5 - 0.5 / 60, clock=clock)
with patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=attached)):
generation = await begin_lease(stack.manager, session_id, "tsk_a")
assert await acquire_lease(stack.manager, session_id, "tsk_a", generation) is attached
if end == "closed_elsewhere":
await stack.repo.close_persistent_browser_session(session_id, ORG_A)
clock.ticking.set()
await asyncio.wait_for(stack.manager._external_deadlines[session_id], timeout=5)
assert await acquire_lease(stack.manager, session_id, "tsk_a", generation) is None
closed = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert closed is not None and closed.completed_at is not None and closed.upstream_cdp_url is None
if end == "deadline":
assert closed.close_reason == "expired" and closed.started_at is not None
assert clock.now(UTC) == closed.started_at.replace(tzinfo=UTC) + timedelta(minutes=5)
else:
assert clock.polls == [external_mod.EXTERNAL_CDP_CLOSE_POLL_SECONDS]
assert session_id not in stack.manager._browser_sessions and not stack.manager._external_deadlines
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
for page in context.pages:
page.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_closing_a_registration_whose_driver_hangs_on_detach_still_closes_the_row(
stack: SimpleNamespace, monkeypatch: pytest.MonkeyPatch
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state(pages=2)
with patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=attached)):
generation = await begin_lease(stack.manager, session_id, "tsk_a")
assert await acquire_lease(stack.manager, session_id, "tsk_a", generation) is attached
driver_process = stall_external_detach(context, pw)
monkeypatch.setattr(real_browser_state_mod, "BROWSER_CLOSE_TIMEOUT", 0.05)
with capture_logs() as logs:
await asyncio.wait_for(stack.manager.close_session(ORG_A, session_id), timeout=5)
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None and row.completed_at is not None and row.upstream_cdp_url is None
assert any(log["log_level"] == "warning" and log.get("session_id") == session_id for log in logs)
driver_process.kill.assert_called_once_with()
context.close.assert_not_awaited()
context.browser.close.assert_not_awaited()
for page in context.pages:
page.close.assert_not_awaited()
@pytest.mark.asyncio
@pytest.mark.parametrize("stale", [False, True], ids=["owner_release", "stale_release"])
async def test_only_the_owners_release_cancels_the_deadline(
stack: SimpleNamespace, monkeypatch: pytest.MonkeyPatch, stale: bool
) -> None:
clock = install_deadline_clock(monkeypatch)
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
await backdate_registration(stack, session_id, minutes=5 - 0.5 / 60, clock=clock)
generation = await begin_lease(stack.manager, session_id, "tsk_a")
deadline = stack.manager._external_deadlines[session_id]
released = await release_lease(stack.manager, session_id, "tsk_a", "gen_stale" if stale else generation)
assert released is not stale
clock.ticking.set()
if stale:
await asyncio.wait_for(deadline, timeout=5)
else:
with pytest.raises(asyncio.CancelledError):
await deadline
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None and (row.completed_at is not None) is stale
assert not stack.manager._external_deadlines
@pytest.mark.asyncio
@pytest.mark.parametrize("stale", [False, True], ids=["owner_release", "stale_release"])
async def test_a_driver_that_fails_to_detach_keeps_the_lease_and_deadline_until_a_retry_detaches_it(
stack: SimpleNamespace, stale: bool
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state()
pw.stop = AsyncMock(side_effect=[RuntimeError("driver stop failed"), None])
no_live_runs = SimpleNamespace(BROWSER_MANAGER=SimpleNamespace(live_session_runnable_ids=set))
with (
patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=attached)),
patch.object(manager_mod, "app", no_live_runs),
):
generation = await begin_lease(stack.manager, session_id, "tsk_a")
assert await acquire_lease(stack.manager, session_id, "tsk_a", generation) is attached
deadline = stack.manager._external_deadlines[session_id]
assert not await release_lease_by(stack, stack.manager, session_id, "tsk_a", generation, attached, stale=stale)
assert await _lease(stack, session_id) == ("tsk_a", generation)
assert stack.manager._external_deadlines[session_id] is deadline and not deadline.done()
assert stack.manager._browser_sessions[session_id].browser_state is attached
assert await release_lease_by(stack, stack.manager, session_id, "tsk_a", generation, attached, stale=stale)
assert await _lease(stack, session_id) == (None, None)
assert session_id not in stack.manager._browser_sessions
assert pw.stop.await_count == 2
context.close.assert_not_awaited()
context.browser.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_a_release_racing_the_next_owners_begin_leaves_the_new_deadline_armed(stack: SimpleNamespace) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
generation_a = await begin_lease(stack.manager, session_id, "tsk_a")
deadline_a = stack.manager._external_deadlines[session_id]
real_release = stack.repo.release_persistent_browser_session
generations_b: list[str] = []
async def release_then_reacquire(
session_id: str,
organization_id: str,
*,
expected_runnable_id: str | None,
expected_runnable_generation_id: str | None,
) -> PersistentBrowserSession | None:
released = await real_release(
session_id,
organization_id,
expected_runnable_id=expected_runnable_id,
expected_runnable_generation_id=expected_runnable_generation_id,
)
generations_b.append(await begin_lease(stack.manager, session_id, "tsk_b"))
return released
with patch.object(stack.repo, "release_persistent_browser_session", release_then_reacquire):
assert await release_lease(stack.manager, session_id, "tsk_a", generation_a)
deadline_b = stack.manager._external_deadlines[session_id]
assert deadline_b is not deadline_a and not deadline_b.done()
with pytest.raises(asyncio.CancelledError):
await deadline_a
assert await _lease(stack, session_id) == ("tsk_b", generations_b[0])
@pytest.mark.asyncio
async def test_a_legacy_cancel_leaves_the_registration_leased_until_the_worker_releases(
stack: SimpleNamespace,
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
generation = await begin_lease(stack.manager, session_id, "wr_a")
run = SimpleNamespace(workflow_run_id="wr_a", browser_session_id=session_id)
route_app = SimpleNamespace(
DATABASE=SimpleNamespace(
workflow_runs=SimpleNamespace(get_workflow_run=AsyncMock(return_value=run)),
browser_sessions=stack.repo,
),
PERSISTENT_SESSIONS_MANAGER=stack.manager,
)
cancel = AsyncMock()
with (
patch.object(agent_protocol_mod, "app", route_app),
patch.object(agent_protocol_mod.run_service, "cancel_workflow_run", cancel),
):
await agent_protocol_mod._cancel_workflow_run("wr_a", ORG_A)
assert cancel.await_args is not None and cancel.await_args.args == ("wr_a",)
assert await _lease(stack, session_id) == ("wr_a", generation)
with pytest.raises(BrowserSessionAlreadyOccupiedError):
await begin_lease(stack.manager, session_id, "wr_b")
assert not stack.manager._external_deadlines[session_id].done()
@pytest.mark.asyncio
async def test_the_deadline_watcher_keeps_its_own_lease_and_detaches_one_another_process_took(
stack: SimpleNamespace, monkeypatch: pytest.MonkeyPatch
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
attached, context, pw = external_browser_state(pages=2)
polled = asyncio.Event()
next_poll = asyncio.Event()
polls: list[float] = []
async def poll_sleep(seconds: float) -> None:
polls.append(seconds)
if len(polls) > 1:
polled.set()
await next_poll.wait()
next_poll.clear()
monkeypatch.setattr(external_mod, "asyncio", ScopedAsyncio(sleep=poll_sleep))
with patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=attached)):
generation = await begin_lease(stack.manager, session_id, "tsk_a")
watcher = stack.manager._external_deadlines[session_id]
assert await acquire_lease(stack.manager, session_id, "tsk_a", generation) is attached
next_poll.set()
await asyncio.wait_for(polled.wait(), timeout=5)
assert stack.manager._external_deadlines[session_id] is watcher and not watcher.done()
assert session_id in stack.manager._browser_sessions
pw.stop.assert_not_awaited()
async with stack.session_factory() as session:
await session.execute(
update(PersistentBrowserSessionModel)
.where(PersistentBrowserSessionModel.persistent_browser_session_id == session_id)
.values(runnable_id="wr_other_process", runnable_generation_id="gen_other")
)
await session.commit()
next_poll.set()
await asyncio.wait_for(watcher, timeout=5)
assert session_id not in stack.manager._browser_sessions and not stack.manager._external_deadlines
pw.stop.assert_awaited_once()
context.close.assert_not_awaited()
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None and row.completed_at is None
assert (row.runnable_id, row.runnable_generation_id) == ("wr_other_process", "gen_other")
@pytest.mark.asyncio
async def test_a_failed_close_at_the_deadline_is_retried_until_the_row_is_final(
stack: SimpleNamespace, monkeypatch: pytest.MonkeyPatch
) -> None:
clock = install_deadline_clock(monkeypatch)
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
await backdate_registration(stack, session_id, minutes=5 - 0.5 / 60, clock=clock)
real_close = stack.repo.close_persistent_browser_session
close_attempts: list[str] = []
async def close_fails_once(session_id: str, organization_id: str) -> PersistentBrowserSession:
close_attempts.append(session_id)
if len(close_attempts) == 1:
raise RuntimeError("transient database error")
return await real_close(session_id, organization_id)
with patch.object(stack.repo, "close_persistent_browser_session", close_fails_once):
await begin_lease(stack.manager, session_id, "tsk_a")
clock.ticking.set()
await asyncio.wait_for(stack.manager._external_deadlines[session_id], timeout=5)
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None and row.completed_at is not None and row.close_reason == "expired"
assert not stack.manager._external_deadlines
@pytest.mark.asyncio
@pytest.mark.parametrize(
("loss", "run_type"),
[
("expired", "workflow_run"),
("killed", "task"),
("killed", "workflow_run"),
("closed", "task"),
("closed", "workflow_run"),
("vanished", "task"),
("vanished", "workflow_run"),
],
)
async def test_the_next_step_after_losing_a_registration_fails_with_that_fact_and_launches_nothing(
stack: SimpleNamespace, monkeypatch: pytest.MonkeyPatch, run_type: str, loss: str
) -> None:
clock = install_deadline_clock(monkeypatch)
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
if loss == "expired":
await backdate_registration(stack, session_id, minutes=5 - 0.5 / 60, clock=clock)
run_id = "tsk_1" if run_type == "task" else "wr_1"
generation = await stack.manager.begin_session(
browser_session_id=session_id, runnable_type=run_type, runnable_id=run_id, organization_id=ORG_A
)
lost, context, _ = external_browser_state()
with patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=lost)):
assert await acquire_lease(stack.manager, session_id, run_id, generation) is lost
if loss == "expired":
clock.ticking.set()
await asyncio.wait_for(stack.manager._external_deadlines[session_id], timeout=5)
if loss in ("closed", "vanished"):
await stack.repo.close_persistent_browser_session(session_id, ORG_A)
context.browser.is_connected.return_value = False
browser_manager = RealBrowserManager()
browser_manager.pages[run_id] = lost
launch = AsyncMock()
rbm_app = MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)
rbm_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
unreachable = AsyncMock(side_effect=ExternalBrowserUnavailable("connection failed"))
with (
patch.object(real_browser_manager_mod, "app", rbm_app),
patch.object(manager_mod, "attach_registered_cdp_browser", unreachable),
patch.object(browser_manager, "_create_browser_state", launch),
patch.object(
stack.manager,
"get_session",
AsyncMock(return_value=None) if loss == "vanished" else stack.manager.get_session,
),
pytest.raises(
{
"expired": BrowserSessionExpired,
"killed": ExternalBrowserUnavailable,
"closed": BrowserSessionClosed,
"vanished": ExternalBrowserUnavailable,
}[loss]
),
):
if run_type == "task":
# A task inside a workflow reuses the workflow's lease, so it reaches the launch lookup without a begin.
inside_workflow = run_id if loss == "vanished" else None
task = MagicMock(task_id=run_id, workflow_run_id=inside_workflow, organization_id=ORG_A)
await browser_manager.get_or_create_for_task(task, browser_session_id=session_id)
else:
workflow_run = MagicMock(workflow_run_id=run_id, parent_workflow_run_id=None, organization_id=ORG_A)
await browser_manager.get_or_create_for_workflow_run(
workflow_run,
url="https://example.test/",
browser_session_id=session_id,
browser_session_runnable_id=run_id,
browser_session_runnable_generation_id=generation,
)
launch.assert_not_awaited()
assert run_id not in browser_manager.pages
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None and (row.completed_at is not None) is (loss != "killed")
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_a_task_whose_registration_drops_between_steps_still_gives_its_lease_back(
stack: SimpleNamespace,
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
generation = await begin_lease(stack.manager, session_id, "tsk_1")
lost, context, _ = external_browser_state()
with patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=lost)):
assert await acquire_lease(stack.manager, session_id, "tsk_1", generation) is lost
browser_manager = RealBrowserManager()
browser_manager.pages["tsk_1"] = lost
browser_manager._persistent_session_leases["tsk_1"] = real_browser_manager_mod._PersistentSessionLease(
session_id=session_id,
organization_id=ORG_A,
runnable_id="tsk_1",
browser_state=lost,
runnable_generation_id=generation,
)
context.browser.is_connected.return_value = False
task = MagicMock(task_id="tsk_1", workflow_run_id=None, organization_id=ORG_A)
unreachable = AsyncMock(side_effect=ExternalBrowserUnavailable("connection failed"))
with (
patch.object(real_browser_manager_mod, "app", MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)),
patch.object(manager_mod, "attach_registered_cdp_browser", unreachable),
):
with pytest.raises(ExternalBrowserUnavailable):
await browser_manager.get_or_create_for_task(task, browser_session_id=session_id)
await browser_manager.cleanup_for_task(
"tsk_1", close_browser_on_completion=False, browser_session_id=session_id, organization_id=ORG_A
)
row = await stack.repo.get_persistent_browser_session(session_id, ORG_A)
assert row is not None and (row.runnable_id, row.runnable_generation_id) == (None, None)
assert session_id not in stack.manager._external_deadlines
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_an_attached_registration_hands_a_runs_download_to_the_runs_scope_without_gating_the_callers_tabs(
tmp_path: Path,
) -> None:
driver, connect = _driver()
context = connect.return_value.contexts[0]
context.browser.contexts = [context]
context.browser.new_browser_cdp_session = AsyncMock(return_value=MagicMock(send=AsyncMock()))
page = MagicMock(context=context)
with (
patch.object(settings, "ENV", "local"),
patch.object(settings, "DOWNLOAD_PATH", str(tmp_path)),
patch.object(external_mod, "async_playwright", lambda: driver),
patch.object(external_mod, "resolve_websocket_url", AsyncMock(return_value="ws://127.0.0.1:9222/devtools")),
):
state = await external_mod.connect_external_cdp_browser("http://127.0.0.1:9222")
assert state.browser_context is context
await rebind_download_dir(context.browser, run_id="wr_download")
async with _adopted_session_download_binding(SimpleNamespace(page=page), page) as (interceptor, _, scope):
assert interceptor is context._skyvern_cdp_download_interceptor
assert scope == "wr_download"
context.new_cdp_session.assert_not_called()
# Browser.setDownloadBehavior is browser-wide: it would move the caller's own downloads to a worker path.
context.browser.new_browser_cdp_session.assert_not_awaited()
@pytest.mark.asyncio
@pytest.mark.parametrize("end", ["closed", "deleted"])
async def test_a_later_task_block_on_a_lost_registration_fails_with_its_fact_and_launches_nothing(
stack: SimpleNamespace, end: str
) -> None:
session_id = (await register_external(stack.client)).json()["browser_session_id"]
lost, context, _ = external_browser_state()
context.browser.is_connected.return_value = False
if end == "closed":
await stack.client.post(f"/v1/browser_sessions/{session_id}/close")
else:
async with stack.session_factory() as session:
await session.execute(
update(PersistentBrowserSessionModel)
.where(PersistentBrowserSessionModel.persistent_browser_session_id == session_id)
.values(deleted_at=naive_utc_now())
)
await session.commit()
block = TaskBlock(label="second", output_parameter=output_parameter(), title="second", url="https://example.test/")
browser_manager = RealBrowserManager()
launch = AsyncMock()
browser_app = MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)
browser_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
with (
mock_block_execute_deps(working_page_url="https://example.test/") as deps,
patch.object(real_browser_manager_mod, "app", browser_app),
patch.object(browser_manager, "_create_browser_state", launch),
pytest.raises(BrowserSessionClosed if end == "closed" else ExternalBrowserUnavailable),
):
workflow_run = deps.workflow_run
workflow_run.__dict__.update(
organization_id=ORG_A, parent_workflow_run_id=None, proxy_location=None, extra_http_headers=None
)
browser_manager.pages[workflow_run.workflow_run_id] = lost
deps.tasks_db.get_last_task_for_workflow_run.return_value = SimpleNamespace(order=0, retry=0)
deps.browser_manager.get_for_workflow_run = browser_manager.get_for_workflow_run
deps.browser_manager.get_or_create_for_workflow_run = browser_manager.get_or_create_for_workflow_run
await block.execute(
workflow_run_id=workflow_run.workflow_run_id,
workflow_run_block_id="wrb_test",
organization_id=ORG_A,
browser_session_id=session_id,
)
launch.assert_not_awaited()
context.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_a_failed_row_read_on_a_cache_miss_is_a_miss(stack: SimpleNamespace) -> None:
with patch.object(stack.repo, "get_persistent_browser_session", AsyncMock(side_effect=RuntimeError("db down"))):
assert await stack.manager.get_browser_state("pbs_uncached", ORG_A) is None
@pytest.mark.asyncio
@pytest.mark.parametrize(
("close_browser_on_completion", "release_driver", "detaches"),
[(True, None, True), (False, None, True), (False, False, False), (True, False, False)],
)
async def test_closing_an_external_state_only_ever_detaches(
close_browser_on_completion: bool, release_driver: bool | None, detaches: bool
) -> None:
state, context, pw = external_browser_state(pages=2)
on_close = AsyncMock()
state.add_on_close(on_close)
await state.close(close_browser_on_completion, release_driver=release_driver)
assert pw.stop.await_count == (1 if detaches else 0)
assert on_close.await_count == (1 if close_browser_on_completion else 0)
context.close.assert_not_awaited()
context.browser.close.assert_not_awaited()
for page in context.pages:
page.close.assert_not_awaited()
@pytest.mark.asyncio
async def test_an_external_state_never_closes_the_callers_tabs_or_rebuilds_the_browser() -> None:
state, context, _ = external_browser_state(pages=3)
with patch.object(BrowserContextFactory, "create_browser_context", AsyncMock()) as rebuild:
await state.check_and_fix_state()
assert await state.list_valid_pages(max_pages=1) == context.pages
await state._close_all_other_pages()
await state.close_pages_opened_after(set())
assert await state.close_current_open_page() is False
crashed = context.pages[0]
crashed.context = context
state._on_page_crashed(crashed)
assert await state._reopen_lost_working_page() is None
await asyncio.sleep(0.05)
state.browser_context = None
with pytest.raises(ExternalBrowserUnavailable) as raised:
await state.check_and_fix_state()
assert str(raised.value) == str(lost_external_browser_error(None))
rebuild.assert_not_awaited()
context.new_page.assert_not_awaited()
context.close.assert_not_awaited()
for page in context.pages:
page.close.assert_not_awaited()