Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::*;
use crate::automation::{
AutomationCommand, AutomationContext, AutomationResult, DevToolsGetRealmsCommand,
DevToolsSessionId, DevToolsTargetId, FrontendProtocol, RuntimeExecutionContextEvent,
};
async fn wait_until_runtime_expression_true(
ctx: &mut TestContext,
session_id: Option<&str>,
command_id_base: u64,
expression: &str,
description: &str,
) {
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
for attempt in 0..256 {
let command_id = command_id_base + attempt;
let mut command = json!({
"id": command_id,
"method": "Runtime.evaluate",
"params": {
"expression": expression,
"returnByValue": true
}
});
if let Some(session_id) = session_id {
command["sessionId"] = json!(session_id);
}
ctx.process_async(command).await;
let response = take_response_by_id(ctx, command_id);
if response["result"]["result"]["value"] == json!(true) {
return;
}
if tokio::time::Instant::now() >= deadline {
panic!("timed out waiting for {description}: {response:?}");
}
ctx.complete_one_ready_scheduler_input_for_test().await;
tokio::task::yield_now().await;
}
panic!("timed out waiting for {description}");
}
fn record_shared_worker_runtime_context(ctx: &mut TestContext, session_id: &str, context_id: i64) {
let event = RuntimeExecutionContextEvent {
target_id: None,
context_id: Some(context_id),
realm_id: None,
frame_id: None,
origin: None,
name: None,
is_default: None,
context_type: Some("worker".to_owned()),
grant_universal_access: None,
};
ctx.conn
.shared_worker_target_for_session_mut(Some(session_id))
.expect("shared worker target session should exist")
.record_runtime_execution_context_created_event(&event);
}
#[tokio::test]
async fn runtime_enable_on_shared_worker_session_without_renderer_context_delays_buffered_logs() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
record_shared_worker_console(&mut ctx, "SID-shared-worker", "warn: boot warning");
ctx.process_async(json!({
"id": 71,
"method": "Runtime.enable",
"sessionId": "SID-shared-worker"
}))
.await;
ctx.expect_result(71, json!({}), Some("SID-shared-worker"));
assert!(
ctx.sent
.iter()
.all(|message| message["method"] != json!("Runtime.executionContextCreated")),
"Runtime.enable must not synthesize a worker execution context before renderer context creation: {:?}",
ctx.sent
);
assert!(
ctx.sent
.iter()
.all(|message| message["method"] != json!("Runtime.consoleAPICalled")),
"Runtime.enable must not emit Runtime.consoleAPICalled before a real renderer context id exists: {:?}",
ctx.sent
);
}
#[tokio::test]
async fn runtime_enable_on_shared_worker_session_replays_real_worker_context() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
record_shared_worker_console(&mut ctx, "SID-shared-worker", "warn: boot warning");
record_shared_worker_runtime_context(&mut ctx, "SID-shared-worker", 81_081);
ctx.process_async(json!({
"id": 72,
"method": "Runtime.enable",
"sessionId": "SID-shared-worker"
}))
.await;
let response_index = ctx
.sent
.iter()
.position(|message| message["id"] == json!(72))
.expect("enable response");
for method in [
"Runtime.executionContextCreated",
"Runtime.consoleAPICalled",
] {
let event_index = ctx
.sent
.iter()
.position(|message| message["method"] == json!(method))
.expect("buffered Runtime replay");
assert!(
event_index < response_index,
"{method} must precede the enable reply: {:#?}",
ctx.sent
);
}
ctx.expect_result(72, json!({}), Some("SID-shared-worker"));
let context_event = ctx.take_first_matching("shared worker execution context", |message| {
message["method"] == json!("Runtime.executionContextCreated")
});
assert_eq!(context_event["sessionId"], "SID-shared-worker");
assert_eq!(context_event["params"]["context"]["id"], json!(81_081));
assert_eq!(
context_event["params"]["context"]["origin"],
json!("https://example.test")
);
assert_eq!(context_event["params"]["context"]["name"], json!("worker"));
assert_eq!(
context_event["params"]["context"]["auxData"],
json!({
"isDefault": true,
"type": "worker"
})
);
let console_event = ctx.take_first_matching("shared worker runtime console", |message| {
message["method"] == json!("Runtime.consoleAPICalled")
});
assert_eq!(console_event["sessionId"], "SID-shared-worker");
assert_eq!(console_event["params"]["type"], "warning");
assert_eq!(
console_event["params"]["args"],
json!([{
"type": "string",
"value": "boot warning"
}])
);
assert_eq!(console_event["params"]["executionContextId"], json!(81_081));
}
#[tokio::test]
async fn get_realms_on_shared_worker_target_waits_for_renderer_context() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
let (result, _) = ctx
.conn
.execute_automation_command(AutomationCommand::GetRealms(DevToolsGetRealmsCommand {
context: AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: Some(DevToolsTargetId::from("TID-shared-worker")),
browser_context_id: None,
},
realm_type: Some("shared-worker".to_owned()),
}))
.await
.into_parts();
let AutomationResult::Realms(result) = result.expect("getRealms should succeed") else {
panic!("expected Realms result");
};
assert!(
result.realms.is_empty(),
"getRealms must not synthesize a shared worker realm before renderer context creation: {:?}",
result.realms
);
}
#[tokio::test]
async fn get_realms_on_shared_worker_target_returns_real_renderer_realm() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
record_shared_worker_runtime_context(&mut ctx, "SID-shared-worker", 81_081);
let (result, _) = ctx
.conn
.execute_automation_command(AutomationCommand::GetRealms(DevToolsGetRealmsCommand {
context: AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: Some(DevToolsTargetId::from("TID-shared-worker")),
browser_context_id: None,
},
realm_type: Some("shared-worker".to_owned()),
}))
.await
.into_parts();
let AutomationResult::Realms(result) = result.expect("getRealms should succeed") else {
panic!("expected Realms result");
};
assert_eq!(result.realms.len(), 1);
let realm = &result.realms[0];
assert_eq!(
realm.target_id.as_ref().map(DevToolsTargetId::as_str),
Some("TID-shared-worker")
);
assert_eq!(realm.context_id, Some(81_081));
assert_eq!(
realm.realm_id.as_ref().map(|realm| realm.as_str()),
Some("shared-worker-TID-shared-worker")
);
assert_eq!(realm.frame_id, None);
assert_eq!(realm.origin.as_deref(), Some("https://example.test"));
assert_eq!(realm.name.as_deref(), Some("worker"));
assert_eq!(realm.context_type.as_deref(), Some("shared-worker"));
}
#[tokio::test]
async fn get_realms_global_enumeration_waits_for_shared_worker_renderer_context() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
let (result, _) = ctx
.conn
.execute_automation_command(AutomationCommand::GetRealms(DevToolsGetRealmsCommand {
context: AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
},
realm_type: Some("shared-worker".to_owned()),
}))
.await
.into_parts();
let AutomationResult::Realms(result) = result.expect("getRealms should succeed") else {
panic!("expected Realms result");
};
assert!(
result.realms.iter().all(|realm| {
realm.target_id.as_ref().map(DevToolsTargetId::as_str) != Some("TID-shared-worker")
}),
"global getRealms must not synthesize shared worker target realms before renderer context creation: {:?}",
result.realms
);
}
#[tokio::test]
async fn get_realms_global_enumeration_includes_shared_worker_real_renderer_realm() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
record_shared_worker_runtime_context(&mut ctx, "SID-shared-worker", 81_081);
let (result, _) = ctx
.conn
.execute_automation_command(AutomationCommand::GetRealms(DevToolsGetRealmsCommand {
context: AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
},
realm_type: Some("shared-worker".to_owned()),
}))
.await
.into_parts();
let AutomationResult::Realms(result) = result.expect("getRealms should succeed") else {
panic!("expected Realms result");
};
assert!(
result.realms.iter().any(|realm| {
realm.target_id.as_ref().map(DevToolsTargetId::as_str) == Some("TID-shared-worker")
&& realm.context_id == Some(81_081)
&& realm.context_type.as_deref() == Some("shared-worker")
&& realm.realm_id.as_ref().map(|realm| realm.as_str())
== Some("shared-worker-TID-shared-worker")
}),
"global getRealms should include shared worker target realms after renderer context creation: {:?}",
result.realms
);
}
#[tokio::test]
async fn runtime_evaluate_on_shared_worker_session_does_not_fall_back_to_page_runtime() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
ctx.process_async(json!({
"id": 72,
"method": "Runtime.evaluate",
"sessionId": "SID-shared-worker",
"params": { "expression": "self.name" }
}))
.await;
let response = ctx.take_response_by_id(72);
assert_eq!(response["sessionId"], "SID-shared-worker");
assert_eq!(response["error"]["code"], -32000);
assert_eq!(
response["error"]["message"],
"SharedWorkerRuntimeUnavailable"
);
}
#[tokio::test]
async fn runtime_enable_on_dedicated_worker_without_renderer_runtime_still_succeeds() {
let mut ctx = TestContext::new();
load_dedicated_worker_target(&mut ctx, "SID-dedicated-worker");
ctx.process_async(json!({
"id": 72_001,
"method": "Runtime.enable",
"sessionId": "SID-dedicated-worker"
}))
.await;
ctx.expect_result(72_001, json!({}), Some("SID-dedicated-worker"));
assert!(
ctx.sent
.iter()
.all(|message| message["method"] != json!("Runtime.executionContextCreated")),
"Runtime.enable must not synthesize a dedicated worker execution context: {:?}",
ctx.sent
);
}
#[tokio::test]
async fn runtime_evaluate_on_dedicated_worker_reports_dedicated_runtime_unavailable() {
let mut ctx = TestContext::new();
load_dedicated_worker_target(&mut ctx, "SID-dedicated-worker");
ctx.process_async(json!({
"id": 72_002,
"method": "Runtime.evaluate",
"sessionId": "SID-dedicated-worker",
"params": { "expression": "self.name" }
}))
.await;
let response = ctx.take_response_by_id(72_002);
assert_eq!(response["sessionId"], "SID-dedicated-worker");
assert_eq!(response["error"]["code"], -32000);
assert_eq!(
response["error"]["message"],
"DedicatedWorkerRuntimeUnavailable"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn runtime_commands_on_real_shared_worker_session_enter_worker_global() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
ctx.process_async(json!({
"id": 73,
"method": "Target.setAutoAttach",
"params": {
"autoAttach": true,
"waitForDebuggerOnStart": false
}
}))
.await;
ctx.expect_result(73, json!({}), None);
ctx.process_async(json!({
"id": 74,
"method": "Runtime.evaluate",
"params": {
"expression": r#"
(() => {
const source = `
globalThis.__workerProbe = "worker:" + name + ":" + (
typeof SharedWorkerGlobalScope !== "undefined" &&
self instanceof SharedWorkerGlobalScope
);
globalThis.__workerObject = {
answer: 42,
label: globalThis.__workerProbe
};
onconnect = event => {
const port = event.ports[0];
port.postMessage("ready:" + globalThis.__workerProbe);
};
`;
const url = "data:text/javascript," + encodeURIComponent(source);
const worker = new SharedWorker(url, "runtime-probe");
globalThis.__sharedWorkerRuntimeProbe = worker;
globalThis.__sharedWorkerRuntimeReady = null;
worker.port.onmessage = event => {
globalThis.__sharedWorkerRuntimeReady = event.data;
};
worker.port.start();
return "started";
})()
"#,
"returnByValue": true
}
}))
.await;
let start_response = take_response_by_id(&mut ctx, 74);
assert_eq!(
start_response["result"]["result"]["value"],
json!("started")
);
wait_until_message(
&mut ctx,
None,
"shared worker target auto-attach",
|message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["targetInfo"]["type"] == json!("shared_worker")
&& message["params"]["targetInfo"]["title"] == json!("runtime-probe")
},
)
.await;
let attached = ctx.take_first_matching("shared worker target auto-attach", |message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["targetInfo"]["type"] == json!("shared_worker")
&& message["params"]["targetInfo"]["title"] == json!("runtime-probe")
});
let shared_worker_session_id = attached["params"]["sessionId"]
.as_str()
.expect("shared worker session id")
.to_owned();
ctx.process_async(json!({
"id": 75,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_response = take_response_by_id(&mut ctx, 75);
assert_eq!(enable_response["sessionId"], shared_worker_session_id);
assert_eq!(enable_response["result"], json!({}));
let context_event = ctx.take_first_matching("shared worker execution context", |message| {
message["method"] == json!("Runtime.executionContextCreated")
&& message["sessionId"] == json!(shared_worker_session_id)
});
assert_eq!(
context_event["params"]["context"]["auxData"]["type"],
json!("worker")
);
ctx.process_async(json!({
"id": 76,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.__workerProbe",
"returnByValue": true
}
}))
.await;
let probe_response = take_response_by_id(&mut ctx, 76);
assert_eq!(
probe_response["result"]["result"]["value"],
json!("worker:runtime-probe:true")
);
ctx.process_async(json!({
"id": 77,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.__workerObject"
}
}))
.await;
let object_id = take_response_by_id(&mut ctx, 77)["result"]["result"]["objectId"]
.as_str()
.map(str::to_owned)
.expect("shared worker object id");
ctx.process_async(json!({
"id": 78,
"method": "Runtime.callFunctionOn",
"sessionId": shared_worker_session_id,
"params": {
"objectId": object_id,
"functionDeclaration": "function() { return this.label + ':' + this.answer; }",
"returnByValue": true
}
}))
.await;
let call_response = take_response_by_id(&mut ctx, 78);
assert_eq!(
call_response["result"]["result"]["value"],
json!("worker:runtime-probe:true:42")
);
ctx.process_async(json!({
"id": 79,
"method": "Runtime.getProperties",
"sessionId": shared_worker_session_id,
"params": {
"objectId": object_id,
"ownProperties": true
}
}))
.await;
let properties_response = take_response_by_id(&mut ctx, 79);
let properties = properties_response["result"]["result"]
.as_array()
.expect("shared worker object properties");
let answer = properties
.iter()
.find(|property| property["name"] == json!("answer"))
.expect("answer property");
assert_eq!(answer["value"]["value"], json!(42));
}
#[tokio::test(flavor = "multi_thread")]
async fn heap_profiler_moli_diagnostics_reports_shared_worker_runtime_counts() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let _shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_010,
"diagnostics-runtime-counts",
r#"
onconnect = event => {
event.ports[0].postMessage('ready');
};
"#,
)
.await;
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_012,
"method": "HeapProfiler.moliDiagnostics"
}))
.await;
let response = take_response_by_id(&mut ctx, 90_012);
let isolate_scope = &response["result"]["isolateScope"];
assert_eq!(isolate_scope["sharedWorkerTargetCount"], json!(1));
assert_eq!(isolate_scope["sharedWorkerMatchingEntryCount"], json!(1));
assert_eq!(isolate_scope["sharedWorkerLoadingInstanceCount"], json!(0));
assert_eq!(isolate_scope["sharedWorkerRunningInstanceCount"], json!(1));
assert_eq!(isolate_scope["sharedWorkerClientCount"], json!(1));
assert_eq!(isolate_scope["sharedWorkerLoadingHostCount"], json!(0));
assert_eq!(
isolate_scope["sharedWorkerRunningWorkerIsolateCount"],
json!(1)
);
assert!(
isolate_scope
.get("sharedWorkerPendingTargetLifecycleEventCount")
.is_none(),
"SharedWorker target lifecycle is carried by its concrete renderer output stream, not a legacy pending-event queue"
);
assert_eq!(
isolate_scope["sharedWorkerPendingServiceLaneEventCount"],
json!(0)
);
assert_eq!(
isolate_scope["sharedWorkerProtocolDispatchRequiresLiveOwnerPageCommand"],
json!(false)
);
}
#[tokio::test(flavor = "multi_thread")]
async fn heap_profiler_moli_diagnostics_splits_document_and_shared_worker_isolates() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body>active</body>").await;
let _shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_020,
"diagnostics-document-worker-split",
r#"
onconnect = event => {
event.ports[0].postMessage('ready');
};
"#,
)
.await;
let background_url = "data:text/html,<!doctype html><body>background</body>";
let background_page = ctx
.conn
.load_page_via_runtime_async(background_url)
.await
.expect("background diagnostics page should load");
let browser_context = ctx
.conn
.browser_context
.as_mut()
.expect("browser context should remain installed");
let mut background = crate::conn::PageTargetHost::with_url(
"TID-diagnostics-document-worker-bg".to_owned(),
Some("SID-diagnostics-document-worker-bg".to_owned()),
background_url.to_owned(),
);
background.replace_loaded_page(Some(background_page));
browser_context.insert_page_target_host(background);
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_022,
"method": "HeapProfiler.moliDiagnostics"
}))
.await;
let response = take_response_by_id(&mut ctx, 90_022);
let isolate_scope = &response["result"]["isolateScope"];
assert_eq!(
isolate_scope["documentIsolateModel"],
json!("related-pages")
);
assert_eq!(isolate_scope["loadedDocumentPageCount"], json!(2));
assert_eq!(
isolate_scope["loadedDocumentRendererOwnerCount"],
json!(1),
"this accounting fixture deliberately reuses the active engine for both document snapshots: {response:?}"
);
assert_eq!(
isolate_scope["estimatedDocumentIsolateCount"],
json!(2),
"document isolate diagnostics must count loaded PageVMs, not renderer owners or worker targets: {response:?}"
);
assert_eq!(
isolate_scope["estimatedWorkerIsolateCount"],
json!(1),
"worker isolate diagnostics should count the SharedWorker separately from document isolates: {response:?}"
);
assert_eq!(
isolate_scope["estimatedLiveV8IsolateCount"],
json!(3),
"live V8 isolate total should be two page document isolates plus one SharedWorker isolate: {response:?}"
);
assert_eq!(
isolate_scope["documentContextCount"],
json!(2),
"active and background pages should contribute separate document contexts: {response:?}"
);
assert_eq!(isolate_scope["sharedWorkerTargetCount"], json!(1));
assert_eq!(
isolate_scope["sharedWorkerRunningWorkerIsolateCount"],
json!(1),
"SharedWorker must be counted as a separate worker isolate, not a document isolate: {response:?}"
);
assert_eq!(
response["result"]["activeBrowserContext"]["backgroundLoadedPageCount"],
json!(1)
);
assert_eq!(
response["result"]["activeBrowserContext"]["isolateScope"]["browserContextRuntime"]["sharedWorker"]
["runningWorkerIsolateCount"],
json!(1)
);
}
#[tokio::test(flavor = "multi_thread")]
async fn heap_profiler_moli_diagnostics_covers_popup_dedicated_and_shared_worker_combo() {
let mut ctx = TestContext::new();
with_loaded_document_for_active_target_async(
&mut ctx,
"<!doctype html><body>opener</body>",
"SID-diagnostics-combo-opener",
"TID-diagnostics-combo-opener",
)
.await;
let _shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_030,
"diagnostics-popup-worker-combo",
r#"
onconnect = event => {
event.ports[0].postMessage('ready');
};
"#,
)
.await;
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_032,
"method": "Runtime.evaluate",
"sessionId": "SID-diagnostics-combo-opener",
"params": {
"expression": r#"
(() => {
globalThis.__lmWorkerDiagnosticsReady = false;
const worker = new Worker("data:text/javascript,postMessage('ready')");
worker.onmessage = () => {
globalThis.__lmWorkerDiagnosticsReady = true;
};
globalThis.__lmWorkerDiagnosticsWorker = worker;
})()
"#
}
}))
.await;
let dedicated_worker_start = take_response_by_id(&mut ctx, 90_032);
assert_eq!(
dedicated_worker_start["result"]["result"]["type"],
json!("undefined")
);
wait_until_runtime_expression_true(
&mut ctx,
Some("SID-diagnostics-combo-opener"),
90_033,
"globalThis.__lmWorkerDiagnosticsReady === true",
"dedicated worker diagnostics probe to become ready",
)
.await;
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_034,
"method": "Runtime.evaluate",
"sessionId": "SID-diagnostics-combo-opener",
"params": {
"expression": "window.open('about:blank#diagnostics-popup-worker-combo', '_blank') !== null",
"returnByValue": true
}
}))
.await;
let open_response = take_response_by_id(&mut ctx, 90_034);
assert_eq!(
open_response["result"]["result"]["value"],
json!(true),
"window.open should create a popup target: {open_response:?}"
);
let target_created = ctx
.sent
.iter()
.find(|message| message["method"] == json!("Target.targetCreated"))
.cloned()
.unwrap_or_else(|| panic!("popup targetCreated should be emitted: {:?}", ctx.sent));
let popup_target_id = target_created["params"]["targetInfo"]["targetId"]
.as_str()
.expect("popup target id")
.to_owned();
let attached = ctx
.sent
.iter()
.find(|message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["targetInfo"]["targetId"] == json!(popup_target_id)
})
.cloned()
.unwrap_or_else(|| panic!("popup target should be auto-attached: {:?}", ctx.sent));
let popup_session_id = attached["params"]["sessionId"]
.as_str()
.expect("popup session id")
.to_owned();
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_035,
"method": "Page.navigate",
"sessionId": popup_session_id,
"params": {
"url": "data:text/html,<!doctype html><body>popup</body>"
}
}))
.await;
let navigate_response = take_response_by_id(&mut ctx, 90_035);
assert_eq!(
navigate_response["result"]["frameId"],
json!(popup_target_id)
);
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_036,
"method": "HeapProfiler.moliDiagnostics"
}))
.await;
let response = take_response_by_id(&mut ctx, 90_036);
let isolate_scope = &response["result"]["isolateScope"];
assert_eq!(isolate_scope["loadedDocumentPageCount"], json!(2));
assert_eq!(
isolate_scope["loadedDocumentRendererOwnerCount"],
json!(1),
"related opener and popup share their renderer owner: {response:?}"
);
assert_eq!(
isolate_scope["estimatedDocumentIsolateCount"],
json!(1),
"related popup and opener must count as one document isolate: {response:?}"
);
assert_eq!(
isolate_scope["documentContextCount"],
json!(2),
"opener and popup should still have separate document contexts: {response:?}"
);
assert_eq!(isolate_scope["sharedWorkerTargetCount"], json!(1));
assert_eq!(
isolate_scope["dedicatedWorkerRunningWorkerIsolateCount"],
json!(1),
"dedicated worker should be counted separately from document isolates: {response:?}"
);
assert_eq!(
isolate_scope["sharedWorkerRunningWorkerIsolateCount"],
json!(1),
"SharedWorker should remain a separate worker isolate in the popup combo: {response:?}"
);
assert_eq!(
isolate_scope["estimatedWorkerIsolateCount"],
json!(2),
"worker isolate total should include both dedicated worker and SharedWorker: {response:?}"
);
assert_eq!(
isolate_scope["estimatedLiveV8IsolateCount"],
json!(3),
"combo should be one related-page document isolate plus two worker isolates: {response:?}"
);
assert_eq!(
response["result"]["activeBrowserContext"]["backgroundLoadedPageCount"],
json!(1)
);
}
#[tokio::test(flavor = "multi_thread")]
async fn runtime_enable_replays_page_and_shared_worker_contexts_to_their_own_sessions() {
let mut ctx = TestContext::new();
with_loaded_document_for_active_target_async(
&mut ctx,
"<!doctype html><script>console.warn('page boot warning')</script><body></body>",
"SID-page",
"TID-page",
)
.await;
ctx.sent.clear();
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_020,
"context-replay-isolation",
r#"
onconnect = event => {
event.ports[0].postMessage('ready');
};
"#,
)
.await;
record_shared_worker_console(
&mut ctx,
&shared_worker_session_id,
"warn: worker boot warning",
);
record_shared_worker_runtime_context(&mut ctx, &shared_worker_session_id, 90_021);
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_022,
"method": "Runtime.enable",
"sessionId": "SID-page"
}))
.await;
let page_messages = ctx.take_all();
assert!(
page_messages.iter().any(|message| {
message["id"] == json!(90_022)
&& message["result"] == json!({})
&& message["sessionId"] == json!("SID-page")
}),
"page Runtime.enable should return a page-session result: {page_messages:?}"
);
let page_context = page_messages
.iter()
.find(|message| {
message["sessionId"] == json!("SID-page")
&& message["method"] == json!("Runtime.executionContextCreated")
})
.unwrap_or_else(|| {
panic!("page Runtime.enable should replay a page execution context: {page_messages:?}")
});
let page_context_id = page_context["params"]["context"]["id"]
.as_i64()
.expect("page context id");
assert_eq!(
page_context["params"]["context"]["auxData"]["frameId"],
json!("TID-page")
);
assert_ne!(
page_context["params"]["context"]["auxData"]["type"],
json!("worker")
);
let page_console = page_messages
.iter()
.find(|message| {
message["sessionId"] == json!("SID-page")
&& message["method"] == json!("Runtime.consoleAPICalled")
})
.unwrap_or_else(|| {
panic!("page Runtime.enable should replay page console output: {page_messages:?}")
});
assert_eq!(
page_console["params"]["args"][0]["value"],
json!("page boot warning")
);
assert_eq!(
page_console["params"]["executionContextId"],
json!(page_context_id)
);
assert!(
page_messages.iter().all(|message| {
message["sessionId"] != json!(shared_worker_session_id)
&& message["params"]["context"]["auxData"]["type"] != json!("worker")
}),
"page Runtime.enable must not replay worker context or console output: {page_messages:?}"
);
ctx.process_async(json!({
"id": 90_023,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let worker_messages = ctx.take_all();
assert!(
worker_messages.iter().any(|message| {
message["id"] == json!(90_023)
&& message["result"] == json!({})
&& message["sessionId"] == json!(shared_worker_session_id)
}),
"shared worker Runtime.enable should return a worker-session result: {worker_messages:?}"
);
let worker_context = worker_messages
.iter()
.find(|message| {
message["sessionId"] == json!(shared_worker_session_id)
&& message["method"] == json!("Runtime.executionContextCreated")
})
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.enable should replay a worker execution context: {worker_messages:?}"
)
});
assert_eq!(
worker_context["params"]["context"]["auxData"]["type"],
json!("worker")
);
let worker_console = worker_messages
.iter()
.find(|message| {
message["sessionId"] == json!(shared_worker_session_id)
&& message["method"] == json!("Runtime.consoleAPICalled")
})
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.enable should replay worker console output: {worker_messages:?}"
)
});
assert_eq!(
worker_console["params"]["args"][0]["value"],
json!("worker boot warning")
);
assert_ne!(
worker_console["params"]["executionContextId"],
json!(page_context_id),
"worker console replay must not use the page execution context id"
);
assert_eq!(
worker_console["params"]["executionContextId"],
json!(90_021),
"worker console replay should use the real shared worker execution context id"
);
assert!(
worker_messages.iter().all(|message| {
message["sessionId"] != json!("SID-page")
&& message["params"]["context"]["auxData"]["frameId"] != json!("TID-page")
}),
"shared worker Runtime.enable must not replay page context or console output: {worker_messages:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_runtime_add_remove_binding_persists_on_target() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_000,
"binding-target",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_010,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_response = take_response_by_id(&mut ctx, 90_010);
assert_eq!(enable_response["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_011,
"method": "Runtime.addBinding",
"sessionId": shared_worker_session_id,
"params": { "name": "sharedWorkerBinding" }
}))
.await;
let add_binding = take_response_by_id(&mut ctx, 90_011);
assert_eq!(add_binding["result"], json!({}));
assert!(
ctx.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist")
.runtime_bindings(&shared_worker_session_id)
.iter()
.any(|binding| {
binding.name == "sharedWorkerBinding" && binding.execution_context_name.is_none()
}),
"shared worker addBinding should persist on the target state"
);
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_012,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.sharedWorkerBinding('from-shared-worker'); 'called'",
"returnByValue": true
}
}))
.await;
let evaluation = take_response_by_id(&mut ctx, 90_012);
assert_eq!(evaluation["result"]["result"]["value"], json!("called"));
let binding_called = ctx.take_first_matching("shared worker bindingCalled", |message| {
message["method"] == json!("Runtime.bindingCalled")
&& message["sessionId"] == json!(shared_worker_session_id)
&& message["params"]["name"] == json!("sharedWorkerBinding")
});
assert_eq!(
binding_called["params"]["payload"],
json!("from-shared-worker")
);
ctx.process_async(json!({
"id": 90_013,
"method": "Runtime.removeBinding",
"sessionId": shared_worker_session_id,
"params": { "name": "sharedWorkerBinding" }
}))
.await;
let remove_binding = take_response_by_id(&mut ctx, 90_013);
assert_eq!(remove_binding["result"], json!({}));
assert!(
ctx.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist")
.runtime_bindings(&shared_worker_session_id)
.iter()
.all(|binding| binding.name != "sharedWorkerBinding"),
"shared worker removeBinding should clear persisted target state"
);
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_014,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.sharedWorkerBinding('after-remove'); typeof globalThis.sharedWorkerBinding",
"returnByValue": true
}
}))
.await;
let removed = take_response_by_id(&mut ctx, 90_014);
assert_eq!(removed["result"]["result"]["value"], json!("function"));
assert!(
!ctx.sent.iter().any(|message| {
message["method"] == json!("Runtime.bindingCalled")
&& message["sessionId"] == json!(shared_worker_session_id)
&& message["params"]["name"] == json!("sharedWorkerBinding")
}),
"shared worker removeBinding should leave the existing function inert"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_runtime_agent_state_commands_dispatch_after_runtime_enable() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_050,
"runtime-agent-state",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_060,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_response = take_response_by_id(&mut ctx, 90_060);
assert_eq!(enable_response["result"], json!({}));
for (id, method, params) in [
(
90_061_u64,
"Runtime.setCustomObjectFormatterEnabled",
json!({ "enabled": true }),
),
(
90_062_u64,
"Runtime.setMaxCallStackSizeToCapture",
json!({ "size": 8 }),
),
] {
ctx.process_async(json!({
"id": id,
"method": method,
"sessionId": shared_worker_session_id,
"params": params
}))
.await;
let response = take_response_by_id(&mut ctx, id);
assert_eq!(
response["result"],
json!({}),
"{method} should return V8 Runtime agent success: {response:?}"
);
}
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_terminate_execution_dispatches_through_v8_runtime_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_065,
"runtime-terminate-execution",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_066,
"method": "Runtime.terminateExecution",
"sessionId": shared_worker_session_id
}))
.await;
let response = take_response_by_id(&mut ctx, 90_066);
assert_eq!(
response["result"],
json!({}),
"shared worker Runtime.terminateExecution should return V8 Runtime agent success: {response:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_heap_profiler_collect_garbage_dispatches_through_v8_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_067,
"heap-profiler-collect-garbage",
r#"
onconnect = event => {
globalThis.__heapProbe = new Array(1024).fill({value: "worker"});
event.ports[0].postMessage("ready");
};
"#,
)
.await;
let raw = json!({
"id": 90_068,
"method": "HeapProfiler.collectGarbage",
"sessionId": shared_worker_session_id
})
.to_string();
let step = ctx.conn.start_command_dispatch(&raw);
assert!(
matches!(&step, CdpCommandTaskStep::Pending(_)),
"shared worker HeapProfiler.collectGarbage should dispatch to the worker V8 HeapProfiler agent"
);
let (messages, scheduler_events) = complete_command_task_step_for_test(&mut ctx, step).await;
assert!(
scheduler_events.is_empty(),
"shared worker HeapProfiler.collectGarbage should not enqueue scheduler work: {scheduler_events:?}"
);
ctx.sent.extend(messages);
wait_until_message(
&mut ctx,
Some(shared_worker_session_id.as_str()),
"shared worker HeapProfiler.collectGarbage response",
|message| message["id"] == json!(90_068),
)
.await;
let response = take_response_by_id(&mut ctx, 90_068);
assert_eq!(
response["result"],
json!({}),
"shared worker HeapProfiler.collectGarbage should return V8 HeapProfiler agent success: {response:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_heap_profiler_sampling_dispatches_through_v8_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_069,
"heap-profiler-sampling",
r#"
globalThis.__heapProbe = [];
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_and_wait_for_response_async(json!({
"id": 90_070,
"method": "HeapProfiler.startSampling",
"sessionId": shared_worker_session_id,
"params": { "samplingInterval": 1024, "stackDepth": 32 }
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_070)["result"], json!({}));
ctx.process_and_wait_for_response_async(json!({
"id": 90_071,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "for (let i = 0; i < 200; i++) globalThis.__heapProbe.push({i, value: 'worker-heap-' + i}); 'done'"
}
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 90_071)["result"]["result"]["value"],
json!("done")
);
ctx.process_and_wait_for_response_async(json!({
"id": 90_072,
"method": "HeapProfiler.getSamplingProfile",
"sessionId": shared_worker_session_id
}))
.await;
let profile = take_response_by_id(&mut ctx, 90_072);
assert!(
profile["result"]["profile"]["head"]["callFrame"]["functionName"].is_string(),
"shared worker HeapProfiler.getSamplingProfile should return V8 sampling profile shape: {profile:?}"
);
ctx.process_and_wait_for_response_async(json!({
"id": 90_073,
"method": "HeapProfiler.stopSampling",
"sessionId": shared_worker_session_id
}))
.await;
let stopped = take_response_by_id(&mut ctx, 90_073);
assert!(
stopped["result"]["profile"]["head"]["callFrame"]["functionName"].is_string(),
"shared worker HeapProfiler.stopSampling should return V8 sampling profile shape: {stopped:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_get_isolate_id_dispatches_through_v8_runtime_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_070,
"runtime-get-isolate-id",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_071,
"method": "Runtime.getIsolateId",
"sessionId": shared_worker_session_id
}))
.await;
let response = take_response_by_id(&mut ctx, 90_071);
let isolate_id = response["result"]["id"]
.as_str()
.expect("Runtime.getIsolateId should return result.id");
assert!(
!isolate_id.is_empty() && isolate_id.chars().all(|ch| ch.is_ascii_hexdigit()),
"shared worker Runtime.getIsolateId should return V8 isolate id as hex: {response:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_get_exception_details_dispatches_through_v8_runtime_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_075,
"runtime-get-exception-details",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_077,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_response = take_response_by_id(&mut ctx, 90_077);
assert_eq!(enable_response["result"], json!({}));
ctx.process_async(json!({
"id": 90_078,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "new Error('moli worker exception details')"
}
}))
.await;
let evaluated = take_response_by_id(&mut ctx, 90_078);
let error_object_id = evaluated["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.evaluate should return an Error object handle: {evaluated:?}"
)
})
.to_owned();
ctx.process_async(json!({
"id": 90_079,
"method": "Runtime.getExceptionDetails",
"sessionId": shared_worker_session_id,
"params": {
"errorObjectId": error_object_id
}
}))
.await;
let response = take_response_by_id(&mut ctx, 90_079);
let details_text = response["result"]["exceptionDetails"]["text"]
.as_str()
.expect("Runtime.getExceptionDetails should return result.exceptionDetails.text");
assert!(
details_text.contains("moli worker exception details"),
"shared worker Runtime.getExceptionDetails should return V8 exception details for the Error object: {response:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_set_async_call_stack_depth_dispatches_through_v8_runtime_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
91_100,
"runtime-set-async-call-stack-depth",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 91_102,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_response = take_response_by_id(&mut ctx, 91_102);
assert_eq!(enable_response["result"], json!({}));
ctx.process_async(json!({
"id": 91_103,
"method": "Runtime.setAsyncCallStackDepth",
"sessionId": shared_worker_session_id,
"params": {
"maxDepth": 8
}
}))
.await;
let response = take_response_by_id(&mut ctx, 91_103);
assert_eq!(response["sessionId"], json!(shared_worker_session_id));
assert_eq!(
response["result"],
json!({}),
"shared worker Runtime.setAsyncCallStackDepth should return V8 inspector success: {response:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_global_lexical_scope_names_dispatches_through_v8_runtime_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_080,
"runtime-global-lexical-scope-names",
r#"
let __lmWorkerLexicalLet = 1;
const __lmWorkerLexicalConst = 2;
class __LmWorkerLexicalClass {}
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_081,
"method": "Runtime.globalLexicalScopeNames",
"sessionId": shared_worker_session_id
}))
.await;
let response = take_response_by_id(&mut ctx, 90_081);
let names = response["result"]["names"]
.as_array()
.expect("Runtime.globalLexicalScopeNames should return result.names");
for expected in [
"__lmWorkerLexicalLet",
"__lmWorkerLexicalConst",
"__LmWorkerLexicalClass",
] {
assert!(
names.iter().any(|name| name.as_str() == Some(expected)),
"shared worker Runtime.globalLexicalScopeNames should include {expected}: {response:?}"
);
}
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_query_objects_dispatches_through_v8_runtime_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_090,
"runtime-query-objects",
r#"
class __LmWorkerQueryObjectsThing {
constructor(value) {
this.value = value;
}
}
globalThis.__lmWorkerQueryObjectsThings = [
new __LmWorkerQueryObjectsThing(1),
new __LmWorkerQueryObjectsThing(2),
];
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_091,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "__LmWorkerQueryObjectsThing.prototype",
"objectGroup": "worker-query-prototype"
}
}))
.await;
let prototype_response = take_response_by_id(&mut ctx, 90_091);
let prototype_object_id = prototype_response["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.evaluate should return a prototype handle: {prototype_response:?}"
)
})
.to_owned();
ctx.process_async(json!({
"id": 90_092,
"method": "Runtime.queryObjects",
"sessionId": shared_worker_session_id,
"params": {
"prototypeObjectId": prototype_object_id,
"objectGroup": "worker-query-results"
}
}))
.await;
let query_response = take_response_by_id(&mut ctx, 90_092);
let objects_id = query_response["result"]["objects"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.queryObjects should return an array handle: {query_response:?}"
)
})
.to_owned();
let worker_target = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist");
assert!(
worker_target.has_runtime_remote_object_id(&shared_worker_session_id, &objects_id),
"shared worker Runtime.queryObjects result handle should be target-local: {query_response:?}"
);
assert_eq!(
worker_target.runtime_remote_object_group(&shared_worker_session_id, &objects_id),
Some("worker-query-results"),
"shared worker Runtime.queryObjects should register its result in the explicit objectGroup"
);
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
std::slice::from_ref(&objects_id)
)
.is_err(),
"active page owner should see shared worker queryObjects result as another target's handle"
);
ctx.process_async(json!({
"id": 90_093,
"method": "Runtime.releaseObjectGroup",
"sessionId": shared_worker_session_id,
"params": {
"objectGroup": "worker-query-results"
}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_093)["result"], json!({}));
let worker_target = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist");
assert!(
!worker_target.has_runtime_remote_object_id(&shared_worker_session_id, &objects_id),
"shared worker Runtime.releaseObjectGroup should clear queryObjects result handle"
);
assert_eq!(
worker_target.runtime_remote_object_group(&shared_worker_session_id, &objects_id),
None,
"shared worker Runtime.releaseObjectGroup should clear queryObjects result group"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_compile_and_run_script_dispatch_through_v8_runtime_agent() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_100,
"runtime-compile-run-script",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_101,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_101)["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_102,
"method": "Runtime.compileScript",
"sessionId": shared_worker_session_id,
"params": {
"expression": "({ workerCompiled: 42 })",
"sourceURL": "moli://runtime-compile-script/shared-worker.js",
"persistScript": true
}
}))
.await;
let compile_response = take_response_by_id(&mut ctx, 90_102);
let script_id = compile_response["result"]["scriptId"]
.as_str()
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.compileScript should return a V8 scriptId: {compile_response:?}"
)
})
.to_owned();
ctx.process_async(json!({
"id": 90_103,
"method": "Runtime.runScript",
"sessionId": shared_worker_session_id,
"params": {
"scriptId": script_id,
"objectGroup": "worker-compiled-script-results"
}
}))
.await;
let run_response = take_response_by_id(&mut ctx, 90_103);
let object_id = run_response["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.runScript should return an object handle: {run_response:?}"
)
})
.to_owned();
let worker_target = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist");
assert!(
worker_target.has_runtime_remote_object_id(&shared_worker_session_id, &object_id),
"shared worker Runtime.runScript result handle should be target-local: {run_response:?}"
);
assert_eq!(
worker_target.runtime_remote_object_group(&shared_worker_session_id, &object_id),
Some("worker-compiled-script-results"),
"shared worker Runtime.runScript should register its result in the explicit objectGroup"
);
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
std::slice::from_ref(&object_id)
)
.is_err(),
"active page owner should see shared worker runScript result as another target's handle"
);
ctx.process_async(json!({
"id": 90_104,
"method": "Runtime.releaseObjectGroup",
"sessionId": shared_worker_session_id,
"params": {
"objectGroup": "worker-compiled-script-results"
}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_104)["result"], json!({}));
let worker_target = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist");
assert!(
!worker_target.has_runtime_remote_object_id(&shared_worker_session_id, &object_id),
"shared worker Runtime.releaseObjectGroup should clear runScript result handle"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_runtime_enable_replays_persisted_bindings_for_new_context() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_100,
"binding-replay",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.conn
.shared_worker_target_for_session_mut(Some(&shared_worker_session_id))
.expect("shared worker target should exist")
.upsert_runtime_binding_definition(
&shared_worker_session_id,
"replayedSharedWorkerBinding".to_owned(),
None,
);
ctx.process_async(json!({
"id": 90_110,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_response = take_response_by_id(&mut ctx, 90_110);
assert_eq!(enable_response["result"], json!({}));
let _ = ctx.take_first_matching("shared worker execution context", |message| {
message["method"] == json!("Runtime.executionContextCreated")
&& message["sessionId"] == json!(shared_worker_session_id)
});
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_111,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.replayedSharedWorkerBinding('after-replay'); typeof globalThis.replayedSharedWorkerBinding",
"returnByValue": true
}
}))
.await;
let evaluation = take_response_by_id(&mut ctx, 90_111);
assert_eq!(evaluation["result"]["result"]["value"], json!("function"));
let binding_called =
ctx.take_first_matching("replayed shared worker bindingCalled", |message| {
message["method"] == json!("Runtime.bindingCalled")
&& message["sessionId"] == json!(shared_worker_session_id)
&& message["params"]["name"] == json!("replayedSharedWorkerBinding")
});
assert_eq!(binding_called["params"]["payload"], json!("after-replay"));
assert!(
ctx.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist")
.runtime_bindings_requiring_replay(&shared_worker_session_id)
.is_empty(),
"successful replay should clear the target replay-pending marker"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_runtime_remote_objects_are_target_local_and_release_clears_registry() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_200,
"remote-object-owner",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_210,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_210)["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_211,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "({ owner: 'shared-worker' })"
}
}))
.await;
let response = take_response_by_id(&mut ctx, 90_211);
let object_id = response["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!("shared worker Runtime.evaluate should return an object handle: {response:?}")
})
.to_owned();
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
std::slice::from_ref(&object_id),
)
.is_err(),
"active page owner should see the shared worker handle as belonging to another target"
);
ctx.process_async(json!({
"id": 90_212,
"method": "Runtime.releaseObject",
"params": {
"objectId": object_id
}
}))
.await;
let active_release = take_response_by_id(&mut ctx, 90_212);
assert_eq!(active_release["error"]["code"], json!(-32000));
assert_eq!(
active_release["error"]["message"],
json!("Cannot find object with given id")
);
ctx.process_async(json!({
"id": 90_213,
"method": "Runtime.releaseObject",
"sessionId": shared_worker_session_id,
"params": {
"objectId": object_id
}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_213)["result"], json!({}));
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(None, &[object_id])
.is_ok(),
"successful shared worker release should remove the handle from target-local ownership"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_runtime_remote_objects_do_not_cross_peer_worker_targets() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let first_session_id = start_attached_shared_worker_session(
&mut ctx,
90_240,
"remote-object-peer-a",
r#"
onconnect = event => {
event.ports[0].postMessage("ready-a");
};
"#,
)
.await;
let second_session_id = start_attached_shared_worker_session(
&mut ctx,
90_260,
"remote-object-peer-b",
r#"
onconnect = event => {
event.ports[0].postMessage("ready-b");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_270,
"method": "Runtime.evaluate",
"sessionId": first_session_id,
"params": {
"expression": "({ owner: 'first-shared-worker' })"
}
}))
.await;
let response = take_response_by_id(&mut ctx, 90_270);
let object_id = response["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!(
"first shared worker Runtime.evaluate should return an object handle: {response:?}"
)
})
.to_owned();
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
Some(&second_session_id),
std::slice::from_ref(&object_id),
)
.is_err(),
"peer shared worker target should see the first worker handle as belonging to another target"
);
ctx.process_async(json!({
"id": 90_271,
"method": "Runtime.releaseObject",
"sessionId": second_session_id,
"params": {
"objectId": object_id
}
}))
.await;
let peer_release = take_response_by_id(&mut ctx, 90_271);
assert_eq!(peer_release["error"]["code"], json!(-32000));
assert_eq!(
peer_release["error"]["message"],
json!("Cannot find object with given id")
);
ctx.process_async(json!({
"id": 90_272,
"method": "Runtime.releaseObject",
"sessionId": first_session_id,
"params": {
"objectId": object_id
}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_272)["result"], json!({}));
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
Some(&second_session_id),
&[object_id],
)
.is_ok(),
"successful release by the owning worker should clear the handle from target-local ownership"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_profiler_state_is_isolated_per_attached_session() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let first_session_id = start_attached_shared_worker_session(
&mut ctx,
92_000,
"profiler-session-isolation",
r#"
globalThis.__sharedWorkerProfilerWork = () => {
let value = 0;
for (let i = 0; i < 200000; i += 1)
value += Math.sqrt(i);
return value > 0;
};
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
let target_id = ctx
.conn
.shared_worker_target_for_session(Some(&first_session_id))
.expect("shared worker target should exist")
.target_id
.clone();
ctx.sent.clear();
ctx.process_async(json!({
"id": 92_010,
"method": "Target.attachToTarget",
"params": {"targetId": target_id}
}))
.await;
let second_session_id = take_response_by_id(&mut ctx, 92_010)["result"]["sessionId"]
.as_str()
.expect("second shared worker session id")
.to_owned();
assert_ne!(second_session_id, first_session_id);
let attached = ctx.take_first_matching("second shared worker attached session", |message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["targetInfo"]["targetId"] == json!(target_id)
&& message["params"]["sessionId"] == json!(second_session_id)
});
assert_eq!(attached["params"]["targetInfo"]["attached"], json!(true));
ctx.sent.clear();
for (command_id, session_id) in [(92_011, &first_session_id), (92_012, &second_session_id)] {
ctx.process_async(json!({
"id": command_id,
"method": "Profiler.enable",
"sessionId": session_id
}))
.await;
let response = take_response_by_id(&mut ctx, command_id);
assert_eq!(response["sessionId"], json!(session_id));
assert_eq!(response["result"], json!({}));
}
ctx.process_async(json!({
"id": 92_023,
"method": "Profiler.startPreciseCoverage",
"sessionId": first_session_id,
"params": {"callCount": true, "detailed": true}
}))
.await;
assert!(
take_response_by_id(&mut ctx, 92_023)["result"]["timestamp"].is_number(),
"first shared worker session should start precise coverage"
);
ctx.process_async(json!({
"id": 92_024,
"method": "Profiler.takePreciseCoverage",
"sessionId": second_session_id
}))
.await;
let second_coverage = take_response_by_id(&mut ctx, 92_024);
assert_eq!(second_coverage["sessionId"], json!(second_session_id));
assert_eq!(second_coverage["error"]["code"], json!(-32000));
assert!(
second_coverage["error"]["message"]
.as_str()
.is_some_and(|message| message.contains("Precise coverage has not been started")),
"second shared worker session must not read peer precise coverage: {second_coverage:?}"
);
ctx.process_async(json!({
"id": 92_013,
"method": "Profiler.start",
"sessionId": first_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 92_013)["result"], json!({}));
ctx.process_async(json!({
"id": 92_022,
"method": "Profiler.start",
"sessionId": second_session_id
}))
.await;
let second_start = take_response_by_id(&mut ctx, 92_022);
assert_eq!(second_start["sessionId"], json!(second_session_id));
assert_eq!(
second_start["result"],
json!({}),
"renderer-side shared worker inspector sessions should own independent Profiler agents: {second_start:?}"
);
ctx.process_async(json!({
"id": 92_014,
"method": "Profiler.stop",
"sessionId": second_session_id
}))
.await;
let second_stop = take_response_by_id(&mut ctx, 92_014);
assert_eq!(second_stop["sessionId"], json!(second_session_id));
assert!(
second_stop["result"]["profile"]["nodes"]
.as_array()
.is_some_and(|nodes| !nodes.is_empty()),
"second shared worker session should stop its own profile without touching the first session: {second_stop:?}"
);
ctx.process_async(json!({
"id": 92_021,
"method": "Profiler.disable",
"sessionId": second_session_id
}))
.await;
let second_disable = take_response_by_id(&mut ctx, 92_021);
assert_eq!(second_disable["sessionId"], json!(second_session_id));
assert_eq!(
second_disable["result"],
json!({}),
"disabling a peer shared worker profiler session must not disable the active session: {second_disable:?}"
);
ctx.process_async(json!({
"id": 92_015,
"method": "Target.detachFromTarget",
"params": {"sessionId": second_session_id}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 92_015)["result"], json!({}));
assert!(
ctx.conn
.shared_worker_target_for_session(Some(&first_session_id))
.is_some(),
"detaching the second shared worker session must not detach the first session"
);
ctx.process_async(json!({
"id": 92_016,
"method": "Runtime.evaluate",
"sessionId": first_session_id,
"params": {
"expression": "globalThis.__sharedWorkerProfilerWork()",
"returnByValue": true
}
}))
.await;
let work = take_response_by_id(&mut ctx, 92_016);
assert_eq!(work["result"]["result"]["value"], json!(true));
ctx.process_async(json!({
"id": 92_017,
"method": "Profiler.stop",
"sessionId": first_session_id
}))
.await;
let first_stop = take_response_by_id(&mut ctx, 92_017);
assert_eq!(first_stop["sessionId"], json!(first_session_id));
assert!(
first_stop["result"]["profile"]["nodes"]
.as_array()
.is_some_and(|nodes| !nodes.is_empty()),
"first shared worker session should still return a CPU profile after peer stop/detach: {first_stop:?}"
);
ctx.process_async(json!({
"id": 92_018,
"method": "Target.detachFromTarget",
"params": {"sessionId": first_session_id}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 92_018)["result"], json!({}));
ctx.process_async(json!({
"id": 92_019,
"method": "Target.attachToTarget",
"params": {"targetId": target_id}
}))
.await;
let replacement_session_id = take_response_by_id(&mut ctx, 92_019)["result"]["sessionId"]
.as_str()
.expect("replacement shared worker session id")
.to_owned();
assert_ne!(replacement_session_id, first_session_id);
ctx.process_async(json!({
"id": 92_020,
"method": "Profiler.start",
"sessionId": replacement_session_id
}))
.await;
let replacement_start = take_response_by_id(&mut ctx, 92_020);
assert_eq!(
replacement_start["sessionId"],
json!(replacement_session_id)
);
assert_eq!(replacement_start["error"]["code"], json!(-32000));
assert!(
replacement_start["error"]["message"]
.as_str()
.is_some_and(|message| message.contains("Profiler is not enabled")),
"newly attached shared worker session must not inherit detached Profiler.enable state: {replacement_start:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_console_profile_events_fan_out_to_attached_profiler_sessions() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let first_session_id = start_attached_shared_worker_session(
&mut ctx,
92_100,
"console-profile-fanout",
r#"
globalThis.__sharedWorkerConsoleProfileWork = () => {
let value = 0;
for (let i = 0; i < 200000; i += 1)
value += Math.sqrt(i + 1);
return value > 0;
};
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
let target_id = ctx
.conn
.shared_worker_target_for_session(Some(&first_session_id))
.expect("shared worker target should exist")
.target_id
.clone();
ctx.sent.clear();
ctx.process_async(json!({
"id": 92_110,
"method": "Target.attachToTarget",
"params": {"targetId": target_id}
}))
.await;
let second_session_id = take_response_by_id(&mut ctx, 92_110)["result"]["sessionId"]
.as_str()
.expect("second shared worker session id")
.to_owned();
assert_ne!(second_session_id, first_session_id);
ctx.sent.clear();
for (command_id, session_id) in [(92_111, &first_session_id), (92_112, &second_session_id)] {
ctx.process_async(json!({
"id": command_id,
"method": "Profiler.enable",
"sessionId": session_id
}))
.await;
let response = take_response_by_id(&mut ctx, command_id);
assert_eq!(response["sessionId"], json!(session_id));
assert_eq!(response["result"], json!({}));
}
ctx.sent.clear();
ctx.process_async(json!({
"id": 92_113,
"method": "Runtime.evaluate",
"sessionId": first_session_id,
"params": {
"expression": r#"
(() => {
console.profile("shared-worker-console-profile");
const result = globalThis.__sharedWorkerConsoleProfileWork();
console.profileEnd("shared-worker-console-profile");
return result;
})()
"#,
"returnByValue": true
}
}))
.await;
let evaluation = take_response_by_id(&mut ctx, 92_113);
assert_eq!(evaluation["sessionId"], json!(first_session_id));
assert_eq!(
evaluation["result"]["result"]["value"],
json!(true),
"shared worker console profile evaluation should complete successfully: {evaluation:?}"
);
wait_until_messages(
&mut ctx,
None,
"shared worker console profile events for both attached sessions",
|messages| {
[
(&first_session_id, "Profiler.consoleProfileStarted"),
(&first_session_id, "Profiler.consoleProfileFinished"),
(&second_session_id, "Profiler.consoleProfileStarted"),
(&second_session_id, "Profiler.consoleProfileFinished"),
]
.into_iter()
.all(|(session_id, method)| {
messages.iter().any(|message| {
message["sessionId"] == json!(session_id) && message["method"] == json!(method)
})
})
},
)
.await;
for session_id in [&first_session_id, &second_session_id] {
let started = ctx.take_first_matching(
"shared worker Profiler.consoleProfileStarted event",
|message| {
message["sessionId"] == json!(session_id)
&& message["method"] == json!("Profiler.consoleProfileStarted")
},
);
assert_eq!(
started["params"]["title"],
json!("shared-worker-console-profile")
);
assert!(
started["params"]["id"].is_string(),
"consoleProfileStarted should include a V8 profile id: {started:?}"
);
let finished = ctx.take_first_matching(
"shared worker Profiler.consoleProfileFinished event",
|message| {
message["sessionId"] == json!(session_id)
&& message["method"] == json!("Profiler.consoleProfileFinished")
},
);
assert_eq!(
finished["params"]["title"],
json!("shared-worker-console-profile")
);
assert_eq!(
finished["params"]["id"], started["params"]["id"],
"console profile finished id should match started id for the same attached session"
);
assert!(
finished["params"]["profile"]["nodes"]
.as_array()
.is_some_and(|nodes| !nodes.is_empty()),
"consoleProfileFinished should include a CPU profile: {finished:?}"
);
}
for (command_id, session_id) in [(92_114, &first_session_id), (92_115, &second_session_id)] {
ctx.process_async(json!({
"id": command_id,
"method": "Profiler.stop",
"sessionId": session_id
}))
.await;
let stop = take_response_by_id(&mut ctx, command_id);
assert_eq!(stop["sessionId"], json!(session_id));
assert_eq!(stop["error"]["code"], json!(-32000));
assert!(
stop["error"]["message"]
.as_str()
.is_some_and(|message| message.contains("No recording profiles found")),
"console.profile must not create a frontend Profiler.start recording: {stop:?}"
);
}
}
#[tokio::test(flavor = "multi_thread")]
async fn target_close_target_terminates_shared_worker_and_cleans_target_state() {
let mut ctx = TestContext::new();
ctx.conn.set_target_discovery_for_owner(
None,
crate::conn::CdpTargetFilter::default_target_discovery(),
);
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_280,
"target-close-cleanup",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_290,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_290)["result"], json!({}));
ctx.process_async(json!({
"id": 90_291,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "new Promise(resolve => setTimeout(() => resolve('too-late'), 1000))",
"awaitPromise": true,
"returnByValue": true
}
}))
.await;
assert!(
!ctx.sent
.iter()
.any(|message| message["id"] == json!(90_291)),
"timer-backed shared worker awaitPromise should still be pending before Target.closeTarget"
);
let target_id = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should be attached before target close")
.target_id
.clone();
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_292,
"method": "Target.closeTarget",
"params": { "targetId": target_id }
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 90_292)["result"],
json!({ "success": true })
);
let failed_await = take_response_by_id(&mut ctx, 90_291);
assert_eq!(failed_await["sessionId"], json!(shared_worker_session_id));
assert_eq!(failed_await["error"]["code"], json!(-32000));
assert_eq!(failed_await["error"]["message"], json!("Target closed"));
let detached =
ctx.take_first_matching("shared worker target detach after closeTarget", |message| {
message["method"] == json!("Target.detachedFromTarget")
&& message["params"]["targetId"] == json!(target_id)
&& message["params"]["sessionId"] == json!(shared_worker_session_id)
});
assert_eq!(detached["params"]["targetId"], json!(target_id));
let destroyed = ctx.take_first_matching(
"shared worker target destroy after closeTarget",
|message| {
message["method"] == json!("Target.targetDestroyed")
&& message["params"]["targetId"] == json!(target_id)
},
);
assert_eq!(destroyed["params"]["targetId"], json!(target_id));
assert_eq!(
ctx.conn.session_route(Some(&shared_worker_session_id)),
None
);
assert!(
ctx.conn
.browser_context
.as_ref()
.and_then(|context| context.shared_worker_target(&target_id))
.is_none(),
"Target.closeTarget should remove the shared worker CDP target state"
);
assert!(
!ctx.conn.has_pending_inspector_awaits(),
"Target.closeTarget should drain shared worker pending awaits"
);
ctx.process_async(json!({
"id": 90_293,
"method": "Runtime.evaluate",
"params": {
"expression": "document.body instanceof HTMLBodyElement",
"returnByValue": true
}
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 90_293)["result"]["result"]["value"],
json!(true),
"closing a SharedWorker target must not disturb the active page target"
);
ctx.process_async(json!({
"id": 90_294,
"method": "HeapProfiler.moliDiagnostics"
}))
.await;
let diagnostics = take_response_by_id(&mut ctx, 90_294);
let isolate_scope = &diagnostics["result"]["isolateScope"];
assert_eq!(isolate_scope["sharedWorkerTargetCount"], json!(0));
assert_eq!(isolate_scope["sharedWorkerRunningInstanceCount"], json!(0));
assert_eq!(
isolate_scope["sharedWorkerRunningWorkerIsolateCount"],
json!(0)
);
assert_eq!(isolate_scope["sharedWorkerClientCount"], json!(0));
ctx.process_async(json!({
"id": 90_295,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "self.name",
"returnByValue": true
}
}))
.await;
let stale_session = take_response_by_id(&mut ctx, 90_295);
assert_eq!(stale_session["error"]["code"], json!(-32001));
assert_eq!(
stale_session["error"]["message"],
json!("Unknown sessionId")
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_runtime_object_groups_inherit_and_clear_on_detach() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_300,
"remote-object-group-owner",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_310,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_310)["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_311,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "({ child: { answer: 42 } })",
"objectGroup": "shared-worker-group"
}
}))
.await;
let response = take_response_by_id(&mut ctx, 90_311);
let parent_object_id = response["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!("shared worker Runtime.evaluate should return an object handle: {response:?}")
})
.to_owned();
ctx.process_async(json!({
"id": 90_312,
"method": "Runtime.getProperties",
"sessionId": shared_worker_session_id,
"params": {
"objectId": parent_object_id,
"ownProperties": true
}
}))
.await;
let properties = take_response_by_id(&mut ctx, 90_312);
let child_object_id = properties["result"]["result"]
.as_array()
.and_then(|properties| {
properties
.iter()
.find(|property| property["name"] == json!("child"))
})
.and_then(|property| property["value"]["objectId"].as_str())
.unwrap_or_else(|| {
panic!(
"shared worker Runtime.getProperties should return a child handle: {properties:?}"
)
})
.to_owned();
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
&[parent_object_id.clone(), child_object_id.clone()],
)
.is_err(),
"active page owner should see grouped shared worker handles as another target's handles"
);
ctx.process_async(json!({
"id": 90_313,
"method": "Target.detachFromTarget",
"params": {
"sessionId": shared_worker_session_id
}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_313)["result"], json!({}));
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
&[parent_object_id, child_object_id],
)
.is_ok(),
"shared worker target detach should clear target-local remote object ownership"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_pending_await_fails_on_target_detach() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_400,
"pending-await-detach",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_410,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_410)["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_411,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "new Promise(resolve => setTimeout(() => resolve('too-late'), 250))",
"awaitPromise": true,
"returnByValue": true
}
}))
.await;
assert!(
!ctx.sent
.iter()
.any(|message| message["id"] == json!(90_411)),
"timer-backed shared worker awaitPromise should still be pending before detach"
);
assert!(
ctx.conn
.has_pending_inspector_awaits_for_session_owner(Some(&shared_worker_session_id)),
"shared worker awaitPromise should register against the shared worker target"
);
ctx.process_async(json!({
"id": 90_412,
"method": "Target.detachFromTarget",
"params": {
"sessionId": shared_worker_session_id
}
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_412)["result"], json!({}));
let failed_await = take_response_by_id(&mut ctx, 90_411);
assert_eq!(failed_await["sessionId"], shared_worker_session_id);
assert_eq!(failed_await["error"]["code"], json!(-32000));
assert_eq!(failed_await["error"]["message"], json!("Target detached"));
assert!(
!ctx.conn.has_pending_inspector_awaits(),
"detaching the shared worker target should drain the pending await registry"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn real_shared_worker_close_cleans_runtime_state_before_destroy_events() {
let mut ctx = TestContext::new();
ctx.conn.set_target_discovery_for_owner(
None,
crate::conn::CdpTargetFilter::default_target_discovery(),
);
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let worker_source = r#"
globalThis.__closeProbe = { child: { answer: 42 } };
onconnect = event => {
const port = event.ports[0];
port.onmessage = event => {
if (event.data === "close") {
close();
}
};
port.start();
port.postMessage("ready");
};
"#;
let shared_worker_session_id =
start_attached_shared_worker_session(&mut ctx, 90_500, "real-close-cleanup", worker_source)
.await;
ctx.process_async(json!({
"id": 90_510,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_510)["result"], json!({}));
ctx.process_async(json!({
"id": 90_511,
"method": "Runtime.addBinding",
"sessionId": shared_worker_session_id,
"params": { "name": "closedWorkerBinding" }
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_511)["result"], json!({}));
ctx.process_async(json!({
"id": 90_512,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.__closeProbe",
"objectGroup": "real-close-cleanup-group"
}
}))
.await;
let close_probe_object_id =
take_response_by_id(&mut ctx, 90_512)["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| panic!("shared worker close probe should return an object handle"))
.to_owned();
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
std::slice::from_ref(&close_probe_object_id),
)
.is_err(),
"active page owner should see the shared worker handle as another target's handle"
);
ctx.process_async(json!({
"id": 90_513,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "new Promise(resolve => setTimeout(() => resolve('too-late'), 1000))",
"awaitPromise": true,
"returnByValue": true
}
}))
.await;
assert!(
!ctx.sent
.iter()
.any(|message| message["id"] == json!(90_513)),
"timer-backed shared worker awaitPromise should still be pending before worker close"
);
assert!(
ctx.conn
.has_pending_inspector_awaits_for_session_owner(Some(&shared_worker_session_id)),
"shared worker awaitPromise should register against the shared worker target"
);
let closing_target_id = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should still be attached before close")
.target_id
.clone();
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_514,
"method": "Runtime.evaluate",
"params": {
"expression": "globalThis.__sharedWorkerRuntimeBindingProbe.port.postMessage('close'); 'closing'",
"returnByValue": true
}
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 90_514)["result"]["result"]["value"],
json!("closing")
);
wait_until_messages(
&mut ctx,
None,
"real shared worker close target teardown",
|messages| {
messages
.iter()
.any(|message| message["id"] == json!(90_513))
&& messages
.iter()
.any(|message| message["method"] == json!("Target.detachedFromTarget"))
&& messages
.iter()
.any(|message| message["method"] == json!("Target.targetDestroyed"))
},
)
.await;
let teardown_messages = ctx.take_all();
let failed_await_index = teardown_messages
.iter()
.position(|message| message["id"] == json!(90_513))
.expect("pending await should fail when the real shared worker closes");
let detached_index = teardown_messages
.iter()
.position(|message| {
message["method"] == json!("Target.detachedFromTarget")
&& message["params"]["targetId"] == json!(closing_target_id)
&& message["params"]["sessionId"] == json!(shared_worker_session_id)
})
.unwrap_or_else(|| {
panic!("real shared worker close should detach target: {teardown_messages:?}")
});
let destroyed_index = teardown_messages
.iter()
.position(|message| {
message["method"] == json!("Target.targetDestroyed")
&& message["params"]["targetId"] == json!(closing_target_id)
})
.unwrap_or_else(|| {
panic!("real shared worker close should destroy target: {teardown_messages:?}")
});
let failed_await = &teardown_messages[failed_await_index];
assert_eq!(failed_await["sessionId"], json!(shared_worker_session_id));
assert_eq!(failed_await["error"]["code"], json!(-32000));
assert_eq!(failed_await["error"]["message"], json!("Target closed"));
assert!(
failed_await_index < detached_index && detached_index < destroyed_index,
"real worker close must fail pending awaits before detached/destroyed events: {teardown_messages:?}"
);
assert_eq!(
ctx.conn.session_route(Some(&shared_worker_session_id)),
None
);
assert!(
!ctx.conn.has_pending_inspector_awaits(),
"destroying the shared worker target should drain pending awaits"
);
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
std::slice::from_ref(&close_probe_object_id),
)
.is_ok(),
"destroying the shared worker target should remove target-local remote object ownership"
);
assert!(
ctx.conn
.browser_context
.as_ref()
.and_then(|context| context.shared_worker_target(&closing_target_id))
.is_none(),
"real shared worker close should remove the destroyed target state"
);
let replacement_session_id =
start_attached_shared_worker_session(&mut ctx, 90_520, "real-close-cleanup", worker_source)
.await;
assert_ne!(
replacement_session_id, shared_worker_session_id,
"fresh shared worker instance should get a fresh target session after close"
);
ctx.process_async(json!({
"id": 90_530,
"method": "Runtime.enable",
"sessionId": replacement_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_530)["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_531,
"method": "Runtime.evaluate",
"sessionId": replacement_session_id,
"params": {
"expression": "typeof globalThis.closedWorkerBinding",
"returnByValue": true
}
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 90_531)["result"]["result"]["value"],
json!("undefined"),
"target-local Runtime.addBinding state from the destroyed shared worker must not replay into a fresh target"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn page_navigation_teardown_terminates_shared_worker_and_cleans_target_state() {
let mut ctx = TestContext::new();
ctx.conn.set_target_discovery_for_owner(
None,
crate::conn::CdpTargetFilter::default_target_discovery(),
);
with_loaded_document_for_active_target_async(
&mut ctx,
"<!doctype html><body>before</body>",
"SID-page",
"TID-page",
)
.await;
let worker_source = r#"
globalThis.__teardownProbe = { child: { answer: 42 } };
onconnect = event => {
const port = event.ports[0];
port.start();
port.postMessage("ready");
};
"#;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_600,
"navigation-teardown-cleanup",
worker_source,
)
.await;
ctx.process_async(json!({
"id": 90_610,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_610)["result"], json!({}));
ctx.process_async(json!({
"id": 90_611,
"method": "Runtime.addBinding",
"sessionId": shared_worker_session_id,
"params": { "name": "navigationTeardownBinding" }
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_611)["result"], json!({}));
ctx.process_async(json!({
"id": 90_612,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.__teardownProbe",
"objectGroup": "navigation-teardown-cleanup-group"
}
}))
.await;
let teardown_probe_response = take_response_by_id(&mut ctx, 90_612);
let teardown_probe_object_id = teardown_probe_response["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!(
"shared worker navigation teardown probe should return an object handle: {teardown_probe_response:?}"
)
})
.to_owned();
ctx.process_async(json!({
"id": 90_613,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "new Promise(resolve => setTimeout(() => resolve('too-late'), 1000))",
"awaitPromise": true,
"returnByValue": true
}
}))
.await;
assert!(
!ctx.sent
.iter()
.any(|message| message["id"] == json!(90_613)),
"timer-backed shared worker awaitPromise should still be pending before page navigation"
);
assert!(
ctx.conn
.has_pending_inspector_awaits_for_session_owner(Some(&shared_worker_session_id)),
"shared worker awaitPromise should register against the shared worker target"
);
let terminating_target_id = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should be attached before navigation teardown")
.target_id
.clone();
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_614,
"method": "Page.navigate",
"sessionId": "SID-page",
"params": { "url": "data:text/html,<body>after</body>" }
}))
.await;
let navigation = take_response_by_id(&mut ctx, 90_614);
assert_eq!(navigation["result"]["frameId"], json!("TID-page"));
wait_until_messages(
&mut ctx,
None,
"shared worker client removal target teardown",
|messages| {
messages
.iter()
.any(|message| message["id"] == json!(90_613))
&& messages
.iter()
.any(|message| message["method"] == json!("Target.detachedFromTarget"))
&& messages
.iter()
.any(|message| message["method"] == json!("Target.targetDestroyed"))
},
)
.await;
let teardown_messages = ctx.take_all();
let failed_await_index = teardown_messages
.iter()
.position(|message| message["id"] == json!(90_613))
.expect("pending await should fail when the last SharedWorker client is removed");
let detached_index = teardown_messages
.iter()
.position(|message| {
message["method"] == json!("Target.detachedFromTarget")
&& message["params"]["targetId"] == json!(terminating_target_id)
&& message["params"]["sessionId"] == json!(shared_worker_session_id)
})
.unwrap_or_else(|| {
panic!("client removal should detach the shared worker target: {teardown_messages:?}")
});
let destroyed_index = teardown_messages
.iter()
.position(|message| {
message["method"] == json!("Target.targetDestroyed")
&& message["params"]["targetId"] == json!(terminating_target_id)
})
.unwrap_or_else(|| {
panic!("client removal should destroy the shared worker target: {teardown_messages:?}")
});
let failed_await = &teardown_messages[failed_await_index];
assert_eq!(failed_await["sessionId"], json!(shared_worker_session_id));
assert_eq!(failed_await["error"]["code"], json!(-32000));
assert_eq!(failed_await["error"]["message"], json!("Target closed"));
assert!(
failed_await_index < detached_index && detached_index < destroyed_index,
"client removal must fail pending awaits before detached/destroyed events: {teardown_messages:?}"
);
assert_eq!(
ctx.conn.session_route(Some(&shared_worker_session_id)),
None
);
assert!(
!ctx.conn.has_pending_inspector_awaits(),
"client removal should drain shared worker pending awaits"
);
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
std::slice::from_ref(&teardown_probe_object_id),
)
.is_ok(),
"destroying the shared worker target should remove target-local remote object ownership"
);
assert!(
ctx.conn
.browser_context
.as_ref()
.and_then(|context| context.shared_worker_target(&terminating_target_id))
.is_none(),
"client removal should remove the destroyed shared worker target state"
);
let replacement_session_id = start_attached_shared_worker_session(
&mut ctx,
90_620,
"navigation-teardown-cleanup",
worker_source,
)
.await;
assert_ne!(
replacement_session_id, shared_worker_session_id,
"new page context should get a fresh shared worker target session after teardown"
);
ctx.process_async(json!({
"id": 90_630,
"method": "Runtime.enable",
"sessionId": replacement_session_id
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 90_630)["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_631,
"method": "Runtime.evaluate",
"sessionId": replacement_session_id,
"params": {
"expression": "typeof globalThis.navigationTeardownBinding",
"returnByValue": true
}
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 90_631)["result"]["result"]["value"],
json!("undefined"),
"target-local binding state from the terminated shared worker must not replay into a fresh target"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_target_runtime_survives_owner_page_navigation_with_peer_client() {
async fn page() -> impl IntoResponse {
(
[(CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><body>shared worker peer page</body>",
)
}
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
axum::serve(listener, Router::new().route("/page", get(page)))
.await
.unwrap();
});
let active_url = format!("http://{addr}/page?active");
let peer_url = format!("http://{addr}/page?peer");
let replacement_url = format!("http://{addr}/page?replacement");
let mut ctx = TestContext::new();
with_loaded_http_document_async(&mut ctx, &active_url, "SID-page", "TID-page").await;
let worker_source = r#"
let connectionCount = 0;
globalThis.__runtimeOwnerProbe = "worker:" + name + ":" + (
typeof SharedWorkerGlobalScope !== "undefined" &&
self instanceof SharedWorkerGlobalScope
);
onconnect = event => {
connectionCount += 1;
const port = event.ports[0];
port.onmessage = event => {
if (event.data === "count") {
port.postMessage("count:" + connectionCount);
}
};
port.start();
port.postMessage("ready:" + connectionCount);
};
"#;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_700,
"survive-owner-navigation",
worker_source,
)
.await;
let shared_worker_target_id = ctx
.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.expect("shared worker target should exist after first client")
.target_id
.clone();
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_710,
"method": "Target.createTarget",
"params": {"browserContextId": "BID-1", "url": "about:blank#peer"}
}))
.await;
let created = ctx.take_first_matching("peer targetCreated", |message| {
message["method"] == json!("Target.targetCreated")
});
let peer_target_id = created["params"]["targetInfo"]["targetId"]
.as_str()
.expect("peer target id")
.to_owned();
let attached = ctx.take_first_matching("peer attachedToTarget", |message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["targetInfo"]["targetId"].as_str() == Some(peer_target_id.as_str())
});
let peer_session_id = attached["params"]["sessionId"]
.as_str()
.expect("peer target session id")
.to_owned();
ctx.expect_result(90_710, json!({ "targetId": peer_target_id }), None);
ctx.process_async(json!({
"id": 90_711,
"method": "Page.navigate",
"sessionId": peer_session_id,
"params": {"url": peer_url}
}))
.await;
let peer_navigation = take_response_by_id(&mut ctx, 90_711);
assert_eq!(peer_navigation["result"]["frameId"], json!(peer_target_id));
ctx.take_all();
let source_literal =
serde_json::to_string(worker_source).expect("worker source should serialize");
ctx.process_async(json!({
"id": 90_712,
"method": "Runtime.evaluate",
"sessionId": peer_session_id,
"params": {
"expression": format!(
r#"
(() => {{
const source = {source_literal};
const url = "data:text/javascript," + encodeURIComponent(source);
const worker = new SharedWorker(url, "survive-owner-navigation");
globalThis.__sharedWorkerPeerProbe = worker;
globalThis.__sharedWorkerPeerMessages = [];
worker.port.onmessage = event => {{
globalThis.__sharedWorkerPeerMessages.push(String(event.data));
}};
worker.port.start();
return "peer-started";
}})()
"#
),
"returnByValue": true
}
}))
.await;
let peer_start = take_response_by_id(&mut ctx, 90_712);
assert_eq!(
peer_start["result"]["result"]["value"],
json!("peer-started")
);
wait_until_runtime_expression_true(
&mut ctx,
Some(&peer_session_id),
90_713,
"globalThis.__sharedWorkerPeerMessages.includes('ready:2')",
"peer SharedWorker client to connect",
)
.await;
assert_eq!(
ctx.conn
.browser_context
.as_ref()
.expect("browser context should exist")
.renderer_runtime()
.shared_worker_running_worker_isolate_count_for_diagnostics(),
1,
"same-origin pages with the same SharedWorker key should share one running worker isolate"
);
ctx.sent.clear();
ctx.process_async(json!({
"id": 90_714,
"method": "Page.navigate",
"sessionId": "SID-page",
"params": {"url": replacement_url}
}))
.await;
let active_navigation = take_response_by_id(&mut ctx, 90_714);
assert_eq!(active_navigation["result"]["frameId"], json!("TID-page"));
let navigation_messages = ctx.take_all();
assert!(
navigation_messages.iter().all(|message| {
let is_shared_worker_teardown = (message["method"]
== json!("Target.detachedFromTarget")
|| message["method"] == json!("Target.targetDestroyed"))
&& message["params"]["targetId"] == json!(shared_worker_target_id);
!is_shared_worker_teardown
}),
"owner page navigation must not detach/destroy a SharedWorker target with a peer client: {navigation_messages:?}"
);
assert!(
ctx.conn
.shared_worker_target_for_session(Some(&shared_worker_session_id))
.is_some(),
"attached SharedWorker target state must survive owner page navigation while a peer client remains"
);
ctx.process_async(json!({
"id": 90_715,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "globalThis.__runtimeOwnerProbe",
"returnByValue": true
}
}))
.await;
let worker_probe = take_response_by_id(&mut ctx, 90_715);
assert_eq!(
worker_probe["result"]["result"]["value"],
json!("worker:survive-owner-navigation:true"),
"Runtime.evaluate on the attached SharedWorker target must still enter the worker global after owner page navigation"
);
ctx.process_async(json!({
"id": 90_716,
"method": "Runtime.evaluate",
"sessionId": peer_session_id,
"params": {
"expression": "globalThis.__sharedWorkerPeerProbe.port.postMessage('count'); 'posted'",
"returnByValue": true
}
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 90_716)["result"]["result"]["value"],
json!("posted")
);
wait_until_runtime_expression_true(
&mut ctx,
Some(&peer_session_id),
90_800,
"globalThis.__sharedWorkerPeerMessages.includes('count:2')",
"owner page navigation to remove only the owner page client endpoint",
)
.await;
server.abort();
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_await_promise_timer_reply_arrives_through_renderer_receiver() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
ctx.process_async(json!({
"id": 80,
"method": "Target.setAutoAttach",
"params": {
"autoAttach": true,
"waitForDebuggerOnStart": false
}
}))
.await;
ctx.expect_result(80, json!({}), None);
ctx.process_async(json!({
"id": 81,
"method": "Runtime.evaluate",
"params": {
"expression": r#"
(() => {
const source = `
globalThis.__workerProbe = "deferred:" + name;
globalThis.__pendingProbeResolve = null;
onconnect = event => {
const port = event.ports[0];
port.onmessage = event => {
if (event.data === "release" && globalThis.__pendingProbeResolve) {
const resolve = globalThis.__pendingProbeResolve;
globalThis.__pendingProbeResolve = null;
resolve("late:" + globalThis.__workerProbe);
}
};
port.postMessage("ready");
};
`;
const url = "data:text/javascript," + encodeURIComponent(source);
const worker = new SharedWorker(url, "deferred-runtime-probe");
globalThis.__sharedWorkerDeferredRuntimeProbe = worker;
worker.port.start();
return "started";
})()
"#,
"returnByValue": true
}
}))
.await;
let start_response = take_response_by_id(&mut ctx, 81);
assert_eq!(
start_response["result"]["result"]["value"],
json!("started")
);
wait_until_message(
&mut ctx,
None,
"shared worker target auto-attach",
|message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["targetInfo"]["type"] == json!("shared_worker")
&& message["params"]["targetInfo"]["title"] == json!("deferred-runtime-probe")
},
)
.await;
let attached = ctx.take_first_matching("shared worker target auto-attach", |message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["targetInfo"]["type"] == json!("shared_worker")
&& message["params"]["targetInfo"]["title"] == json!("deferred-runtime-probe")
});
let shared_worker_session_id = attached["params"]["sessionId"]
.as_str()
.expect("shared worker session id")
.to_owned();
ctx.process_async(json!({
"id": 82,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_response = take_response_by_id(&mut ctx, 82);
assert_eq!(enable_response["sessionId"], shared_worker_session_id);
ctx.sent.clear();
ctx.process_async(json!({
"id": 83,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "new Promise(resolve => { globalThis.__pendingProbeResolve = resolve; })",
"awaitPromise": true,
"returnByValue": true
}
}))
.await;
assert!(
!ctx.sent.iter().any(|message| message["id"] == json!(83)),
"timer-backed shared worker awaitPromise should defer until the worker timer settles: {:?}",
ctx.sent
);
assert!(
ctx.conn
.has_pending_inspector_awaits_for_session_owner(Some(&shared_worker_session_id)),
"shared worker awaitPromise should register against the shared worker target"
);
ctx.process_async(json!({
"id": 84,
"method": "Runtime.evaluate",
"params": {
"expression": "globalThis.__sharedWorkerDeferredRuntimeProbe.port.postMessage('release'); 'released'",
"returnByValue": true
}
}))
.await;
assert_eq!(
take_response_by_id(&mut ctx, 84)["result"]["result"]["value"],
json!("released")
);
wait_until_message(
&mut ctx,
None,
"shared worker deferred awaitPromise",
|message| message["id"] == json!(83),
)
.await;
let response = take_response_by_id(&mut ctx, 83);
assert_eq!(response["sessionId"], shared_worker_session_id);
assert_eq!(
response["result"]["result"]["value"],
json!("late:deferred:deferred-runtime-probe")
);
assert!(
!ctx.conn
.has_pending_inspector_awaits_for_session_owner(Some(&shared_worker_session_id)),
"settled shared worker awaitPromise should clear the target pending-await entry"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_await_promise_releases_dispatch_before_session_response() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
91_100,
"deferred-receiver",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
let raw = json!({
"id": 91_102,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "new Promise(() => {})",
"awaitPromise": true,
"returnByValue": true
}
})
.to_string();
let pending = ctx
.conn
.try_start_pending_command_dispatch(&raw)
.expect("shared worker Runtime.evaluate awaitPromise should start as a pending command");
let completed = tokio::time::timeout(std::time::Duration::from_secs(1), pending.wait())
.await
.expect("initial Worker Inspector dispatch must not wait for Promise settlement");
let CdpCommandTaskStep::Complete(outcome) =
ctx.conn.complete_pending_command_dispatch(completed).await
else {
panic!("a Worker session response must not enter the AdapterReply deferred-reply lane");
};
assert!(
outcome.into_parts().0.is_empty(),
"the unresolved terminal response must remain in the Worker session output journal"
);
assert!(
ctx.conn
.has_pending_inspector_awaits_for_session_owner(Some(&shared_worker_session_id)),
"the unresolved await must remain registered to its exact Worker session"
);
ctx.process_async(json!({
"id": 91_103,
"method": "Target.detachFromTarget",
"params": { "sessionId": shared_worker_session_id }
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 91_103)["result"], json!({}));
let failed_await = take_response_by_id(&mut ctx, 91_102);
assert_eq!(failed_await["error"]["message"], json!("Target detached"));
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_release_object_group_is_target_local() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
90_900,
"release-object-group",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.process_async(json!({
"id": 90_910,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "({ owner: 'shared-worker-group' })",
"objectGroup": "shared-worker-group"
}
}))
.await;
let response = take_response_by_id(&mut ctx, 90_910);
let object_id = response["result"]["result"]["objectId"]
.as_str()
.unwrap_or_else(|| {
panic!("shared worker Runtime.evaluate should return an object handle: {response:?}")
})
.to_owned();
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(
None,
std::slice::from_ref(&object_id),
)
.is_err(),
"active page owner should see the grouped shared worker handle as another target's handle"
);
ctx.process_async(json!({
"id": 90_911,
"method": "Runtime.releaseObjectGroup",
"sessionId": shared_worker_session_id,
"params": {
"objectGroup": "shared-worker-group"
}
}))
.await;
let release = take_response_by_id(&mut ctx, 90_911);
assert_eq!(release["sessionId"], json!(shared_worker_session_id));
assert_eq!(release["result"], json!({}));
assert!(
ctx.conn
.validate_runtime_remote_object_ids_for_session_owner(None, &[object_id])
.is_ok(),
"successful shared worker releaseObjectGroup should remove grouped handles from the target-local registry"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_discard_console_entries_clears_v8_console_storage() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let shared_worker_session_id = start_attached_shared_worker_session(
&mut ctx,
91_020,
"runtime-discard-native-console",
r#"
onconnect = event => {
event.ports[0].postMessage("ready");
};
"#,
)
.await;
ctx.sent.clear();
ctx.process_async(json!({
"id": 91_021,
"method": "Runtime.evaluate",
"sessionId": shared_worker_session_id,
"params": {
"expression": "console.warn('worker native boot warning'); 'logged'",
"returnByValue": true
}
}))
.await;
let log_response = take_response_by_id(&mut ctx, 91_021);
assert_eq!(log_response["sessionId"], json!(shared_worker_session_id));
assert_eq!(log_response["result"]["result"]["value"], json!("logged"));
ctx.sent.clear();
ctx.process_async(json!({
"id": 91_022,
"method": "Runtime.discardConsoleEntries",
"sessionId": shared_worker_session_id
}))
.await;
let discard = take_response_by_id(&mut ctx, 91_022);
assert_eq!(discard["sessionId"], json!(shared_worker_session_id));
assert_eq!(discard["result"], json!({}));
ctx.sent.clear();
ctx.process_async(json!({
"id": 91_023,
"method": "Runtime.enable",
"sessionId": shared_worker_session_id
}))
.await;
let enable_messages = ctx.take_all();
assert!(
enable_messages.iter().any(|message| {
message["id"] == json!(91_023)
&& message["sessionId"] == json!(shared_worker_session_id)
&& message["result"] == json!({})
}),
"Runtime.enable should complete on the shared worker session: {enable_messages:?}"
);
assert!(
enable_messages.iter().any(|message| {
message["method"] == json!("Runtime.executionContextCreated")
&& message["sessionId"] == json!(shared_worker_session_id)
}),
"Runtime.enable should still replay the shared worker execution context: {enable_messages:?}"
);
assert!(
enable_messages.iter().all(|message| {
message["method"] != json!("Runtime.consoleAPICalled")
|| message["sessionId"] != json!(shared_worker_session_id)
|| message["params"]["args"].as_array().is_none_or(|args| {
!args
.iter()
.any(|arg| arg["value"] == json!("worker native boot warning"))
})
}),
"Runtime.discardConsoleEntries should clear V8 buffered console storage before Runtime.enable replay: {enable_messages:?}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_discard_console_entries_is_target_local() {
let mut ctx = TestContext::new();
load_shared_worker_target(&mut ctx, "SID-shared-worker");
{
let browser_context = ctx
.conn
.browser_context
.as_mut()
.expect("browser context should exist");
browser_context.set_active_target_id("TID-page");
browser_context.attach_active_session("SID-page");
}
record_shared_worker_console(&mut ctx, "SID-shared-worker", "warn: worker boot warning");
ctx.process_async(json!({
"id": 91_010,
"method": "Runtime.discardConsoleEntries",
"sessionId": "SID-shared-worker"
}))
.await;
let discard = take_response_by_id(&mut ctx, 91_010);
assert_eq!(discard["sessionId"], json!("SID-shared-worker"));
assert_eq!(discard["result"], json!({}));
ctx.process_async(json!({
"id": 91_011,
"method": "Runtime.enable",
"sessionId": "SID-shared-worker"
}))
.await;
assert_eq!(take_response_by_id(&mut ctx, 91_011)["result"], json!({}));
assert!(
ctx.sent.iter().all(|message| {
message["method"] != json!("Runtime.consoleAPICalled")
|| message["sessionId"] != json!("SID-shared-worker")
}),
"Runtime.discardConsoleEntries should suppress buffered shared worker Runtime console replay: {:?}",
ctx.sent
);
assert_eq!(
ctx.conn.session_route(Some("SID-page")),
Some(crate::conn::CdpSessionRoute::PageTarget {
browser_context_id: "BID-shared".to_owned(),
target_id: "TID-page".to_owned(),
session_key: moli_page_types::DevToolsSessionKey::Primary,
}),
"shared worker Runtime.discardConsoleEntries must not consume or rewrite the page session route"
);
assert!(
ctx.sent.iter().all(|message| {
message["method"] != json!("Runtime.consoleAPICalled")
|| message.get("sessionId").is_some()
}),
"shared worker Runtime console output must not replay on the active page session: {:?}",
ctx.sent
);
}
#[tokio::test(flavor = "multi_thread")]
async fn worker_navigator_query_overrides_are_independent_of_the_page() {
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
ctx.process_and_wait_for_response_async(json!({"id":99000,"method":"Emulation.setHardwareConcurrencyOverride","params":{"hardwareConcurrency":2}})).await;
ctx.expect_result(99000, json!({}), None);
ctx.process_and_wait_for_response_async(json!({"id":99015,"method":"Emulation.setDataSaverOverride","params":{"dataSaverEnabled":true}})).await;
ctx.expect_result(99015, json!({}), None);
let worker = start_attached_shared_worker_session(
&mut ctx,
99001,
"native-hardware",
"onconnect = () => {};",
)
.await;
ctx.process_and_wait_for_response_async(json!({"id":99019,"sessionId":worker,"method":"Emulation.setAutomationOverride","params":{"enabled":true}})).await;
ctx.expect_result(99019, json!({}), Some(&worker));
ctx.process_and_wait_for_response_async(json!({"id":99020,"sessionId":worker,"method":"Runtime.evaluate","params":{"expression":"'webdriver' in navigator","returnByValue":true}})).await;
assert_eq!(
take_response_by_id(&mut ctx, 99020)["result"]["result"]["value"],
json!(false)
);
for (params, worker_expected) in [
(json!({}), false),
(json!({"dataSaverEnabled":true}), true),
(json!({"dataSaverEnabled":false}), false),
] {
ctx.process_and_wait_for_response_async(json!({"id":99016,"sessionId":worker,"method":"Emulation.setDataSaverOverride","params":params})).await;
ctx.expect_result(99016, json!({}), Some(&worker));
for (id, session, expected) in [
(99017, None, true),
(99018, Some(worker.as_str()), worker_expected),
] {
let mut request = json!({"id":id,"method":"Runtime.evaluate","params":{"expression":"globalThis.heldConnection ??= navigator.connection; [heldConnection.saveData, heldConnection === navigator.connection]","returnByValue":true}});
if let Some(session) = session {
request["sessionId"] = json!(session);
}
ctx.process_and_wait_for_response_async(request).await;
assert_eq!(
take_response_by_id(&mut ctx, id)["result"]["result"]["value"],
json!([expected, true])
);
}
}
for (id, session, expected) in [(99010, None, 2), (99011, Some(worker.as_str()), 4)] {
let mut request = json!({"id":id,"method":"Runtime.evaluate","params":{"expression":"navigator.hardwareConcurrency","returnByValue":true}});
if let Some(session) = session {
request["sessionId"] = json!(session);
}
ctx.process_and_wait_for_response_async(request).await;
assert_eq!(
take_response_by_id(&mut ctx, id)["result"]["result"]["value"],
json!(expected)
);
}
for (value, valid) in [(3, true), (0, false)] {
ctx.process_and_wait_for_response_async(json!({"id":99012,"sessionId":worker,"method":"Emulation.setHardwareConcurrencyOverride","params":{"hardwareConcurrency":value}})).await;
let reply = take_response_by_id(&mut ctx, 99012);
if valid {
assert_eq!(reply["result"], json!({}), "{reply}");
} else {
assert_eq!(reply["error"]["code"], -32602, "{reply}");
}
for (id, session, expected) in [(99013, None, 2), (99014, Some(worker.as_str()), 3)] {
let mut request = json!({"id":id,"method":"Runtime.evaluate","params":{"expression":"navigator.hardwareConcurrency","returnByValue":true}});
if let Some(session) = session {
request["sessionId"] = json!(session);
}
ctx.process_and_wait_for_response_async(request).await;
assert_eq!(
take_response_by_id(&mut ctx, id)["result"]["result"]["value"],
json!(expected)
);
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn shared_worker_emulation_activation_tracks_user_agent_commands() {
async fn snapshot(ctx: &mut TestContext, session_id: Option<&str>) -> serde_json::Value {
let mut request = json!({
"id": 99190, "method": "Runtime.evaluate",
"params": {
"expression": "globalThis.heldNavigator ??= navigator; globalThis.heldConnection ??= navigator.connection; [heldNavigator.hardwareConcurrency, heldConnection.saveData, heldNavigator.userAgent]",
"returnByValue": true
}
});
if let Some(session_id) = session_id {
request["sessionId"] = json!(session_id);
}
ctx.process_and_wait_for_response_async(request).await;
take_response_by_id(ctx, 99190)["result"]["result"]["value"].clone()
}
let mut ctx = TestContext::new();
with_loaded_document_async(&mut ctx, "<!doctype html><body></body>").await;
let page_baseline = snapshot(&mut ctx, None).await;
let first = start_attached_shared_worker_session(
&mut ctx,
99100,
"emulation-activation-order",
"onconnect = () => {};",
)
.await;
let baseline = snapshot(&mut ctx, Some(&first)).await;
let target_id = ctx
.conn
.shared_worker_target_for_session(Some(&first))
.unwrap()
.target_id
.clone();
ctx.process_async(json!({
"id": 99102, "method": "Target.attachToTarget",
"params": {"targetId": target_id, "flatten": true}
}))
.await;
let second = take_response_by_id(&mut ctx, 99102)["result"]["sessionId"]
.as_str()
.unwrap()
.to_owned();
// Invalid UA commands must not reserve a place in the Worker agent order.
// Both CDP spellings validate before publishing any state.
for method in [
"Emulation.setUserAgentOverride",
"Network.setUserAgentOverride",
] {
ctx.process_and_wait_for_response_async(json!({
"id": 99103, "sessionId": first, "method": method,
"params": {"userAgent": "invalid\nagent"}
}))
.await;
ctx.expect_error(99103, -32602, "Invalid characters found in userAgent");
assert_eq!(snapshot(&mut ctx, Some(&first)).await, baseline);
assert_eq!(snapshot(&mut ctx, None).await, page_baseline);
}
ctx.process_and_wait_for_response_async(json!({
"id": 99104, "sessionId": first, "method": "Emulation.setHardwareConcurrencyOverride",
"params": {"hardwareConcurrency": 0}
}))
.await;
ctx.expect_error(
99104,
-32602,
"HardwareConcurrency must be a positive int32",
);
// UA alone activates the second agent before the first sets concurrency.
// Clearing UA must preserve that position for subsequent query overrides.
ctx.process_and_wait_for_response_async(json!({
"id": 99109, "sessionId": second, "method": "Emulation.setUserAgentOverride",
"params": {"userAgent": "worker-emulation-order"}
}))
.await;
ctx.expect_result(99109, json!({}), Some(&second));
ctx.process_and_wait_for_response_async(json!({
"id": 99110, "sessionId": first, "method": "Emulation.setHardwareConcurrencyOverride",
"params": {"hardwareConcurrency": 2}
}))
.await;
ctx.expect_result(99110, json!({}), Some(&first));
ctx.process_and_wait_for_response_async(json!({
"id": 99111, "sessionId": second, "method": "Network.setUserAgentOverride",
"params": {"userAgent": ""}
}))
.await;
ctx.expect_result(99111, json!({}), Some(&second));
for (session, method, params, expected) in [
(
&second,
"Emulation.setDataSaverOverride",
json!({"dataSaverEnabled": true}),
json!([2, true]),
),
(
&first,
"Emulation.setHardwareConcurrencyOverride",
json!({"hardwareConcurrency": 2}),
json!([2, true]),
),
(
&second,
"Emulation.setHardwareConcurrencyOverride",
json!({"hardwareConcurrency": 8}),
json!([2, true]),
),
(
&first,
"Emulation.setDataSaverOverride",
json!({"dataSaverEnabled": false}),
json!([2, false]),
),
(
&second,
"Emulation.setDataSaverOverride",
json!({"dataSaverEnabled": true}),
json!([2, false]),
),
(
&first,
"Emulation.setDataSaverOverride",
json!({}),
json!([2, true]),
),
(
&second,
"Emulation.setHardwareConcurrencyOverride",
json!({"hardwareConcurrency": 6}),
json!([2, true]),
),
(
&first,
"Emulation.setHardwareConcurrencyOverride",
json!({"hardwareConcurrency": 3}),
json!([3, true]),
),
] {
ctx.process_and_wait_for_response_async(json!({
"id": 99105, "sessionId": session, "method": method, "params": params
}))
.await;
ctx.expect_result(99105, json!({}), Some(session));
assert_eq!(
snapshot(&mut ctx, Some(session)).await,
json!([expected[0], expected[1], baseline[2]])
);
}
ctx.process_async(json!({
"id": 99106, "method": "Target.detachFromTarget", "params": {"sessionId": first}
}))
.await;
ctx.expect_result(99106, json!({}), None);
assert_eq!(
snapshot(&mut ctx, Some(&second)).await,
json!([6, true, baseline[2]])
);
ctx.process_async(json!({
"id": 99107, "method": "Target.detachFromTarget", "params": {"sessionId": second}
}))
.await;
ctx.expect_result(99107, json!({}), None);
ctx.process_async(json!({
"id": 99108, "method": "Target.attachToTarget",
"params": {"targetId": target_id, "flatten": true}
}))
.await;
let observer = take_response_by_id(&mut ctx, 99108)["result"]["sessionId"]
.as_str()
.unwrap()
.to_owned();
assert_eq!(snapshot(&mut ctx, Some(&observer)).await, baseline);
assert_eq!(snapshot(&mut ctx, None).await, page_baseline);
}