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::*;
#[tokio::test]
async fn websocket_bidi_existing_classic_session_preload_channel_mutation_observer_emits_message() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let session_id = classic_new_session_on_server(cdp_addr).await;
let mut socket = connect_classic_session_bidi_socket(cdp_addr, &session_id).await;
let tree = send_bidi_command(&mut socket, 1, "browsingContext.getTree", json!({})).await;
assert_eq!(tree["type"], json!("success"));
let context_id = tree["result"]["contexts"][0]["context"]
.as_str()
.expect("attached Classic context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
2,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let preload_script = send_bidi_add_preload_script(
&mut socket,
3,
"(channel) => {
const onMutation = (mutationList) => mutationList.forEach((mutation) => {
const attributeName = mutation.attributeName;
const newValue = mutation.target.getAttribute(mutation.attributeName);
channel({ attributeName, newValue });
});
const observer = new MutationObserver(onMutation);
observer.observe(document, { attributes: true, subtree: true });
}",
vec![json!({
"type": "channel",
"value": {
"channel": "classic_attached_channel"
}
})],
)
.await;
let page_url =
classic_data_url_for_bidi_test("<!doctype html><div class='old class name'>foo</div>");
let navigated = classic_request_on_server_with_body(
cdp_addr,
"POST",
&format!("/session/{session_id}/url"),
json!({ "url": page_url }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
socket
.send(WsMessage::Text(
json!({
"id": 4_u64,
"method": "script.evaluate",
"params": {
"expression": "document.querySelector('div').setAttribute('class', 'mutated')",
"target": {
"context": context_id.clone()
},
"awaitPromise": true
}
})
.to_string()
.into(),
))
.await
.expect("send attached Classic mutation script.evaluate");
let messages = recv_until_id(&mut socket, 4).await;
let messages =
collect_bidi_messages_until_method_count(&mut socket, messages, "script.message", 1).await;
let evaluate = bidi_message_by_id(&messages, 4);
assert_eq!(evaluate["type"], json!("success"), "{messages:#?}");
let realm = evaluate["result"]["realm"]
.as_str()
.expect("attached mutation evaluate realm");
let event = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("attached mutation observer script.message event");
assert_eq!(
event["params"],
json!({
"channel": "classic_attached_channel",
"data": {
"type": "object",
"value": [
["attributeName", {"type": "string", "value": "class"}],
["newValue", {"type": "string", "value": "mutated"}]
]
},
"source": {
"realm": realm,
"context": context_id
}
})
);
remove_bidi_preload_script(&mut socket, 5, &preload_script).await;
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_script_message_channel_matches_wpt_shape() {
// Mirrors webdriver/tests/bidi/script/call_function/channel.py::test_channel
// for the default channel ownership/serialization case.
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
socket
.send(WsMessage::Text(
json!({
"id": 4_u64,
"method": "script.callFunction",
"params": {
"functionDeclaration": "(channel) => channel({'foo': 'bar', 'baz': {'1': 2}})",
"arguments": [{
"type": "channel",
"value": {
"channel": "channel_name"
}
}],
"awaitPromise": false,
"target": {
"context": context_id.clone()
}
}
})
.to_string()
.into(),
))
.await
.expect("send channel script.callFunction");
let mut messages = recv_until_id(&mut socket, 4).await;
if !messages
.iter()
.any(|message| message["method"] == json!("script.message"))
{
messages.push(
timeout(Duration::from_secs(1), recv_ws_json(&mut socket))
.await
.expect("script.message should arrive after callFunction response"),
);
}
let call_function = messages
.iter()
.find(|message| message["id"] == json!(4_u64))
.unwrap_or_else(|| panic!("expected callFunction response: {messages:#?}"));
assert_eq!(call_function["type"], json!("success"));
assert_eq!(call_function["result"]["type"], json!("success"));
let realm_id = call_function["result"]["realm"]
.as_str()
.expect("callFunction response realm");
let script_message = messages
.iter()
.find(|message| message["method"] == json!("script.message"))
.unwrap_or_else(|| panic!("expected script.message event: {messages:#?}"));
assert_eq!(
script_message["params"],
json!({
"channel": "channel_name",
"data": {
"type": "object",
"value": [
["foo", {"type": "string", "value": "bar"}],
[
"baz",
{
"type": "object",
"value": [["1", {"type": "number", "value": 2}]]
}
]
]
},
"source": {
"realm": realm_id,
"context": context_id
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_script_message_channel_observes_payload_mutation_before_serialization() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
4,
&context_id,
"(channel) => {
const payload = { foo: 'before', nested: { value: 1 }, list: ['a'] };
channel(payload);
payload.foo = 'after';
payload.nested.value = 2;
payload.list.push('b');
}",
vec![json!({
"type": "channel",
"value": {
"channel": "mutation_channel"
}
})],
1,
)
.await;
let response = bidi_message_by_id(&messages, 4);
assert_eq!(response["type"], json!("success"));
let realm = response["result"]["realm"]
.as_str()
.expect("callFunction response realm");
let event = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("script.message event");
assert_eq!(
event["params"],
json!({
"channel": "mutation_channel",
"data": {
"type": "object",
"value": [
["foo", {"type": "string", "value": "after"}],
[
"nested",
{
"type": "object",
"value": [["value", {"type": "number", "value": 2}]]
}
],
[
"list",
{
"type": "array",
"value": [
{"type": "string", "value": "a"},
{"type": "string", "value": "b"}
]
}
]
]
},
"source": {
"realm": realm,
"context": context_id
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_script_message_channel_ignores_spoofed_to_string_tag() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
4,
&context_id,
"(channel) => {
const payload = { foo: 'bar' };
Object.defineProperty(payload, Symbol.toStringTag, { value: 'Map' });
channel(payload);
return 'sent';
}",
vec![json!({
"type": "channel",
"value": {
"channel": "tag_spoof_channel"
}
})],
1,
)
.await;
let response = bidi_message_by_id(&messages, 4);
assert_eq!(response["type"], json!("success"));
assert_eq!(
response["result"]["result"],
json!({"type": "string", "value": "sent"})
);
let realm = response["result"]["realm"]
.as_str()
.expect("callFunction response realm");
let event = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("script.message event");
assert_eq!(
event["params"],
json!({
"channel": "tag_spoof_channel",
"data": {
"type": "object",
"value": [
["foo", {"type": "string", "value": "bar"}]
]
},
"source": {
"realm": realm,
"context": context_id
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_script_message_channel_variants_match_wpt_shape() {
// Mirrors the remaining Chromium/WPT
// webdriver/tests/bidi/script/call_function/channel.py channel cases.
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let shallow_messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
4,
&context_id,
"(channel) => channel({'foo': 'bar', 'baz': {'1': 2}})",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name",
"serializationOptions": {
"maxObjectDepth": 0
}
}
})],
1,
)
.await;
let shallow_response = bidi_message_by_id(&shallow_messages, 4);
let shallow_realm = shallow_response["result"]["realm"]
.as_str()
.expect("shallow callFunction response realm");
let shallow_event = bidi_events_by_method(&shallow_messages, "script.message")
.pop()
.expect("shallow script.message event");
assert_eq!(
shallow_event["params"],
json!({
"channel": "channel_name",
"data": {
"type": "object"
},
"source": {
"realm": shallow_realm,
"context": context_id
}
}),
"channel serializationOptions should apply to script.message data"
);
let root_messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
5,
&context_id,
"(channel) => channel({'foo': 'bar', 'baz': {'1': 2}})",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name",
"ownership": "root"
}
})],
1,
)
.await;
let root_response = bidi_message_by_id(&root_messages, 5);
let root_realm = root_response["result"]["realm"]
.as_str()
.expect("root callFunction response realm");
let root_event = bidi_events_by_method(&root_messages, "script.message")
.pop()
.expect("root script.message event");
assert!(
root_event["params"]["data"]["handle"]
.as_str()
.is_some_and(|handle| !handle.is_empty()),
"root channel data should include a handle: {root_event:?}"
);
assert_eq!(
root_event["params"]["data"]["type"],
json!("object"),
"root channel data should keep object type"
);
assert_eq!(
root_event["params"]["data"]["value"],
json!([
["foo", {"type": "string", "value": "bar"}],
[
"baz",
{
"type": "object",
"value": [["1", {"type": "number", "value": 2}]]
}
]
]),
"root channel data should still include the serialized object value"
);
assert_eq!(
root_event["params"]["source"],
json!({
"realm": root_realm,
"context": context_id
})
);
let multiple_arg_messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
6,
&context_id,
"(channel) => channel('will_be_send', 'will_be_ignored')",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name"
}
})],
1,
)
.await;
let multiple_arg_response = bidi_message_by_id(&multiple_arg_messages, 6);
let multiple_arg_realm = multiple_arg_response["result"]["realm"]
.as_str()
.expect("multiple-argument callFunction response realm");
let multiple_arg_event = bidi_events_by_method(&multiple_arg_messages, "script.message")
.pop()
.expect("multiple-argument script.message event");
assert_eq!(
multiple_arg_event["params"],
json!({
"channel": "channel_name",
"data": {"type": "string", "value": "will_be_send"},
"source": {
"realm": multiple_arg_realm,
"context": context_id
}
})
);
let two_channel_messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
7,
&context_id,
"(channel_1, channel_2) => { channel_1('message_from_channel_1'); channel_2('message_from_channel_2'); }",
vec![
json!({
"type": "channel",
"value": {
"channel": "channel_name_1"
}
}),
json!({
"type": "channel",
"value": {
"channel": "channel_name_2"
}
}),
],
2,
)
.await;
let two_channel_response = bidi_message_by_id(&two_channel_messages, 7);
let two_channel_realm = two_channel_response["result"]["realm"]
.as_str()
.expect("two-channel callFunction response realm");
let two_channel_events = bidi_events_by_method(&two_channel_messages, "script.message");
assert_eq!(two_channel_events.len(), 2);
assert_eq!(
two_channel_events[0]["params"],
json!({
"channel": "channel_name_1",
"data": {"type": "string", "value": "message_from_channel_1"},
"source": {
"realm": two_channel_realm,
"context": context_id
}
})
);
assert_eq!(
two_channel_events[1]["params"],
json!({
"channel": "channel_name_2",
"data": {"type": "string", "value": "message_from_channel_2"},
"source": {
"realm": two_channel_realm,
"context": context_id
}
})
);
let mixed_arg_messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
8,
&context_id,
"(string, channel) => channel(string)",
vec![
json!({"type": "string", "value": "foo"}),
json!({
"type": "channel",
"value": {
"channel": "channel_name"
}
}),
],
1,
)
.await;
let mixed_arg_response = bidi_message_by_id(&mixed_arg_messages, 8);
let mixed_arg_realm = mixed_arg_response["result"]["realm"]
.as_str()
.expect("mixed-argument callFunction response realm");
let mixed_arg_event = bidi_events_by_method(&mixed_arg_messages, "script.message")
.pop()
.expect("mixed-argument script.message event");
assert_eq!(
mixed_arg_event["params"],
json!({
"channel": "channel_name",
"data": {"type": "string", "value": "foo"},
"source": {
"realm": mixed_arg_realm,
"context": context_id
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_script_message_unsubscribe_stops_events() {
// Mirrors webdriver/tests/bidi/script/message/message.py::test_unsubscribe.
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let unsubscribe = send_bidi_command(
&mut socket,
4,
"session.unsubscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(unsubscribe["type"], json!("success"));
let messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
5,
&context_id,
"(channel) => channel('foo')",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name"
}
})],
0,
)
.await;
assert_eq!(bidi_message_by_id(&messages, 5)["type"], json!("success"));
assert!(
bidi_events_by_method(&messages, "script.message").is_empty(),
"script.message should not be emitted after unsubscribe: {messages:#?}"
);
let no_late_event = timeout(Duration::from_millis(300), recv_ws_json(&mut socket)).await;
match no_late_event {
Err(_) => {}
Ok(message) => panic!("unexpected script.message after unsubscribe: {message:#?}"),
}
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_script_message_subscription_filters_context() {
// Mirrors webdriver/tests/bidi/script/message/message.py::test_subscribe_to_one_context.
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let first = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(first["type"], json!("success"));
let first_context = first["result"]["context"]
.as_str()
.expect("first context id")
.to_owned();
let second = send_bidi_command(
&mut socket,
3,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(second["type"], json!("success"));
let second_context = second["result"]["context"]
.as_str()
.expect("second context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
4,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [first_context.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let second_messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
5,
&second_context,
"(channel) => channel('foo')",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name"
}
})],
0,
)
.await;
assert_eq!(
bidi_message_by_id(&second_messages, 5)["type"],
json!("success")
);
assert!(
bidi_events_by_method(&second_messages, "script.message").is_empty(),
"script.message should be filtered for unsubscribed context: {second_messages:#?}"
);
let no_second_context_event =
timeout(Duration::from_millis(300), recv_ws_json(&mut socket)).await;
match no_second_context_event {
Err(_) => {}
Ok(message) => panic!("unexpected script.message for unsubscribed context: {message:#?}"),
}
let first_messages = send_bidi_script_call_function_and_collect_messages(
&mut socket,
6,
&first_context,
"(channel) => channel('foo')",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name"
}
})],
1,
)
.await;
let first_response = bidi_message_by_id(&first_messages, 6);
assert_eq!(first_response["type"], json!("success"));
let first_realm = first_response["result"]["realm"]
.as_str()
.expect("first context callFunction realm");
let first_event = bidi_events_by_method(&first_messages, "script.message")
.pop()
.expect("script.message for subscribed context");
assert_eq!(
first_event["params"],
json!({
"channel": "channel_name",
"data": {"type": "string", "value": "foo"},
"source": {
"realm": first_realm,
"context": first_context
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_script_runs_after_navigation_and_remove() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
socket
.send(WsMessage::Text(
json!({
"id": 1_u64,
"method": "session.new",
"params": {}
})
.to_string()
.into(),
))
.await
.expect("send session.new");
let session = recv_ws_json(&mut socket).await;
assert_eq!(session["type"], json!("success"));
socket
.send(WsMessage::Text(
json!({
"id": 2_u64,
"method": "browsingContext.create",
"params": {
"type": "tab"
}
})
.to_string()
.into(),
))
.await
.expect("send browsingContext.create");
let create = recv_ws_json(&mut socket).await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
socket
.send(WsMessage::Text(
json!({
"id": 3_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id.clone(),
"url": "data:text/html,bidi-preload-before-add",
"wait": "complete"
}
})
.to_string()
.into(),
))
.await
.expect("send initial browsingContext.navigate");
let initial_navigate = recv_ws_json(&mut socket).await;
assert_eq!(initial_navigate["type"], json!("success"));
assert_eq!(initial_navigate["id"], json!(3_u64));
socket
.send(WsMessage::Text(
json!({
"id": 4_u64,
"method": "script.addPreloadScript",
"params": {
"functionDeclaration": "() => { globalThis.__bidiPreload = 'from-preload'; }",
"contexts": [context_id.clone()]
}
})
.to_string()
.into(),
))
.await
.expect("send script.addPreloadScript");
let add_preload = recv_ws_json(&mut socket).await;
assert_eq!(
add_preload["type"],
json!("success"),
"addPreloadScript should succeed: {add_preload:?}"
);
assert_eq!(add_preload["id"], json!(4_u64));
let preload_script = add_preload["result"]["script"]
.as_str()
.expect("preload script id")
.to_owned();
assert!(
preload_script.starts_with(&context_id),
"BiDi preload script id should be target-qualified"
);
socket
.send(WsMessage::Text(
json!({
"id": 5_u64,
"method": "script.evaluate",
"params": {
"expression": "typeof globalThis.__bidiPreload",
"target": {
"context": context_id.clone()
}
}
})
.to_string()
.into(),
))
.await
.expect("send pre-navigation script.evaluate");
let pre_navigation_value = recv_ws_json(&mut socket).await;
assert_eq!(pre_navigation_value["type"], json!("success"));
assert_eq!(pre_navigation_value["id"], json!(5_u64));
assert_eq!(
pre_navigation_value["result"]["result"],
json!({
"type": "string",
"value": "undefined"
})
);
socket
.send(WsMessage::Text(
json!({
"id": 6_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id.clone(),
"url": "data:text/html,bidi-preload",
"wait": "complete"
}
})
.to_string()
.into(),
))
.await
.expect("send browsingContext.navigate");
let navigate = recv_ws_json(&mut socket).await;
assert_eq!(navigate["type"], json!("success"));
assert_eq!(navigate["id"], json!(6_u64));
socket
.send(WsMessage::Text(
json!({
"id": 7_u64,
"method": "script.evaluate",
"params": {
"expression": "globalThis.__bidiPreload",
"target": {
"context": context_id.clone()
}
}
})
.to_string()
.into(),
))
.await
.expect("send post-navigation script.evaluate");
let preload_value = recv_ws_json(&mut socket).await;
assert_eq!(preload_value["type"], json!("success"));
assert_eq!(preload_value["id"], json!(7_u64));
assert_eq!(
preload_value["result"]["result"],
json!({
"type": "string",
"value": "from-preload"
})
);
socket
.send(WsMessage::Text(
json!({
"id": 8_u64,
"method": "script.removePreloadScript",
"params": {
"script": preload_script.clone()
}
})
.to_string()
.into(),
))
.await
.expect("send script.removePreloadScript");
let remove_preload = recv_ws_json(&mut socket).await;
assert_eq!(remove_preload["type"], json!("success"));
assert_eq!(remove_preload["id"], json!(8_u64));
assert_eq!(remove_preload["result"], json!({}));
socket
.send(WsMessage::Text(
json!({
"id": 9_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id.clone(),
"url": "data:text/html,bidi-preload-removed",
"wait": "complete"
}
})
.to_string()
.into(),
))
.await
.expect("send navigation after remove");
let navigate_after_remove = recv_ws_json(&mut socket).await;
assert_eq!(navigate_after_remove["type"], json!("success"));
assert_eq!(navigate_after_remove["id"], json!(9_u64));
socket
.send(WsMessage::Text(
json!({
"id": 10_u64,
"method": "script.evaluate",
"params": {
"expression": "typeof globalThis.__bidiPreload",
"target": {
"context": context_id.clone()
}
}
})
.to_string()
.into(),
))
.await
.expect("send post-remove script.evaluate");
let post_remove_value = recv_ws_json(&mut socket).await;
assert_eq!(post_remove_value["type"], json!("success"));
assert_eq!(post_remove_value["id"], json!(10_u64));
assert_eq!(
post_remove_value["result"]["result"],
json!({
"type": "string",
"value": "undefined"
})
);
socket
.send(WsMessage::Text(
json!({
"id": 11_u64,
"method": "script.removePreloadScript",
"params": {
"script": preload_script
}
})
.to_string()
.into(),
))
.await
.expect("send second script.removePreloadScript");
let second_remove = recv_ws_json(&mut socket).await;
assert_eq!(second_remove["type"], json!("error"));
assert_eq!(second_remove["id"], json!(11_u64));
assert_eq!(second_remove["error"], json!("no such script"));
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_add_preload_script_rejects_iframe_context() {
// Reduced from Chromium/WPT
// webdriver/tests/bidi/script/add_preload_script/invalid.py.
async fn child() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><title>Child Preload Context</title><main>child</main>",
)
}
let child_app = Router::new().route("/child", get(child));
let (child_addr, _child_server) =
spawn_dedicated_fixture_server(child_app, "bidi-preload-invalid-child-context");
let child_url = format!("http://{child_addr}/child");
let parent_html = format!(
"<!doctype html><title>Parent Preload Context</title><iframe src=\"{child_url}\"></iframe>"
);
let parent_app = Router::new().route(
"/",
get(move || {
let parent_html = parent_html.clone();
async move {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
parent_html,
)
}
}),
);
let (parent_addr, _parent_server) =
spawn_dedicated_fixture_server(parent_app, "bidi-preload-invalid-parent-context");
let parent_url = format!("http://{parent_addr}/");
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, context_id) = bidi_session_with_context(cdp_addr).await;
let navigate = send_bidi_command(
&mut socket,
3,
"browsingContext.navigate",
json!({
"context": context_id.clone(),
"url": parent_url,
"wait": "complete"
}),
)
.await;
assert_eq!(navigate["type"], json!("success"), "{navigate:?}");
let tree = send_bidi_command(
&mut socket,
4,
"browsingContext.getTree",
json!({"root": context_id.clone()}),
)
.await;
assert_eq!(tree["type"], json!("success"), "{tree:?}");
let child_context_id = tree["result"]["contexts"][0]["children"][0]["context"]
.as_str()
.expect("iframe context id")
.to_owned();
let add_preload = send_bidi_command(
&mut socket,
5,
"script.addPreloadScript",
json!({
"functionDeclaration": "() => {}",
"contexts": [child_context_id]
}),
)
.await;
assert_bidi_error(
&add_preload,
"invalid argument",
"script.addPreloadScript should reject iframe contexts",
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_script_channel_argument_emits_script_message() {
// Mirrors webdriver/tests/bidi/script/add_preload_script/arguments.py::test_channel
// for the default channel serialization case.
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let subscribe = send_bidi_command(
&mut socket,
2,
"session.subscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let add_preload = send_bidi_command(
&mut socket,
3,
"script.addPreloadScript",
json!({
"functionDeclaration": "(channel) => channel({'foo': 'bar', 'baz': {'1': 2}})",
"arguments": [{
"type": "channel",
"value": {
"channel": "channel_name"
}
}]
}),
)
.await;
assert_eq!(
add_preload["type"],
json!("success"),
"addPreloadScript should succeed: {add_preload:?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 4_u64,
"method": "browsingContext.create",
"params": {
"type": "tab"
}
})
.to_string()
.into(),
))
.await
.expect("send browsingContext.create");
let create_messages = recv_until_id(&mut socket, 4).await;
let messages =
collect_bidi_messages_until_method_count(&mut socket, create_messages, "script.message", 1)
.await;
let create = bidi_message_by_id(&messages, 4);
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id");
let script_message = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("preload script.message event");
let realm = script_message["params"]["source"]["realm"]
.as_str()
.expect("preload script.message realm");
assert!(!realm.is_empty());
assert_eq!(
script_message["params"],
json!({
"channel": "channel_name",
"data": {
"type": "object",
"value": [
["foo", {"type": "string", "value": "bar"}],
[
"baz",
{
"type": "object",
"value": [["1", {"type": "number", "value": 2}]]
}
]
]
},
"source": {
"realm": realm,
"context": context_id
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_channel_variants_match_wpt_shape() {
// Mirrors the remaining Chromium/WPT
// webdriver/tests/bidi/script/add_preload_script/arguments.py channel cases.
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let subscribe = send_bidi_command(
&mut socket,
2,
"session.subscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let shallow_script = send_bidi_add_preload_script(
&mut socket,
3,
"(channel) => channel({'foo': 'bar', 'baz': {'1': 2}})",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name",
"serializationOptions": {
"maxObjectDepth": 0
}
}
})],
)
.await;
let shallow_messages = create_bidi_context_and_collect_script_messages(&mut socket, 4, 1).await;
let shallow_create = bidi_message_by_id(&shallow_messages, 4);
assert_eq!(shallow_create["type"], json!("success"));
let shallow_context = shallow_create["result"]["context"]
.as_str()
.expect("shallow context id")
.to_owned();
let shallow_event = bidi_events_by_method(&shallow_messages, "script.message")
.pop()
.expect("shallow preload script.message event");
let shallow_realm = shallow_event["params"]["source"]["realm"]
.as_str()
.expect("shallow preload script.message realm");
assert_eq!(
shallow_event["params"],
json!({
"channel": "channel_name",
"data": {
"type": "object"
},
"source": {
"realm": shallow_realm,
"context": shallow_context
}
}),
"preload channel serializationOptions should apply to script.message data"
);
remove_bidi_preload_script(&mut socket, 5, &shallow_script).await;
let root_script = send_bidi_add_preload_script(
&mut socket,
6,
"(channel) => channel({'foo': 'bar', 'baz': {'1': 2}})",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name",
"ownership": "root"
}
})],
)
.await;
let root_messages = create_bidi_context_and_collect_script_messages(&mut socket, 7, 1).await;
let root_create = bidi_message_by_id(&root_messages, 7);
assert_eq!(root_create["type"], json!("success"));
let root_context = root_create["result"]["context"]
.as_str()
.expect("root context id")
.to_owned();
let root_event = bidi_events_by_method(&root_messages, "script.message")
.pop()
.expect("root preload script.message event");
let root_realm = root_event["params"]["source"]["realm"]
.as_str()
.expect("root preload script.message realm");
assert!(
root_event["params"]["data"]["handle"]
.as_str()
.is_some_and(|handle| !handle.is_empty()),
"root preload channel data should include a handle: {root_event:?}"
);
assert_eq!(root_event["params"]["channel"], json!("channel_name"));
assert_eq!(root_event["params"]["data"]["type"], json!("object"));
assert_eq!(
root_event["params"]["data"]["value"],
json!([
["foo", {"type": "string", "value": "bar"}],
[
"baz",
{
"type": "object",
"value": [["1", {"type": "number", "value": 2}]]
}
]
])
);
assert_eq!(
root_event["params"]["source"],
json!({
"realm": root_realm,
"context": root_context
})
);
remove_bidi_preload_script(&mut socket, 8, &root_script).await;
let multiple_arg_script = send_bidi_add_preload_script(
&mut socket,
9,
"(channel) => channel('will_be_send', 'will_be_ignored')",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name"
}
})],
)
.await;
let multiple_arg_messages =
create_bidi_context_and_collect_script_messages(&mut socket, 10, 1).await;
let multiple_arg_create = bidi_message_by_id(&multiple_arg_messages, 10);
assert_eq!(multiple_arg_create["type"], json!("success"));
let multiple_arg_context = multiple_arg_create["result"]["context"]
.as_str()
.expect("multiple-argument context id")
.to_owned();
let multiple_arg_event = bidi_events_by_method(&multiple_arg_messages, "script.message")
.pop()
.expect("multiple-argument preload script.message event");
let multiple_arg_realm = multiple_arg_event["params"]["source"]["realm"]
.as_str()
.expect("multiple-argument preload script.message realm");
assert_eq!(
multiple_arg_event["params"],
json!({
"channel": "channel_name",
"data": {"type": "string", "value": "will_be_send"},
"source": {
"realm": multiple_arg_realm,
"context": multiple_arg_context
}
})
);
remove_bidi_preload_script(&mut socket, 11, &multiple_arg_script).await;
let two_channel_script = send_bidi_add_preload_script(
&mut socket,
12,
"(channel_1, channel_2) => { channel_1('message_from_channel_1'); channel_2('message_from_channel_2'); }",
vec![
json!({
"type": "channel",
"value": {
"channel": "channel_name_1"
}
}),
json!({
"type": "channel",
"value": {
"channel": "channel_name_2"
}
}),
],
)
.await;
let two_channel_messages =
create_bidi_context_and_collect_script_messages(&mut socket, 13, 2).await;
let two_channel_create = bidi_message_by_id(&two_channel_messages, 13);
assert_eq!(two_channel_create["type"], json!("success"));
let two_channel_context = two_channel_create["result"]["context"]
.as_str()
.expect("two-channel context id")
.to_owned();
let two_channel_events = bidi_events_by_method(&two_channel_messages, "script.message");
assert_eq!(two_channel_events.len(), 2);
let first_realm = two_channel_events[0]["params"]["source"]["realm"]
.as_str()
.expect("first two-channel preload script.message realm");
let second_realm = two_channel_events[1]["params"]["source"]["realm"]
.as_str()
.expect("second two-channel preload script.message realm");
assert_eq!(
two_channel_events[0]["params"],
json!({
"channel": "channel_name_1",
"data": {"type": "string", "value": "message_from_channel_1"},
"source": {
"realm": first_realm,
"context": two_channel_context
}
})
);
assert_eq!(
two_channel_events[1]["params"],
json!({
"channel": "channel_name_2",
"data": {"type": "string", "value": "message_from_channel_2"},
"source": {
"realm": second_realm,
"context": two_channel_context
}
})
);
remove_bidi_preload_script(&mut socket, 14, &two_channel_script).await;
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_channel_mutation_observer_matches_wpt_shape() {
// Mirrors webdriver/tests/bidi/script/add_preload_script/arguments.py::test_mutation_observer.
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let preload_script = send_bidi_add_preload_script(
&mut socket,
4,
"(channel) => {
const onMutation = (mutationList) => mutationList.forEach((mutation) => {
const attributeName = mutation.attributeName;
const newValue = mutation.target.getAttribute(mutation.attributeName);
channel({ attributeName, newValue });
});
const observer = new MutationObserver(onMutation);
observer.observe(document, { attributes: true, subtree: true });
}",
vec![json!({
"type": "channel",
"value": {
"channel": "channel_name"
}
})],
)
.await;
socket
.send(WsMessage::Text(
json!({
"id": 5_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id.clone(),
"url": "data:text/html,<div class='old class name'>foo</div>",
"wait": "complete"
}
})
.to_string()
.into(),
))
.await
.expect("send browsingContext.navigate");
let mut messages = recv_until_id(&mut socket, 5).await;
let navigate = bidi_message_by_id(&messages, 5);
assert_eq!(
navigate["type"],
json!("success"),
"navigation should succeed before mutation observer event: {messages:#?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 6_u64,
"method": "script.evaluate",
"params": {
"expression": "document.querySelector('div').setAttribute('class', 'mutated')",
"target": {
"context": context_id.clone()
},
"awaitPromise": true
}
})
.to_string()
.into(),
))
.await
.expect("send mutation script.evaluate");
messages.extend(recv_until_id(&mut socket, 6).await);
let messages =
collect_bidi_messages_until_method_count(&mut socket, messages, "script.message", 1).await;
let evaluate = bidi_message_by_id(&messages, 6);
assert_eq!(evaluate["type"], json!("success"));
let realm = evaluate["result"]["realm"]
.as_str()
.expect("mutation evaluate realm");
let event = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("mutation observer script.message event");
assert_eq!(
event["params"],
json!({
"channel": "channel_name",
"data": {
"type": "object",
"value": [
["attributeName", {"type": "string", "value": "class"}],
["newValue", {"type": "string", "value": "mutated"}]
]
},
"source": {
"realm": realm,
"context": context_id
}
})
);
remove_bidi_preload_script(&mut socket, 7, &preload_script).await;
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_channel_observes_payload_mutation_before_serialization() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let subscribe = send_bidi_command(
&mut socket,
2,
"session.subscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let add_preload = send_bidi_command(
&mut socket,
3,
"script.addPreloadScript",
json!({
"functionDeclaration": "(channel) => {
const payload = { foo: 'before', nested: { value: 1 }, list: ['a'] };
channel(payload);
payload.foo = 'after';
payload.nested.value = 2;
payload.list.push('b');
}",
"arguments": [{
"type": "channel",
"value": {
"channel": "preload_mutation_channel"
}
}]
}),
)
.await;
assert_eq!(
add_preload["type"],
json!("success"),
"addPreloadScript should succeed: {add_preload:?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 4_u64,
"method": "browsingContext.create",
"params": {
"type": "tab"
}
})
.to_string()
.into(),
))
.await
.expect("send browsingContext.create");
let create_messages = recv_until_id(&mut socket, 4).await;
let messages =
collect_bidi_messages_until_method_count(&mut socket, create_messages, "script.message", 1)
.await;
let create = bidi_message_by_id(&messages, 4);
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id");
let event = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("preload mutation script.message event");
let realm = event["params"]["source"]["realm"]
.as_str()
.expect("preload mutation script.message realm");
assert_eq!(
event["params"],
json!({
"channel": "preload_mutation_channel",
"data": {
"type": "object",
"value": [
["foo", {"type": "string", "value": "after"}],
[
"nested",
{
"type": "object",
"value": [["value", {"type": "number", "value": 2}]]
}
],
[
"list",
{
"type": "array",
"value": [
{"type": "string", "value": "a"},
{"type": "string", "value": "b"}
]
}
]
]
},
"source": {
"realm": realm,
"context": context_id
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_channel_handoff_proxy_is_not_page_forgeable_after_start() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let subscribe = send_bidi_command(
&mut socket,
2,
"session.subscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let add_preload = send_bidi_command(
&mut socket,
3,
"script.addPreloadScript",
json!({
"functionDeclaration": "(channel) => channel('legit')",
"arguments": [{
"type": "channel",
"value": {
"channel": "preload_cleanup_channel"
}
}]
}),
)
.await;
assert_eq!(add_preload["type"], json!("success"));
socket
.send(WsMessage::Text(
json!({
"id": 4_u64,
"method": "browsingContext.create",
"params": {
"type": "tab"
}
})
.to_string()
.into(),
))
.await
.expect("send browsingContext.create");
let create_messages = recv_until_id(&mut socket, 4).await;
let messages =
collect_bidi_messages_until_method_count(&mut socket, create_messages, "script.message", 1)
.await;
let create = bidi_message_by_id(&messages, 4);
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let event = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("legit preload script.message event");
assert_eq!(
event["params"]["data"],
json!({"type": "string", "value": "legit"})
);
socket
.send(WsMessage::Text(
json!({
"id": 5_u64,
"method": "script.evaluate",
"params": {
"expression": "(() => {
const handoffs = Object.getOwnPropertyNames(globalThis)
.filter((name) => name.indexOf('__lmBidiPreloadChannel_') === 0);
for (const name of handoffs) {
const take = globalThis[name];
if (typeof take === 'function') {
const proxy = take('wrong-token');
if (proxy && typeof proxy.sendMessage === 'function') {
proxy.sendMessage('forged');
}
}
}
return JSON.stringify({handoffs, legacyRegistry: typeof globalThis.__moliBidiPreloadChannelRegistry});
})()",
"target": {
"context": context_id
},
"awaitPromise": false
}
})
.to_string()
.into(),
))
.await
.expect("send registry forge probe");
let probe_messages = recv_until_id(&mut socket, 5).await;
assert!(
bidi_events_by_method(&probe_messages, "script.message").is_empty(),
"fixed preload registry probe should not produce forged script.message: {probe_messages:#?}"
);
let probe = bidi_message_by_id(&probe_messages, 5);
assert_eq!(probe["type"], json!("success"));
let probe_json: serde_json::Value = serde_json::from_str(
probe["result"]["result"]["value"]
.as_str()
.expect("probe JSON string"),
)
.expect("probe JSON should decode");
assert_eq!(probe_json["legacyRegistry"], json!("undefined"));
assert_eq!(
probe_json["handoffs"],
json!([]),
"preload handoff globals should be deleted after listener start"
);
match timeout(Duration::from_millis(200), recv_ws_json(&mut socket)).await {
Ok(message) if message["method"] == json!("script.message") => {
panic!("unexpected forged script.message after registry probe: {message:#?}")
}
_ => {}
}
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_channel_handoff_is_token_gated_during_page_script() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let add_preload = send_bidi_command(
&mut socket,
4,
"script.addPreloadScript",
json!({
"functionDeclaration": "(channel) => channel('legit-during-navigation')",
"arguments": [{
"type": "channel",
"value": {
"channel": "preload_token_gate_channel"
}
}]
}),
)
.await;
assert_eq!(add_preload["type"], json!("success"));
socket
.send(WsMessage::Text(
json!({
"id": 5_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id,
"url": "data:text/html,<script>window.__handoffProbe=[];for(const name of Object.getOwnPropertyNames(globalThis)){if(name.indexOf('__lmBidiPreloadChannel_')===0){const take=globalThis[name];let wrongTokenValue;let directSendValue;try{wrongTokenValue=take('wrong-token');}catch(error){wrongTokenValue=String(error);}try{if(take&&typeof take.sendMessage==='function'){directSendValue=take.sendMessage('forged');}}catch(error){directSendValue=String(error);}window.__handoffProbe.push([typeof take,wrongTokenValue,directSendValue]);}}</script><main>preload-token-gate</main>",
"wait": "complete"
}
})
.to_string()
.into(),
))
.await
.expect("send browsingContext.navigate");
let navigate_messages = recv_until_id(&mut socket, 5).await;
let messages = collect_bidi_messages_until_method_count(
&mut socket,
navigate_messages,
"script.message",
1,
)
.await;
let script_messages = bidi_events_by_method(&messages, "script.message");
assert_eq!(
script_messages.len(),
1,
"wrong-token page probes should not forge script.message events: {messages:#?}"
);
assert_eq!(
script_messages[0]["params"],
json!({
"channel": "preload_token_gate_channel",
"data": {
"type": "string",
"value": "legit-during-navigation"
},
"source": {
"context": context_id,
"realm": script_messages[0]["params"]["source"]["realm"]
.as_str()
.expect("script.message source realm")
}
})
);
match timeout(Duration::from_millis(200), recv_ws_json(&mut socket)).await {
Ok(message) if message["method"] == json!("script.message") => {
panic!("unexpected forged script.message after wrong-token probe: {message:#?}")
}
_ => {}
}
let probe = send_bidi_command(
&mut socket,
6,
"script.evaluate",
json!({
"expression": "JSON.stringify({legacyRegistry: typeof globalThis.__moliBidiPreloadChannelRegistry, handoffGlobals: Object.getOwnPropertyNames(globalThis).filter((name) => name.indexOf('__lmBidiPreloadChannel_') === 0), probe: window.__handoffProbe, forged: window.__forgedMessage})",
"target": {
"context": context_id
},
"awaitPromise": false
}),
)
.await;
assert_eq!(probe["type"], json!("success"));
let probe_json: serde_json::Value = serde_json::from_str(
probe["result"]["result"]["value"]
.as_str()
.expect("probe JSON string"),
)
.expect("probe JSON should decode");
assert_eq!(probe_json["legacyRegistry"], json!("undefined"));
assert_eq!(
probe_json["handoffGlobals"],
json!([]),
"transient preload handoff should be deleted after listener starts: {probe_json:#?}"
);
assert_eq!(probe_json["forged"], serde_json::Value::Null);
let probe_items = probe_json["probe"]
.as_array()
.expect("handoff probe should serialize an array");
assert!(
!probe_items.is_empty(),
"page should see only token-gated handoff functions, not the old proxy registry: {probe_json:#?}"
);
for item in probe_items {
assert_eq!(item[0], json!("function"));
assert_eq!(item[1], serde_json::Value::Null);
assert_eq!(item[2], serde_json::Value::Null);
}
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_preload_channel_emits_after_wait_none_navigation() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let add_preload = send_bidi_command(
&mut socket,
4,
"script.addPreloadScript",
json!({
"functionDeclaration": "(channel) => channel('wait-none-preload')",
"arguments": [{
"type": "channel",
"value": {
"channel": "wait_none_channel"
}
}],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(
add_preload["type"],
json!("success"),
"addPreloadScript should succeed: {add_preload:?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 5_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id.clone(),
"url": "data:text/html,<body>wait-none-preload</body>",
"wait": "none"
}
})
.to_string()
.into(),
))
.await
.expect("send wait=none browsingContext.navigate");
let navigate_messages = recv_until_id(&mut socket, 5).await;
let messages = collect_bidi_messages_until_method_count(
&mut socket,
navigate_messages,
"script.message",
1,
)
.await;
let navigate = bidi_message_by_id(&messages, 5);
assert_eq!(
navigate["type"],
json!("success"),
"wait=none navigation should return successfully: {messages:#?}"
);
let script_message = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("wait=none preload script.message event");
let realm = script_message["params"]["source"]["realm"]
.as_str()
.expect("wait=none preload script.message realm");
assert_eq!(
script_message["params"],
json!({
"channel": "wait_none_channel",
"data": {
"type": "string",
"value": "wait-none-preload"
},
"source": {
"realm": realm,
"context": context_id
}
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_context_preload_channel_survives_frame_navigation() {
// Reduced from Selenium Python bidi_script_tests.py preload channel cases,
// with a child frame to cover default-world preload replay.
async fn parent() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
r#"<!doctype html>
<html>
<head><title>Preload Frame Parent</title></head>
<body><main>parent</main><iframe src="/child"></iframe></body>
</html>"#,
)
}
async fn child() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><title>Preload Frame Child</title><main>child</main>",
)
}
let fixture_app = Router::new()
.route("/parent", get(parent))
.route("/child", get(child));
let (fixture_addr, _fixture_server) =
spawn_dedicated_fixture_server(fixture_app, "bidi-preload-channel-frame");
let parent_url = format!("http://{fixture_addr}/parent");
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(
create["type"],
json!("success"),
"browsingContext.create should succeed: {create:?}"
);
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({ "events": ["script.message"] }),
)
.await;
assert_eq!(
subscribe["type"],
json!("success"),
"session.subscribe should succeed: {subscribe:?}"
);
let add_preload = send_bidi_command(
&mut socket,
4,
"script.addPreloadScript",
json!({
"functionDeclaration": "(channel) => { channel('preload:' + location.pathname); globalThis.__bidiPreloadChannel = 'received'; }",
"arguments": [{
"type": "channel",
"value": {
"channel": "frame_channel",
"ownership": "none"
}
}],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(
add_preload["type"],
json!("success"),
"addPreloadScript should succeed: {add_preload:?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 5_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id.clone(),
"url": parent_url,
"wait": "complete"
}
})
.to_string()
.into(),
))
.await
.expect("send frame browsingContext.navigate");
let navigation_messages = recv_until_id(&mut socket, 5).await;
let navigation_messages = collect_bidi_messages_until(
&mut socket,
navigation_messages,
|messages| {
let script_messages = bidi_events_by_method(messages, "script.message");
script_messages.iter().any(|message| {
message["params"]["channel"] == json!("frame_channel")
&& message["params"]["data"]
== json!({
"type": "string",
"value": "preload:/parent"
})
}) && script_messages.iter().any(|message| {
message["params"]["channel"] == json!("frame_channel")
&& message["params"]["data"]
== json!({
"type": "string",
"value": "preload:/child"
})
})
},
"top-frame and child-frame preload script.message events",
)
.await;
let navigate = bidi_message_by_id(&navigation_messages, 5);
assert_eq!(
navigate["type"],
json!("success"),
"frame navigation should succeed without renderer abort: {navigation_messages:#?}"
);
let top_script_message = bidi_events_by_method(&navigation_messages, "script.message")
.into_iter()
.find(|message| {
message["params"]["channel"] == json!("frame_channel")
&& message["params"]["data"]
== json!({
"type": "string",
"value": "preload:/parent"
})
})
.unwrap_or_else(|| {
panic!("expected top-frame preload script.message: {navigation_messages:#?}")
});
assert_eq!(
top_script_message["params"]["source"]["context"],
json!(context_id)
);
assert!(
top_script_message["params"]["source"]["realm"]
.as_str()
.is_some_and(|realm| !realm.is_empty()),
"top script.message should include a realm: {top_script_message:?}"
);
let child_script_message = bidi_events_by_method(&navigation_messages, "script.message")
.into_iter()
.find(|message| {
message["params"]["channel"] == json!("frame_channel")
&& message["params"]["data"]
== json!({
"type": "string",
"value": "preload:/child"
})
})
.unwrap_or_else(|| {
panic!("expected child-frame preload script.message: {navigation_messages:#?}")
});
let child_context = child_script_message["params"]["source"]["context"]
.as_str()
.expect("child script.message context");
assert_ne!(
child_context, context_id,
"child script.message should report the iframe browsing context"
);
assert!(
child_script_message["params"]["source"]["realm"]
.as_str()
.is_some_and(|realm| !realm.is_empty()),
"child script.message should include a realm: {child_script_message:?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 6_u64,
"method": "script.evaluate",
"params": {
"expression": "globalThis.__bidiPreloadChannel",
"target": {
"context": context_id
}
}
})
.to_string()
.into(),
))
.await
.expect("send preload channel marker script.evaluate");
let evaluate_messages = recv_until_id(&mut socket, 6).await;
let evaluate = bidi_message_by_id(&evaluate_messages, 6);
assert_eq!(
evaluate["type"],
json!("success"),
"preload marker evaluate should succeed: {evaluate_messages:#?}"
);
assert_eq!(
evaluate["result"]["result"],
json!({
"type": "string",
"value": "received"
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_bidi_sandbox_preload_channel_reports_sandbox_realm() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/session"))
.await
.expect("connect to BiDi websocket");
let session = send_bidi_command(&mut socket, 1, "session.new", json!({})).await;
assert_eq!(session["type"], json!("success"));
let create = send_bidi_command(
&mut socket,
2,
"browsingContext.create",
json!({ "type": "tab" }),
)
.await;
assert_eq!(create["type"], json!("success"));
let context_id = create["result"]["context"]
.as_str()
.expect("created context id")
.to_owned();
let subscribe = send_bidi_command(
&mut socket,
3,
"session.subscribe",
json!({
"events": ["script.message"],
"contexts": [context_id.clone()]
}),
)
.await;
assert_eq!(subscribe["type"], json!("success"));
let add_preload = send_bidi_command(
&mut socket,
4,
"script.addPreloadScript",
json!({
"functionDeclaration": "(channel) => { globalThis.__bidiSandboxPreload = 'sandbox'; channel('sandbox-preload'); }",
"arguments": [{
"type": "channel",
"value": {
"channel": "sandbox_channel"
}
}],
"contexts": [context_id.clone()],
"sandbox": "sandbox-channel"
}),
)
.await;
assert_eq!(
add_preload["type"],
json!("success"),
"sandbox addPreloadScript should succeed: {add_preload:?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 5_u64,
"method": "browsingContext.navigate",
"params": {
"context": context_id.clone(),
"url": "data:text/html,<body>sandbox-preload</body>",
"wait": "complete"
}
})
.to_string()
.into(),
))
.await
.expect("send sandbox preload browsingContext.navigate");
let navigation_messages = recv_until_id(&mut socket, 5).await;
let messages = collect_bidi_messages_until_method_count(
&mut socket,
navigation_messages,
"script.message",
1,
)
.await;
let navigate = bidi_message_by_id(&messages, 5);
assert_eq!(
navigate["type"],
json!("success"),
"sandbox preload navigation should succeed: {messages:#?}"
);
let script_message = bidi_events_by_method(&messages, "script.message")
.pop()
.expect("sandbox preload script.message event");
let script_message_realm = script_message["params"]["source"]["realm"]
.as_str()
.expect("sandbox script.message realm")
.to_owned();
assert_eq!(
script_message["params"],
json!({
"channel": "sandbox_channel",
"data": {
"type": "string",
"value": "sandbox-preload"
},
"source": {
"realm": script_message_realm,
"context": context_id
}
})
);
let realms = send_bidi_command(
&mut socket,
6,
"script.getRealms",
json!({ "context": context_id }),
)
.await;
assert_eq!(
realms["type"],
json!("success"),
"script.getRealms should succeed: {realms:?}"
);
let default_realm = bidi_window_realm(&realms, &context_id)["realm"]
.as_str()
.expect("default realm id")
.to_owned();
let sandbox_realm = bidi_sandbox_window_realm(&realms, &context_id, "sandbox-channel")["realm"]
.as_str()
.expect("sandbox realm id")
.to_owned();
assert_ne!(
default_realm, sandbox_realm,
"sandbox preload should use a distinct realm"
);
assert_eq!(
script_message_realm, sandbox_realm,
"script.message source realm should identify the sandbox realm"
);
let default_probe = send_bidi_command(
&mut socket,
7,
"script.evaluate",
json!({
"expression": "globalThis.__bidiSandboxPreload",
"target": {
"context": context_id
}
}),
)
.await;
assert_eq!(default_probe["type"], json!("success"));
assert_eq!(
default_probe["result"]["result"],
json!({ "type": "undefined" }),
"sandbox preload globals must not leak into the default realm"
);
let sandbox_probe = send_bidi_command(
&mut socket,
8,
"script.evaluate",
json!({
"expression": "globalThis.__bidiSandboxPreload",
"target": {
"context": context_id,
"sandbox": "sandbox-channel"
}
}),
)
.await;
assert_eq!(sandbox_probe["type"], json!("success"));
assert_eq!(
sandbox_probe["result"]["result"],
json!({
"type": "string",
"value": "sandbox"
})
);
let _ = socket.close(None).await;
protocol_server.abort();
}