Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::*;
use std::time::Instant;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio::task::JoinHandle;
use url::Url;
use crate::live_document_parser::{
DocumentParserRunState, ParserResumeOwner, ParserSuspensionCause,
};
use crate::page_resource_completion::{
PageResourceCompletionDocumentEffect, PageResourceCompletionOutputEffect,
RendererPageResourceCompletion, RendererPageResourceCompletionOwner,
RendererPageResourceCompletionTestSource,
};
use crate::page_task_queue::RendererPageNetworkingSource;
use crate::types::{
DocumentWriteExternalScriptFetchTarget, DocumentWriteExternalScriptLoadCompletion,
DocumentWriteExternalScriptNetworkAttribution, ScriptNetworkOutputItem,
SubresourceNetworkOutcome,
};
async fn spawn_document_write_script_server(script: &'static str) -> (Url, JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("document.write script server should bind");
let address = listener
.local_addr()
.expect("document.write script server should have an address");
let server = tokio::spawn(async move {
let (mut stream, _) = listener
.accept()
.await
.expect("document.write script request should arrive");
let mut request = vec![0; 4096];
let read = stream
.read(&mut request)
.await
.expect("document.write script request should be readable");
let request = String::from_utf8_lossy(&request[..read]);
assert!(
request.starts_with("GET /written.js "),
"unexpected document.write script request: {request}"
);
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
script.len(),
script,
);
stream
.write_all(response.as_bytes())
.await
.expect("document.write script response should be writable");
stream
.shutdown()
.await
.expect("document.write script response should close");
});
(
Url::parse(&format!("http://{address}/written.js"))
.expect("document.write script URL should parse"),
server,
)
}
async fn spawn_aborted_document_write_script_server() -> (Url, JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("aborted document.write script server should bind");
let address = listener
.local_addr()
.expect("aborted document.write script server should have an address");
let server = tokio::spawn(async move {
let (mut stream, _) = listener
.accept()
.await
.expect("aborted document.write script request should arrive");
let mut request = vec![0; 4096];
let read = stream
.read(&mut request)
.await
.expect("aborted document.write script request should be readable");
let request = String::from_utf8_lossy(&request[..read]);
assert!(
request.starts_with("GET /written.js "),
"unexpected aborted document.write script request: {request}"
);
stream
.shutdown()
.await
.expect("aborted document.write script response should close");
});
(
Url::parse(&format!("http://{address}/written.js"))
.expect("aborted document.write script URL should parse"),
server,
)
}
async fn spawn_two_document_write_script_server(
first_script: &'static str,
second_script: &'static str,
) -> (
Url,
Url,
tokio::sync::oneshot::Sender<()>,
JoinHandle<(usize, usize)>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("two-script document.write server should bind");
let address = listener
.local_addr()
.expect("two-script document.write server should have an address");
let (shutdown_tx, mut shutdown_rx) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let mut first_requests = 0;
let mut second_requests = 0;
loop {
let (mut stream, _) = tokio::select! {
biased;
_ = &mut shutdown_rx => break,
accepted = listener.accept() => {
accepted.expect("document.write script request should arrive")
}
};
let mut request = vec![0; 4096];
let read = stream
.read(&mut request)
.await
.expect("document.write script request should be readable");
let request = String::from_utf8_lossy(&request[..read]);
let script = if request.starts_with("GET /first.js ") {
first_requests += 1;
first_script
} else if request.starts_with("GET /second.js ") {
second_requests += 1;
second_script
} else {
panic!("unexpected sequential document.write script request: {request}");
};
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
script.len(),
script,
);
stream
.write_all(response.as_bytes())
.await
.expect("document.write script response should be writable");
stream
.shutdown()
.await
.expect("document.write script response should close");
}
(first_requests, second_requests)
});
(
Url::parse(&format!("http://{address}/first.js"))
.expect("first document.write script URL should parse"),
Url::parse(&format!("http://{address}/second.js"))
.expect("second document.write script URL should parse"),
shutdown_tx,
server,
)
}
async fn spawn_document_write_script_with_completed_stylesheet_preload_server() -> (
Url,
Url,
tokio::sync::oneshot::Sender<()>,
tokio::sync::oneshot::Receiver<()>,
JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("document.write stylesheet preload server should bind");
let address = listener
.local_addr()
.expect("document.write stylesheet preload server should have an address");
let (script_release_tx, script_release_rx) = tokio::sync::oneshot::channel();
let (stylesheet_served_tx, stylesheet_served_rx) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let mut script_stream = None;
let mut stylesheet_served_tx = Some(stylesheet_served_tx);
while script_stream.is_none() || stylesheet_served_tx.is_some() {
let (mut stream, _) = listener
.accept()
.await
.expect("document.write stylesheet preload request should arrive");
let mut request = vec![0; 4096];
let read = stream
.read(&mut request)
.await
.expect("document.write stylesheet preload request should be readable");
let request = String::from_utf8_lossy(&request[..read]);
if request.starts_with("GET /written.js ") {
assert!(
script_stream.replace(stream).is_none(),
"document.write external script should be requested once"
);
continue;
}
assert!(
request.starts_with("GET /ready.css "),
"unexpected document.write stylesheet preload request: {request}"
);
let body = "body { color: rgb(1, 2, 3); }";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/css\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body,
);
stream
.write_all(response.as_bytes())
.await
.expect("stylesheet preload response should be writable");
stream
.shutdown()
.await
.expect("stylesheet preload response should close");
stylesheet_served_tx
.take()
.expect("stylesheet preload should be served once")
.send(())
.expect("stylesheet preload observer should remain attached");
}
script_release_rx
.await
.expect("document.write external script should be released");
let mut stream = script_stream.expect("document.write script request should be retained");
let body = "globalThis.__completedPreloadEvents.push('external');";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body,
);
stream
.write_all(response.as_bytes())
.await
.expect("document.write external script response should be writable");
stream
.shutdown()
.await
.expect("document.write external script response should close");
});
(
Url::parse(&format!("http://{address}/written.js"))
.expect("document.write external script URL should parse"),
Url::parse(&format!("http://{address}/ready.css"))
.expect("stylesheet preload URL should parse"),
script_release_tx,
stylesheet_served_rx,
server,
)
}
struct PendingStandaloneDocumentWritePage {
runtime: Box<ConcurrentParseTimeRuntime>,
started: Instant,
owner_wake_rx: tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
}
async fn start_standalone_document_write_page(
html: String,
document_url: Url,
) -> PendingStandaloneDocumentWritePage {
start_standalone_document_write_page_for_page_id(
PageId::new_for_testing(901),
html,
document_url,
)
.await
}
async fn start_standalone_document_write_page_for_page_id(
page_id: PageId,
html: String,
document_url: Url,
) -> PendingStandaloneDocumentWritePage {
let pending = start_standalone_parser_page(page_id, html, document_url).await;
let target = pending
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target()
.expect("pending document.write load should retain its exact target");
assert_eq!(
pending
.runtime
.page_vm
.vm()
.current_main_document_task_owner(),
Some(target.task_owner()),
"producer target must capture the current main Document owner"
);
pending
}
async fn start_standalone_parser_page(
page_id: PageId,
html: String,
document_url: Url,
) -> PendingStandaloneDocumentWritePage {
let loader_owner =
ResourceRequestClient::new(&FetchConfig::default()).expect("document.write test loader");
let local_executor = JsLocalExecutor::new();
let (owner_wake_tx, owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
let owner_wake = crate::page_task_queue::RendererOwnerWakeSender::new(
owner_wake_tx,
crate::runtime::RendererPageToken::new_for_testing(page_id),
);
let runtime_hooks =
PageVmRuntimeHooks::standalone_with_owner_wake_without_owner_reservation_for_test(
owner_wake,
);
let env = super::tests::default_test_page_vm_env_config();
let creation_executor = local_executor.clone();
let outcome = super::access::run_named_owner_local_task(
local_executor,
"owner-attached document.write phase-one bootstrap channel closed",
async move {
let outcome = ConcurrentParseTimeRuntime::finish_creation_from_html_bootstrap(
page_id,
creation_executor,
&loader_owner,
&env,
runtime_hooks,
document_url,
PageVmInitStage::Load,
html,
Instant::now(),
)
.await?;
anyhow::Ok((outcome, loader_owner))
},
)
.await
.expect("document.write phase one should reach its typed-resource boundary");
let (outcome, loader_owner) = outcome;
let ParseTimePageVmCreationOutcome::PendingPhaseOne(
PendingPhaseOneResidence::ClosedInputPageWork {
mut runtime,
started,
},
) = outcome
else {
panic!("owner-attached document.write must park on its typed Page resource source");
};
runtime
.page_vm
.retain_standalone_request_client_owner_for_test(loader_owner);
PendingStandaloneDocumentWritePage {
runtime,
started,
owner_wake_rx,
}
}
async fn wait_for_standalone_page_resource(
pending: &mut PendingStandaloneDocumentWritePage,
) -> crate::page_task_queue::RendererPageResourceCompletionTestSource {
let resource_source = pending.runtime.page_vm.page_resource_completion_queue();
while !resource_source.has_ready_completion() {
pending
.owner_wake_rx
.recv()
.await
.expect("document.write producer should retain its owner wake route");
}
resource_source
}
async fn wait_for_standalone_stylesheet_completion(
pending: &mut PendingStandaloneDocumentWritePage,
) {
loop {
if pending
.runtime
.page_vm
.page_task_executor_sources_for_test()
.has_scheduler_task_for_executor_test(|descriptor| {
matches!(
descriptor,
crate::page_task_queue::RendererPageReadyDescriptor::Networking {
owner:
crate::page_task_queue::RendererPageNetworkingOwner::StylesheetCompletion(
_
),
..
}
)
})
{
return;
}
pending
.owner_wake_rx
.recv()
.await
.expect("stylesheet preload producer should retain its owner wake route");
}
}
async fn run_standalone_selected_page_task(
mut pending: PendingStandaloneDocumentWritePage,
selector: crate::runtime::page_vm::PageSelectedTaskTestSelector,
) -> PendingStandaloneDocumentWritePage {
let executor = pending.runtime.page_vm.local_executor.clone();
super::access::run_named_owner_local_task(
executor,
"standalone selected Page task channel closed",
async move {
let loader = pending.runtime.loader.clone();
assert!(
pending
.runtime
.page_vm
.run_exact_selected_page_task_for_test(selector, &loader)
.await?,
"the fixture should expose one exact {selector:?} task"
);
Ok(pending)
},
)
.await
.expect("selected standalone Page task should execute on the owner lane")
}
async fn resume_standalone_document_write_page(
pending: PendingStandaloneDocumentWritePage,
) -> (
ParseTimePageVmCreationOutcome,
tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
) {
let mut pending = pending;
let mut resource_source = wait_for_standalone_page_resource(&mut pending).await;
let PendingStandaloneDocumentWritePage {
mut runtime,
started,
owner_wake_rx,
} = pending;
// This fixture deliberately has no RendererOwnerLocalPageSlot. Give its
// standalone source heads to the real Page scheduler policy, then execute
// exactly the selected task. The following phase-one continuation may
// observe the result, but it never receives dequeue authority itself.
let loader = runtime.loader.clone();
let turn_executor = runtime.page_vm.local_executor.clone();
runtime = super::access::run_named_owner_local_task(
turn_executor,
"standalone document.write Page turn channel closed",
async move {
let ready = resource_source
.next_ready_metadata()
.expect("standalone resource source must retain its ready head");
let owner = resource_source
.next_ready_owner()
.map(crate::page_task_queue::RendererPageNetworkingOwner::ResourceCompletion)
.expect("standalone resource source must retain its exact owner");
let mut descriptors = vec![
crate::page_task_queue::RendererPageReadyDescriptor::Networking { ready, owner },
];
if let Some(timer) = runtime.page_vm.due_page_timer_ready_descriptor(
crate::page_task_queue::RendererPageTimerSelection::AnyReady,
) {
descriptors.push(timer);
}
let selected = crate::runtime::page_turn_scheduler::PageTurnScheduler::new(())
.select_ready_descriptor(descriptors)
.expect("standalone Page fixture must expose one runnable source");
match selected {
crate::page_task_queue::RendererPageReadyDescriptor::Networking { .. } => {
runtime
.page_vm
.apply_one_page_resource_terminal_owner_admission_for_test(
&mut resource_source,
)?
.expect("selected standalone resource head must be executable");
}
crate::page_task_queue::RendererPageReadyDescriptor::Timer {
deadline,
selection,
} => {
runtime
.page_vm
.apply_selected_page_scheduler_task(
crate::page_task_queue::RendererPageSchedulerTask::Timer {
deadline,
selection,
},
&loader,
)
.await?;
}
other => unreachable!(
"standalone document.write fixture exposed unexpected source: {other:?}"
),
}
Ok(runtime)
},
)
.await
.expect("standalone document.write fixture should execute one bounded Page turn");
let continuation_executor = runtime.page_vm.local_executor.clone();
let outcome = super::access::run_named_owner_local_task(
continuation_executor,
"owner-attached document.write phase-one continuation channel closed",
async move {
(*runtime)
.continue_creation_from_phase_one_runtime(started)
.await
},
)
.await
.expect("typed document.write completion should resume phase one");
(outcome, owner_wake_rx)
}
async fn resume_standalone_main_parser_continuation_if_ready(
outcome: ParseTimePageVmCreationOutcome,
owner_wake_rx: tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
) -> (
ParseTimePageVmCreationOutcome,
tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
) {
let residence = match outcome {
ParseTimePageVmCreationOutcome::PendingPhaseOne(residence) => residence,
outcome => return (outcome, owner_wake_rx),
};
if !residence
.page_vm()
.page_task_executor_sources_for_test()
.has_scheduler_task_for_executor_test(|descriptor| {
matches!(
descriptor,
crate::page_task_queue::RendererPageReadyDescriptor::Networking {
owner:
crate::page_task_queue::RendererPageNetworkingOwner::MainParserContinuation(
_
),
..
}
)
})
{
return (
ParseTimePageVmCreationOutcome::PendingPhaseOne(residence),
owner_wake_rx,
);
};
let PendingPhaseOneResidence::ClosedInputPageWork {
mut runtime,
started,
} = residence
else {
panic!("closed document.write fixture should retain a blocked parser runtime");
};
let executor = runtime.page_vm.local_executor.clone();
runtime = super::access::run_named_owner_local_task(
executor,
"standalone main-parser continuation Page turn channel closed",
async move {
let request_client = runtime
.page_vm
.main_document_resource_loader()
.request_client()
.clone();
assert!(
runtime
.page_vm
.run_exact_selected_page_task_for_test(
crate::runtime::page_vm::PageSelectedTaskTestSelector::MainParserContinuation,
&request_client,
)
.await?,
"fixture should execute its exact parser continuation through the production dispatcher"
);
Ok(runtime)
},
)
.await
.expect("standalone parser continuation should execute one bounded Page turn");
let executor = runtime.page_vm.local_executor.clone();
let outcome = super::access::run_named_owner_local_task(
executor,
"standalone admitted parser continuation channel closed",
async move {
(*runtime)
.continue_creation_from_phase_one_runtime(started)
.await
},
)
.await
.expect("admitted parser continuation should resume phase one");
(outcome, owner_wake_rx)
}
async fn finish_standalone_document_write_page(html: String, document_url: Url) -> PageVm {
let (outcome, owner_wake_rx) = resume_standalone_document_write_page(
start_standalone_document_write_page(html, document_url).await,
)
.await;
let (outcome, _) =
resume_standalone_main_parser_continuation_if_ready(outcome, owner_wake_rx).await;
let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = outcome else {
panic!(
"one document.write terminal and its continuation should finish this full-body fixture"
);
};
page_vm
}
async fn evaluate_on_owner_local_task(
mut page_vm: PageVm,
expression: &'static str,
) -> serde_json::Value {
let local_executor = page_vm.local_executor.clone();
super::access::run_named_owner_local_task(
local_executor,
"document.write phase-one result evaluation channel closed",
async move { page_vm.evaluate_expression(expression) },
)
.await
.expect("document.write result should evaluate")
}
async fn evaluate_pending_on_owner_local_task(
mut pending: PendingStandaloneDocumentWritePage,
expression: &'static str,
) -> (PendingStandaloneDocumentWritePage, serde_json::Value) {
let local_executor = pending.runtime.page_vm.local_executor.clone();
super::access::run_named_owner_local_task(
local_executor,
"pending document.write result evaluation channel closed",
async move {
let result = pending.runtime.page_vm.evaluate_expression(expression)?;
Ok((pending, result))
},
)
.await
.expect("pending document.write result should evaluate")
}
async fn spawn_gated_parser_resource(
content_type: &'static str,
body: &'static str,
) -> (Url, tokio::sync::oneshot::Sender<()>, JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let (release, released) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.unwrap();
let mut request = vec![0; 4096];
let read = stream.read(&mut request).await.unwrap();
assert!(String::from_utf8_lossy(&request[..read]).starts_with("GET /resource "));
released.await.expect("release parser resource");
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len(),
);
stream.write_all(response.as_bytes()).await.unwrap();
stream.shutdown().await.unwrap();
});
(
Url::parse(&format!("http://{address}/resource")).unwrap(),
release,
server,
)
}
fn retain_pending_parser_page(
outcome: ParseTimePageVmCreationOutcome,
owner_wake_rx: tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
) -> PendingStandaloneDocumentWritePage {
let ParseTimePageVmCreationOutcome::PendingPhaseOne(
PendingPhaseOneResidence::ClosedInputPageWork { runtime, started },
) = outcome
else {
panic!("the remaining resource must keep the parser suspended");
};
PendingStandaloneDocumentWritePage {
runtime,
started,
owner_wake_rx,
}
}
async fn resume_after_stylesheet_completion(
mut pending: PendingStandaloneDocumentWritePage,
) -> (
ParseTimePageVmCreationOutcome,
tokio::sync::mpsc::UnboundedReceiver<crate::page_task_queue::RendererOwnerWake>,
) {
tokio::time::timeout(
std::time::Duration::from_secs(5),
wait_for_standalone_stylesheet_completion(&mut pending),
)
.await
.expect("stylesheet completion");
let pending = run_standalone_selected_page_task(
pending,
crate::runtime::page_vm::PageSelectedTaskTestSelector::StylesheetCompletion,
)
.await;
let PendingStandaloneDocumentWritePage {
runtime,
started,
owner_wake_rx,
} = pending;
resume_standalone_main_parser_continuation_if_ready(
ParseTimePageVmCreationOutcome::PendingPhaseOne(
PendingPhaseOneResidence::ClosedInputPageWork { runtime, started },
),
owner_wake_rx,
)
.await
}
#[test]
fn document_write_source_before_stylesheet_executes_once_after_both_are_ready() {
assert_parser_insertion_resource_order(true);
}
#[test]
fn document_write_stylesheet_before_source_executes_once_after_both_are_ready() {
assert_parser_insertion_resource_order(false);
}
fn assert_parser_insertion_resource_order(source_first: bool) {
super::tests::run_phase_one_large_stack_test("parser-insertion-resource-order", move || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (css, release_css, css_server) = spawn_gated_parser_resource(
"text/css", "html { color: rgb(1, 2, 3); }",
).await;
let (js, release_js, js_server) = spawn_gated_parser_resource(
"text/javascript", "events.push('external'); globalThis.tailAtScript = !!document.getElementById('tail');",
).await;
let mut release_css = Some(release_css);
let mut release_js = Some(release_js);
let html = format!(r#"<!doctype html><html><head><script>
globalThis.events = [];
document.write(`<link rel="stylesheet" href="{css}"><script src="{js}" onload="events.push('load')"><\/script><span id="written">written</span>`);
events.push('outer');
</script></head><body><p id="tail">tail</p></body></html>"#);
let pending = start_standalone_document_write_page(html, css.join("page.html").unwrap()).await;
let (outcome, wake) = if source_first {
release_js.take().unwrap().send(()).unwrap();
resume_standalone_document_write_page(pending).await
} else {
release_css.take().unwrap().send(()).unwrap();
resume_after_stylesheet_completion(pending).await
};
let pending = retain_pending_parser_page(outcome, wake);
let (pending, result) = evaluate_pending_on_owner_local_task(pending,
"JSON.stringify({events, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
).await;
assert_eq!(result["value"], r#"{"events":["outer"],"tail":false,"written":false}"#);
let (outcome, wake) = if source_first {
release_css.take().unwrap().send(()).unwrap();
resume_after_stylesheet_completion(pending).await
} else {
release_js.take().unwrap().send(()).unwrap();
resume_standalone_document_write_page(pending).await
};
let (outcome, _) = resume_standalone_main_parser_continuation_if_ready(outcome, wake).await;
let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = outcome else {
panic!("both resources must release the same parser blocker");
};
let result = evaluate_on_owner_local_task(page_vm,
"JSON.stringify({events, tailAtScript, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
).await;
assert_eq!(result["value"], r#"{"events":["outer","external","load"],"tailAtScript":false,"tail":true,"written":true}"#);
css_server.await.unwrap();
js_server.await.unwrap();
}));
});
}
#[test]
fn resumed_main_parser_script_preserves_the_blocker_installed_by_its_nested_write() {
super::tests::run_phase_one_large_stack_test("main-parser-reentrant-blocker", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (css, release_css, css_server) = spawn_gated_parser_resource(
"text/css", "html { color: rgb(1, 2, 3); }",
).await;
let (js, release_js, js_server) = spawn_gated_parser_resource(
"text/javascript", "events.push('inner');",
).await;
let html = format!(r#"<!doctype html><html><head><link rel="stylesheet" href="{css}"><script>
globalThis.events = ['outer-before'];
document.write(`<script src="{js}"><\/script><span id="written">written</span>`);
events.push('outer-after');
</script></head><body><p id="tail">tail</p></body></html>"#);
let pending = start_standalone_parser_page(
PageId::new_for_testing(903), html, css.join("page.html").unwrap(),
).await;
assert!(pending.runtime.page_vm.vm().document_runtime.pending_main_parser_script().is_some());
release_css.send(()).unwrap();
let (outcome, wake) = resume_after_stylesheet_completion(pending).await;
let pending = retain_pending_parser_page(outcome, wake);
let document = &pending.runtime.page_vm.vm().document_runtime;
assert!(document.pending_main_parser_script().is_none());
assert!(document.has_pending_document_write_external_script_load());
let (pending, result) = evaluate_pending_on_owner_local_task(pending,
"JSON.stringify({events, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
).await;
assert_eq!(result["value"], r#"{"events":["outer-before","outer-after"],"tail":false,"written":false}"#);
release_js.send(()).unwrap();
let (outcome, wake) = resume_standalone_document_write_page(pending).await;
let (outcome, _) = resume_standalone_main_parser_continuation_if_ready(outcome, wake).await;
let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = outcome else {
panic!("the nested blocker must retain its own continuation");
};
let result = evaluate_on_owner_local_task(page_vm,
"JSON.stringify({events, tail: !!document.getElementById('tail'), written: !!document.getElementById('written')})",
).await;
assert_eq!(result["value"], r#"{"events":["outer-before","outer-after","inner"],"tail":true,"written":true}"#);
css_server.await.unwrap();
js_server.await.unwrap();
}));
});
}
#[test]
fn parser_driver_retains_stylesheet_suspension_until_its_continuation() {
assert_stylesheet_suspension_resume_owner(ParserResumeOwner::ParserDriver);
}
#[test]
fn document_write_retains_stylesheet_suspension_until_its_continuation() {
assert_stylesheet_suspension_resume_owner(ParserResumeOwner::DocumentWrite);
}
fn assert_stylesheet_suspension_resume_owner(resume_owner: ParserResumeOwner) {
super::tests::run_phase_one_large_stack_test("stylesheet-suspension-owner", move || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let listener = TcpListener::bind("127.0.0.1:0").await.expect("stylesheet server");
let address = listener.local_addr().expect("server address");
let document_url = Url::parse(&format!("http://{address}/page.html")).unwrap();
let (release_tx, release_rx) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.expect("stylesheet request");
let mut request = vec![0; 4096];
let read = stream.read(&mut request).await.expect("read stylesheet request");
assert!(String::from_utf8_lossy(&request[..read]).starts_with("GET /slow.css "));
release_rx.await.expect("release stylesheet response");
let css = "html { color: rgb(1, 2, 3); }";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/css\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{css}",
css.len(),
);
stream.write_all(response.as_bytes()).await.expect("stylesheet response");
stream.shutdown().await.expect("stylesheet response closed");
});
let blocked_html = r#"<link rel="stylesheet" href="/slow.css"><script>
__resumeEvents.push('script');
globalThis.__tailAtScript = !!document.getElementById('parser-tail');
</script>"#;
let html = match resume_owner {
ParserResumeOwner::ParserDriver => format!(
"<!doctype html><html><head><script>globalThis.__resumeEvents = ['outer'];</script>{blocked_html}</head><body><p id='parser-tail'>tail</p></body></html>",
),
ParserResumeOwner::DocumentWrite => format!(
"<!doctype html><html><head><script>globalThis.__resumeEvents = ['outer']; document.write(`{}`); __resumeEvents.push('outer-done');</script></head><body><p id='parser-tail'>tail</p></body></html>",
blocked_html.replace("</script>", "<\\/script>"),
),
};
let mut pending = start_standalone_parser_page(
PageId::new_for_testing(902), html, document_url,
).await;
let suspended_state = pending.runtime.state.parser_session.run_state();
assert!(matches!(suspended_state, DocumentParserRunState::Suspended {
cause: ParserSuspensionCause::ParserClassicStylesheets { .. },
resume_owner: actual_owner, ..
} if actual_owner == resume_owner));
let (next_pending, result) = evaluate_pending_on_owner_local_task(
pending,
"JSON.stringify({events: __resumeEvents, tail: !!document.getElementById('parser-tail')})",
).await;
pending = next_pending;
let expected_before = match resume_owner {
ParserResumeOwner::ParserDriver => r#"{"events":["outer"],"tail":false}"#,
ParserResumeOwner::DocumentWrite => r#"{"events":["outer","outer-done"],"tail":false}"#,
};
assert_eq!(result.get("value").and_then(serde_json::Value::as_str), Some(expected_before));
// A fresh parser turn must preserve the same blocker while CSS is pending.
let executor = pending.runtime.page_vm.local_executor.clone();
pending = super::access::run_named_owner_local_task(
executor,
"stylesheet-suspended parser turn channel closed",
async move {
pending.runtime.owner = ParseTimeOwner::Parser;
pending.runtime.pending_parsing_blocking_wait = PendingParsingBlockingWait::None;
assert_eq!(pending.runtime.drive_owner_step().await?, OwnerStepProgress::BlockedOnPageTask);
assert_eq!(pending.runtime.state.parser_session.run_state(), suspended_state);
Ok(pending)
},
).await.expect("parser should remain suspended");
release_tx.send(()).expect("release CSS");
tokio::time::timeout(
std::time::Duration::from_secs(2),
wait_for_standalone_stylesheet_completion(&mut pending),
).await.expect("CSS completion should arrive");
pending = run_standalone_selected_page_task(
pending,
crate::runtime::page_vm::PageSelectedTaskTestSelector::StylesheetCompletion,
).await;
assert_eq!(
pending.runtime.state.parser_session.run_state(), suspended_state,
"CSS completion must leave resumption to the selected parser continuation",
);
let PendingStandaloneDocumentWritePage { runtime, started, owner_wake_rx } = pending;
let (outcome, _) = resume_standalone_main_parser_continuation_if_ready(
ParseTimePageVmCreationOutcome::PendingPhaseOne(
PendingPhaseOneResidence::ClosedInputPageWork { runtime, started },
),
owner_wake_rx,
).await;
let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = outcome else {
panic!("the owning continuation should finish the parser");
};
let result = evaluate_on_owner_local_task(
page_vm,
"JSON.stringify({events: __resumeEvents, tailAtScript: __tailAtScript, tail: !!document.getElementById('parser-tail')})",
).await;
let expected_after = match resume_owner {
ParserResumeOwner::ParserDriver => r#"{"events":["outer","script"],"tailAtScript":false,"tail":true}"#,
ParserResumeOwner::DocumentWrite => r#"{"events":["outer","outer-done","script"],"tailAtScript":false,"tail":true}"#,
};
assert_eq!(result.get("value").and_then(serde_json::Value::as_str), Some(expected_after));
server.await.expect("stylesheet server should finish");
}));
});
}
#[test]
fn standalone_document_write_external_script_uses_typed_phase_one_route() {
super::tests::run_phase_one_large_stack_test("typed-document-write-phase-one", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) = spawn_document_write_script_server(
"globalThis.__documentWriteEvents.push('external');",
)
.await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><html><body><script>
globalThis.__documentWriteEvents = ['inline-before'];
document.write(`<script src="{script_url}" onload="globalThis.__documentWriteEvents.push('load')"><\/script><span id="written-tail">written</span>`);
globalThis.__documentWriteEvents.push('inline-after');
</script><p id="parser-tail">parser</p></body></html>"#,
);
let page_vm = finish_standalone_document_write_page(html, document_url).await;
let result = evaluate_on_owner_local_task(
page_vm,
r#"JSON.stringify({
events: globalThis.__documentWriteEvents,
writtenTail: !!document.getElementById('written-tail'),
parserTail: !!document.getElementById('parser-tail')
})"#,
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(
r#"{"events":["inline-before","inline-after","external","load"],"writtenTail":true,"parserTail":true}"#,
),
"one typed terminal must execute the external script and synchronously resume its parser insertion"
);
server
.await
.expect("document.write script server should finish");
}));
});
}
#[test]
fn document_write_completion_settles_a_completed_stylesheet_preload_during_parser_admission() {
super::tests::run_phase_one_large_stack_test(
"document-write-completed-stylesheet-preload",
|| {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (
script_url,
stylesheet_url,
script_release,
stylesheet_served,
server,
) = spawn_document_write_script_with_completed_stylesheet_preload_server().await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><html><head><script>
globalThis.__completedPreloadEvents = ['inline-before'];
document.write(`<script src="{script_url}" onload="__completedPreloadEvents.push('script-load')"><\/script><link id="inserted-ready-style" rel="stylesheet" href="{stylesheet_url}" onload="__completedPreloadEvents.push('style-load')"><script>__completedPreloadEvents.push('tail')<\/script>`);
globalThis.__completedPreloadEvents.push('inline-after');
</script><link rel="preload" as="style" href="{stylesheet_url}"></head><body></body></html>"#,
);
let mut pending =
start_standalone_document_write_page(html, document_url).await;
tokio::time::timeout(std::time::Duration::from_secs(2), stylesheet_served)
.await
.expect("the scanned stylesheet preload should reach the local server")
.expect("the scanned stylesheet preload server should report completion");
wait_for_standalone_stylesheet_completion(&mut pending).await;
pending = run_standalone_selected_page_task(
pending,
crate::runtime::page_vm::PageSelectedTaskTestSelector::StylesheetCompletion,
)
.await;
assert!(
!pending
.runtime
.page_vm
.has_ready_dom_manipulation_task_for_test(),
"an ownerless preload must not publish an element event"
);
script_release
.send(())
.expect("document.write script response should be released");
drop(wait_for_standalone_page_resource(&mut pending).await);
pending = run_standalone_selected_page_task(
pending,
crate::runtime::page_vm::PageSelectedTaskTestSelector::ResourceCompletion,
)
.await;
let (pending_after_resource, result) = evaluate_pending_on_owner_local_task(
pending,
r#"JSON.stringify({
events: globalThis.__completedPreloadEvents,
linkConnected: !!document.getElementById('inserted-ready-style'),
sheet: Object.prototype.toString.call(document.getElementById('inserted-ready-style').sheet)
})"#,
)
.await;
pending = pending_after_resource;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(
r#"{"events":["inline-before","inline-after","external","script-load","tail"],"linkConnected":true,"sheet":"[object CSSStyleSheet]"}"#,
),
"the completed-preload client must install synchronously and release the following parser script independently of its event"
);
assert!(
pending
.runtime
.page_vm
.has_ready_dom_manipulation_task_for_test(),
"parser admission must settle the adopted stylesheet and publish its later link event"
);
pending = run_standalone_selected_page_task(
pending,
crate::runtime::page_vm::PageSelectedTaskTestSelector::DomManipulation(
crate::runtime::page_vm::PageDomManipulationTestFamily::ConnectedStyleEvent,
),
)
.await;
let (_, result) = evaluate_pending_on_owner_local_task(
pending,
"__completedPreloadEvents.join('|')",
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some("inline-before|inline-after|external|script-load|tail|style-load"),
"the adopted stylesheet event must remain asynchronous after parser execution resumes"
);
server
.await
.expect("document.write stylesheet preload server should finish");
}));
},
);
}
#[test]
fn document_write_external_script_live_collection_walk_uses_incremental_parser_frontier() {
super::tests::run_phase_one_large_stack_test("document-write-live-collection", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) = spawn_document_write_script_server(
r#"
const nodes = document.getElementsByTagName("*");
const ids = [];
for (let index = 0; index < nodes.length; index++) {
if (nodes[index].id) ids.push(nodes[index].id);
}
globalThis.__documentWriteVisibleIds = ids.join("|");
"#,
)
.await;
let document_url = script_url.join("page.html").expect("document URL");
let before = (0..256)
.map(|index| format!(r#"<div id="before-{index}"><span></span></div>"#))
.collect::<String>();
let future = (0..256)
.map(|index| format!(r#"<article id="future-{index}"><i></i></article>"#))
.collect::<String>();
let html = format!(
r#"<!doctype html><html><body>{before}<script>document.write(`<script src="{script_url}"><\/script>`);</script>{future}</body></html>"#,
);
let page_vm = finish_standalone_document_write_page(html, document_url).await;
let result = evaluate_on_owner_local_task(
page_vm,
r#"JSON.stringify({
sawFirst: __documentWriteVisibleIds.includes("before-0"),
sawLast: __documentWriteVisibleIds.includes("before-255"),
hidFuture: !__documentWriteVisibleIds.includes("future-0"),
parserResumed: !!document.getElementById("future-255")
})"#,
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(
r#"{"sawFirst":true,"sawLast":true,"hidFuture":true,"parserResumed":true}"#
),
"a repeated live-collection indexed walk must observe only parser-committed DOM and let parsing resume"
);
server
.await
.expect("document.write script server should finish");
}));
});
}
#[test]
fn document_write_external_runaway_script_is_terminated_and_parser_recovers() {
super::tests::run_phase_one_large_stack_test("document-write-script-watchdog", || {
let _watchdog_timeout =
crate::v8_execution_watchdog::V8ExecutionWatchdog::override_timeout_for_test(
crate::v8_execution_watchdog::V8ExecutionWatchdogKind::ScriptTurn,
std::time::Duration::from_millis(500),
);
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) =
spawn_document_write_script_server("for (;;) {}").await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><script>document.write(`<script src="{script_url}"><\/script>`);</script><main id="parser-recovered">ready</main>"#,
);
let started = Instant::now();
let page_vm = finish_standalone_document_write_page(html, document_url).await;
assert!(
started.elapsed() < std::time::Duration::from_secs(4),
"the document.write script watchdog should interrupt the runaway turn promptly"
);
let result = evaluate_on_owner_local_task(
page_vm,
"String(!!document.getElementById('parser-recovered'))",
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some("true"),
"the parser and isolate must remain usable after terminating the written script"
);
server
.await
.expect("document.write script server should finish");
}));
});
}
#[test]
fn resident_queue_phase_one_continuation_uses_the_exact_owner_arbiter() {
super::tests::run_phase_one_large_stack_test("document-write-resident-queue", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) = spawn_document_write_script_server(
"globalThis.__residentQueueScriptRan = true;",
)
.await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><script>document.write(`<script src="{script_url}"><\/script><main id="resident-tail">tail</main>`);</script>"#,
);
let mut pending = start_standalone_document_write_page(html, document_url).await;
let resident_queue = wait_for_standalone_page_resource(&mut pending).await;
let (outcome, owner_wake_rx) =
resume_standalone_document_write_page(pending).await;
assert!(
!resident_queue.has_ready_completion(),
"one resident typed terminal should be consumed exactly once"
);
let (outcome, _) =
resume_standalone_main_parser_continuation_if_ready(outcome, owner_wake_rx).await;
let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = outcome else {
panic!("the resident terminal's parser continuation should finish this fixture");
};
let result = evaluate_on_owner_local_task(
page_vm,
r#"JSON.stringify({
scriptRan: !!globalThis.__residentQueueScriptRan,
tail: !!document.getElementById('resident-tail')
})"#,
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(r#"{"scriptRan":true,"tail":true}"#)
);
server
.await
.expect("resident queue script server should finish");
}));
});
}
#[test]
fn older_due_timer_runs_before_ready_document_write_terminal() {
super::tests::run_phase_one_large_stack_test("document-write-timer-arbitration", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) = spawn_document_write_script_server(
"globalThis.__documentWriteEvents.push('external');",
)
.await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><script>
globalThis.__documentWriteEvents = ['inline-before'];
setTimeout(() => globalThis.__documentWriteEvents.push('timer'), 0);
document.write(`<script src="{script_url}" onload="globalThis.__documentWriteEvents.push('load')"><\/script>`);
globalThis.__documentWriteEvents.push('inline-after');
</script>"#,
);
let first_pending =
start_standalone_document_write_page(html, document_url).await;
let (first_outcome, owner_wake_rx) =
resume_standalone_document_write_page(first_pending).await;
let ParseTimePageVmCreationOutcome::PendingPhaseOne(
PendingPhaseOneResidence::ClosedInputPageWork { runtime, started },
) = first_outcome
else {
panic!("the older timer must consume its own turn before the typed terminal");
};
let pending = PendingStandaloneDocumentWritePage {
runtime,
started,
owner_wake_rx,
};
let (pending, result) = evaluate_pending_on_owner_local_task(
pending,
"JSON.stringify(globalThis.__documentWriteEvents)",
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(r#"["inline-before","inline-after","timer"]"#),
"the first continuation must run only the older due timer"
);
let (second_outcome, owner_wake_rx) =
resume_standalone_document_write_page(pending).await;
let (third_outcome, _) =
resume_standalone_main_parser_continuation_if_ready(
second_outcome,
owner_wake_rx,
)
.await;
let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { page_vm, .. } = third_outcome
else {
panic!(
"the parser continuation after the retained terminal should finish phase one"
);
};
let result = evaluate_on_owner_local_task(
page_vm,
"JSON.stringify(globalThis.__documentWriteEvents)",
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(r#"["inline-before","inline-after","timer","external","load"]"#),
"transitional arbitration must preserve timer/resource order without draining both"
);
server
.await
.expect("timer arbitration script server should finish");
}));
});
}
#[test]
fn typed_document_write_fetch_failure_dispatches_error_and_resumes_parser() {
super::tests::run_phase_one_large_stack_test("typed-document-write-fetch-failure", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) = spawn_aborted_document_write_script_server().await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><html><body><script>
globalThis.__documentWriteEvents = ['inline-before'];
document.write(`<script src="{script_url}" onerror="globalThis.__documentWriteEvents.push('error')"><\/script><span id="written-tail">written</span>`);
globalThis.__documentWriteEvents.push('inline-after');
</script><p id="parser-tail">parser</p></body></html>"#,
);
let page_vm = finish_standalone_document_write_page(html, document_url).await;
let result = evaluate_on_owner_local_task(
page_vm,
r#"JSON.stringify({
events: globalThis.__documentWriteEvents,
writtenTail: !!document.getElementById('written-tail'),
parserTail: !!document.getElementById('parser-tail')
})"#,
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(
r#"{"events":["inline-before","inline-after","error"],"writtenTail":true,"parserTail":true}"#,
),
"a failed typed fetch must dispatch error and resume the suspended parser insertion"
);
server
.await
.expect("aborted document.write script server should finish");
}));
});
}
#[test]
fn document_open_before_terminal_discards_document_write_effect_but_preserves_network() {
super::tests::run_phase_one_large_stack_test("document-write-stale-before-terminal", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) = spawn_document_write_script_server(
"globalThis.__retiredDocumentWriteScriptRan = true;",
)
.await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><html><body><script>
document.write(`<script src="{script_url}"><\/script><span id="retired-written-tail">retired</span>`);
</script><p id="retired-parser-tail">retired parser</p></body></html>"#,
);
let mut pending =
start_standalone_document_write_page(html, document_url).await;
let root_document = pending.runtime.page_vm.document_lifecycle.identity().document;
let retired_target = pending
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target()
.expect("retired document.write target should exist before document.open");
let executor = pending.runtime.page_vm.local_executor.clone();
pending = super::access::run_named_owner_local_task(
executor,
"document.write stale-target replacement channel closed",
async move {
pending.runtime.page_vm.vm_mut().eval(
r#"
document.open();
document.write('<main id="replacement">replacement</main>');
document.close();
"#,
)?;
Ok(pending)
},
)
.await
.expect("document.open should replace the pending document.write owner");
assert_ne!(
pending
.runtime
.page_vm
.vm()
.current_main_document_task_owner(),
Some(retired_target.task_owner()),
"document.open must install a new main Document owner"
);
assert_eq!(
pending
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target(),
None,
"replacement must retire the old pending script target"
);
let page_resource_queue =
pending.runtime.page_vm.page_resource_completion_queue();
while !page_resource_queue.has_ready_completion() {
pending
.owner_wake_rx
.recv()
.await
.expect("the retired request should retain its owner wake route");
}
let activity_epoch_before = pending
.runtime
.page_vm
.vm()
.subresource_activity_epoch();
let executor = pending.runtime.page_vm.local_executor.clone();
let (mut pending, outcome) = super::access::run_named_owner_local_task(
executor,
"document.write stale terminal owner turn channel closed",
async move {
let (_, completion) = page_resource_queue
.pop_front()
.expect("the retired terminal should remain queued for its lane executor");
let outcome = pending
.runtime
.page_vm
.apply_selected_page_resource_completion_turn(completion)?;
Ok((pending, outcome))
},
)
.await
.expect("stale document.write terminal arbitration should succeed");
assert_eq!(
outcome.action.owner,
RendererPageResourceCompletionOwner::document_write_external_script(
root_document,
retired_target,
)
);
assert_eq!(
outcome.action.document_effect,
PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
current_owner: None,
}
);
assert_eq!(
outcome.action.output_effect,
PageResourceCompletionOutputEffect::CaptureRequired,
"the completed retired request remains historical Network output"
);
assert_eq!(
pending
.runtime
.page_vm
.vm()
.subresource_activity_epoch(),
activity_epoch_before,
"historical Network output must not become replacement Document activity"
);
let network_output = pending.runtime.page_vm.vm_mut().take_network_output();
assert!(network_output.into_items().into_iter().any(|item| {
matches!(
item,
ScriptNetworkOutputItem::SubresourceNetworkRecord(record)
if record.url() == &script_url
)
}));
let ConcurrentParseTimeRuntime { page_vm, .. } = *pending.runtime;
let result = evaluate_on_owner_local_task(
page_vm,
r#"JSON.stringify({
replacement: !!document.getElementById('replacement'),
retiredScriptRan: !!globalThis.__retiredDocumentWriteScriptRan,
writtenTail: !!document.getElementById('retired-written-tail'),
parserTail: !!document.getElementById('retired-parser-tail')
})"#,
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(
r#"{"replacement":true,"retiredScriptRan":false,"writtenTail":false,"parserTail":false}"#,
)
);
server
.await
.expect("retired document.write script server should finish");
}));
});
}
#[test]
fn load_id_mismatch_is_rejected_by_the_page_arbiter() {
super::tests::run_phase_one_large_stack_test("document-write-stale-load-id", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) = spawn_document_write_script_server(
"globalThis.__currentDocumentWriteScriptRan = true;",
)
.await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><script>document.write(`<script src="{script_url}"><\/script>`);</script>"#,
);
let mut pending =
start_standalone_document_write_page(html, document_url.clone()).await;
let root_document = pending.runtime.page_vm.document_lifecycle.identity().document;
let current_target = pending
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target()
.expect("current pending load should expose its exact target");
let stale_target = DocumentWriteExternalScriptFetchTarget::new(
current_target.task_owner(),
current_target
.load_id()
.checked_add(1)
.expect("test load id should have a successor"),
);
let stale_completion = DocumentWriteExternalScriptLoadCompletion::new(
stale_target,
Ok("globalThis.__staleLoadIdScriptRan = true;".to_owned()),
None,
DocumentWriteExternalScriptNetworkAttribution::new(
document_url,
script_url.clone(),
),
);
let mut stale_queue = RendererPageNetworkingSource::new_for_test();
stale_queue
.sender()
.send(RendererPageResourceCompletion::document_write_external_script(
root_document,
stale_completion,
))
.expect("stale load-id terminal should enter the test queue");
let executor = pending.runtime.page_vm.local_executor.clone();
let (pending, outcome) = super::access::run_named_owner_local_task(
executor,
"document.write stale-load-id arbitration channel closed",
async move {
let outcome = pending
.runtime
.page_vm
.apply_one_page_resource_terminal_owner_admission_for_test(&mut stale_queue)?
.expect("stale load-id terminal should consume one bounded turn");
Ok((pending, outcome))
},
)
.await
.expect("stale load-id arbitration should succeed");
assert_eq!(
outcome.action.document_effect,
PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
current_owner: None,
},
"an exact-target mismatch must be rejected before projecting a current owner"
);
assert_eq!(
outcome.action.output_effect,
PageResourceCompletionOutputEffect::None
);
assert_eq!(
pending
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target(),
Some(current_target),
"a mismatched load id must not consume the current pending load"
);
let (pending, result) = evaluate_pending_on_owner_local_task(
pending,
"String(globalThis.__staleLoadIdScriptRan)",
)
.await;
assert_eq!(result.get("value").and_then(serde_json::Value::as_str), Some("undefined"));
// Keep the pending page, and therefore its request client, alive until the server has
// accepted and served the current script load. Dropping it before this await can
// cancel the connect while the server is still blocked in `accept()`.
server
.await
.expect("current document.write script server should finish");
drop(pending);
}));
});
}
#[test]
fn root_document_namespace_rejects_cross_page_target_collision() {
super::tests::run_phase_one_large_stack_test("document-write-root-document-namespace", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (retired_script_url, retired_server) = spawn_document_write_script_server(
"globalThis.__retiredNamespaceScriptRan = true;",
)
.await;
let (current_script_url, current_server) = spawn_document_write_script_server(
"globalThis.__currentNamespaceScriptRan = true;",
)
.await;
let retired_html = format!(
r#"<!doctype html><script>document.write(`<script src="{retired_script_url}"><\/script>`);</script>"#,
);
let current_html = format!(
r#"<!doctype html><script>document.write(`<script src="{current_script_url}"><\/script>`);</script>"#,
);
let mut retired = start_standalone_document_write_page(
retired_html,
retired_script_url.join("page.html").expect("retired page URL"),
)
.await;
let mut current = start_standalone_document_write_page_for_page_id(
PageId::new_for_testing(902),
current_html,
current_script_url.join("page.html").expect("current page URL"),
)
.await;
let retired_root = retired
.runtime
.page_vm
.document_lifecycle
.identity()
.document;
let current_root = current
.runtime
.page_vm
.document_lifecycle
.identity()
.document;
let retired_target = retired
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target()
.expect("retired PageVm should expose its pending exact target");
let current_target = current
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target()
.expect("current PageVm should expose its pending exact target");
assert_eq!(
retired_target, current_target,
"fresh PageVms naturally reuse their PageVm-local owner/load namespace"
);
assert_ne!(
retired_root, current_root,
"root Document tokens must distinguish the colliding local targets"
);
let mut retired_queue = wait_for_standalone_page_resource(&mut retired).await;
let _current_queue = wait_for_standalone_page_resource(&mut current).await;
let activity_epoch_before = current
.runtime
.page_vm
.vm()
.subresource_activity_epoch();
let executor = current.runtime.page_vm.local_executor.clone();
let (mut current, outcome) = super::access::run_named_owner_local_task(
executor,
"document.write root namespace arbitration channel closed",
async move {
let outcome = current
.runtime
.page_vm
.apply_one_page_resource_terminal_owner_admission_for_test(&mut retired_queue)?
.expect("the retired terminal should consume one bounded turn");
Ok((current, outcome))
},
)
.await
.expect("root namespace arbitration should succeed");
assert_eq!(
outcome.action.owner,
RendererPageResourceCompletionOwner::document_write_external_script(
retired_root,
retired_target,
)
);
assert_eq!(
outcome.action.document_effect,
PageResourceCompletionDocumentEffect::DiscardedStaleOwner {
current_owner: Some(
RendererPageResourceCompletionOwner::document_write_external_script(
current_root,
current_target,
),
),
}
);
assert_eq!(
outcome.action.output_effect,
PageResourceCompletionOutputEffect::CaptureRequired
);
assert_eq!(
current
.runtime
.page_vm
.vm()
.subresource_activity_epoch(),
activity_epoch_before,
"retired Network output must not become current PageVm activity"
);
assert_eq!(
current
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target(),
Some(current_target),
"a colliding retired terminal must leave the current pending load untouched"
);
let network_output = current.runtime.page_vm.vm_mut().take_network_output();
assert!(network_output.into_items().into_iter().any(|item| {
matches!(
item,
ScriptNetworkOutputItem::SubresourceNetworkRecord(record)
if record.url() == &retired_script_url
)
}));
let ConcurrentParseTimeRuntime { page_vm, .. } = *current.runtime;
let result = evaluate_on_owner_local_task(
page_vm,
"String(globalThis.__retiredNamespaceScriptRan)",
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some("undefined"),
"retired source must not execute in the colliding current PageVm"
);
retired_server
.await
.expect("retired namespace script server should finish");
current_server
.await
.expect("current namespace script server should finish");
}));
});
}
#[test]
fn sequential_document_write_scripts_require_distinct_fifo_owner_turns() {
super::tests::run_phase_one_large_stack_test("document-write-sequential-fifo", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (first_url, second_url, shutdown_server, server) =
spawn_two_document_write_script_server(
"globalThis.__documentWriteEvents.push('first');",
"globalThis.__documentWriteEvents.push('second');",
)
.await;
let document_url = first_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><html><body><script>
globalThis.__documentWriteEvents = ['inline-before'];
document.write(`<script src="{first_url}" onload="globalThis.__documentWriteEvents.push('first-load')" onerror="globalThis.__documentWriteEvents.push('first-error')"><\/script><script src="{second_url}" onload="globalThis.__documentWriteEvents.push('second-load')" onerror="globalThis.__documentWriteEvents.push('second-error')"><\/script><span id="written-tail">written</span>`);
globalThis.__documentWriteEvents.push('inline-after');
</script><p id="parser-tail">parser</p></body></html>"#,
);
let first_pending =
start_standalone_document_write_page(html, document_url).await;
let first_target = first_pending
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target()
.expect("first sequential script should expose its exact target");
let (first_outcome, owner_wake_rx) =
resume_standalone_document_write_page(first_pending).await;
let (first_outcome, owner_wake_rx) =
resume_standalone_main_parser_continuation_if_ready(
first_outcome,
owner_wake_rx,
)
.await;
let ParseTimePageVmCreationOutcome::PendingPhaseOne(
PendingPhaseOneResidence::ClosedInputPageWork { runtime, started },
) = first_outcome
else {
panic!("one owner turn must not consume both sequential script terminals");
};
let second_pending = PendingStandaloneDocumentWritePage {
runtime,
started,
owner_wake_rx,
};
let second_target = second_pending
.runtime
.page_vm
.vm()
.current_document_write_external_script_fetch_target()
.expect("second sequential script should install its own exact target");
assert_eq!(
second_target.task_owner(),
first_target.task_owner(),
"both sequential loads belong to the same exact Document"
);
assert!(
second_target.load_id() > first_target.load_id(),
"sequential loads need distinct monotonic request identities"
);
let (second_outcome, owner_wake_rx) =
resume_standalone_document_write_page(second_pending).await;
let (second_outcome, _) =
resume_standalone_main_parser_continuation_if_ready(
second_outcome,
owner_wake_rx,
)
.await;
let ParseTimePageVmCreationOutcome::ContinuePhaseTwo { mut page_vm, .. } =
second_outcome
else {
panic!("the second script continuation should finish this two-script fixture");
};
shutdown_server
.send(())
.expect("completed two-script fixture should stop its server");
let (first_requests, second_requests) = server
.await
.expect("two-script document.write server should finish");
assert_eq!(first_requests, 1, "the first blocking script loads once");
assert!(
second_requests >= 1,
"the second blocking script must perform or join a real fetch"
);
let network_output = page_vm.vm_mut().take_network_output();
let network_records = network_output
.into_items()
.filter_map(|item| match item {
ScriptNetworkOutputItem::SubresourceNetworkRecord(record) => Some(record),
_ => None,
})
.collect::<Vec<_>>();
assert_eq!(network_records.len(), 2);
assert_eq!(network_records[0].url(), &first_url);
assert_eq!(network_records[1].url(), &second_url);
assert!(matches!(
network_records[0].outcome(),
SubresourceNetworkOutcome::Success { .. }
));
assert!(matches!(
network_records[1].outcome(),
SubresourceNetworkOutcome::Success { .. }
));
let result = evaluate_on_owner_local_task(
page_vm,
r#"JSON.stringify({
events: globalThis.__documentWriteEvents,
writtenTail: !!document.getElementById('written-tail'),
parserTail: !!document.getElementById('parser-tail')
})"#,
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(
r#"{"events":["inline-before","inline-after","first","first-load","second","second-load"],"writtenTail":true,"parserTail":true}"#,
),
"separate owner turns must preserve parser insertion and script-event FIFO order"
);
}));
});
}
#[test]
fn document_write_load_handler_replacement_cannot_resume_retired_parser_insertion() {
super::tests::run_phase_one_large_stack_test("document-write-replacement-reentry", || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("current-thread runtime should build");
runtime.block_on(tokio::task::LocalSet::new().run_until(async move {
let _js_runtime = crate::JsRuntime::initialize();
let (script_url, server) =
spawn_document_write_script_server("globalThis.__documentWriteExternalRan = true;")
.await;
let document_url = script_url.join("page.html").expect("document URL");
let html = format!(
r#"<!doctype html><html><body><script>
document.write(`<script src="{script_url}" onload="document.open(); document.write('<main id="replacement">replacement</main>'); document.close();"><\/script><span id="retired-written-tail">retired</span>`);
</script><p id="retired-parser-tail">retired parser</p></body></html>"#,
);
let page_vm = finish_standalone_document_write_page(html, document_url).await;
let result = evaluate_on_owner_local_task(
page_vm,
r#"JSON.stringify({
replacement: !!document.getElementById('replacement'),
writtenTail: !!document.getElementById('retired-written-tail'),
parserTail: !!document.getElementById('retired-parser-tail')
})"#,
)
.await;
assert_eq!(
result.get("value").and_then(serde_json::Value::as_str),
Some(r#"{"replacement":true,"writtenTail":false,"parserTail":false}"#),
"load-handler document.open must retire the old insertion before it can resume"
);
server
.await
.expect("document.write replacement script server should finish");
}));
});
}