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_cdp_handle_javascript_dialog_accept_resumes_confirm_with_true() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to cdp websocket");
let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
let session = cdp_create_attached_target(&mut socket, 2, &browser_context_id).await;
let session_id = session.session_id;
let _ = send_cdp_command(
&mut socket,
4,
"Runtime.enable",
Some(&session_id),
json!({}),
)
.await;
let enable =
send_cdp_command(&mut socket, 6, "Page.enable", Some(&session_id), json!({})).await;
assert!(
enable
.iter()
.any(|message| message["id"] == json!(6_u64) && message["result"] == json!({})),
"Page.enable should resolve before dialog handling: {enable:#?}"
);
let _ = cdp_navigate_and_wait_for_load(
&mut socket,
11,
&session_id,
"data:text/html,<title>dialog replacement</title>",
)
.await;
let scheduled = send_cdp_command(
&mut socket,
100,
"Runtime.evaluate",
Some(&session_id),
json!({
"expression": "setTimeout(() => { window.__moliScheduledConfirm = confirm('moli scheduled confirm'); }, 0); 'scheduled'",
"returnByValue": true
}),
)
.await;
assert!(
scheduled.iter().any(|message| {
message["id"] == json!(100_u64)
&& message["result"]["result"]["value"] == json!("scheduled")
}),
"scheduling a timer dialog must reply before the timer task blocks: {scheduled:#?}"
);
let mut scheduled_dialog = scheduled;
if !scheduled_dialog.iter().any(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["message"] == json!("moli scheduled confirm")
}) {
scheduled_dialog.extend(
recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["message"] == json!("moli scheduled confirm")
})
.await,
);
}
scheduled_dialog.extend(
send_cdp_command(
&mut socket,
101,
"Page.handleJavaScriptDialog",
Some(&session_id),
json!({ "accept": true }),
)
.await,
);
if !scheduled_dialog
.iter()
.any(|message| message["id"] == json!(101_u64))
{
scheduled_dialog
.extend(recv_until_match(&mut socket, |message| message["id"] == json!(101_u64)).await);
}
let scheduled_result = cdp_runtime_evaluate_string(
&mut socket,
&session_id,
102,
"String(window.__moliScheduledConfirm)",
)
.await;
assert_eq!(scheduled_result, "true");
socket
.send(WsMessage::Text(
json!({
"id": 7_u64,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": r#"
confirm("moli confirm");
"#,
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.evaluate that opens confirm");
let mut observed = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["type"] == json!("confirm")
&& message["params"]["message"] == json!("moli confirm")
})
.await;
assert!(
!observed.iter().any(|message| message["id"] == json!(7_u64)),
"Runtime.evaluate must remain pending while confirm is open: {observed:#?}"
);
observed.extend(
send_cdp_command(
&mut socket,
8,
"Page.handleJavaScriptDialog",
Some(&session_id),
json!({ "accept": true }),
)
.await,
);
assert!(
observed.iter().any(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogClosed")
&& message["params"]["result"] == json!(true)
}),
"accepting confirm should emit javascriptDialogClosed: {observed:#?}"
);
if !observed.iter().any(|message| message["id"] == json!(7_u64)) {
observed
.extend(recv_until_match(&mut socket, |message| message["id"] == json!(7_u64)).await);
}
let evaluate = observed
.iter()
.find(|message| message["id"] == json!(7_u64))
.expect("Runtime.evaluate should resolve after confirm is handled");
assert_eq!(
evaluate["result"]["result"]["value"],
json!(true),
"accepted confirm should return true to page JavaScript: {observed:#?}"
);
let receiver = send_cdp_command(
&mut socket,
14,
"Runtime.evaluate",
Some(&session_id),
json!({ "expression": "({})" }),
)
.await;
let receiver_object_id = receiver
.iter()
.find(|message| message["id"] == json!(14_u64))
.and_then(|message| message["result"]["result"]["objectId"].as_str())
.expect("Runtime.evaluate should return a receiver objectId")
.to_owned();
socket
.send(WsMessage::Text(
json!({
"id": 15_u64,
"method": "Runtime.callFunctionOn",
"sessionId": session_id,
"params": {
"objectId": receiver_object_id,
"functionDeclaration": "function () { console.log('moli callFunctionOn marker', document.body); return confirm('moli callFunctionOn confirm'); }",
"awaitPromise": true,
"returnByValue": true,
"userGesture": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.callFunctionOn that opens confirm");
let mut called = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["message"] == json!("moli callFunctionOn confirm")
})
.await;
assert!(
!called.iter().any(|message| message["id"] == json!(15_u64)),
"Runtime.callFunctionOn must remain pending while confirm is open: {called:#?}"
);
let console_position = called
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Runtime.consoleAPICalled")
&& message["params"]["args"][0]["value"] == json!("moli callFunctionOn marker")
&& message["params"]["args"][1]["objectId"].is_string()
&& message["params"]["args"][1]["subtype"] == json!("node")
})
.unwrap_or_else(|| {
panic!("console output before callFunctionOn confirm must be published: {called:#?}")
});
let dialog_position = called
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["message"] == json!("moli callFunctionOn confirm")
})
.expect("callFunctionOn confirm opening event");
assert!(
console_position < dialog_position,
"the suspending prefix must preserve console -> dialog producer order: {called:#?}"
);
called.extend(
send_cdp_command(
&mut socket,
16,
"Page.handleJavaScriptDialog",
Some(&session_id),
json!({ "accept": true }),
)
.await,
);
if !called.iter().any(|message| message["id"] == json!(15_u64)) {
called
.extend(recv_until_match(&mut socket, |message| message["id"] == json!(15_u64)).await);
}
let call_function = called
.iter()
.find(|message| message["id"] == json!(15_u64))
.expect("Runtime.callFunctionOn should resolve after confirm is handled");
assert_eq!(
call_function["result"]["result"]["value"],
json!(true),
"accepted confirm should return true through Runtime.callFunctionOn: {called:#?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 9_u64,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": "confirm('moli dismiss confirm')",
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.evaluate that opens dismissed confirm");
let mut dismissed = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["message"] == json!("moli dismiss confirm")
})
.await;
assert!(
!dismissed
.iter()
.any(|message| message["id"] == json!(9_u64)),
"dismissed confirm must also remain pending before handle: {dismissed:#?}"
);
dismissed.extend(
send_cdp_command(
&mut socket,
10,
"Page.handleJavaScriptDialog",
Some(&session_id),
json!({ "accept": false }),
)
.await,
);
if !dismissed
.iter()
.any(|message| message["id"] == json!(9_u64))
{
dismissed
.extend(recv_until_match(&mut socket, |message| message["id"] == json!(9_u64)).await);
}
let evaluate = dismissed
.iter()
.find(|message| message["id"] == json!(9_u64))
.expect("Runtime.evaluate should resolve after confirm is dismissed");
assert_eq!(
evaluate["result"]["result"]["value"],
json!(false),
"dismissed confirm should return false to page JavaScript: {dismissed:#?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 12_u64,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": "new Promise(resolve => setTimeout(() => resolve(confirm('moli timer confirm')), 0))",
"awaitPromise": true,
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.evaluate that opens confirm from a timer");
let mut timer = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["message"] == json!("moli timer confirm")
})
.await;
assert!(
!timer.iter().any(|message| message["id"] == json!(12_u64)),
"awaitPromise evaluation must remain pending while timer confirm is open: {timer:#?}"
);
timer.extend(
send_cdp_command(
&mut socket,
13,
"Page.handleJavaScriptDialog",
Some(&session_id),
json!({ "accept": true }),
)
.await,
);
if !timer.iter().any(|message| message["id"] == json!(12_u64)) {
timer.extend(recv_until_match(&mut socket, |message| message["id"] == json!(12_u64)).await);
}
let evaluate = timer
.iter()
.find(|message| message["id"] == json!(12_u64))
.expect("awaitPromise Runtime.evaluate should resolve after timer confirm is accepted");
assert_eq!(
evaluate["result"]["result"]["value"],
json!(true),
"accepted timer confirm should resolve awaitPromise with true: {timer:#?}"
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_cdp_handle_javascript_dialog_prompt_text_resumes_prompt() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to cdp websocket");
let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
let session = cdp_create_attached_target(&mut socket, 2, &browser_context_id).await;
let session_id = session.session_id;
let _ = send_cdp_command(
&mut socket,
4,
"Runtime.enable",
Some(&session_id),
json!({}),
)
.await;
let _ = send_cdp_command(&mut socket, 6, "Page.enable", Some(&session_id), json!({})).await;
socket
.send(WsMessage::Text(
json!({
"id": 7_u64,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": r#"
prompt("moli prompt", "default answer");
"#,
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.evaluate that opens prompt");
let mut observed = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["type"] == json!("prompt")
&& message["params"]["message"] == json!("moli prompt")
})
.await;
assert!(
!observed.iter().any(|message| message["id"] == json!(7_u64)),
"Runtime.evaluate must remain pending while prompt is open: {observed:#?}"
);
assert!(
observed.iter().any(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["defaultPrompt"] == json!("default answer")
&& message["params"]["hasBrowserHandler"] == json!(false)
}),
"prompt opening should include defaultPrompt and report that Moli has no native dialog UI: {observed:#?}"
);
observed.extend(
send_cdp_command(
&mut socket,
8,
"Page.handleJavaScriptDialog",
Some(&session_id),
json!({ "accept": true, "promptText": "typed answer" }),
)
.await,
);
assert!(
observed.iter().any(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogClosed")
&& message["params"]["result"] == json!(true)
}),
"accepting prompt should emit javascriptDialogClosed: {observed:#?}"
);
if !observed.iter().any(|message| message["id"] == json!(7_u64)) {
observed
.extend(recv_until_match(&mut socket, |message| message["id"] == json!(7_u64)).await);
}
let evaluate = observed
.iter()
.find(|message| message["id"] == json!(7_u64))
.expect("Runtime.evaluate should resolve after prompt is handled");
assert_eq!(
evaluate["result"]["result"]["value"],
json!("typed answer"),
"accepted prompt should return the supplied text to page JavaScript: {observed:#?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 9_u64,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": "prompt('moli dismiss prompt', 'default answer')",
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.evaluate that opens dismissed prompt");
let mut dismissed = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.javascriptDialogOpening")
&& message["params"]["message"] == json!("moli dismiss prompt")
})
.await;
assert!(
!dismissed
.iter()
.any(|message| message["id"] == json!(9_u64)),
"dismissed prompt must remain pending before handle: {dismissed:#?}"
);
dismissed.extend(
send_cdp_command(
&mut socket,
10,
"Page.handleJavaScriptDialog",
Some(&session_id),
json!({ "accept": false }),
)
.await,
);
if !dismissed
.iter()
.any(|message| message["id"] == json!(9_u64))
{
dismissed
.extend(recv_until_match(&mut socket, |message| message["id"] == json!(9_u64)).await);
}
let evaluate = dismissed
.iter()
.find(|message| message["id"] == json!(9_u64))
.expect("Runtime.evaluate should resolve after prompt is dismissed");
assert_eq!(
evaluate["result"]["result"]["subtype"],
json!("null"),
"dismissed prompt should return null to page JavaScript: {dismissed:#?}"
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_cdp_lifecycle_events_include_load_marker() {
async fn page() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><body><main>lifecycle load</main></body></html>",
)
}
async fn blank() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><title>blank</title>",
)
}
let fixture_app = Router::new()
.route("/blank", get(blank))
.route("/page", get(page));
let (fixture_addr, _fixture_server) =
spawn_dedicated_fixture_server(fixture_app, "lifecycle-load-marker");
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to cdp websocket");
let blank_url = format!("http://{fixture_addr}/blank");
let session_id = cdp_create_session_and_navigate(&mut socket, &blank_url).await;
let _ = send_cdp_command(&mut socket, 6, "Page.enable", Some(&session_id), json!({})).await;
let _ = send_cdp_command(
&mut socket,
7,
"Page.setLifecycleEventsEnabled",
Some(&session_id),
json!({ "enabled": true }),
)
.await;
let page_url = format!("http://{fixture_addr}/page");
socket
.send(WsMessage::Text(
json!({
"id": 8_u64,
"method": "Page.navigate",
"sessionId": session_id,
"params": { "url": page_url }
})
.to_string()
.into(),
))
.await
.expect("send Page.navigate");
let messages = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.lifecycleEvent")
&& message["params"]["name"] == json!("load")
})
.await;
let loader_id = messages
.iter()
.find(|message| message["id"] == json!(8_u64))
.and_then(|message| message["result"]["loaderId"].as_str())
.expect("Page.navigate should return the committed loaderId");
let init_index = messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.lifecycleEvent")
&& message["params"]["name"] == json!("init")
&& message["params"]["loaderId"].as_str() == Some(loader_id)
})
.expect("new document should emit lifecycle init for the navigation loader");
let frame_navigated_index = messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["loaderId"].as_str() == Some(loader_id)
})
.expect("new document should commit the same navigation loader");
let load_index = messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.lifecycleEvent")
&& message["params"]["name"] == json!("load")
&& message["params"]["loaderId"].as_str() == Some(loader_id)
})
.expect("new document should load with the same navigation loader");
assert!(
init_index < frame_navigated_index && frame_navigated_index < load_index,
"navigation lifecycle should order init before frame commit and load: {messages:#?}"
);
assert!(
messages.iter().any(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
}),
"Page.loadEventFired should accompany lifecycle load: {messages:#?}"
);
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn websocket_cdp_same_document_navigation_after_dcl_does_not_cancel_pending_load() {
async fn page() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><head><link rel='stylesheet' href='/slow.css'></head><body><main id='ready'>ready</main></body></html>",
)
}
let css_requested = Arc::new(tokio::sync::Notify::new());
let release_css = Arc::new(tokio::sync::Notify::new());
let css_requested_for_route = Arc::clone(&css_requested);
let release_css_for_route = Arc::clone(&release_css);
let fixture_app = Router::new().route("/", get(page)).route(
"/slow.css",
get(move || {
let css_requested_for_route = Arc::clone(&css_requested_for_route);
let release_css_for_route = Arc::clone(&release_css_for_route);
async move {
css_requested_for_route.notify_one();
release_css_for_route.notified().await;
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/css")],
"body { color: black; }",
)
}
}),
);
let (fixture_addr, fixture_server) =
spawn_dedicated_fixture_server(fixture_app, "same-document-pending-load");
let fixture_url = format!("http://{fixture_addr}/");
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to cdp websocket");
socket
.send(WsMessage::Text(
json!({
"id": 1_u64,
"method": "Target.createTarget",
"params": { "url": "about:blank" }
})
.to_string()
.into(),
))
.await
.expect("send createTarget");
let create_target = recv_until_id(&mut socket, 1).await;
let target_id = create_target
.iter()
.find(|message| message["id"] == json!(1_u64))
.and_then(|message| message["result"]["targetId"].as_str())
.expect("targetId")
.to_owned();
socket
.send(WsMessage::Text(
json!({
"id": 2_u64,
"method": "Target.attachToTarget",
"params": { "targetId": target_id, "flatten": true }
})
.to_string()
.into(),
))
.await
.expect("send attachToTarget");
let attach = recv_until_id(&mut socket, 2).await;
let session_id = attach
.iter()
.find(|message| message["id"] == json!(2_u64))
.and_then(|message| message["result"]["sessionId"].as_str())
.expect("sessionId")
.to_owned();
for (id, method) in [
(3_u64, "Page.enable"),
(4_u64, "Runtime.enable"),
(5_u64, "Page.setLifecycleEventsEnabled"),
] {
let params = if method == "Page.setLifecycleEventsEnabled" {
json!({ "enabled": true })
} else {
json!({})
};
socket
.send(WsMessage::Text(
json!({
"id": id,
"method": method,
"sessionId": session_id,
"params": params
})
.to_string()
.into(),
))
.await
.unwrap_or_else(|_| panic!("send {method}"));
let _ = recv_until_id(&mut socket, id).await;
}
socket
.send(WsMessage::Text(
json!({
"id": 6_u64,
"method": "Page.navigate",
"sessionId": session_id,
"params": { "url": fixture_url }
})
.to_string()
.into(),
))
.await
.expect("send Page.navigate");
let _ = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.domContentEventFired")
})
.await;
tokio::time::timeout(Duration::from_secs(5), css_requested.notified())
.await
.expect("stylesheet request should be pending before same-document navigation");
socket
.send(WsMessage::Text(
json!({
"id": 7_u64,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": "location.hash = 'after-dcl'; location.href",
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.evaluate");
let evaluate_messages = recv_until_id(&mut socket, 7).await;
let evaluate_response = evaluate_messages
.iter()
.find(|message| message["id"] == json!(7_u64))
.expect("Runtime.evaluate response");
assert!(
evaluate_response.get("error").is_none(),
"same-document navigation after DCL should be accepted while load is still pending: {evaluate_response}"
);
assert_eq!(
evaluate_response["result"]["result"]["value"],
json!(format!("{fixture_url}#after-dcl"))
);
release_css.notify_one();
let mut saw_load_event = evaluate_messages.iter().any(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
});
if !saw_load_event {
let load_messages = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
})
.await;
saw_load_event = load_messages.iter().any(|message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
});
}
assert!(
saw_load_event,
"same-document URL changes must not make the current document's deferred load completion stale"
);
let _ = socket.close(None).await;
abort_test_cdp_server(protocol_server).await;
drop(fixture_server);
}
#[tokio::test]
async fn websocket_cdp_raw_client_second_navigate_does_not_cancel_subsequent_awaitpromise() {
// Regression test for the cdp-session race that was missed by the
// first navigation gate: `has_inflight_background_navigation` originally
// checked `loaded_page.is_none()`, which is only true on the very
// first Page.navigate per target (before any page is installed).
//
// On every SUBSEQUENT Page.navigate, the old loaded_page survives
// until the new completion commits — so the flag returned false,
// the drain hook did NOT fire, and:
// T0: client → Page.navigate (run N, N>=2).
// T1: client → Runtime.evaluate(awaitPromise=true). Handler registers
// a pending inspector await on the OLD page's context.
// T2: background completion arrives → commit_loaded_navigation_page
// swaps OLD → NEW, then fail_pending_inspector_awaits cancels the
// await from T1 with "Page navigated". Client sees command failed.
//
// The counter-based fix tracks "background nav spawned but not yet
// drained" explicitly, so the gate applies to every in-flight navigation,
// not just the first one. This test sends TWO sequential
// navigate+evaluate cycles over the same session and asserts both
// evaluates succeed.
async fn page_a() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><body><span id='m'>A</span></body></html>",
)
}
async fn page_b() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><body><span id='m'>B</span></body></html>",
)
}
let fixture_app = Router::new()
.route("/a", get(page_a))
.route("/b", get(page_b));
let fixture_listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fixture listener");
let fixture_addr = fixture_listener.local_addr().expect("fixture addr");
let fixture_server =
tokio::spawn(async move { axum::serve(fixture_listener, fixture_app).await });
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to cdp websocket");
// Bring up a single session and reuse it for both cases.
socket
.send(WsMessage::Text(
json!({ "id": 1_u64, "method": "Target.createBrowserContext" })
.to_string()
.into(),
))
.await
.expect("send createBrowserContext");
let _ = recv_until_id(&mut socket, 1).await;
socket
.send(WsMessage::Text(
json!({
"id": 2_u64,
"method": "Target.createTarget",
"params": { "url": "about:blank" }
})
.to_string()
.into(),
))
.await
.expect("send createTarget");
let create_target = recv_until_id(&mut socket, 2).await;
let target_id = create_target
.iter()
.find(|m| m["id"] == json!(2_u64))
.and_then(|m| m["result"]["targetId"].as_str())
.expect("targetId")
.to_owned();
socket
.send(WsMessage::Text(
json!({
"id": 3_u64,
"method": "Target.attachToTarget",
"params": { "targetId": target_id, "flatten": true }
})
.to_string()
.into(),
))
.await
.expect("send attachToTarget");
let attach = recv_until_id(&mut socket, 3).await;
let session_id = attach
.iter()
.find(|m| m["id"] == json!(3_u64))
.and_then(|m| m["result"]["sessionId"].as_str())
.expect("sessionId")
.to_owned();
// Cycle 1: navigate(/a) → evaluate awaitPromise that polls #m.
let mut next_id = 4_u64;
for (cycle, (path, expected)) in [("/a", "A"), ("/b", "B")].iter().enumerate() {
let url = format!("http://{fixture_addr}{path}");
let navigate_id = next_id;
next_id += 1;
socket
.send(WsMessage::Text(
json!({
"id": navigate_id,
"method": "Page.navigate",
"sessionId": session_id,
"params": { "url": url }
})
.to_string()
.into(),
))
.await
.expect("send Page.navigate");
let evaluate_id = next_id;
next_id += 1;
socket
.send(WsMessage::Text(
json!({
"id": evaluate_id,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": "new Promise(resolve => { const deadline = Date.now() + 3000; (function tick() { const n = document.querySelector('#m'); if (n && n.textContent) resolve(n.textContent); else if (Date.now() > deadline) resolve(''); else setTimeout(tick, 10); })(); })",
"awaitPromise": true,
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send Runtime.evaluate");
let messages = recv_until_id(&mut socket, evaluate_id).await;
let eval_response = messages
.iter()
.find(|m| m["id"] == json!(evaluate_id))
.expect("evaluate response");
assert!(
eval_response.get("error").is_none(),
"cycle {cycle}: Runtime.evaluate must not be cancelled by the preceding Page.navigate commit; got {eval_response}"
);
let value = eval_response["result"]["result"]["value"]
.as_str()
.expect("evaluate value should be a string");
assert_eq!(
value, *expected,
"cycle {cycle}: evaluate must observe the new document body for {path}"
);
}
let _ = socket.close(None).await;
abort_test_cdp_server(protocol_server).await;
fixture_server.abort();
}
#[tokio::test]
async fn websocket_cdp_runtime_self_navigation_gate_is_not_applied_to_next_command() {
async fn plain() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><body><main>plain</main></body></html>",
)
}
async fn history_a() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><body><main>history a</main></body></html>",
)
}
let fixture_app = Router::new()
.route("/plain", get(plain))
.route("/history-a", get(history_a));
let fixture_listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fixture listener");
let fixture_addr = fixture_listener.local_addr().expect("fixture addr");
let fixture_server =
tokio::spawn(async move { axum::serve(fixture_listener, fixture_app).await });
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect websocket");
let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
let target = cdp_create_attached_target(&mut socket, 2, &browser_context_id).await;
let session_id = target.session_id;
let _ = send_cdp_command(
&mut socket,
4,
"Runtime.enable",
Some(&session_id),
json!({}),
)
.await;
let _ = send_cdp_command(&mut socket, 5, "Page.enable", Some(&session_id), json!({})).await;
let plain_url = format!("http://{fixture_addr}/plain");
let _ = cdp_navigate_and_wait_for_load(&mut socket, 6, &session_id, &plain_url).await;
let history_url = format!("http://{fixture_addr}/history-a?open-self=1");
let _ = send_cdp_command(
&mut socket,
7,
"Runtime.evaluate",
Some(&session_id),
json!({
"expression": format!("window.open('{}', '_self')", history_url),
"returnByValue": true
}),
)
.await;
let _ = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
})
.await;
let one_plus_one = send_cdp_command(
&mut socket,
8,
"Runtime.evaluate",
Some(&session_id),
json!({
"expression": "1 + 1",
"returnByValue": true
}),
)
.await;
assert!(
one_plus_one.iter().any(|message| {
message["id"] == json!(8_u64) && message["result"]["result"]["value"] == json!(2_u64)
}),
"sanity Runtime.evaluate should succeed after self navigation: {one_plus_one:#?}"
);
socket
.send(WsMessage::Text(
json!({
"id": 9_u64,
"method": "Runtime.evaluate",
"sessionId": session_id,
"params": {
"expression": "typeof globalThis.__pwClock",
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("send post-navigation Runtime.evaluate");
let typeof_clock = timeout(Duration::from_secs(3), recv_until_id(&mut socket, 9))
.await
.expect("post-navigation Runtime.evaluate must not wait on stale navigation gate");
assert!(
typeof_clock
.iter()
.any(|message| message["id"] == json!(9_u64) && message.get("result").is_some()),
"post-navigation Runtime.evaluate should return a result: {typeof_clock:#?}"
);
let main_text = cdp_runtime_evaluate_string(
&mut socket,
&session_id,
10,
"document.querySelector('main') && document.querySelector('main').textContent",
)
.await;
assert_eq!(main_text, "history a");
let _ = socket.close(None).await;
abort_test_cdp_server(protocol_server).await;
fixture_server.abort();
}
#[tokio::test]
async fn websocket_cdp_window_open_self_navigation_reaches_attached_page_session() {
async fn plain() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><body><main>plain</main></body></html>",
)
}
async fn history_a() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
"<!doctype html><html><body><main>history a</main></body></html>",
)
}
let fixture_app = Router::new()
.route("/plain", get(plain))
.route("/history-a", get(history_a));
let fixture_listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fixture listener");
let fixture_addr = fixture_listener.local_addr().expect("fixture addr");
let fixture_server =
tokio::spawn(async move { axum::serve(fixture_listener, fixture_app).await });
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect websocket");
let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
let target = cdp_create_attached_target(&mut socket, 2, &browser_context_id).await;
let primary_session_id = target.session_id;
let target_id = target.target_id;
let _ = send_cdp_command(
&mut socket,
4,
"Runtime.enable",
Some(&primary_session_id),
json!({}),
)
.await;
let _ = send_cdp_command(
&mut socket,
5,
"Page.enable",
Some(&primary_session_id),
json!({}),
)
.await;
let browser_attach = send_cdp_command(
&mut socket,
6,
"Target.attachToBrowserTarget",
None,
json!({}),
)
.await;
let browser_session_id = browser_attach
.iter()
.find(|message| message["id"] == json!(6_u64))
.and_then(|message| message["result"]["sessionId"].as_str())
.expect("browser session id")
.to_owned();
let attached_session_response = send_cdp_command(
&mut socket,
7,
"Target.attachToTarget",
Some(&browser_session_id),
json!({ "targetId": target_id }),
)
.await;
let attached_session_id = attached_session_response
.iter()
.find(|message| message["id"] == json!(7_u64))
.and_then(|message| message["result"]["sessionId"].as_str())
.expect("attached session id")
.to_owned();
assert_ne!(attached_session_id, primary_session_id);
for (id, method) in [
(8_u64, "Page.enable"),
(9_u64, "Runtime.enable"),
(10_u64, "Network.enable"),
] {
let _ = send_cdp_command(
&mut socket,
id,
method,
Some(&attached_session_id),
json!({}),
)
.await;
}
let plain_url = format!("http://{fixture_addr}/plain");
let mut initial_navigation =
cdp_navigate_and_wait_for_load(&mut socket, 11, &primary_session_id, &plain_url).await;
if !initial_navigation.iter().any(|message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["url"] == json!(plain_url)
}) {
initial_navigation.append(
&mut recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["url"] == json!(plain_url)
})
.await,
);
}
if !initial_navigation.iter().any(|message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
}) {
let _ = recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
})
.await;
}
let history_url = format!("http://{fixture_addr}/history-a?open-self=1");
let isolated_world = send_cdp_command(
&mut socket,
120,
"Page.createIsolatedWorld",
Some(&primary_session_id),
json!({
"frameId": target_id,
"worldName": "__moli_playwright_utility_world__",
"grantUniversalAccess": true
}),
)
.await;
let isolated_context_id = isolated_world
.iter()
.find(|message| message["id"] == json!(120_u64))
.and_then(|message| message["result"]["executionContextId"].as_u64())
.expect("isolated utility world executionContextId");
let utility_object = send_cdp_command(
&mut socket,
12,
"Runtime.evaluate",
Some(&primary_session_id),
json!({
"contextId": isolated_context_id,
"expression": r#"({
evaluate(isFunction, returnByValue, expression, argCount, ...args) {
let result = globalThis.eval(expression);
if (isFunction === true || (isFunction !== false && typeof result === "function")) {
result = result(...args.slice(0, argCount));
}
return returnByValue ? { v: result === null ? "null" : "undefined" } : result;
}
})"#
}),
)
.await;
let utility_object_id = utility_object
.iter()
.find(|message| message["id"] == json!(12_u64))
.and_then(|message| message["result"]["result"]["objectId"].as_str())
.expect("utility objectId")
.to_owned();
let mut navigation_messages = send_cdp_command(
&mut socket,
13,
"Runtime.callFunctionOn",
Some(&primary_session_id),
json!({
"objectId": utility_object_id,
"functionDeclaration": "(utilityScript, ...args) => utilityScript.evaluate(...args)",
"arguments": [
{ "objectId": utility_object_id },
{},
{ "value": true },
{ "value": "(url) => window.open(url, '_self')" },
{ "value": 1 },
{ "value": history_url }
],
"returnByValue": true,
"awaitPromise": true,
"userGesture": true
}),
)
.await;
let runtime_response_index = navigation_messages
.iter()
.position(|message| message["id"] == json!(13_u64))
.expect("Runtime.callFunctionOn response should be received");
let runtime_response = &navigation_messages[runtime_response_index];
assert!(
runtime_response.get("result").is_some() && runtime_response.get("error").is_none(),
"Runtime.callFunctionOn must complete successfully before its _self navigation is released: {navigation_messages:#?}"
);
assert!(
!navigation_messages[..runtime_response_index]
.iter()
.any(|message| {
let routed_to_target = matches!(
message["sessionId"].as_str(),
Some(session_id)
if session_id == primary_session_id || session_id == attached_session_id
);
routed_to_target
&& (message["method"] == json!("Runtime.executionContextsCleared")
|| (message["method"] == json!("Page.frameStartedNavigating")
&& message["params"]["url"] == json!(history_url))
|| (message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["url"] == json!(history_url))
|| (message["method"] == json!("Network.requestWillBeSent")
&& message["params"]["request"]["url"] == json!(history_url))
|| message["method"] == json!("Page.loadEventFired"))
}),
"Runtime.callFunctionOn response must precede command-caused navigation output on every session attached to the target: {navigation_messages:#?}"
);
if !navigation_messages.iter().any(|message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["url"] == json!(history_url)
}) {
navigation_messages.append(
&mut recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["url"] == json!(history_url)
})
.await,
);
}
if !navigation_messages.iter().any(|message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
}) {
navigation_messages.append(
&mut recv_until_match(&mut socket, |message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
})
.await,
);
}
let started = navigation_messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.frameStartedNavigating")
&& message["params"]["url"] == json!(history_url)
})
.expect("attached session should receive Page.frameStartedNavigating for _self URL");
let navigated = navigation_messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["url"] == json!(history_url)
})
.expect("attached session should receive Page.frameNavigated for _self URL");
let loaded = navigation_messages
.iter()
.enumerate()
.find_map(|(index, message)| {
(index > navigated
&& message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Page.loadEventFired"))
.then_some(index)
})
.expect("attached session should receive Page.loadEventFired after _self frameNavigated");
assert!(
started < navigated && navigated < loaded,
"attached Page event order should be started < navigated < load: {navigation_messages:#?}"
);
assert!(
navigation_messages.iter().any(|message| {
message["sessionId"].as_str() == Some(attached_session_id.as_str())
&& message["method"] == json!("Network.requestWillBeSent")
&& message["params"]["request"]["url"] == json!(history_url)
}),
"attached Network session should observe the _self document request: {navigation_messages:#?}"
);
navigation_messages.append(
&mut send_cdp_command(
&mut socket,
14,
"Runtime.evaluate",
Some(&primary_session_id),
json!({
"expression": "document.querySelector('main') && document.querySelector('main').textContent"
}),
)
.await,
);
assert_eq!(
navigation_messages
.iter()
.filter(|message| {
message["id"] == json!(13_u64)
&& message["sessionId"].as_str() == Some(primary_session_id.as_str())
})
.count(),
1,
"Runtime.callFunctionOn must receive exactly one terminal response: {navigation_messages:#?}"
);
let main_text = navigation_messages
.iter()
.find(|message| message["id"] == json!(14_u64))
.and_then(|message| message["result"]["result"]["value"].as_str())
.expect("post-navigation Runtime.evaluate string result");
assert_eq!(main_text, "history a");
let _ = socket.close(None).await;
abort_test_cdp_server(protocol_server).await;
fixture_server.abort();
}
#[tokio::test]
async fn websocket_cdp_multi_target_sync_awaitpromise_precedes_realm_replacement() {
const TARGET_COUNT: usize = 8;
async fn start_page() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
r#"<!doctype html>
<html>
<body>
<main></main>
<script>
const target = new URL(location.href).searchParams.get('target');
globalThis.__realmMarker = `initial-${target}`;
document.querySelector('main').textContent = globalThis.__realmMarker;
</script>
</body>
</html>"#,
)
}
async fn replacement_page() -> impl IntoResponse {
(
[(axum::http::header::CONTENT_TYPE.as_str(), "text/html")],
r#"<!doctype html>
<html>
<body>
<main></main>
<script>
const target = new URL(location.href).searchParams.get('target');
globalThis.__realmMarker = `replacement-${target}`;
document.querySelector('main').textContent = globalThis.__realmMarker;
</script>
</body>
</html>"#,
)
}
let fixture_app = Router::new()
.route("/start", get(start_page))
.route("/replacement", get(replacement_page));
let (fixture_addr, _fixture_server) =
spawn_dedicated_fixture_server(fixture_app, "multi-target-sync-awaitpromise");
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to the single browser CDP websocket");
let browser_context_id = cdp_create_browser_context(&mut socket, 1).await;
let mut targets = Vec::with_capacity(TARGET_COUNT);
for index in 0..TARGET_COUNT {
let id_base = 10 + (index as u64 * 2);
let target = cdp_create_attached_target(&mut socket, id_base, &browser_context_id).await;
for (id, method) in [
(100 + index as u64 * 2, "Runtime.enable"),
(101 + index as u64 * 2, "Page.enable"),
] {
let _ = send_cdp_command(&mut socket, id, method, Some(&target.session_id), json!({}))
.await;
}
let start_url = format!("http://{fixture_addr}/start?target={index}");
let _ = cdp_navigate_and_wait_for_load(
&mut socket,
200 + index as u64,
&target.session_id,
&start_url,
)
.await;
targets.push(target);
}
const SCHEDULE_REPLACEMENT: &str = r#"(() => {
const target = new URL(location.href).searchParams.get('target');
const marker = document.querySelector('main').textContent;
history.pushState(null, '', `${location.pathname}${location.search}#queued`);
queueMicrotask(() => { location.href = `/replacement?target=${target}`; });
return JSON.stringify({ marker, phase: 'scheduled' });
})()"#;
for (index, target) in targets.iter().enumerate() {
socket
.send(WsMessage::Text(
json!({
"id": 1_000 + index as u64,
"method": "Runtime.evaluate",
"sessionId": target.session_id,
"params": {
"expression": SCHEDULE_REPLACEMENT,
"awaitPromise": true,
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("pipeline synchronous awaitPromise Runtime.evaluate");
}
let mut navigation_messages = Vec::new();
let mut saw_runtime_response = vec![false; TARGET_COUNT];
let mut saw_replacement_load = vec![false; TARGET_COUNT];
let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
while saw_runtime_response.iter().any(|seen| !seen)
|| saw_replacement_load.iter().any(|seen| !seen)
{
let message = tokio::time::timeout_at(deadline, recv_ws_json(&mut socket))
.await
.unwrap_or_else(|_| {
panic!(
"timed out waiting for pipelined Runtime replies and realm replacements; \
responses={saw_runtime_response:?}, loads={saw_replacement_load:?}, \
messages={navigation_messages:#?}"
)
});
if let Some(id) = message["id"].as_u64()
&& (1_000..1_000 + TARGET_COUNT as u64).contains(&id)
{
saw_runtime_response[(id - 1_000) as usize] = true;
}
for (index, target) in targets.iter().enumerate() {
if message["sessionId"].as_str() == Some(target.session_id.as_str())
&& message["method"] == json!("Page.loadEventFired")
{
saw_replacement_load[index] = true;
}
}
navigation_messages.push(message);
}
assert!(
!navigation_messages
.iter()
.any(|message| { message["error"]["message"] == json!("Promise was collected") }),
"synchronous awaitPromise results must never be reported as collected: {navigation_messages:#?}"
);
for (index, target) in targets.iter().enumerate() {
let response_id = 1_000 + index as u64;
let response_indexes = navigation_messages
.iter()
.enumerate()
.filter(|(_, message)| {
message["id"] == json!(response_id)
&& message["sessionId"].as_str() == Some(target.session_id.as_str())
})
.collect::<Vec<_>>();
assert_eq!(
response_indexes.len(),
1,
"target {index} must receive exactly one terminal Runtime response: {navigation_messages:#?}"
);
let (response_index, response) = response_indexes[0];
assert!(
response.get("error").is_none(),
"target {index} synchronous awaitPromise evaluation failed: {response:#?}"
);
assert_eq!(response["result"]["result"]["type"], json!("string"));
assert_eq!(
response["result"]["result"]["value"],
json!(format!(
r#"{{"marker":"initial-{index}","phase":"scheduled"}}"#
))
);
let same_document_index = navigation_messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(target.session_id.as_str())
&& message["method"] == json!("Page.navigatedWithinDocument")
&& message["params"]["url"]
== json!(format!(
"http://{fixture_addr}/start?target={index}#queued"
))
&& message["params"]["navigationType"] == json!("historyApi")
})
.unwrap_or_else(|| {
panic!(
"target {index} should expose the same-document history mutation: {navigation_messages:#?}"
)
});
assert!(
same_document_index < response_index,
"same-document output produced inside the expression should precede its Runtime response for target {index}: {navigation_messages:#?}"
);
let replacement_url = format!("http://{fixture_addr}/replacement?target={index}");
let contexts_cleared_index = navigation_messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(target.session_id.as_str())
&& message["method"] == json!("Runtime.executionContextsCleared")
})
.unwrap_or_else(|| {
panic!("target {index} should clear the old realm: {navigation_messages:#?}")
});
let started_index = navigation_messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(target.session_id.as_str())
&& message["method"] == json!("Page.frameStartedNavigating")
&& message["params"]["url"] == json!(replacement_url.as_str())
})
.unwrap_or_else(|| {
panic!(
"target {index} should start the replacement navigation: {navigation_messages:#?}"
)
});
let navigated_index = navigation_messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(target.session_id.as_str())
&& message["method"] == json!("Page.frameNavigated")
&& message["params"]["frame"]["url"] == json!(replacement_url.as_str())
})
.unwrap_or_else(|| {
panic!("target {index} should commit the replacement: {navigation_messages:#?}")
});
let replacement_context_index = navigation_messages
.iter()
.position(|message| {
message["sessionId"].as_str() == Some(target.session_id.as_str())
&& message["method"] == json!("Runtime.executionContextCreated")
&& message["params"]["context"]["auxData"]["isDefault"] == json!(true)
&& message["params"]["context"]["auxData"]["frameId"]
== json!(target.target_id.as_str())
})
.unwrap_or_else(|| {
panic!(
"target {index} should publish its new default realm: {navigation_messages:#?}"
)
});
let load_index = navigation_messages
.iter()
.enumerate()
.find_map(|(message_index, message)| {
(message_index > navigated_index
&& message["sessionId"].as_str() == Some(target.session_id.as_str())
&& message["method"] == json!("Page.loadEventFired"))
.then_some(message_index)
})
.unwrap_or_else(|| {
panic!(
"target {index} should finish its replacement load: {navigation_messages:#?}"
)
});
assert!(
[contexts_cleared_index, started_index, navigated_index]
.into_iter()
.all(|navigation_index| response_index < navigation_index),
"target {index} must flush its Runtime response before output that destroys the command realm: {navigation_messages:#?}"
);
assert!(
contexts_cleared_index < replacement_context_index,
"target {index} must clear the old realm before publishing the replacement realm: {navigation_messages:#?}"
);
assert!(
started_index < navigated_index && navigated_index < load_index,
"target {index} replacement order should be started < navigated < load: {navigation_messages:#?}"
);
}
const OBSERVE_REPLACEMENT: &str = r#"JSON.stringify({
marker: document.querySelector('main').textContent,
realm: globalThis.__realmMarker
})"#;
for (index, target) in targets.iter().enumerate() {
socket
.send(WsMessage::Text(
json!({
"id": 2_000 + index as u64,
"method": "Runtime.evaluate",
"sessionId": target.session_id,
"params": {
"expression": OBSERVE_REPLACEMENT,
"awaitPromise": true,
"returnByValue": true
}
})
.to_string()
.into(),
))
.await
.expect("pipeline post-navigation synchronous awaitPromise observation");
}
let mut replacement_messages = Vec::new();
let mut saw_replacement_response = vec![false; TARGET_COUNT];
let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
while saw_replacement_response.iter().any(|seen| !seen) {
let message = tokio::time::timeout_at(deadline, recv_ws_json(&mut socket))
.await
.unwrap_or_else(|_| {
panic!(
"timed out waiting for post-navigation Runtime replies; \
responses={saw_replacement_response:?}, messages={replacement_messages:#?}"
)
});
if let Some(id) = message["id"].as_u64()
&& (2_000..2_000 + TARGET_COUNT as u64).contains(&id)
{
saw_replacement_response[(id - 2_000) as usize] = true;
}
replacement_messages.push(message);
}
assert!(
!replacement_messages
.iter()
.any(|message| { message["error"]["message"] == json!("Promise was collected") }),
"new-realm synchronous awaitPromise results must not be reported as collected: {replacement_messages:#?}"
);
for (index, target) in targets.iter().enumerate() {
let response_id = 2_000 + index as u64;
let responses = replacement_messages
.iter()
.filter(|message| {
message["id"] == json!(response_id)
&& message["sessionId"].as_str() == Some(target.session_id.as_str())
})
.collect::<Vec<_>>();
assert_eq!(
responses.len(),
1,
"target {index} post-navigation observation should have one terminal response: {replacement_messages:#?}"
);
assert!(
responses[0].get("error").is_none(),
"target {index} should evaluate in its replacement realm: {replacement_messages:#?}"
);
assert_eq!(
responses[0]["result"]["result"]["value"],
json!(format!(
r#"{{"marker":"replacement-{index}","realm":"replacement-{index}"}}"#
))
);
}
let _ = socket.close(None).await;
abort_test_cdp_server(protocol_server).await;
}