Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
from __future__ import annotations
import asyncio
import json
from collections.abc import AsyncIterator
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
import pytest_asyncio
from aiohttp import ClientSession, ClientWebSocketResponse
import skyvern.browser_extension.cdp_adapter as cdp_adapter_module
from skyvern.browser_extension.cdp_adapter import ExtensionCdpAdapter
from skyvern.browser_extension.errors import (
BrowserExtensionBrokerError,
BrowserExtensionNotConnectedError,
ExtensionRequestError,
)
from skyvern.browser_extension.event_order import EventHold
from skyvern.browser_extension.protocol import PAGE_CHANGED_BEFORE_START_MESSAGE, PAGE_CHANGED_WHILE_RUNNING_MESSAGE
from skyvern.browser_extension.runtime import BrowserExtensionRuntime
from skyvern.browser_extension.target_registry import VirtualTargetRegistry
class StubRelay:
def __init__(self, scoped_tabs: list[dict] | None = None) -> None:
self.scoped_tabs = scoped_tabs or []
self.connected = True
self.calls: list[tuple[str, dict]] = []
self.next_tab_id = 100
self.fail_next: BrowserExtensionBrokerError | ExtensionRequestError | None = None
self.fail_attach_tab_ids: set[int] = set()
self.block_attach_tab_id: int | None = None
self.attach_started = asyncio.Event()
self.release_attach = asyncio.Event()
self.block_detach_tab_id: int | None = None
self.detach_started = asyncio.Event()
self.release_detach = asyncio.Event()
self.main_frame_ids: dict[int, str] = {}
self.block_send_keys: set[tuple[str | None, str]] = set()
self.fail_send_keys: dict[
tuple[str | None, str],
BrowserExtensionBrokerError
| BrowserExtensionNotConnectedError
| ExtensionRequestError
| list[ExtensionRequestError]
| asyncio.CancelledError,
] = {}
self.send_started: dict[tuple[str | None, str], asyncio.Event] = {}
self.release_send: dict[tuple[str | None, str], asyncio.Event] = {}
self.released_tabs: list[int] = []
async def request(self, op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None) -> dict:
self.calls.append((op, args))
if self.fail_next is not None:
error = self.fail_next
self.fail_next = None
raise error
if op == "debugger.attach":
tab_id = args["tabId"]
if tab_id in self.fail_attach_tab_ids:
raise ExtensionRequestError("ATTACH_FAILED", "attach failed")
if tab_id == self.block_attach_tab_id:
self.attach_started.set()
await self.release_attach.wait()
if op == "debugger.detach" and args["tabId"] == self.block_detach_tab_id:
self.detach_started.set()
await self.release_detach.wait()
if op == "tabs.create":
tab_id = self.next_tab_id
self.next_tab_id += 1
return {"tabId": tab_id}
if op == "debugger.send":
key = (args.get("sessionId"), args["method"])
if key in self.block_send_keys:
self.send_started.setdefault(key, asyncio.Event()).set()
await self.release_send.setdefault(key, asyncio.Event()).wait()
if key in self.fail_send_keys:
send_error = self.fail_send_keys.pop(key)
if isinstance(send_error, list):
next_error = send_error.pop(0)
if send_error:
self.fail_send_keys[key] = send_error
raise next_error
raise send_error
if args["method"] == "Page.getFrameTree" and args["tabId"] in self.main_frame_ids:
frame_id = self.main_frame_ids[args["tabId"]]
return {"result": {"frameTree": {"frame": {"id": frame_id}}}}
return {"result": {"forwardedMethod": args["method"]}}
return {}
async def release_tab(self, tab_id: int) -> None:
self.released_tabs.append(tab_id)
await self.request("debugger.detach", {"tabId": tab_id}, timeout=2.0)
@pytest_asyncio.fixture
async def adapter_server() -> AsyncIterator[tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry]]:
relay = StubRelay()
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
yield adapter, relay, registry
finally:
await adapter.stop()
async def receive_response(ws: ClientWebSocketResponse, request_id: int) -> dict:
while True:
message = await ws.receive_json(timeout=2)
if message.get("id") == request_id:
return message
async def receive_event(ws: ClientWebSocketResponse, method: str) -> dict:
while True:
message = await ws.receive_json(timeout=2)
if message.get("method") == method:
return message
def assert_subset(actual: dict, expected: dict) -> None:
for key, value in expected.items():
if isinstance(value, dict):
assert_subset(actual[key], value)
else:
assert actual[key] == value
# Derived from chromium/crBrowser.js, chromium/crConnection.js, and chromium/chromium.js.
ROOT_CONNECT_CONTRACT = [
(
"Browser.getVersion",
{"product": "Chrome/999.0.0.0", "userAgent": "Skyvern-Extension-Bridge"},
),
("Target.setAutoAttach", {}),
("Browser.setDownloadBehavior", {}),
("Target.getTargetInfo", {"targetInfo": {"targetId": "skyvern-browser", "type": "browser"}}),
]
ROOT_CONNECT_PARAMS = {
"Browser.getVersion": {},
"Target.setAutoAttach": {"autoAttach": True, "waitForDebuggerOnStart": True, "flatten": True},
"Browser.setDownloadBehavior": {"behavior": "allowAndName", "eventsEnabled": True},
"Target.getTargetInfo": {},
}
@pytest.mark.asyncio
async def test_capability_path_is_required(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, _ = adapter_server
wrong_url = adapter.cdp_ws_url.rsplit("/", 1)[0] + "/wrong"
async with ClientSession() as client:
response = await client.get(wrong_url.replace("ws://", "http://"))
assert response.status == 404
response.release()
ws = await client.ws_connect(adapter.cdp_ws_url)
assert not ws.closed
await ws.close()
@pytest.mark.asyncio
async def test_root_connect_contract_fixture(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, _ = adapter_server
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
for request_id, (method, minimal_reply) in enumerate(ROOT_CONNECT_CONTRACT, start=1):
await ws.send_json({"id": request_id, "method": method, "params": ROOT_CONNECT_PARAMS[method]})
response = await receive_response(ws, request_id)
assert "error" not in response
assert_subset(response["result"], minimal_reply)
@pytest.mark.asyncio
async def test_auto_attach_creates_blank_tab_when_scope_is_empty(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
assert await receive_response(ws, 1) == {"id": 1, "result": {}}
attached = await receive_event(ws, "Target.attachedToTarget")
root_session_id = registry.root_session_id(100)
assert relay.calls[:2] == [
("tabs.create", {"url": "about:blank"}),
("debugger.attach", {"tabId": 100}),
]
assert attached["params"] == {
"sessionId": root_session_id,
"targetInfo": {
"targetId": "tab-100",
"type": "page",
"title": "",
"url": "about:blank",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
}
@pytest.mark.asyncio
async def test_auto_attach_scope_event_during_blank_tab_creation_attaches_once(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, _ = adapter_server
relay.block_attach_tab_id = 100
original_request = relay.request
async def request_with_scope_event(
op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
) -> dict:
result = await original_request(op, args, timeout)
if op == "tabs.create":
await adapter.handle_extension_event(
"scope.tabAdded",
{"tabId": result["tabId"], "url": args["url"], "title": ""},
)
asyncio.get_running_loop().call_soon(relay.release_attach.set)
return result
relay.request = request_with_scope_event
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
assert await receive_response(ws, 1) == {"id": 1, "result": {}}
await receive_event(ws, "Target.attachedToTarget")
assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
("debugger.attach", {"tabId": 100}),
]
@pytest.mark.asyncio
async def test_auto_attach_existing_and_later_scoped_tabs() -> None:
relay = StubRelay(
[
{"tabId": 7, "url": "https://one.example", "title": "One"},
{"tabId": 8, "url": "https://two.example", "title": "Two"},
]
)
relay.fail_next = ExtensionRequestError("CDP_ERROR", "Another debugger is already attached")
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
events = [await receive_event(ws, "Target.attachedToTarget") for _ in range(2)]
await adapter.handle_extension_event(
"scope.tabAdded", {"tabId": 9, "url": "https://three.example", "title": "Three"}
)
later = await receive_event(ws, "Target.attachedToTarget")
await adapter.handle_extension_event(
"tabs.created", {"tabId": 10, "openerTabId": 7, "url": "https://popup.example"}
)
popup = await receive_event(ws, "Target.attachedToTarget")
finally:
await adapter.stop()
assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
("debugger.attach", {"tabId": 7}),
("debugger.attach", {"tabId": 8}),
("debugger.attach", {"tabId": 9}),
("debugger.attach", {"tabId": 10}),
]
assert [event["params"]["targetInfo"]["targetId"] for event in events] == ["tab-7", "tab-8"]
assert later["params"]["targetInfo"]["targetId"] == "tab-9"
assert popup["params"]["targetInfo"]["openerId"] == "tab-7"
@pytest.mark.asyncio
async def test_coded_attach_failed_already_attached_error_propagates_without_unsharing_tab() -> None:
tab = {"tabId": 11, "url": "https://shared.example", "title": "Shared"}
relay = StubRelay([tab])
relay.fail_next = ExtensionRequestError("ATTACH_FAILED", "Another debugger is already attached")
adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), relay)
adapter._send = AsyncMock()
await adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
)
adapter._send.assert_awaited_once_with(
None,
{"id": 1, "error": {"code": -32000, "message": "ATTACH_FAILED: Another debugger is already attached"}},
)
assert relay.scoped_tabs == [tab]
assert not any(op == "debugger.detach" for op, _ in relay.calls)
assert not any(op == "debugger.send" for op, _ in relay.calls)
@pytest.mark.asyncio
async def test_adopted_group_tab_uses_same_attach_flow_as_session_created_tab() -> None:
relay = StubRelay()
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
adapter._auto_attach = True
emit_attached = AsyncMock()
adapter._emit_attached = emit_attached
try:
await adapter.handle_extension_event(
"tabs.created",
{"tabId": 50, "url": "https://created.example", "title": "Created"},
)
await asyncio.gather(*list(adapter._background_tasks))
await adapter.handle_extension_event(
"scope.tabAdded",
{"tabId": 51, "url": "https://adopted.example", "title": "Adopted"},
)
await asyncio.gather(*list(adapter._background_tasks))
finally:
await adapter.stop()
assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
("debugger.attach", {"tabId": 50}),
("debugger.attach", {"tabId": 51}),
]
assert [call.args[:2] for call in emit_attached.await_args_list] == [
(50, "tab-50"),
(51, "tab-51"),
]
@pytest.mark.asyncio
async def test_root_target_discovery_waits_for_auto_attach_while_session_commands_continue() -> None:
scoped_tabs = [
{"tabId": 41, "url": "https://one.example", "title": "One"},
{"tabId": 42, "url": "https://two.example", "title": "Two"},
]
relay = StubRelay(scoped_tabs)
relay.main_frame_ids = {41: "frame-41", 42: "frame-42"}
relay.block_attach_tab_id = 42
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.handle_extension_event("extension.hello", {"scopedTabs": scoped_tabs})
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await asyncio.wait_for(relay.attach_started.wait(), 1)
attached_session_id = registry.root_session_id(41)
await ws.send_json({"id": 2, "method": "Target.getTargets", "params": {}})
await ws.send_json({"id": 3, "sessionId": attached_session_id, "method": "Runtime.enable", "params": {}})
early_get_targets = None
session_response = None
while session_response is None:
message = await ws.receive_json(timeout=1)
if message.get("id") == 2:
early_get_targets = message
elif message.get("id") == 3:
session_response = message
assert early_get_targets is None
assert session_response == {
"id": 3,
"sessionId": attached_session_id,
"result": {"forwardedMethod": "Runtime.enable"},
}
relay.release_attach.set()
assert await receive_response(ws, 1) == {"id": 1, "result": {}}
targets = await receive_response(ws, 2)
finally:
relay.release_attach.set()
await adapter.stop()
assert {info["targetId"] for info in targets["result"]["targetInfos"]} == {"frame-41", "frame-42"}
@pytest.mark.asyncio
async def test_auto_attach_failure_reaches_client_instead_of_acknowledging_success() -> None:
relay = StubRelay([{"tabId": 30, "url": "https://bad.example", "title": "Bad"}])
relay.fail_attach_tab_ids.add(30)
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
adapter._send = AsyncMock()
await adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
)
adapter._send.assert_awaited_once_with(
None,
{"id": 1, "error": {"code": -32000, "message": "ATTACH_FAILED: attach failed"}},
)
@pytest.mark.asyncio
async def test_repeated_auto_attach_failure_restores_enabled_state_for_later_scoped_tabs() -> None:
relay = StubRelay([{"tabId": 30, "url": "https://good.example", "title": "Good"}])
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
assert await receive_response(ws, 1) == {"id": 1, "result": {}}
await receive_event(ws, "Target.attachedToTarget")
relay.scoped_tabs.append({"tabId": 31, "url": "https://bad.example", "title": "Bad"})
relay.fail_attach_tab_ids.add(31)
await ws.send_json({"id": 2, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
assert await receive_response(ws, 2) == {
"id": 2,
"error": {"code": -32000, "message": "ATTACH_FAILED: attach failed"},
}
assert adapter._auto_attach is True
relay.fail_attach_tab_ids.remove(31)
await adapter.handle_extension_event(
"scope.tabAdded", {"tabId": 32, "url": "https://later.example", "title": "Later"}
)
later = await receive_event(ws, "Target.attachedToTarget")
finally:
await adapter.stop()
assert later["params"]["targetInfo"]["targetId"] == "tab-32"
@pytest.mark.asyncio
async def test_empty_scope_auto_attach_broker_failure_reaches_client() -> None:
relay = StubRelay()
relay.fail_next = BrowserExtensionBrokerError("BROKER_UNAVAILABLE", "broker unavailable")
adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), relay)
adapter._send = AsyncMock()
await adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
)
adapter._send.assert_awaited_once_with(
None,
{"id": 1, "error": {"code": -32000, "message": "BROKER_UNAVAILABLE: broker unavailable"}},
)
assert adapter._auto_attach is False
@pytest.mark.asyncio
async def test_auto_attach_replies_before_a_concurrent_scope_event() -> None:
relay = StubRelay()
relay.block_attach_tab_id = 100
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
original_request = relay.request
order: list[str] = []
async def request_with_scope_event(
op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
) -> dict:
result = await original_request(op, args, timeout)
if op == "tabs.create":
await adapter.handle_extension_event(
"scope.tabAdded",
{"tabId": result["tabId"], "url": args["url"], "title": ""},
)
asyncio.get_running_loop().call_soon(relay.release_attach.set)
return result
relay.request = request_with_scope_event
adapter._reply = AsyncMock(side_effect=lambda *_args: order.append("reply"))
adapter._emit_attached = AsyncMock(side_effect=lambda *_args: order.append("attached"))
await adapter._handle_root_command(None, 1, "Target.setAutoAttach", {"autoAttach": True}) # type: ignore[arg-type]
await asyncio.gather(*list(adapter._background_tasks))
assert order == ["reply", "attached"]
assert [call for call in relay.calls if call[0] == "debugger.attach"] == [
("debugger.attach", {"tabId": 100}),
]
@pytest.mark.asyncio
async def test_frame_discovery_timeout_does_not_register_a_phantom_attached_page() -> None:
relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
relay.fail_send_keys[(None, "Page.getFrameTree")] = ExtensionRequestError(
"COMMAND_TIMEOUT", "frame discovery timed out"
)
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
generation = adapter._begin_tab_scope(32)
with pytest.raises(ExtensionRequestError, match="frame discovery timed out"):
await adapter._ensure_attached(relay.scoped_tabs[0], generation=generation)
assert 32 not in adapter._attached_tabs
with pytest.raises(KeyError):
registry.target_id_for_tab(32)
assert ("debugger.detach", {"tabId": 32}) in relay.calls
@pytest.mark.asyncio
@pytest.mark.parametrize("message", [PAGE_CHANGED_BEFORE_START_MESSAGE, PAGE_CHANGED_WHILE_RUNNING_MESSAGE])
@pytest.mark.parametrize("cancel_twice", [False, True])
async def test_page_changed_read_has_two_identical_sends_and_one_response(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry], message: str, cancel_twice: bool
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
registry.register_child_session(42, "child-42", {"targetId": "frame-42", "type": "iframe"})
args = {"tabId": 42, "sessionId": "child-42", "method": "Page.captureScreenshot", "params": {"format": "png"}}
relay.fail_send_keys[("child-42", "Page.captureScreenshot")] = [
ExtensionRequestError("COMMAND_TIMEOUT", message) for _ in range(2 if cancel_twice else 1)
]
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 17, "sessionId": "child-42", "method": args["method"], "params": args["params"]})
messages = [await ws.receive_json(timeout=2)]
with pytest.raises(TimeoutError):
messages.append(await ws.receive_json(timeout=0.05))
assert [m["id"] for m in messages] == [17]
assert ("error" in messages[0]) is cancel_twice
assert relay.calls == [("debugger.send", args), ("debugger.send", args)]
@pytest.mark.asyncio
@pytest.mark.parametrize(
("method", "params", "code", "message", "attempts"),
[
("Input.dispatchMouseEvent", {"type": "mousePressed"}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
("Runtime.callFunctionOn", {}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
("Runtime.evaluate", {"expression": "1"}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
(
"Runtime.evaluate",
{
"expression": "(() => { const module = {};\nreturn new (module.exports.UtilityScript())(globalThis, false);\n})();",
"contextId": 1,
},
"COMMAND_TIMEOUT",
PAGE_CHANGED_WHILE_RUNNING_MESSAGE,
2,
),
(
"Runtime.evaluate",
{
"expression": '(() => { const module = {};\nreturn new (module.exports.InjectedScript())(globalThis, {"browserName":"chromium"});\n})();',
"contextId": 0,
},
"COMMAND_TIMEOUT",
PAGE_CHANGED_BEFORE_START_MESSAGE,
2,
),
("Runtime.runIfWaitingForDebugger", {}, "COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE, 1),
("Runtime.runIfWaitingForDebugger", {}, "COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE, 2),
("Page.enable", {}, "RESTRICTED_URL", PAGE_CHANGED_BEFORE_START_MESSAGE, 1),
("Page.enable", {}, "COMMAND_TIMEOUT", "operation timed out", 1),
(
"Page.addScriptToEvaluateOnNewDocument",
{"source": ""},
"COMMAND_TIMEOUT",
PAGE_CHANGED_WHILE_RUNNING_MESSAGE,
2,
),
(
"Page.addScriptToEvaluateOnNewDocument",
{"source": "1"},
"COMMAND_TIMEOUT",
PAGE_CHANGED_BEFORE_START_MESSAGE,
1,
),
(
"Page.addScriptToEvaluateOnNewDocument",
{"source": "", "runImmediately": True},
"COMMAND_TIMEOUT",
PAGE_CHANGED_BEFORE_START_MESSAGE,
1,
),
],
)
async def test_page_changed_retry_allowlist(method: str, params: dict, code: str, message: str, attempts: int) -> None:
relay = StubRelay()
registry = VirtualTargetRegistry()
registry.register_tab(42, "about:blank", "")
adapter = ExtensionCdpAdapter(registry, relay)
adapter._send = AsyncMock()
relay.fail_send_keys[(None, method)] = ExtensionRequestError(code, message)
await adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 17, "sessionId": registry.root_session_id(42), "method": method, "params": params}),
)
assert relay.calls == [("debugger.send", {"tabId": 42, "method": method, "params": params})] * attempts
adapter._send.assert_awaited_once()
assert ("error" in adapter._send.call_args.args[1]) is (attempts == 1)
@pytest.mark.asyncio
@pytest.mark.parametrize(
("method", "params", "newer_method", "newer_params"),
[
(
"Target.setAutoAttach",
{"autoAttach": True, "filter": [{"type": "iframe", "exclude": False}]},
"Target.setAutoAttach",
{"autoAttach": False},
),
("Page.setLifecycleEventsEnabled", {"enabled": True}, "Page.setLifecycleEventsEnabled", {"enabled": False}),
(
"Emulation.setFocusEmulationEnabled",
{"enabled": True},
"Emulation.setFocusEmulationEnabled",
{"enabled": False},
),
("Emulation.setEmulatedMedia", {"media": "print"}, "Emulation.setEmulatedMedia", {"media": "screen"}),
("Page.enable", {}, "Page.disable", {}),
("Runtime.enable", {}, "Runtime.disable", {}),
("Log.enable", {}, "Log.disable", {}),
("Network.enable", {}, "Network.disable", {}),
],
)
@pytest.mark.parametrize("identical", [False, True])
@pytest.mark.parametrize("newer_in_flight", [False, True])
async def test_page_changed_reissue_respects_latest_requested_state(
method: str, params: dict, newer_method: str, newer_params: dict, identical: bool, newer_in_flight: bool
) -> None:
if identical:
newer_method, newer_params = method, params
message = (
PAGE_CHANGED_BEFORE_START_MESSAGE if method.startswith("Emulation.") else PAGE_CHANGED_WHILE_RUNNING_MESSAGE
)
relay = StubRelay()
registry = VirtualTargetRegistry()
registry.register_tab(42, "about:blank", "")
adapter = ExtensionCdpAdapter(registry, relay)
adapter._send = AsyncMock()
key = (None, method)
relay.block_send_keys.add(key)
session_id = registry.root_session_id(42)
older = asyncio.create_task(
adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 1, "sessionId": session_id, "method": method, "params": params}),
)
)
await asyncio.wait_for(relay.send_started.setdefault(key, asyncio.Event()).wait(), 1)
release_older = relay.release_send.pop(key)
relay.send_started.pop(key)
relay.block_send_keys.remove(key)
newer_key = (None, newer_method)
if newer_in_flight:
relay.block_send_keys.add(newer_key)
newer = asyncio.create_task(
adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 2, "sessionId": session_id, "method": newer_method, "params": newer_params}),
)
)
try:
if newer_in_flight:
await asyncio.wait_for(relay.send_started.setdefault(newer_key, asyncio.Event()).wait(), 1)
else:
await asyncio.wait_for(newer, 1)
relay.fail_send_keys[key] = ExtensionRequestError("COMMAND_TIMEOUT", message)
relay.block_send_keys.discard(newer_key)
release_older.set()
await asyncio.wait_for(older, 1)
finally:
if newer_in_flight:
relay.release_send[newer_key].set()
await asyncio.wait_for(newer, 1)
expected_commands = [(method, params), (newer_method, newer_params)]
if identical:
expected_commands.append((method, params))
assert [(args["method"], args["params"]) for op, args in relay.calls if op == "debugger.send"] == expected_commands
messages = [call.args[1] for call in adapter._send.await_args_list]
assert [m["id"] for m in messages] == ([1, 2] if newer_in_flight else [2, 1])
responses = {m["id"]: m for m in messages}
assert responses[2]["result"] == {"forwardedMethod": newer_method}
if identical:
assert responses[1]["result"] == {"forwardedMethod": method}
else:
assert responses[1]["error"] == {
"code": -32000,
"message": f"COMMAND_TIMEOUT: {message}",
}
@pytest.mark.asyncio
@pytest.mark.parametrize("invalidate", ["scope", "session", "connection"])
async def test_page_changed_retry_requires_original_scope_session_and_connection(invalidate: str) -> None:
relay = StubRelay()
registry = VirtualTargetRegistry()
registry.register_tab(42, "about:blank", "")
adapter = ExtensionCdpAdapter(registry, relay)
adapter._send = AsyncMock()
key = (None, "Page.getLayoutMetrics")
relay.block_send_keys.add(key)
relay.fail_send_keys[key] = ExtensionRequestError("COMMAND_TIMEOUT", PAGE_CHANGED_BEFORE_START_MESSAGE)
command = asyncio.create_task(
adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 1, "sessionId": registry.root_session_id(42), "method": key[1]}),
)
)
await asyncio.wait_for(relay.send_started.setdefault(key, asyncio.Event()).wait(), 1)
if invalidate == "scope":
adapter._revoke_tab_scope(42)
elif invalidate == "session":
registry.remove_tab(42)
else:
adapter._connection_generation += 1
relay.release_send[key].set()
await asyncio.wait_for(command, 1)
assert len(relay.calls) == 1
adapter._send.assert_awaited_once()
assert "error" in adapter._send.call_args.args[1]
@pytest.mark.asyncio
@pytest.mark.parametrize("message", [PAGE_CHANGED_BEFORE_START_MESSAGE, PAGE_CHANGED_WHILE_RUNNING_MESSAGE])
@pytest.mark.parametrize("registered", [False, True])
async def test_page_changed_probe_preserves_attachment_and_next_probe_recovers(message: str, registered: bool) -> None:
tab = {"tabId": 32, "url": "about:blank", "title": ""}
relay = StubRelay([tab])
relay.main_frame_ids[32] = "frame-32"
relay.fail_send_keys[(None, "Page.getFrameTree")] = [ExtensionRequestError("COMMAND_TIMEOUT", message)] * 2
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
generation = adapter._begin_tab_scope(32)
if registered:
adapter._register_scoped_tabs()
old_target_id = registry.target_id_for_tab(32) if registered else "tab-32"
with pytest.raises(ExtensionRequestError, match=message):
await adapter._ensure_attached(tab, generation=generation)
assert 32 in adapter._attached_tabs
assert adapter._scope_is_current(32, generation)
adapter._register_scoped_tabs()
assert registry.has_tab(32) is registered
assert adapter._page_target_infos() == []
adapter._send = AsyncMock()
adapter._emit = AsyncMock()
await adapter._handle_root_command(None, 1, "Target.getTargets", {})
assert adapter._send.call_args.args[1]["result"]["targetInfos"] == []
await adapter._handle_root_command(None, 2, "Target.getTargetInfo", {"targetId": old_target_id})
assert adapter._send.call_args.args[1]["error"]["message"] == "target not found"
await adapter._handle_root_command(None, 3, "Target.setDiscoverTargets", {"discover": True})
assert all(call.args[1]["targetInfo"]["type"] == "browser" for call in adapter._emit.await_args_list)
if registered:
await adapter._handle_session_command(None, 4, registry.root_session_id(32), "Target.getTargetInfo", {})
assert adapter._send.call_args.args[1]["error"]["message"] == "target not found"
registry.register_tab(33, "about:blank", "")
params = {"filter": [{"type": "iframe", "exclude": False}, {"exclude": True}]}
for request_id, tab_id in enumerate((32, 33), start=6):
await adapter._handle_session_command(
None, request_id, registry.root_session_id(tab_id), "Target.getTargets", params
)
assert relay.calls[-1] == (
"debugger.send",
{"tabId": tab_id, "method": "Target.getTargets", "params": params},
)
assert adapter._send.call_args.args[1]["result"] == {"forwardedMethod": "Target.getTargets"}
await adapter._handle_session_command(
None, 8, registry.root_session_id(33), "Target.getTargetInfo", {"targetId": old_target_id}
)
assert adapter._send.call_args.args[1]["error"]["message"] == "target not found"
registry.remove_tab(33)
assert not any(op == "debugger.detach" for op, _ in relay.calls)
relay.fail_attach_tab_ids.add(32)
assert await adapter._ensure_attached(tab, generation=generation) == ("frame-32", True)
assert registry.target_id_for_tab(32) == "frame-32"
assert [op for op, _ in relay.calls].count("debugger.attach") == 1
assert [op for op, _ in relay.calls].count("debugger.send") == (5 if registered else 3)
assert adapter.target_attachment_snapshot("frame-32")
assert [info["targetId"] for info in adapter._page_target_infos()] == ["frame-32"]
await adapter._handle_root_command(None, 5, "Target.getTargetInfo", {"targetId": "frame-32"})
assert adapter._send.call_args.args[1]["result"]["targetInfo"]["targetId"] == "frame-32"
@pytest.mark.asyncio
async def test_page_session_get_targets_propagates_relay_failure() -> None:
relay = StubRelay()
registry = VirtualTargetRegistry()
registry.register_tab(42, "about:blank", "")
adapter = ExtensionCdpAdapter(registry, relay)
adapter._send = AsyncMock()
relay.fail_send_keys[(None, "Target.getTargets")] = ExtensionRequestError("COMMAND_TIMEOUT", "probe timed out")
await adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 1, "sessionId": registry.root_session_id(42), "method": "Target.getTargets"}),
)
adapter._send.assert_awaited_once()
assert adapter._send.call_args.args[1]["error"] == {"code": -32000, "message": "COMMAND_TIMEOUT: probe timed out"}
@pytest.mark.asyncio
@pytest.mark.parametrize("other_tab", [False, True])
async def test_auto_attach_page_changed_probe_replies_then_recovers_deferred_tab(other_tab: bool) -> None:
tabs = [{"tabId": 32, "url": "about:blank", "title": ""}]
if other_tab:
tabs.append({"tabId": 33, "url": "about:blank", "title": ""})
relay = StubRelay(tabs)
relay.fail_send_keys[(None, "Page.getFrameTree")] = [
ExtensionRequestError("COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE)
] * 2
adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), relay)
order: list[object] = []
adapter._reply = AsyncMock(side_effect=lambda *_args: order.append("reply"))
adapter._emit_attached = AsyncMock(side_effect=lambda tab_id, *_args: order.append(tab_id))
await adapter._handle_root_command(None, 1, "Target.setAutoAttach", {"autoAttach": True}) # type: ignore[arg-type]
await asyncio.gather(*list(adapter._background_tasks))
assert order == (["reply", 33, 32] if other_tab else ["reply", 32])
assert adapter._auto_attach
assert not any(op == "debugger.detach" for op, _ in relay.calls)
assert [args["tabId"] for op, args in relay.calls if op == "debugger.attach"] == ([32, 33] if other_tab else [32])
@pytest.mark.asyncio
@pytest.mark.parametrize("close_browser", [False, True])
async def test_unexposed_attachment_browser_close_releases_or_raw_reconnect_exposes(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry], close_browser: bool
) -> None:
adapter, relay, registry = adapter_server
tab = {"tabId": 32, "url": "about:blank", "title": ""}
relay.scoped_tabs = [tab]
relay.fail_send_keys[(None, "Page.getFrameTree")] = [
ExtensionRequestError("COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE)
] * 2
async with ClientSession() as client:
ws = await client.ws_connect(adapter.cdp_ws_url)
with pytest.raises(ExtensionRequestError):
await adapter._ensure_attached(tab)
assert not registry.has_tab(32)
if close_browser:
relay.scoped_tabs = [] # Release must include the adapter's own attachment record.
await ws.send_json({"id": 9, "method": "Browser.close"})
assert await ws.receive_json(timeout=2) == {"id": 9, "result": {}}
await ws.receive(timeout=2)
assert relay.released_tabs == [32]
assert ("debugger.detach", {"tabId": 32}) in relay.calls
else:
await ws.close()
assert relay.released_tabs == []
relay.fail_next = ExtensionRequestError("CDP_ERROR", "already attached")
async with client.ws_connect(adapter.cdp_ws_url) as reconnected:
await reconnected.send_json(
{"id": 10, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}
)
messages = [await reconnected.receive_json(timeout=2) for _ in range(2)]
assert messages[0] == {"id": 10, "result": {}}
assert messages[1]["method"] == "Target.attachedToTarget"
assert registry.has_tab(32)
@pytest.mark.asyncio
async def test_child_auto_attach_reissues_while_only_pending_with_original_timeout() -> None:
relay = StubRelay()
registry = VirtualTargetRegistry()
registry.register_tab(42, "about:blank", "")
adapter = ExtensionCdpAdapter(registry, relay)
adapter._auto_attach = True
adapter._pending_child_sessions.add("child-42")
relay.fail_send_keys[("child-42", "Target.setAutoAttach")] = ExtensionRequestError(
"COMMAND_TIMEOUT", PAGE_CHANGED_WHILE_RUNNING_MESSAGE
)
original_request = relay.request
async def request_while_pending(
op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
) -> dict:
assert "child-42" in adapter._pending_child_sessions
with pytest.raises(KeyError):
registry.resolve_session("child-42")
assert timeout == 3.0
return await original_request(op, args, timeout)
relay.request = request_while_pending
target_info = {"targetId": "frame-42", "type": "iframe"}
await adapter._initialize_child_target(
42, "child-42", target_info, {"sessionId": "child-42", "targetInfo": target_info}, registry.root_session_ids(42)
)
assert len(relay.calls) == 2 and relay.calls[0] == relay.calls[1]
assert registry.resolve_session("child-42") == (42, "child-42")
assert "child-42" not in adapter._pending_child_sessions
@pytest.mark.asyncio
async def test_frame_discovery_not_connected_discards_attachment_and_restores_auto_attach() -> None:
relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
relay.fail_send_keys[(None, "Page.getFrameTree")] = BrowserExtensionNotConnectedError()
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
with pytest.raises(BrowserExtensionNotConnectedError):
await adapter._set_auto_attach(None, 1, {"autoAttach": True}, None) # type: ignore[arg-type]
assert adapter._auto_attach is False
assert 32 not in adapter._attached_tabs
with pytest.raises(KeyError):
registry.target_id_for_tab(32)
assert ("debugger.detach", {"tabId": 32}) in relay.calls
@pytest.mark.asyncio
async def test_frame_discovery_cancellation_discards_attachment_and_restores_auto_attach() -> None:
relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
relay.fail_send_keys[(None, "Page.getFrameTree")] = asyncio.CancelledError()
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
with pytest.raises(asyncio.CancelledError):
await adapter._set_auto_attach(None, 1, {"autoAttach": True}, None) # type: ignore[arg-type]
assert adapter._auto_attach is False
assert 32 not in adapter._attached_tabs
with pytest.raises(KeyError):
registry.target_id_for_tab(32)
assert ("debugger.detach", {"tabId": 32}) in relay.calls
@pytest.mark.asyncio
async def test_frame_discovery_broker_failure_discards_attachment_and_restores_auto_attach() -> None:
relay = StubRelay([{"tabId": 32, "url": "https://frame.example", "title": "Frame"}])
relay.fail_send_keys[(None, "Page.getFrameTree")] = BrowserExtensionBrokerError(
"EXTENSION_RESET_IN_PROGRESS", "extension reset in progress"
)
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
adapter._send = AsyncMock()
await adapter._handle_client_text(
None, # type: ignore[arg-type]
json.dumps({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}}),
)
adapter._send.assert_awaited_once_with(
None,
{
"id": 1,
"error": {
"code": -32000,
"message": "EXTENSION_RESET_IN_PROGRESS: extension reset in progress",
},
},
)
assert adapter._auto_attach is False
assert 32 not in adapter._attached_tabs
with pytest.raises(KeyError):
registry.target_id_for_tab(32)
assert ("debugger.detach", {"tabId": 32}) in relay.calls
@pytest.mark.asyncio
async def test_create_target_reuses_the_scope_the_echoed_tab_added_event_opened(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
# The extension announces a created tab before it answers tabs.create, so the announcement's
# attach is always the one already in flight when Target.createTarget resumes.
adapter, relay, _registry = adapter_server
adapter._auto_attach = True
relay.block_attach_tab_id = 100
original_request = relay.request
async def request_announcing_the_tab_before_returning_it(
op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
) -> dict:
result = await original_request(op, args, timeout)
if op == "tabs.create":
await adapter.handle_extension_event(
"scope.tabAdded", {"tabId": result["tabId"], "url": args["url"], "title": ""}
)
return result
relay.request = request_announcing_the_tab_before_returning_it
async with ClientSession() as session:
async with session.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.createTarget", "params": {"url": "https://new.example"}})
await asyncio.wait_for(relay.attach_started.wait(), timeout=2)
relay.release_attach.set()
response = await receive_response(ws, 1)
assert "error" not in response, response
assert response["result"]["targetId"]
assert ("debugger.detach", {"tabId": 100}) not in relay.calls
@pytest.mark.asyncio
async def test_create_target_survives_a_tab_added_event_that_lands_mid_attach(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, _registry = adapter_server
relay.block_attach_tab_id = 100
async with ClientSession() as session:
async with session.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.createTarget", "params": {"url": "https://new.example"}})
await asyncio.wait_for(relay.attach_started.wait(), timeout=2)
await adapter.handle_extension_event(
"scope.tabAdded", {"tabId": 100, "url": "https://new.example", "title": ""}
)
relay.release_attach.set()
response = await receive_response(ws, 1)
assert "error" not in response, response
assert response["result"]["targetId"]
@pytest.mark.asyncio
async def test_scope_revoked_during_frame_discovery_discards_the_attachment() -> None:
relay = StubRelay([{"tabId": 33, "url": "https://racy.example", "title": "Racy"}])
frame_key = (None, "Page.getFrameTree")
relay.block_send_keys.add(frame_key)
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
generation = adapter._begin_tab_scope(33)
attaching = asyncio.create_task(adapter._ensure_attached(relay.scoped_tabs[0], generation=generation))
await relay.send_started.setdefault(frame_key, asyncio.Event()).wait()
adapter._revoke_tab_scope(33)
relay.release_send.setdefault(frame_key, asyncio.Event()).set()
assert await attaching is None
assert 33 not in adapter._attached_tabs
assert ("debugger.detach", {"tabId": 33}) in relay.calls
@pytest.mark.asyncio
async def test_auto_attach_scope_revocation_cancellation_rolls_back_prior_tabs() -> None:
relay = StubRelay(
[
{"tabId": 33, "url": "https://first.example", "title": "First"},
{"tabId": 34, "url": "https://revoked.example", "title": "Revoked"},
]
)
relay.block_detach_tab_id = 34
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
original_request = relay.request
revoked_detach_finished = asyncio.Event()
async def request_with_scope_revocation(
op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
) -> dict:
result = await original_request(op, args, timeout)
if op == "debugger.send" and args["tabId"] == 34 and args["method"] == "Page.getFrameTree":
adapter._revoke_tab_scope(34)
if op == "debugger.detach" and args["tabId"] == 34:
revoked_detach_finished.set()
return result
relay.request = request_with_scope_revocation
attaching = asyncio.create_task(
adapter._set_auto_attach(None, 1, {"autoAttach": True}, None) # type: ignore[arg-type]
)
await relay.detach_started.wait()
attaching.cancel()
with pytest.raises(asyncio.CancelledError):
await attaching
relay.release_detach.set()
await asyncio.wait_for(revoked_detach_finished.wait(), timeout=1)
assert adapter._auto_attach is False
assert adapter._attached_tabs == set()
assert ("debugger.detach", {"tabId": 33}) in relay.calls
with pytest.raises(KeyError):
registry.target_id_for_tab(33)
with pytest.raises(KeyError):
registry.target_id_for_tab(34)
@pytest.mark.asyncio
async def test_auto_attach_transactional_failure_restores_state_without_second_response() -> None:
relay = StubRelay(
[
{"tabId": 30, "url": "https://bad.example", "title": "Bad"},
{"tabId": 31, "url": "https://good.example", "title": "Good"},
]
)
relay.fail_attach_tab_ids.add(30)
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
assert await receive_response(ws, 1) == {
"id": 1,
"error": {"code": -32000, "message": "ATTACH_FAILED: attach failed"},
}
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
finally:
await adapter.stop()
@pytest.mark.asyncio
async def test_tab_removal_tombstones_in_flight_background_attach() -> None:
relay = StubRelay([{"tabId": 40, "url": "https://existing.example", "title": "Existing"}])
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
await receive_event(ws, "Target.attachedToTarget")
relay.block_attach_tab_id = 41
await adapter.handle_extension_event(
"scope.tabAdded", {"tabId": 41, "url": "https://racy.example", "title": "Racy"}
)
await asyncio.wait_for(relay.attach_started.wait(), 1)
removal_task = asyncio.create_task(
adapter.handle_extension_event("scope.tabRemoved", {"tabId": 41, "reason": "unshared"})
)
await asyncio.sleep(0)
relay.release_attach.set()
await removal_task
with pytest.raises(KeyError):
registry.root_session_id(41)
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
finally:
await adapter.stop()
@pytest.mark.asyncio
async def test_session_command_routes_to_relay_and_preserves_session_id(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{"id": 5, "sessionId": session_id, "method": "Runtime.evaluate", "params": {"expression": "1+1"}}
)
response = await receive_response(ws, 5)
await ws.send_json({"id": 6, "sessionId": "missing", "method": "Runtime.enable", "params": {}})
missing = await receive_response(ws, 6)
assert relay.calls[-1] == (
"debugger.send",
{"tabId": 42, "method": "Runtime.evaluate", "params": {"expression": "1+1"}},
)
assert response == {"id": 5, "sessionId": session_id, "result": {"forwardedMethod": "Runtime.evaluate"}}
assert missing == {
"id": 6,
"sessionId": "missing",
"error": {"code": -32001, "message": "session not found"},
}
@pytest.mark.asyncio
async def test_navigation_response_precedes_buffered_commit_events(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
navigation_events = [
{
"method": "Page.frameStartedNavigating",
"params": {"frameId": "frame-42", "url": "https://destination.example"},
},
{
"method": "Network.requestWillBeSent",
"params": {"requestId": "request-42", "type": "Document"},
},
{
"method": "Network.responseReceived",
"params": {"requestId": "request-42", "type": "Document"},
},
{
"method": "Page.lifecycleEvent",
"params": {"frameId": "frame-42", "name": "init"},
},
{
"method": "Page.frameNavigated",
"params": {"frame": {"id": "frame-42", "url": "https://destination.example", "title": "Destination"}},
},
]
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
for event in navigation_events:
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
relay.release_send[navigation_key].set()
messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]
assert messages[0] == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]
assert registry.target_info_for_tab(42)["url"] == "https://destination.example"
@pytest.mark.asyncio
async def test_stale_navigation_cleanup_does_not_clear_new_connection_navigation(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
old_session_id = registry.root_session_id(42)
old_send_started = asyncio.Event()
old_cleanup_started = asyncio.Event()
old_response_cancelled = asyncio.Event()
original_cancel_client_tasks = adapter._cancel_client_tasks
async def block_old_client_cleanup(*args: object) -> None:
old_cleanup_started.set()
await original_cancel_client_tasks(*args)
async with ClientSession() as client:
old = await client.ws_connect(adapter.cdp_ws_url)
old_server_ws = adapter._client_ws
assert old_server_ws is not None
original_send_json = old_server_ws.send_json
async def block_old_response(payload: dict, *args: object, **kwargs: object) -> None:
if payload.get("id") == 1:
old_send_started.set()
try:
await asyncio.Event().wait()
except asyncio.CancelledError:
old_response_cancelled.set()
raise
await original_send_json(payload, *args, **kwargs)
with (
patch.object(adapter, "_cancel_client_tasks", side_effect=block_old_client_cleanup),
patch.object(old_server_ws, "send_json", side_effect=block_old_response),
):
await old.send_json(
{
"id": 1,
"sessionId": old_session_id,
"method": "Page.navigate",
"params": {"url": "https://old.example"},
}
)
await asyncio.wait_for(old_send_started.wait(), 1)
disconnect_task = asyncio.create_task(adapter.on_extension_disconnect())
await asyncio.wait_for(old_cleanup_started.wait(), 1)
new = await client.ws_connect(adapter.cdp_ws_url)
registry.register_tab(42, "https://example.com", "Example")
new_session_id = registry.root_session_id(42)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
await new.send_json(
{
"id": 1,
"sessionId": new_session_id,
"method": "Page.navigate",
"params": {"url": "https://new.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://new.example",
"title": "New",
}
},
},
)
await asyncio.wait_for(disconnect_task, 2)
await asyncio.wait_for(old_response_cancelled.wait(), 1)
relay.release_send[navigation_key].set()
messages = [await new.receive_json(timeout=2) for _ in range(2)]
assert registry.target_info_for_tab(42)["url"] == "https://new.example"
await new.close()
assert messages == [
{
"id": 1,
"sessionId": new_session_id,
"result": {"forwardedMethod": "Page.navigate"},
},
{
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://new.example",
"title": "New",
}
},
"sessionId": new_session_id,
},
]
@pytest.mark.asyncio
async def test_stale_navigation_cleanup_after_new_navigation_flush_is_noop(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
old_send_started = asyncio.Event()
release_old_send = asyncio.Event()
sent: list[dict] = []
async def record_send(_ws: object, payload: dict, _scope_guard: tuple[int, int] | None = None) -> None:
if payload.get("id") == "old":
old_send_started.set()
await release_old_send.wait()
sent.append(payload)
adapter._client_ws = MagicMock(closed=False)
adapter._client_ws.close = AsyncMock()
old_ws = MagicMock()
new_ws = MagicMock()
old_session_id = registry.root_session_id(42)
old_marker = await adapter._begin_navigation(42)
old_cleanup = asyncio.create_task(
adapter._finish_navigation(
old_ws,
"old",
old_session_id,
42,
old_marker,
result={"source": "old"},
)
)
with patch.object(adapter, "_send", side_effect=record_send):
await asyncio.wait_for(old_send_started.wait(), 1)
adapter._reset_connection_state()
registry.register_tab(42, "https://example.com", "Example")
new_session_id = registry.root_session_id(42)
new_marker = await adapter._begin_navigation(42)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://new.example",
"title": "New",
}
},
},
)
await adapter._finish_navigation(
new_ws,
"new",
new_session_id,
42,
new_marker,
result={"source": "new"},
)
assert sent == [
{"id": "new", "sessionId": new_session_id, "result": {"source": "new"}},
{
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://new.example",
"title": "New",
}
},
"sessionId": new_session_id,
},
]
assert not adapter._navigation_in_flight
assert not adapter._navigation_events
latest_marker = await adapter._begin_navigation(42)
await adapter.handle_extension_event(
"debugger.event",
{"tabId": 42, "method": "Page.lifecycleEvent", "params": {"name": "init"}},
)
release_old_send.set()
await asyncio.wait_for(old_cleanup, 1)
assert adapter._navigation_in_flight[42] == {latest_marker}
assert len(adapter._navigation_events[42]) == 1
await adapter._finish_navigation(
new_ws,
"latest",
new_session_id,
42,
latest_marker,
result={"source": "latest"},
)
assert sent[-2:] == [
{"id": "latest", "sessionId": new_session_id, "result": {"source": "latest"}},
{
"method": "Page.lifecycleEvent",
"params": {"name": "init"},
"sessionId": new_session_id,
},
]
assert not adapter._navigation_in_flight
assert not adapter._navigation_events
@pytest.mark.asyncio
async def test_stale_navigation_batch_is_dropped_after_connection_reset(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
old_session_id = registry.root_session_id(42)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
old_event_started = asyncio.Event()
release_old_event = asyncio.Event()
old_event_finished = asyncio.Event()
old_cleanup_started = asyncio.Event()
release_old_cleanup = asyncio.Event()
original_cancel_client_tasks = adapter._cancel_client_tasks
async def block_old_client_cleanup(*args: object) -> None:
old_cleanup_started.set()
await release_old_cleanup.wait()
await original_cancel_client_tasks(*args)
async with ClientSession() as client:
old = await client.ws_connect(adapter.cdp_ws_url)
old_server_ws = adapter._client_ws
assert old_server_ws is not None
original_send_json = old_server_ws.send_json
async def block_old_event(payload: dict, *args: object, **kwargs: object) -> None:
if payload.get("method") == "Page.lifecycleEvent":
old_event_started.set()
await release_old_event.wait()
old_event_finished.set()
return
await original_send_json(payload, *args, **kwargs)
with (
patch.object(adapter, "_cancel_client_tasks", side_effect=block_old_client_cleanup),
patch.object(old_server_ws, "send_json", side_effect=block_old_event),
):
await old.send_json(
{
"id": 1,
"sessionId": old_session_id,
"method": "Page.navigate",
"params": {"url": "https://old.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Page.lifecycleEvent",
"params": {"frameId": "frame-42", "name": "init"},
},
)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://old.example/commit",
"title": "Old",
}
},
},
)
relay.release_send[navigation_key].set()
assert await receive_response(old, 1) == {
"id": 1,
"sessionId": old_session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
await asyncio.wait_for(old_event_started.wait(), 1)
disconnect_task = asyncio.create_task(adapter.on_extension_disconnect())
await asyncio.wait_for(old_cleanup_started.wait(), 1)
new = await client.ws_connect(adapter.cdp_ws_url)
registry.register_tab(42, "https://new.example", "New")
new_session_id = registry.root_session_id(42)
assert new_session_id != old_session_id
release_old_event.set()
await asyncio.wait_for(old_event_finished.wait(), 1)
release_old_cleanup.set()
await asyncio.wait_for(disconnect_task, 2)
with pytest.raises(TimeoutError):
await new.receive_json(timeout=0.05)
assert registry.target_info_for_tab(42)["url"] == "https://new.example"
await new.close()
@pytest.mark.asyncio
async def test_stale_navigation_overflow_batch_is_dropped_after_connection_reset(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
adapter._client_ws = MagicMock(closed=False)
adapter._client_ws.close = AsyncMock()
sent: list[dict] = []
flush_started = asyncio.Event()
release_flush = asyncio.Event()
original_flush = adapter._flush_navigation_events
async def pause_flush(
tab_id: int,
events: list[dict] | None = None,
event_generation: int | None = None,
*,
forward_navigation_sensitive: bool = True,
) -> None:
flush_started.set()
await release_flush.wait()
await original_flush(
tab_id,
events,
event_generation,
forward_navigation_sensitive=forward_navigation_sensitive,
)
async def record_send(_ws: object, payload: dict, _scope_guard: tuple[int, int] | None = None) -> None:
sent.append(payload)
await adapter._begin_navigation(42)
for index in range(cdp_adapter_module._NAVIGATION_EVENT_BUFFER_LIMIT):
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Network.requestWillBeSent",
"params": {"requestId": f"request-{index}"},
},
)
with (
patch.object(adapter, "_flush_navigation_events", side_effect=pause_flush),
patch.object(adapter, "_send", side_effect=record_send),
patch.object(cdp_adapter_module.LOG, "debug") as debug,
):
overflow_task = asyncio.create_task(
adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://old.example/commit",
"title": "Old",
}
},
},
)
)
await asyncio.wait_for(flush_started.wait(), 1)
adapter._reset_connection_state()
registry.register_tab(42, "https://new.example", "New")
release_flush.set()
await asyncio.wait_for(overflow_task, 1)
debug.assert_called_once_with(
"browser_extension_stale_navigation_event_batch_dropped",
tab_id=42,
batch_generation=0,
current_generation=1,
buffered_event_count=cdp_adapter_module._NAVIGATION_EVENT_BUFFER_LIMIT,
)
assert sent == []
assert registry.target_info_for_tab(42)["url"] == "https://new.example"
@pytest.mark.asyncio
async def test_stale_navigation_detach_batch_is_dropped_after_connection_reset(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
adapter._client_ws = MagicMock(closed=False)
adapter._client_ws.close = AsyncMock()
sent: list[dict] = []
flush_started = asyncio.Event()
release_flush = asyncio.Event()
original_flush = adapter._flush_navigation_events
async def pause_flush(
tab_id: int,
events: list[dict] | None = None,
event_generation: int | None = None,
*,
forward_navigation_sensitive: bool = True,
) -> None:
flush_started.set()
await release_flush.wait()
await original_flush(
tab_id,
events,
event_generation,
forward_navigation_sensitive=forward_navigation_sensitive,
)
async def record_send(_ws: object, payload: dict, _scope_guard: tuple[int, int] | None = None) -> None:
sent.append(payload)
await adapter._begin_navigation(42)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://old.example/commit",
"title": "Old",
}
},
},
)
with (
patch.object(adapter, "_flush_navigation_events", side_effect=pause_flush),
patch.object(adapter, "_send", side_effect=record_send),
patch.object(cdp_adapter_module.LOG, "debug") as debug,
):
detach_task = asyncio.create_task(adapter._abort_navigation(42))
await asyncio.wait_for(flush_started.wait(), 1)
adapter._reset_connection_state()
registry.register_tab(42, "https://new.example", "New")
release_flush.set()
await asyncio.wait_for(detach_task, 1)
debug.assert_called_once_with(
"browser_extension_stale_navigation_event_batch_dropped",
tab_id=42,
batch_generation=0,
current_generation=1,
buffered_event_count=1,
)
assert sent == []
assert registry.target_info_for_tab(42)["url"] == "https://new.example"
@pytest.mark.asyncio
async def test_debugger_detached_discards_buffered_navigation_event_before_error_response(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
relay.fail_send_keys[navigation_key] = ExtensionRequestError(
"RESTRICTED_URL", "Navigation to a restricted URL is not allowed"
)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://restricted.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Page.frameNavigated",
"params": {"frame": {"id": "frame-42", "url": "https://restricted.example"}},
},
)
await adapter.handle_extension_event("debugger.detached", {"tabId": 42, "reason": "canceled_by_user"})
teardown = [await ws.receive_json(timeout=2) for _ in range(2)]
assert [message["method"] for message in teardown] == [
"Target.detachedFromTarget",
"Target.targetDestroyed",
]
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
relay.release_send[navigation_key].set()
navigation_response = await receive_response(ws, 1)
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
assert navigation_response == {
"id": 1,
"sessionId": session_id,
"error": {"code": -32000, "message": "RESTRICTED_URL: Navigation to a restricted URL is not allowed"},
}
assert teardown[0]["params"] == {"sessionId": session_id, "targetId": "tab-42"}
assert teardown[1]["params"] == {"targetId": "tab-42"}
@pytest.mark.asyncio
async def test_navigation_response_first_passes_events_through_unchanged(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
response = await receive_response(ws, 1)
event_params = {"frameId": "frame-42", "name": "init"}
await adapter.handle_extension_event(
"debugger.event",
{"tabId": 42, "method": "Page.lifecycleEvent", "params": event_params},
)
event = await receive_event(ws, "Page.lifecycleEvent")
assert response == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert event == {"method": "Page.lifecycleEvent", "params": event_params, "sessionId": session_id}
@pytest.mark.asyncio
async def test_navigation_error_flushes_buffered_events(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
relay.fail_send_keys[navigation_key] = ExtensionRequestError("COMMAND_TIMEOUT", "navigation timed out")
navigation_events = [
{"method": "Page.frameStartedNavigating", "params": {"frameId": "frame-42"}},
{"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
]
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
for event in navigation_events:
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
relay.release_send[navigation_key].set()
messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]
assert messages[0] == {
"id": 1,
"sessionId": session_id,
"error": {"code": -32000, "message": "COMMAND_TIMEOUT: navigation timed out"},
}
assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]
@pytest.mark.asyncio
async def test_navigation_events_for_another_tab_are_not_held(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://one.example", "One")
registry.register_tab(43, "https://two.example", "Two")
session_id = registry.root_session_id(42)
other_session_id = registry.root_session_id(43)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
event_params = {"frameId": "frame-43", "name": "init"}
await adapter.handle_extension_event(
"debugger.event",
{"tabId": 43, "method": "Page.lifecycleEvent", "params": event_params},
)
other_tab_event = await receive_event(ws, "Page.lifecycleEvent")
relay.release_send[navigation_key].set()
navigation_response = await receive_response(ws, 1)
assert other_tab_event == {
"method": "Page.lifecycleEvent",
"params": event_params,
"sessionId": other_session_id,
}
assert navigation_response["result"] == {"forwardedMethod": "Page.navigate"}
@pytest.mark.asyncio
async def test_navigation_event_buffer_overflow_flushes_and_warns(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
event_count = cdp_adapter_module._NAVIGATION_EVENT_BUFFER_LIMIT + 1
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
with patch.object(cdp_adapter_module.LOG, "warning") as warning:
for index in range(event_count):
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Network.requestWillBeSent",
"params": {"requestId": f"request-{index}"},
},
)
relay.release_send[navigation_key].set()
messages = [await ws.receive_json(timeout=2) for _ in range(event_count + 1)]
warning.assert_called_once()
assert [message["params"]["requestId"] for message in messages[:-1]] == [
f"request-{index}" for index in range(event_count)
]
assert messages[-1] == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert warning.call_args.args == ("browser_extension_navigation_event_buffer_overflow",)
assert warning.call_args.kwargs["tab_id"] == 42
assert warning.call_args.kwargs["forwarded_non_navigation_event_count"] == event_count
assert warning.call_args.kwargs["buffered_navigation_event_count"] == 0
def test_navigation_sensitive_event_bound_keeps_execution_context_events() -> None:
adapter = ExtensionCdpAdapter(VirtualTargetRegistry(), StubRelay())
execution_context_event = {
"method": "Runtime.executionContextCreated",
"params": {"context": {"id": 1}},
}
other_events = [
{"method": "Page.frameAttached", "params": {"frameId": f"frame-{index}"}}
for index in range(cdp_adapter_module._NAVIGATION_SENSITIVE_EVENT_BUFFER_LIMIT + 1)
]
with patch.object(cdp_adapter_module.LOG, "warning") as warning:
retained_events = adapter._bound_navigation_sensitive_events(42, [execution_context_event, *other_events])
assert len(retained_events) == cdp_adapter_module._NAVIGATION_SENSITIVE_EVENT_BUFFER_LIMIT
assert retained_events[0] == execution_context_event
assert retained_events[1:] == other_events[-(cdp_adapter_module._NAVIGATION_SENSITIVE_EVENT_BUFFER_LIMIT - 1) :]
assert warning.call_args.kwargs["dropped_execution_context_event_count"] == 0
@pytest.mark.asyncio
async def test_navigation_event_overflow_keeps_sensitive_events_until_response(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
navigation_key = (None, "Page.navigate")
relay.block_send_keys.add(navigation_key)
network_event_count = 2500
navigation_events = [
{"method": "Page.frameStartedLoading", "params": {"frameId": "frame-42"}},
{
"method": "Page.frameNavigated",
"params": {
"frame": {
"id": "frame-42",
"url": "https://destination.example",
"title": "Destination",
}
},
},
{"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
]
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigation_key, asyncio.Event()).wait(), 1)
for index in range(network_event_count):
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 42,
"method": "Network.requestWillBeSent",
"params": {"requestId": f"request-{index}"},
},
)
early_messages = [await ws.receive_json(timeout=2) for _ in range(network_event_count)]
assert [message["method"] for message in early_messages] == ["Network.requestWillBeSent"] * network_event_count
assert [message["params"]["requestId"] for message in early_messages] == [
f"request-{index}" for index in range(network_event_count)
]
for event in navigation_events:
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
relay.release_send[navigation_key].set()
messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]
assert messages[0] == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]
assert registry.target_info_for_tab(42)["url"] == "https://destination.example"
@pytest.mark.asyncio
async def test_overlapping_navigation_error_waits_for_earlier_response_before_flushing_events(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
first_started = asyncio.Event()
second_started = asyncio.Event()
release_first = asyncio.Event()
navigation_count = 0
original_request = relay.request
async def request_in_answer_order(op: str, args: dict, timeout: float = 30.0) -> dict:
nonlocal navigation_count
if op == "debugger.send" and args["method"] == "Page.navigate":
navigation_count += 1
if navigation_count == 1:
first_started.set()
await release_first.wait()
else:
second_started.set()
raise ExtensionRequestError("RESOURCE_LIMIT", "navigation rejected")
return await original_request(op, args, timeout)
relay.request = request_in_answer_order
navigation_events = [
{
"method": "Page.frameNavigated",
"params": {"frame": {"id": "frame-42", "url": "https://destination.example", "title": "Destination"}},
},
{"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
]
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://first.example"},
}
)
await asyncio.wait_for(first_started.wait(), 1)
await ws.send_json(
{
"id": 2,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://second.example"},
}
)
await asyncio.wait_for(second_started.wait(), 1)
second_error = await receive_response(ws, 2)
for event in navigation_events:
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
release_first.set()
messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]
assert second_error == {
"id": 2,
"sessionId": session_id,
"error": {"code": -32000, "message": "RESOURCE_LIMIT: navigation rejected"},
}
assert messages[0] == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]
@pytest.mark.asyncio
async def test_overlapping_navigation_responses_flush_interleaved_events_after_both_responses(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
first_started = asyncio.Event()
second_started = asyncio.Event()
release_first = asyncio.Event()
release_second = asyncio.Event()
navigation_count = 0
original_request = relay.request
async def request_in_answer_order(op: str, args: dict, timeout: float = 30.0) -> dict:
nonlocal navigation_count
if op == "debugger.send" and args["method"] == "Page.navigate":
navigation_count += 1
if navigation_count == 1:
first_started.set()
await release_first.wait()
else:
second_started.set()
await release_second.wait()
return await original_request(op, args, timeout)
relay.request = request_in_answer_order
navigation_events = [
{"method": "Page.frameStartedNavigating", "params": {"frameId": "frame-42", "url": "https://first.example"}},
{"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}},
{
"method": "Page.frameNavigated",
"params": {"frame": {"id": "frame-42", "url": "https://second.example", "title": "Second"}},
},
]
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://first.example"},
}
)
await asyncio.wait_for(first_started.wait(), 1)
await ws.send_json(
{
"id": 2,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://second.example"},
}
)
await asyncio.wait_for(second_started.wait(), 1)
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **navigation_events[0]})
release_first.set()
first_response = await receive_response(ws, 1)
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **navigation_events[1]})
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **navigation_events[2]})
release_second.set()
messages = [await ws.receive_json(timeout=2) for _ in range(len(navigation_events) + 1)]
assert first_response == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert messages[0] == {
"id": 2,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert [message["method"] for message in messages[1:]] == [event["method"] for event in navigation_events]
@pytest.mark.asyncio
async def test_navigation_completion_does_not_flush_events_while_another_navigation_is_outstanding(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
first_started = asyncio.Event()
second_started = asyncio.Event()
release_first = asyncio.Event()
navigation_count = 0
original_request = relay.request
async def request_with_second_completion_first(op: str, args: dict, timeout: float = 30.0) -> dict:
nonlocal navigation_count
if op == "debugger.send" and args["method"] == "Page.navigate":
navigation_count += 1
if navigation_count == 1:
first_started.set()
await release_first.wait()
else:
second_started.set()
return await original_request(op, args, timeout)
relay.request = request_with_second_completion_first
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://first.example"},
}
)
await asyncio.wait_for(first_started.wait(), 1)
await ws.send_json(
{
"id": 2,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://second.example"},
}
)
await asyncio.wait_for(second_started.wait(), 1)
assert await receive_response(ws, 2) == {
"id": 2,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
event = {"method": "Page.lifecycleEvent", "params": {"frameId": "frame-42", "name": "init"}}
await adapter.handle_extension_event("debugger.event", {"tabId": 42, **event})
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
release_first.set()
assert await receive_response(ws, 1) == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Page.navigate"},
}
assert await receive_event(ws, "Page.lifecycleEvent") == {
"method": "Page.lifecycleEvent",
"params": event["params"],
"sessionId": session_id,
}
@pytest.mark.parametrize(
("method", "params"),
[
("Network.getAllCookies", {}),
("Network.getCookies", {"urls": ["https://unshared.example"]}),
],
)
@pytest.mark.asyncio
async def test_session_command_rejects_denied_cdp_methods(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
method: str,
params: dict,
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(42, "https://example.com", "Example")
session_id = registry.root_session_id(42)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "sessionId": session_id, "method": method, "params": params})
response = await receive_response(ws, 1)
assert response == {
"id": 1,
"sessionId": session_id,
"error": {
"code": -32000,
"message": "CDP_METHOD_NOT_ALLOWED: The requested CDP method is not allowed.",
},
}
assert relay.calls == []
@pytest.mark.asyncio
async def test_page_attach_aliases_are_unique_route_commands_and_receive_root_events() -> None:
relay = StubRelay([{"tabId": 42, "url": "https://example.com", "title": "Example"}])
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
primary_attached = await receive_event(ws, "Target.attachedToTarget")
primary_session_id = primary_attached["params"]["sessionId"]
for request_id in (2, 3):
await ws.send_json(
{
"id": request_id,
"method": "Target.attachToTarget",
"params": {"targetId": "tab-42", "flatten": True},
}
)
first_alias = (await receive_response(ws, 2))["result"]["sessionId"]
second_alias = (await receive_response(ws, 3))["result"]["sessionId"]
assert len({primary_session_id, first_alias, second_alias}) == 3
await ws.send_json({"id": 4, "sessionId": first_alias, "method": "Runtime.enable", "params": {}})
assert (await receive_response(ws, 4))["sessionId"] == first_alias
event_params = {"name": "networkAlmostIdle", "frameId": "main"}
await adapter.handle_extension_event(
"debugger.event",
{"tabId": 42, "method": "Page.lifecycleEvent", "params": event_params},
)
routed_events = [await receive_event(ws, "Page.lifecycleEvent") for _ in range(3)]
assert {event["sessionId"] for event in routed_events} == {
primary_session_id,
first_alias,
second_alias,
}
await ws.send_json({"id": 5, "method": "Target.detachFromTarget", "params": {"sessionId": first_alias}})
assert await receive_response(ws, 5) == {"id": 5, "result": {}}
assert all(op != "debugger.detach" for op, _ in relay.calls)
with pytest.raises(KeyError):
registry.resolve_session(first_alias)
assert registry.resolve_session(second_alias) == (42, None)
finally:
await adapter.stop()
@pytest.mark.asyncio
async def test_browser_alias_routes_root_commands_and_detaches_independently(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.attachToBrowserTarget", "params": {}})
first_alias = (await receive_response(ws, 1))["result"]["sessionId"]
await ws.send_json({"id": 2, "method": "Target.attachToBrowserTarget", "params": {}})
second_alias = (await receive_response(ws, 2))["result"]["sessionId"]
assert first_alias != second_alias
await ws.send_json({"id": 3, "sessionId": first_alias, "method": "Browser.getVersion", "params": {}})
version = await receive_response(ws, 3)
assert version["sessionId"] == first_alias
assert version["result"]["protocolVersion"] == "1.3"
await ws.send_json({"id": 4, "method": "Target.detachFromTarget", "params": {"sessionId": first_alias}})
assert await receive_response(ws, 4) == {"id": 4, "result": {}}
assert not registry.is_browser_session_alias(first_alias)
assert registry.is_browser_session_alias(second_alias)
await ws.send_json({"id": 5, "sessionId": first_alias, "method": "Browser.getVersion", "params": {}})
assert (await receive_response(ws, 5))["error"]["code"] == -32001
@pytest.mark.asyncio
async def test_child_attach_recurses_and_detach_unregisters(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(12, "https://example.com", "Example")
root_session_id = registry.root_session_id(12)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
await receive_event(ws, "Target.attachedToTarget")
relay.calls.clear()
target_info = {
"targetId": "frame-12",
"type": "iframe",
"title": "",
"url": "https://example.com/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
}
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 12,
"method": "Target.attachedToTarget",
"params": {"sessionId": "child-12", "targetInfo": target_info, "waitingForDebugger": False},
},
)
attached = await receive_event(ws, "Target.attachedToTarget")
await ws.send_json({"id": 2, "sessionId": "child-12", "method": "Runtime.enable", "params": {}})
await receive_response(ws, 2)
await adapter.handle_extension_event(
"debugger.event",
{"tabId": 12, "method": "Target.detachedFromTarget", "params": {"sessionId": "child-12"}},
)
detached = await receive_event(ws, "Target.detachedFromTarget")
assert attached["sessionId"] == root_session_id
assert relay.calls[0] == (
"debugger.send",
{
"tabId": 12,
"sessionId": "child-12",
"method": "Target.setAutoAttach",
"params": {
"flatten": True,
"autoAttach": True,
"waitForDebuggerOnStart": False,
"filter": [{"type": "iframe", "exclude": False}],
},
},
)
assert relay.calls[1][1]["sessionId"] == "child-12"
assert detached["params"] == {"sessionId": "child-12"}
with pytest.raises(KeyError):
registry.resolve_session("child-12")
@pytest.mark.asyncio
async def test_child_detach_during_post_registration_window_emits_and_unregisters(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(17, "https://example.com", "Example")
child_session_id = "child-17"
replay_started = asyncio.Event()
release_replay = asyncio.Event()
async def block_replay(session_id: str) -> None:
assert session_id == child_session_id
replay_started.set()
await release_replay.wait()
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
await receive_event(ws, "Target.attachedToTarget")
with patch.object(adapter, "_replay_buffered_child_events", side_effect=block_replay):
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 17,
"method": "Target.attachedToTarget",
"params": {
"sessionId": child_session_id,
"targetInfo": {
"targetId": "frame-17",
"type": "iframe",
"title": "",
"url": "https://example.com/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
},
},
)
await receive_event(ws, "Target.attachedToTarget")
await asyncio.wait_for(replay_started.wait(), 1)
assert child_session_id in adapter._pending_child_sessions
assert registry.resolve_session(child_session_id) == (17, child_session_id)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 17,
"method": "Target.detachedFromTarget",
"params": {"sessionId": child_session_id},
},
)
detached = await receive_event(ws, "Target.detachedFromTarget")
await ws.send_json({"id": 2, "sessionId": child_session_id, "method": "Runtime.enable", "params": {}})
missing = await receive_response(ws, 2)
release_replay.set()
assert detached["params"] == {"sessionId": child_session_id}
assert missing == {
"id": 2,
"sessionId": child_session_id,
"error": {"code": -32001, "message": "session not found"},
}
@pytest.mark.asyncio
async def test_child_detach_before_probe_completes_is_swallowed_and_tombstones_initialization(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(18, "https://example.com", "Example")
child_session_id = "child-18"
probe_key = (child_session_id, "Target.setAutoAttach")
relay.block_send_keys.add(probe_key)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
await receive_event(ws, "Target.attachedToTarget")
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 18,
"method": "Target.attachedToTarget",
"params": {
"sessionId": child_session_id,
"targetInfo": {
"targetId": "frame-18",
"type": "iframe",
"title": "",
"url": "https://example.com/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
},
},
)
await asyncio.wait_for(relay.send_started.setdefault(probe_key, asyncio.Event()).wait(), 1)
initialization_task = next(task for task in adapter._background_tasks if not task.done())
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 18,
"method": "Target.detachedFromTarget",
"params": {"sessionId": child_session_id},
},
)
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
relay.release_send[probe_key].set()
await asyncio.wait_for(initialization_task, 1)
with pytest.raises(KeyError):
registry.resolve_session(child_session_id)
@pytest.mark.asyncio
async def test_nested_child_attach_during_parent_probe_is_replayed_in_parent_first_order(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(13, "https://parent.example", "Parent")
root_session_id = registry.root_session_id(13)
parent_session_id = "parent-child-13"
grandchild_session_id = "grandchild-13"
parent_probe_key = (parent_session_id, "Target.setAutoAttach")
relay.block_send_keys.add(parent_probe_key)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
await receive_event(ws, "Target.attachedToTarget")
relay.calls.clear()
parent_params = {
"sessionId": parent_session_id,
"targetInfo": {
"targetId": "parent-frame-13",
"type": "iframe",
"title": "",
"url": "https://parent.example/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
}
await adapter.handle_extension_event(
"debugger.event",
{"tabId": 13, "method": "Target.attachedToTarget", "params": parent_params},
)
await asyncio.wait_for(relay.send_started.setdefault(parent_probe_key, asyncio.Event()).wait(), 1)
grandchild_params = {
"sessionId": grandchild_session_id,
"targetInfo": {
"targetId": "grandchild-frame-13",
"type": "iframe",
"title": "",
"url": "https://grandchild.example/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
}
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 13,
"sessionId": parent_session_id,
"method": "Target.attachedToTarget",
"params": grandchild_params,
},
)
relay.release_send[parent_probe_key].set()
parent_attached = await receive_event(ws, "Target.attachedToTarget")
grandchild_attached = await receive_event(ws, "Target.attachedToTarget")
assert registry.resolve_session(grandchild_session_id) == (13, grandchild_session_id)
assert parent_attached["sessionId"] == root_session_id
assert parent_attached["params"] == parent_params
assert grandchild_attached["sessionId"] == parent_session_id
assert grandchild_attached["params"] == grandchild_params
@pytest.mark.asyncio
async def test_nested_child_attach_is_detached_when_parent_probe_fails(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(15, "https://parent.example", "Parent")
parent_session_id = "parent-child-15"
grandchild_session_id = "grandchild-15"
parent_probe_key = (parent_session_id, "Target.setAutoAttach")
relay.block_send_keys.add(parent_probe_key)
relay.fail_send_keys[parent_probe_key] = ExtensionRequestError("INTERNAL", "parent probe failed")
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
await receive_event(ws, "Target.attachedToTarget")
relay.calls.clear()
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 15,
"method": "Target.attachedToTarget",
"params": {
"sessionId": parent_session_id,
"targetInfo": {
"targetId": "parent-frame-15",
"type": "iframe",
"title": "",
"url": "https://parent.example/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
},
},
)
await asyncio.wait_for(relay.send_started.setdefault(parent_probe_key, asyncio.Event()).wait(), 1)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 15,
"sessionId": parent_session_id,
"method": "Target.attachedToTarget",
"params": {
"sessionId": grandchild_session_id,
"targetInfo": {
"targetId": "grandchild-frame-15",
"type": "iframe",
"title": "",
"url": "https://grandchild.example/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
},
},
)
relay.release_send[parent_probe_key].set()
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
with pytest.raises(KeyError):
registry.resolve_session(parent_session_id)
with pytest.raises(KeyError):
registry.resolve_session(grandchild_session_id)
assert (
"debugger.send",
{
"tabId": 15,
"sessionId": grandchild_session_id,
"method": "Runtime.runIfWaitingForDebugger",
"params": {},
},
) in relay.calls
assert (
"debugger.send",
{
"tabId": 15,
"method": "Target.detachFromTarget",
"params": {"sessionId": grandchild_session_id},
},
) in relay.calls
@pytest.mark.asyncio
async def test_pending_child_detach_does_not_wait_for_buffered_grandchild_cleanup(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(19, "https://parent.example", "Parent")
parent_session_id = "parent-child-19"
grandchild_session_id = "grandchild-19"
resume_key = (grandchild_session_id, "Runtime.runIfWaitingForDebugger")
relay.block_send_keys.add(resume_key)
adapter._pending_child_sessions.add(parent_session_id)
adapter._pending_child_events[parent_session_id] = [
{
"tabId": 19,
"sessionId": parent_session_id,
"method": "Target.attachedToTarget",
"params": {
"sessionId": grandchild_session_id,
"targetInfo": {
"targetId": "grandchild-frame-19",
"type": "iframe",
"title": "",
"url": "https://grandchild.example/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
},
}
]
await asyncio.wait_for(
adapter.handle_extension_event(
"debugger.event",
{
"tabId": 19,
"method": "Target.detachedFromTarget",
"params": {"sessionId": parent_session_id},
},
),
0.5,
)
await asyncio.wait_for(relay.send_started.setdefault(resume_key, asyncio.Event()).wait(), 0.5)
relay.release_send.setdefault(resume_key, asyncio.Event()).set()
async def grandchild_detached() -> None:
expected = (
"debugger.send",
{
"tabId": 19,
"method": "Target.detachFromTarget",
"params": {"sessionId": grandchild_session_id},
},
)
while expected not in relay.calls:
await asyncio.sleep(0)
await asyncio.wait_for(grandchild_detached(), 0.5)
assert parent_session_id not in adapter._pending_child_sessions
assert parent_session_id not in adapter._pending_child_events
@pytest.mark.asyncio
async def test_child_initialization_keeps_live_outer_alias_when_another_alias_is_dead(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(20, "https://parent.example", "Parent")
adapter._auto_attach = True
dead_alias = registry.create_root_session_alias(20)
live_alias = registry.create_root_session_alias(20)
assert registry.remove_root_session_alias(dead_alias)
child_session_id = "child-20"
target_info = {
"targetId": "frame-20",
"type": "iframe",
"title": "",
"url": "https://child.example/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
}
event_params = {
"sessionId": child_session_id,
"targetInfo": target_info,
"waitingForDebugger": False,
}
adapter._pending_child_sessions.add(child_session_id)
with patch.object(adapter, "_emit_to_sessions", wraps=adapter._emit_to_sessions) as emit_to_sessions:
await adapter._initialize_child_target(
20,
child_session_id,
target_info,
event_params,
[dead_alias, live_alias],
)
assert registry.resolve_session(child_session_id) == (20, child_session_id)
emit_to_sessions.assert_awaited_once_with("Target.attachedToTarget", event_params, [live_alias])
@pytest.mark.asyncio
async def test_child_initialization_resumes_and_detaches_when_all_outer_aliases_are_dead(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(21, "https://parent.example", "Parent")
adapter._auto_attach = True
outer_session_ids = registry.root_session_ids(21)
registry.remove_tab(21)
child_session_id = "child-21"
target_info = {
"targetId": "frame-21",
"type": "iframe",
"title": "",
"url": "https://child.example/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
}
adapter._pending_child_sessions.add(child_session_id)
await adapter._initialize_child_target(
21,
child_session_id,
target_info,
{"sessionId": child_session_id, "targetInfo": target_info, "waitingForDebugger": False},
outer_session_ids,
)
assert (
"debugger.send",
{
"tabId": 21,
"sessionId": child_session_id,
"method": "Runtime.runIfWaitingForDebugger",
"params": {},
},
) in relay.calls
assert (
"debugger.send",
{
"tabId": 21,
"method": "Target.detachFromTarget",
"params": {"sessionId": child_session_id},
},
) in relay.calls
assert child_session_id not in adapter._pending_child_sessions
with pytest.raises(KeyError):
registry.resolve_session(child_session_id)
@pytest.mark.asyncio
async def test_child_auto_attach_failure_skips_session_and_navigation_lifecycle_continues() -> None:
relay = StubRelay([{"tabId": 14, "url": "https://page.example", "title": "Page"}])
registry = VirtualTargetRegistry()
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setAutoAttach", "params": {"autoAttach": True}})
await receive_response(ws, 1)
await receive_event(ws, "Target.attachedToTarget")
relay.calls.clear()
relay.fail_send_keys[("unsupported-child", "Target.setAutoAttach")] = ExtensionRequestError(
"INTERNAL", "child target does not support auto-attach"
)
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 14,
"method": "Target.attachedToTarget",
"params": {
"sessionId": "unsupported-child",
"targetInfo": {
"targetId": "unsupported-target",
"type": "iframe",
"title": "",
"url": "https://frame.example",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
},
"waitingForDebugger": False,
},
},
)
await asyncio.sleep(0)
with pytest.raises(KeyError):
registry.resolve_session("unsupported-child")
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
root_session_id = registry.root_session_id(14)
await ws.send_json(
{
"id": 2,
"sessionId": root_session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
assert (await receive_response(ws, 2))["result"] == {"forwardedMethod": "Page.navigate"}
lifecycle_params = {"name": "DOMContentLoaded", "frameId": "main"}
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 14,
"method": "Page.lifecycleEvent",
"params": lifecycle_params,
},
)
lifecycle = await receive_event(ws, "Page.lifecycleEvent")
assert lifecycle["sessionId"] == root_session_id
assert lifecycle["params"] == lifecycle_params
finally:
await adapter.stop()
assert (
"debugger.send",
{
"tabId": 14,
"method": "Target.detachFromTarget",
"params": {"sessionId": "unsupported-child"},
},
) in relay.calls
@pytest.mark.asyncio
async def test_slow_session_command_does_not_block_independent_session_command() -> None:
relay = StubRelay()
registry = VirtualTargetRegistry()
registry.register_tab(16, "https://page.example", "Page")
session_id = registry.root_session_id(16)
navigate_key = (None, "Page.navigate")
relay.block_send_keys.add(navigate_key)
adapter = ExtensionCdpAdapter(registry, relay)
await adapter.start()
try:
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json(
{
"id": 1,
"sessionId": session_id,
"method": "Page.navigate",
"params": {"url": "https://destination.example"},
}
)
await asyncio.wait_for(relay.send_started.setdefault(navigate_key, asyncio.Event()).wait(), 1)
await ws.send_json(
{
"id": 2,
"sessionId": session_id,
"method": "Runtime.runIfWaitingForDebugger",
"params": {},
}
)
fast_response = await receive_response(ws, 2)
assert fast_response["result"] == {"forwardedMethod": "Runtime.runIfWaitingForDebugger"}
relay.release_send.setdefault(navigate_key, asyncio.Event()).set()
navigate_response = await receive_response(ws, 1)
assert navigate_response["result"] == {"forwardedMethod": "Page.navigate"}
finally:
relay.release_send.setdefault(navigate_key, asyncio.Event()).set()
await adapter.stop()
@pytest.mark.asyncio
async def test_get_target_info_returns_registered_child_target(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(13, "https://example.com", "Example")
child_target_info = {
"targetId": "frame-13",
"type": "iframe",
"title": "Frame",
"url": "https://example.com/frame",
"attached": True,
"canAccessOpener": False,
"browserContextId": "skyvern-default",
}
registry.register_child_session(13, "child-13", child_target_info)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.getTargetInfo", "params": {"targetId": "frame-13"}})
response = await receive_response(ws, 1)
assert response == {"id": 1, "result": {"targetInfo": child_target_info}}
@pytest.mark.asyncio
async def test_root_session_target_info_is_answered_locally_but_explicit_target_is_forwarded(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(13, "https://example.com", "Example")
root_session_id = registry.root_session_id(13)
alias_session_id = registry.create_root_session_alias(13)
adapter._active_scope_generation(13)
adapter._attached_tabs.add(13)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "sessionId": alias_session_id, "method": "Target.getTargetInfo", "params": {}})
local_response = await receive_response(ws, 1)
await ws.send_json(
{
"id": 2,
"sessionId": alias_session_id,
"method": "Target.getTargetInfo",
"params": {"targetId": "tab-13"},
}
)
forwarded_response = await receive_response(ws, 2)
await ws.send_json({"id": 3, "method": "Target.detachFromTarget", "params": {"sessionId": alias_session_id}})
assert await receive_response(ws, 3) == {"id": 3, "result": {}}
await ws.send_json({"id": 4, "sessionId": root_session_id, "method": "Runtime.evaluate", "params": {}})
main_response = await receive_response(ws, 4)
assert local_response["result"]["targetInfo"]["targetId"] == "tab-13"
assert forwarded_response["result"] == {"forwardedMethod": "Target.getTargetInfo"}
assert main_response["result"] == {"forwardedMethod": "Runtime.evaluate"}
assert relay.calls == [
(
"debugger.send",
{"tabId": 13, "method": "Target.getTargetInfo", "params": {"targetId": "tab-13"}},
),
(
"debugger.send",
{"tabId": 13, "method": "Runtime.evaluate", "params": {}},
),
]
@pytest.mark.asyncio
async def test_revoked_root_session_target_info_uses_forwarded_error(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(14, "https://example.com", "Example")
adapter._active_scope_generation(14)
adapter._attached_tabs.add(14)
alias_session_id = registry.create_root_session_alias(14)
lock = adapter._attach_locks.setdefault(14, asyncio.Lock())
await lock.acquire()
removal_task = asyncio.create_task(adapter._remove_tab_with_events(14))
try:
await asyncio.sleep(0)
relay.fail_next = BrowserExtensionBrokerError("LEASE_REQUIRED", "Tab 14 is not in the controlled scope")
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "sessionId": alias_session_id, "method": "Target.getTargetInfo", "params": {}})
response = await receive_response(ws, 1)
finally:
lock.release()
await removal_task
assert response == {
"id": 1,
"sessionId": alias_session_id,
"error": {"code": -32000, "message": "LEASE_REQUIRED: Tab 14 is not in the controlled scope"},
}
@pytest.mark.asyncio
async def test_target_attachment_snapshot_requires_attached_live_root_target(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(15, "https://example.com", "Example")
generation = adapter._active_scope_generation(15)
assert generation is not None
target_id = registry.target_id_for_tab(15)
assert adapter.target_attachment_snapshot(target_id) is False
adapter._attached_tabs.add(15)
assert adapter.target_attachment_snapshot(target_id) is True
await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "canceled_by_user"})
assert adapter.target_attachment_snapshot(target_id) is False
@pytest.mark.asyncio
async def test_debugger_detached_relay_clears_page_attachment_and_forwards_target_detach_once(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(15, "https://example.com", "Example")
adapter._active_scope_generation(15)
adapter._attached_tabs.add(15)
target_id = registry.target_id_for_tab(15)
session_id = registry.root_session_id(15)
runtime = BrowserExtensionRuntime(relay, adapter)
page = MagicMock()
page.is_closed.return_value = False
cdp_session = MagicMock()
cdp_session.send = AsyncMock(return_value={"targetInfo": {"targetId": target_id}})
cdp_session.detach = AsyncMock()
page.context = SimpleNamespace(new_cdp_session=AsyncMock(return_value=cdp_session))
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
assert await runtime.page_debugger_attached(page) is True
await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "controllability_lost"})
await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "controllability_lost"})
assert await runtime.page_debugger_attached(page) is False
assert adapter.target_attachment_snapshot(target_id) is False
detached = await receive_event(ws, "Target.detachedFromTarget")
destroyed = await receive_event(ws, "Target.targetDestroyed")
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
assert detached["params"] == {"sessionId": session_id, "targetId": target_id}
assert destroyed["params"] == {"targetId": target_id}
assert 15 not in adapter._attached_tabs
with pytest.raises(KeyError):
registry.target_id_for_tab(15)
@pytest.mark.asyncio
async def test_target_attachment_snapshot_rejects_revoked_disconnect_and_reset(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(16, "https://example.com", "Example")
generation = adapter._active_scope_generation(16)
assert generation is not None
target_id = registry.target_id_for_tab(16)
adapter._attached_tabs.add(16)
assert adapter.target_attachment_snapshot(target_id) is True
adapter._revoke_tab_scope(16)
assert adapter.target_attachment_snapshot(target_id) is False
adapter._begin_tab_scope(16)
adapter._attached_tabs.add(16)
assert adapter.target_attachment_snapshot(target_id) is True
await adapter.on_extension_disconnect()
assert adapter.target_attachment_snapshot(target_id) is False
registry.register_tab(16, "https://example.com", "Example")
adapter._active_scope_generation(16)
adapter._attached_tabs.add(16)
adapter._reset_connection_state()
assert adapter.target_attachment_snapshot(target_id) is False
@pytest.mark.asyncio
async def test_create_and_close_target(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, _ = adapter_server
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.createTarget", "params": {"url": "https://example.com"}})
attached = await receive_event(ws, "Target.attachedToTarget")
created = await receive_response(ws, 1)
await ws.send_json({"id": 2, "method": "Target.closeTarget", "params": {"targetId": "tab-100"}})
closed = await receive_response(ws, 2)
await adapter.handle_extension_event("scope.tabRemoved", {"tabId": 100, "reason": "closed"})
detached = await receive_event(ws, "Target.detachedFromTarget")
destroyed = await receive_event(ws, "Target.targetDestroyed")
assert created == {"id": 1, "result": {"targetId": "tab-100"}}
assert attached["params"]["targetInfo"]["url"] == "https://example.com"
assert closed == {"id": 2, "result": {"success": True}}
assert detached["params"]["sessionId"].startswith("sess-tab-100-")
assert destroyed["params"] == {"targetId": "tab-100"}
assert ("tabs.remove", {"tabId": 100}) in relay.calls
@pytest.mark.asyncio
async def test_create_target_and_scope_event_register_tab_once(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
original_request = relay.request
async def request_with_scope_event(
op: str, args: dict, timeout: float = 30.0, *, hold: EventHold | None = None
) -> dict:
result = await original_request(op, args, timeout)
if op == "tabs.create":
await adapter.handle_extension_event(
"scope.tabAdded",
{"tabId": result["tabId"], "url": args["url"], "title": ""},
)
return result
relay.request = request_with_scope_event
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Target.setDiscoverTargets", "params": {"discover": True}})
assert await receive_response(ws, 1) == {"id": 1, "result": {}}
browser_created = await receive_event(ws, "Target.targetCreated")
assert browser_created["params"]["targetInfo"]["targetId"] == "skyvern-browser"
with patch.object(registry, "register_tab", wraps=registry.register_tab) as register_tab:
await ws.send_json({"id": 2, "method": "Target.createTarget", "params": {"url": "https://example.com"}})
target_created = await receive_event(ws, "Target.targetCreated")
await receive_event(ws, "Target.attachedToTarget")
created = await receive_response(ws, 2)
assert register_tab.call_count == 1
assert target_created["params"]["targetInfo"]["targetId"] == "tab-100"
assert created == {"id": 2, "result": {"targetId": "tab-100"}}
assert len(registry.list_page_targets()) == 1
await adapter.handle_extension_event(
"scope.tabAdded",
{"tabId": 100, "url": "https://example.com", "title": ""},
)
with pytest.raises(TimeoutError):
await ws.receive_json(timeout=0.05)
@pytest.mark.asyncio
async def test_debugger_detached_emits_destroyed_and_navigation_updates_target(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(15, "https://old.example", "Old")
session_id = registry.root_session_id(15)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await adapter.handle_extension_event(
"debugger.event",
{
"tabId": 15,
"method": "Page.frameNavigated",
"params": {"frame": {"id": "main", "url": "https://new.example"}},
},
)
navigated = await receive_event(ws, "Page.frameNavigated")
assert navigated["sessionId"] == session_id
assert registry.target_info("tab-15")["url"] == "https://new.example"
await adapter.handle_extension_event("debugger.detached", {"tabId": 15, "reason": "canceled_by_user"})
detached = await receive_event(ws, "Target.detachedFromTarget")
destroyed = await receive_event(ws, "Target.targetDestroyed")
assert detached["params"] == {"sessionId": session_id, "targetId": "tab-15"}
assert destroyed["params"] == {"targetId": "tab-15"}
with pytest.raises(KeyError):
registry.root_session_id(15)
@pytest.mark.asyncio
async def test_unknown_root_and_extension_request_errors(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(18, "https://example.com", "Example")
session_id = registry.root_session_id(18)
async with ClientSession() as client, client.ws_connect(adapter.cdp_ws_url) as ws:
await ws.send_json({"id": 1, "method": "Nope.missing", "params": {}})
unknown = await receive_response(ws, 1)
relay.fail_next = ExtensionRequestError("CDP_ERROR", "command failed")
await ws.send_json({"id": 2, "sessionId": session_id, "method": "Runtime.enable", "params": {}})
failed = await receive_response(ws, 2)
assert unknown == {"id": 1, "error": {"code": -32601, "message": "'Nope.missing' wasn't found"}}
assert failed == {
"id": 2,
"sessionId": session_id,
"error": {"code": -32000, "message": "CDP_ERROR: command failed"},
}
@pytest.mark.asyncio
async def test_second_client_rejected_and_disconnect_allows_future_client(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, _, registry = adapter_server
registry.register_tab(20, "https://example.com", "Example")
async with ClientSession() as client:
first = await client.ws_connect(adapter.cdp_ws_url)
second = await client.ws_connect(adapter.cdp_ws_url)
await second.receive(timeout=2)
assert second.close_code == 4409
await adapter.on_extension_disconnect()
await first.receive(timeout=2)
assert first.close_code == 1001
assert registry.list_page_targets() == []
future = await client.ws_connect(adapter.cdp_ws_url)
await future.send_json({"id": 1, "method": "Browser.getVersion", "params": {}})
assert (await receive_response(future, 1))["result"]["protocolVersion"] == "1.3"
await future.close()
@pytest.mark.asyncio
async def test_old_client_disconnect_does_not_cancel_new_client_command(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
old_cancel_started = asyncio.Event()
release_old_cancel = asyncio.Event()
original_cancel_client_tasks = adapter._cancel_client_tasks
async def block_old_cancel(*args: object) -> None:
old_cancel_started.set()
await release_old_cancel.wait()
await original_cancel_client_tasks(*args)
async with ClientSession() as client:
await client.ws_connect(adapter.cdp_ws_url)
with patch.object(adapter, "_cancel_client_tasks", side_effect=block_old_cancel):
disconnect_task = asyncio.create_task(adapter.on_extension_disconnect())
await asyncio.wait_for(old_cancel_started.wait(), 1)
new = await client.ws_connect(adapter.cdp_ws_url)
registry.register_tab(24, "https://example.com", "Example")
session_id = registry.root_session_id(24)
send_key = (None, "Runtime.evaluate")
relay.block_send_keys.add(send_key)
await new.send_json(
{"id": 1, "sessionId": session_id, "method": "Runtime.evaluate", "params": {"expression": "1+1"}}
)
await asyncio.wait_for(relay.send_started.setdefault(send_key, asyncio.Event()).wait(), 1)
release_old_cancel.set()
await asyncio.wait_for(disconnect_task, 2)
relay.release_send[send_key].set()
assert await receive_response(new, 1) == {
"id": 1,
"sessionId": session_id,
"result": {"forwardedMethod": "Runtime.evaluate"},
}
await asyncio.sleep(0)
assert adapter._client_tasks == {}
await new.close()
@pytest.mark.asyncio
async def test_browser_close_detaches_all_tabs_when_client_closes_after_reply(
adapter_server: tuple[ExtensionCdpAdapter, StubRelay, VirtualTargetRegistry],
) -> None:
adapter, relay, registry = adapter_server
registry.register_tab(22, "https://example.com", "Example")
registry.register_tab(23, "https://other.example", "Other")
relay.block_detach_tab_id = 22
async with ClientSession() as client:
ws = await client.ws_connect(adapter.cdp_ws_url)
await ws.send_json({"id": 9, "method": "Browser.close", "params": {}})
assert await receive_response(ws, 9) == {"id": 9, "result": {}}
close_task = asyncio.create_task(ws.close())
await asyncio.wait_for(relay.detach_started.wait(), 1)
await asyncio.sleep(0.05)
relay.release_detach.set()
await asyncio.wait_for(close_task, 2)
assert {args["tabId"] for op, args in relay.calls if op == "debugger.detach"} == {22, 23}
assert all(op != "tabs.remove" for op, _ in relay.calls)
assert set(relay.released_tabs) == {22, 23}
@pytest.mark.asyncio
@pytest.mark.parametrize("method", ["Target.targetCreated", "Target.targetInfoChanged", "Target.attachedToTarget"])
async def test_unexposed_target_events_are_hidden_at_delivery(method: str) -> None:
registry = VirtualTargetRegistry()
registry.register_tab(32, "about:blank", "")
adapter = ExtensionCdpAdapter(registry, StubRelay())
ws = SimpleNamespace(closed=False, send_json=AsyncMock())
payload = {"method": method, "params": {"targetInfo": registry.target_info_for_tab(32)}}
async with adapter._send_lock:
pending = asyncio.create_task(adapter._send(ws, payload))
await asyncio.sleep(0)
adapter._unexposed_attached_tabs.add(32)
await pending
ws.send_json.assert_not_awaited()
adapter._unexposed_attached_tabs.clear()
await adapter._send(ws, payload)
ws.send_json.assert_awaited_once_with(payload)