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::{
ExternalRawDocumentBodyStream, JsRuntime, JsRuntimeOwner, PageVmInitStage,
PreparedRendererDocument, RendererCaptureScreenshotReply, RendererInputDispatchOutcome,
RendererOutputItem, RendererOutputPublication, RendererOutputResidenceIdentity,
RendererOutputTransportMessage, RendererOutputTransportReceiver, RendererOutputTransportSender,
RendererOwnerAction, RendererPageCommand, RendererPageHandle, RendererPageReply,
RendererPageTestingHandle, RendererPendingPopupActivation, RendererPointerEventProperties,
RendererProtocolObservation, RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage,
};
use crate::local_executor::{is_on_script_execution_lane_for, scope_on_scaffold_js_local_executor};
use crate::network::ResourceRequestClient;
use crate::{
RendererDocumentLifecycleEventKind, RendererDocumentLifecycleMilestone,
RendererNavigationReplyPolicy, RendererReplyBoundary, RendererTopLevelNavigationDispatch,
};
use std::collections::HashSet;
use std::io::Cursor;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio::sync::{mpsc, oneshot};
mod auxiliary_pages;
mod open_streaming;
mod redirect_chain;
async fn prepare_test_external_raw_document(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
raw_body: ExternalRawDocumentBodyStream,
) -> PreparedRendererDocument {
prepare_test_external_raw_document_with_content_type(
runtime,
loader,
url,
"text/html",
raw_body,
)
.await
}
async fn prepare_test_external_raw_document_with_content_type(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
content_type: &str,
raw_body: ExternalRawDocumentBodyStream,
) -> PreparedRendererDocument {
prepare_test_external_raw_document_with_content_type_and_reply_boundary(
runtime,
loader,
url,
content_type,
raw_body,
RendererReplyBoundary::Stage,
)
.await
}
async fn prepare_test_external_raw_document_with_content_type_and_reply_boundary(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
content_type: &str,
raw_body: ExternalRawDocumentBodyStream,
reply_boundary: RendererReplyBoundary,
) -> PreparedRendererDocument {
runtime
.prepare_streaming_raw_document_from_external_body(
runtime.reserve_page_for_creation(),
url.clone(),
url,
None,
false,
0,
Vec::new(),
200,
vec![("content-type".to_owned(), content_type.as_bytes().to_vec())],
loader,
crate::RendererWebStorageHandles::ephemeral(),
raw_body,
false,
PageVmInitStage::Load,
reply_boundary,
RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,
RendererNavigationReplyPolicy::FollowBeforeReply,
None,
None,
crate::RendererDocumentOptions {
..Default::default()
},
)
.await
.expect("external raw document should prepare")
}
struct RendererExternalActivityTestReceiver(RendererOutputTransportReceiver);
impl RendererExternalActivityTestReceiver {
async fn recv_message(&mut self) -> RendererOutputTransportMessage {
tokio::time::timeout(Duration::from_secs(1), self.0.recv())
.await
.expect("renderer output message should arrive before the test deadline")
.expect("renderer output transport should remain open")
}
async fn recv(&mut self) -> Option<RendererOutputPublication> {
loop {
match self.0.recv().await? {
RendererOutputTransportMessage::Publication(publication) => {
return Some(publication);
}
RendererOutputTransportMessage::StreamControl(_)
| RendererOutputTransportMessage::PageReservationReleased { .. }
| RendererOutputTransportMessage::CursorLeaseDeclared { .. }
| RendererOutputTransportMessage::CursorLeaseReleased { .. } => {}
}
}
}
fn try_recv(&mut self) -> Result<RendererOutputPublication, mpsc::error::TryRecvError> {
loop {
match self.0.try_recv()? {
RendererOutputTransportMessage::Publication(publication) => {
return Ok(publication);
}
RendererOutputTransportMessage::StreamControl(_)
| RendererOutputTransportMessage::PageReservationReleased { .. }
| RendererOutputTransportMessage::CursorLeaseDeclared { .. }
| RendererOutputTransportMessage::CursorLeaseReleased { .. } => {}
}
}
}
fn drain(&mut self) -> Vec<RendererOutputPublication> {
let mut publications = Vec::new();
while let Ok(publication) = self.try_recv() {
publications.push(publication);
}
publications
}
fn drain_runtime_binding_calls_for_page(
&mut self,
page: &RendererPageHandle,
) -> Vec<crate::native_bridge::PendingRuntimeBindingCall> {
self.drain()
.into_iter()
.filter(|publication| publication_is_for_page(publication, page))
.flat_map(RendererOutputPublication::into_records)
.filter_map(|record| match record.into_parts().1 {
RendererOutputItem::Observation(RendererProtocolObservation::RuntimeBinding(
call,
)) => Some(call),
_ => None,
})
.collect()
}
fn drain_runtime_inspector_messages_for_page(
&mut self,
page: &RendererPageHandle,
) -> Vec<serde_json::Value> {
self.drain()
.into_iter()
.filter(|publication| publication_is_for_page(publication, page))
.flat_map(RendererOutputPublication::into_records)
.filter_map(|record| match record.into_parts().1 {
RendererOutputItem::Observation(RendererProtocolObservation::RuntimeInspector(
batch,
)) => Some(batch.messages),
_ => None,
})
.flatten()
.map(runtime_inspector_message_protocol_message_for_test)
.collect()
}
async fn recv_top_level_location_navigation(
&mut self,
) -> Option<super::RendererDocumentSourcedTopLevelLocationNavigation> {
loop {
if let Some(navigation) =
self.recv()
.await?
.records()
.iter()
.find_map(|record| match record.item() {
super::RendererOutputItem::OwnerAction(
super::RendererOwnerAction::TopLevelLocationNavigation(navigation),
) => Some(navigation.clone()),
_ => None,
})
{
return Some(navigation);
}
}
}
}
fn renderer_external_activity_test_channel() -> (
RendererOutputTransportSender,
RendererExternalActivityTestReceiver,
) {
let (tx, rx) = super::renderer_output_transport_channel();
(tx, RendererExternalActivityTestReceiver(rx))
}
fn publication_is_for_page(
publication: &RendererOutputPublication,
page: &RendererPageHandle,
) -> bool {
matches!(
publication.cursor().stream().residence(),
RendererOutputResidenceIdentity::Page {
owner_local_host_id,
page_id,
} if owner_local_host_id == page.owner_local_host_id()
&& page_id == page.renderer_page_id()
)
}
fn publication_document_lifecycle_events(
publication: &RendererOutputPublication,
) -> impl Iterator<Item = &super::RendererDocumentLifecycleEvent> {
publication
.records()
.iter()
.filter_map(|record| match record.item() {
super::RendererOutputItem::Observation(
super::RendererProtocolObservation::DocumentLifecycle(event),
) => Some(event),
_ => None,
})
}
fn popup_activations_for_page(
publications: &[RendererOutputPublication],
page: &RendererPageHandle,
) -> Vec<RendererPendingPopupActivation> {
publications
.iter()
.filter(|publication| publication_is_for_page(publication, page))
.flat_map(RendererOutputPublication::records)
.filter_map(|record| match record.item() {
RendererOutputItem::OwnerAction(RendererOwnerAction::Popup(activation)) => {
Some(activation.clone())
}
_ => None,
})
.collect()
}
async fn recv_page_lifecycle_until(
receiver: &mut RendererExternalActivityTestReceiver,
page: &RendererPageHandle,
milestone: RendererDocumentLifecycleMilestone,
) -> Vec<super::RendererDocumentLifecycleEvent> {
let mut events = Vec::new();
while let Some(publication) = receiver.recv().await {
if !publication_is_for_page(&publication, page) {
continue;
}
let publication_events = publication_document_lifecycle_events(&publication)
.copied()
.collect::<Vec<_>>();
let reached_milestone = publication_events
.iter()
.any(|event| event.kind == RendererDocumentLifecycleEventKind::Milestone(milestone));
events.extend(publication_events);
if reached_milestone {
return events;
}
}
panic!("renderer output transport closed before {milestone:?}")
}
async fn serialize_html_for_renderer_page(page: &RendererPageHandle) -> String {
let (reply, _) = page
.run_async_command(RendererPageCommand::SerializeDocument)
.await
.expect("renderer page should serialize HTML");
match reply {
RendererPageReply::SerializedDocument { html, .. } => html,
_ => panic!("expected serialized document reply"),
}
}
async fn outer_html_for_renderer_document(
page: &RendererPageHandle,
include_shadow_dom: bool,
) -> String {
let (reply, _) = page
.run_async_command(RendererPageCommand::OuterHtmlForDocument { include_shadow_dom })
.await
.expect("renderer page should serialize document outer HTML");
match reply {
RendererPageReply::OptionalString(Some(html)) => html,
_ => panic!("expected document outer HTML string reply"),
}
}
fn initialize_layout_test_runtime() -> JsRuntimeOwner {
let runtime = JsRuntime::initialize();
runtime
.renderer_owner_handle()
.configure_layout_policy(crate::real_layout_test_policy())
.expect("layout test policy should configure before page creation");
runtime
}
async fn capture_screenshot_for_renderer_page(
page: &RendererPageHandle,
) -> super::RendererCapturedScreenshot {
let (reply, _) = page
.run_async_command(RendererPageCommand::CaptureScreenshot(
super::RendererCaptureScreenshotRequest::viewport_png(),
))
.await
.expect("renderer page should capture a screenshot");
match reply {
RendererPageReply::CaptureScreenshot(RendererCaptureScreenshotReply::Captured(image)) => {
image
}
_ => panic!("expected captured screenshot reply"),
}
}
fn mouse_input_json_witness(reply: &RendererPageReply) -> serde_json::Value {
let RendererPageReply::RuntimeEvaluationResult(result) = reply else {
panic!(
"expected JSON-string input witness; unexpected reply variant: {:?}",
std::mem::discriminant(reply)
);
};
let payload = result.as_protocol_payload();
let serialized = payload
.get("value")
.and_then(serde_json::Value::as_str)
.unwrap_or_else(|| panic!("expected JSON-string input witness; raw payload: {payload:?}"));
serde_json::from_str(serialized).unwrap_or_else(|error| {
panic!("invalid input witness JSON: {error}; raw payload: {payload:?}")
})
}
async fn dispatch_wheel_for_action_window_test(
page: &RendererPageHandle,
delta_y: f64,
) -> RendererInputDispatchOutcome {
let (reply, _) = page
.run_async_command(RendererPageCommand::DispatchMouseEventAtPoint {
x: 10.0,
y: 10.0,
event_name: "wheel".to_owned(),
button: -1,
buttons: Some(0),
click_count: 0,
delta_x: 0.0,
delta_y,
pointer: RendererPointerEventProperties::default(),
modifiers: 0,
})
.await
.expect("wheel action should enter the renderer action window");
match reply {
RendererPageReply::InputDispatchOutcome(outcome) => outcome,
_ => panic!("wheel action should return an input dispatch outcome"),
}
}
async fn capture_screenshot_with_request(
page: &RendererPageHandle,
request: super::RendererCaptureScreenshotRequest,
) -> super::RendererCapturedScreenshot {
let (reply, _) = page
.run_async_command(RendererPageCommand::CaptureScreenshot(request))
.await
.expect("renderer page should capture a screenshot");
match reply {
RendererPageReply::CaptureScreenshot(RendererCaptureScreenshotReply::Captured(image)) => {
image
}
_ => panic!("expected captured screenshot reply"),
}
}
async fn capture_screencast_frame_with_request(
page: &RendererPageHandle,
request: super::RendererCaptureScreencastFrameRequest,
) -> super::RendererCapturedScreencastFrame {
let (reply, _) = page
.run_async_command(RendererPageCommand::CaptureScreencastFrame(request))
.await
.expect("renderer page should capture a screencast frame");
match reply {
RendererPageReply::CaptureScreencastFrame(
super::RendererCaptureScreencastFrameReply::Captured(frame),
) => frame,
_ => panic!("expected captured screencast frame reply"),
}
}
fn decoded_png_pixel(bytes: &[u8], x: u32, y: u32) -> [u8; 4] {
let decoder = png::Decoder::new(Cursor::new(bytes));
let mut reader = decoder.read_info().expect("valid PNG header");
let mut buffer = vec![
0;
reader
.output_buffer_size()
.expect("decoded PNG buffer size fits in memory")
];
let output = reader.next_frame(&mut buffer).expect("valid PNG data");
assert_eq!(output.color_type, png::ColorType::Rgba);
assert_eq!(output.bit_depth, png::BitDepth::Eight);
let offset = ((y * output.width + x) * 4) as usize;
buffer[offset..offset + 4]
.try_into()
.expect("one RGBA pixel")
}
fn decoded_png_dark_pixel_count(
bytes: &[u8],
x_start: u32,
x_end: u32,
y_start: u32,
y_end: u32,
) -> usize {
let decoder = png::Decoder::new(Cursor::new(bytes));
let mut reader = decoder.read_info().expect("valid PNG header");
let mut buffer = vec![
0;
reader
.output_buffer_size()
.expect("decoded PNG buffer size fits in memory")
];
let output = reader.next_frame(&mut buffer).expect("valid PNG data");
assert_eq!(output.color_type, png::ColorType::Rgba);
assert_eq!(output.bit_depth, png::BitDepth::Eight);
let x_end = x_end.min(output.width);
let y_end = y_end.min(output.height);
let mut count = 0;
for y in y_start.min(y_end)..y_end {
for x in x_start.min(x_end)..x_end {
let offset = ((y * output.width + x) * 4) as usize;
let pixel = &buffer[offset..offset + 4];
if pixel[0] < 80 && pixel[1] < 80 && pixel[2] < 80 && pixel[3] > 0 {
count += 1;
}
}
}
count
}
async fn assert_committed_navigation_bootstrap_injection_retires_page(
injection_header: &'static str,
expected_failure: &str,
) {
let runtime = JsRuntime::initialize();
let loader =
ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader");
let (base_url, server) = spawn_owner_wake_server_with_content_type_and_headers(
"/replacement",
"<!doctype html><main>replacement</main>",
"text/html",
vec![(injection_header, "1")],
Duration::ZERO,
)
.await;
let source_url = url::Url::parse(&format!("{base_url}/source")).expect("source URL");
let replacement_url = format!("{base_url}/replacement");
let replacement_url_literal =
serde_json::to_string(&replacement_url).expect("serialize replacement URL");
let html = format!(
"<!doctype html><script>location.href = {replacement_url_literal};</script><main>source</main>"
);
let pending = start_test_html_page_with_optional_indexed_db_manager_and_navigation_dispatch(
&runtime,
&loader,
source_url,
&html,
None,
RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,
);
let result = pending.await_ready().await;
let Err(error) = result else {
panic!("the injected post-commit bootstrap termination must reject page creation")
};
let failure = format!("{error:#}");
assert!(
failure.contains(expected_failure),
"page creation must report the injected post-commit failure: {failure}"
);
server
.await
.expect("post-commit failure server should finish");
assert_eq!(
runtime.renderer_page_count_for_testing(),
0,
"a committed navigation bootstrap failure must not restore its inert PageVm as live"
);
let mut survivor = create_test_html_page(
&runtime,
&loader,
url::Url::parse("about:blank").expect("survivor URL"),
"<!doctype html><main>survivor</main>",
)
.await;
survivor
.close_async()
.await
.expect("renderer owner should remain usable after retiring the failed navigation");
assert_eq!(runtime.renderer_page_count_for_testing(), 0);
}
// This witness needs one renderer-owner worker and one observer worker.
fn renderer_json_value(reply: RendererPageReply) -> Option<serde_json::Value> {
match reply {
RendererPageReply::RuntimeEvaluationResult(result) => {
result.into_protocol_payload().get("value").cloned()
}
_ => None,
}
}
async fn assert_window_performance_surface_for_test(page: &RendererPageHandle, phase: &str) {
let (surface, _) = page
.run_async_command(RendererPageCommand::EvaluateExpression {
expression: r#"JSON.stringify({
sameObject: performance === performance,
prototype: Object.getPrototypeOf(performance) === Performance.prototype,
finiteTimeOrigin: Number.isFinite(performance.timeOrigin)
})"#
.to_owned(),
await_promise: false,
})
.await
.unwrap_or_else(|error| panic!("{phase} Performance surface should evaluate: {error}"));
assert_eq!(
renderer_json_value(surface),
Some(serde_json::json!(
r#"{"sameObject":true,"prototype":true,"finiteTimeOrigin":true}"#
)),
"{phase} must bind Performance to its realm's canonical Window"
);
}
async fn runtime_heap_usage_for_test(page: &RendererPageHandle) -> serde_json::Value {
let (reply, _) = page
.run_async_command(RendererPageCommand::RuntimeHeapUsage)
.await
.expect("runtime heap usage command should run");
match reply {
RendererPageReply::RuntimeHeapUsage(usage) => usage.to_diagnostics_json(),
_ => panic!("runtime heap usage should return typed heap usage"),
}
}
fn renderer_bool(reply: RendererPageReply) -> Option<bool> {
match reply {
RendererPageReply::Bool(value) => Some(value),
_ => None,
}
}
async fn has_pending_location_navigation_for_test(page: &RendererPageHandle) -> Option<bool> {
let (reply, _) = page
.run_async_command(RendererPageCommand::HasPendingLocationNavigation)
.await
.expect("pending location navigation state should evaluate");
renderer_bool(reply)
}
async fn store_indexed_db_value_for_test(
page: &RendererPageHandle,
loader: &ResourceRequestClient,
value: &str,
) {
let expression = format!(
r#"
(() => {{
globalThis.__lm_runtime_indexed_db_store = "pending";
const open = indexedDB.open("shared-manager-db", 1);
open.onerror = () => {{
globalThis.__lm_runtime_indexed_db_store = `open-error:${{open.error && open.error.name}}`;
}};
open.onupgradeneeded = () => {{
open.result.createObjectStore("kv");
}};
open.onsuccess = () => {{
const db = open.result;
const tx = db.transaction("kv", "readwrite");
const put = tx.objectStore("kv").put({value:?}, "key");
put.onerror = () => {{
globalThis.__lm_runtime_indexed_db_store = `put-error:${{put.error && put.error.name}}`;
}};
tx.oncomplete = () => {{
db.close();
globalThis.__lm_runtime_indexed_db_store = "stored";
}};
}};
return "scheduled";
}})()
"#
);
let (scheduled, _) = page
.run_async_command(RendererPageCommand::EvaluateExpression {
expression,
await_promise: false,
})
.await
.expect("indexedDB store should schedule");
assert_eq!(
renderer_json_value(scheduled),
Some(serde_json::json!("scheduled"))
);
page.run_async_command(RendererPageCommand::WaitForScriptTruthy {
expression: r#"globalThis.__lm_runtime_indexed_db_store === "stored""#.to_owned(),
timeout_ms: 2_000,
loader: loader.clone(),
})
.await
.expect("indexedDB store should complete");
}
fn runtime_indexed_db_test_root(label: &str) -> std::path::PathBuf {
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("system clock should be after epoch")
.as_nanos();
std::env::temp_dir().join(format!(
"moli-runtime-indexeddb-{label}-{}-{nonce}",
std::process::id()
))
}
fn runtime_indexed_db_origin_file(root: &std::path::Path, origin: &str) -> std::path::PathBuf {
let mut encoded = String::with_capacity(origin.len() * 2);
for byte in origin.as_bytes() {
use std::fmt::Write;
let _ = write!(&mut encoded, "{byte:02x}");
}
if encoded.len() > 180 {
encoded = moli_crypto::sha256_hex(origin.as_bytes());
encoded.insert_str(0, "h-");
}
root.join(format!("{encoded}.json"))
}
async fn create_isolated_world_for_test(
page: &RendererPageHandle,
name: &str,
) -> anyhow::Result<i64> {
let (reply, _) = page
.run_async_command(RendererPageCommand::CreateIsolatedWorld {
name: name.to_owned(),
grant_universal_access: false,
frame_id: None,
})
.await?;
match reply {
RendererPageReply::ExecutionContextId(execution_context_id) => Ok(execution_context_id),
_ => Err(anyhow::anyhow!(
"expected CreateIsolatedWorld to return an execution context id"
)),
}
}
async fn create_isolated_world_runtime_activity_for_test(
page: &RendererPageHandle,
inspector_session_id: Option<&str>,
name: &str,
) -> anyhow::Result<i64> {
let (reply, _) = page
.run_async_command(RendererPageCommand::CreateIsolatedWorldRuntimeActivity {
inspector_session_id: inspector_session_id.map(str::to_owned),
frame_id: None,
name: name.to_owned(),
grant_universal_access: false,
})
.await?;
match reply {
RendererPageReply::ExecutionContextId(execution_context_id) => Ok(execution_context_id),
_ => Err(anyhow::anyhow!(
"expected CreateIsolatedWorldRuntimeActivity to return an execution context id"
)),
}
}
async fn create_isolated_world_for_frame_for_test(
page: &RendererPageHandle,
frame_id: &str,
name: &str,
) -> anyhow::Result<i64> {
let (reply, _) = page
.run_async_command(RendererPageCommand::CreateIsolatedWorld {
name: name.to_owned(),
grant_universal_access: false,
frame_id: Some(frame_id.to_owned()),
})
.await?;
match reply {
RendererPageReply::ExecutionContextId(execution_context_id) => Ok(execution_context_id),
_ => Err(anyhow::anyhow!(
"expected frame CreateIsolatedWorld to return an execution context id"
)),
}
}
async fn default_or_initial_execution_context_id_for_test(
page: &RendererPageHandle,
) -> anyhow::Result<Option<i64>> {
let (reply, _) = page
.run_async_command(RendererPageCommand::DefaultOrInitialExecutionContextId)
.await?;
match reply {
RendererPageReply::OptionalExecutionContextId(execution_context_id) => {
Ok(execution_context_id)
}
_ => Err(anyhow::anyhow!(
"expected DefaultOrInitialExecutionContextId to return an optional execution context id"
)),
}
}
async fn default_execution_context_id_for_test(
page: &RendererPageHandle,
) -> anyhow::Result<Option<i64>> {
let (reply, _) = page
.run_async_command(RendererPageCommand::DefaultExecutionContextId)
.await?;
match reply {
RendererPageReply::OptionalExecutionContextId(execution_context_id) => {
Ok(execution_context_id)
}
_ => Err(anyhow::anyhow!(
"expected DefaultExecutionContextId to return an optional execution context id"
)),
}
}
async fn child_frame_id_for_default_context_id_for_test(
page: &RendererPageHandle,
execution_context_id: i64,
) -> anyhow::Result<String> {
let (reply, _) = page
.run_async_command(
RendererPageCommand::ChildFrameIdForDefaultExecutionContextId(execution_context_id),
)
.await?;
match reply {
RendererPageReply::OptionalString(Some(frame_id)) => Ok(frame_id),
_ => Err(anyhow::anyhow!(
"expected child frame id lookup to return an optional string"
)),
}
}
async fn child_default_context_ids_for_test(page: &RendererPageHandle) -> anyhow::Result<Vec<i64>> {
let (reply, _) = page
.run_async_command(RendererPageCommand::LiveChildDefaultRuntimeRealmInventory)
.await?;
match reply {
RendererPageReply::RuntimeRealmInventory(realms) => {
Ok(realms.into_iter().map(|realm| realm.context_id).collect())
}
_ => Err(anyhow::anyhow!(
"expected child default context replay to return runtime realm inventory"
)),
}
}
async fn create_test_html_page(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
) -> RendererPageHandle {
create_test_html_page_with_optional_indexed_db_manager(runtime, loader, url, html, None).await
}
async fn create_test_html_page_with_indexed_db_manager(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
indexed_db_manager: &crate::SharedIndexedDbManager,
) -> RendererPageHandle {
create_test_html_page_with_optional_indexed_db_manager(
runtime,
loader,
url,
html,
Some(crate::downgrade_indexed_db_manager(indexed_db_manager)),
)
.await
}
async fn create_test_html_page_with_optional_indexed_db_manager(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
indexed_db_manager: Option<crate::WeakIndexedDbManager>,
) -> RendererPageHandle {
create_test_html_page_with_optional_indexed_db_manager_and_navigation_dispatch(
runtime,
loader,
url,
html,
indexed_db_manager,
RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,
)
.await
}
async fn create_test_html_page_with_navigation_dispatch(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
top_level_navigation_dispatch: RendererTopLevelNavigationDispatch,
) -> RendererPageHandle {
create_test_html_page_with_optional_indexed_db_manager_and_navigation_dispatch(
runtime,
loader,
url,
html,
None,
top_level_navigation_dispatch,
)
.await
}
async fn create_test_html_page_with_optional_indexed_db_manager_and_navigation_dispatch(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
indexed_db_manager: Option<crate::WeakIndexedDbManager>,
top_level_navigation_dispatch: RendererTopLevelNavigationDispatch,
) -> RendererPageHandle {
let pending = start_test_html_page_with_optional_indexed_db_manager_and_navigation_dispatch(
runtime,
loader,
url,
html,
indexed_db_manager,
top_level_navigation_dispatch,
);
let (page, _, _, _creation_artifacts, pending_download) = pending
.await_ready()
.await
.expect("test HTML page should load");
assert!(pending_download.is_none());
page
}
fn start_test_html_page_with_optional_indexed_db_manager_and_navigation_dispatch(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
indexed_db_manager: Option<crate::WeakIndexedDbManager>,
top_level_navigation_dispatch: RendererTopLevelNavigationDispatch,
) -> super::PendingHtmlPage {
runtime
.start_create_html_page_from_response(
runtime.reserve_page_for_creation(),
url.clone(),
url,
None,
false,
0,
200,
vec![("content-type".to_owned(), b"text/html".to_vec())],
loader,
crate::RendererWebStorageHandles::ephemeral(),
html.to_owned(),
None,
top_level_navigation_dispatch,
crate::RendererDocumentOptions {
indexed_db_manager,
..Default::default()
},
)
.expect("test HTML page should start")
}
async fn create_test_html_page_at_document_commit(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
) -> RendererPageHandle {
create_test_html_page_at_document_commit_with_navigation_dispatch(
runtime,
loader,
url,
html,
RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,
RendererNavigationReplyPolicy::FollowBeforeReply,
)
.await
}
async fn create_test_html_page_at_document_commit_with_navigation_dispatch(
runtime: &JsRuntime,
loader: &ResourceRequestClient,
url: url::Url,
html: &str,
top_level_navigation_dispatch: RendererTopLevelNavigationDispatch,
navigation_reply_policy: RendererNavigationReplyPolicy,
) -> RendererPageHandle {
let (completion_tx, completion_rx) = oneshot::channel();
let (body_tx, raw_body) = ExternalRawDocumentBodyStream::channel(completion_rx);
let html = html.as_bytes().to_vec();
let producer = tokio::spawn(async move {
body_tx
.send(html)
.await
.expect("document-commit HTML body should send");
drop(body_tx);
completion_tx
.send(Ok(()))
.expect("document-commit HTML body should complete");
});
let (mut page, _, _, creation_artifacts, pending_download) = runtime
.create_streaming_raw_page_from_external_body(
url.clone(),
url,
None,
false,
0,
Vec::new(),
200,
vec![("content-type".to_owned(), b"text/html".to_vec())],
loader,
crate::RendererWebStorageHandles::ephemeral(),
raw_body,
false,
PageVmInitStage::Load,
RendererReplyBoundary::DocumentCommit,
top_level_navigation_dispatch,
navigation_reply_policy,
None,
None,
crate::RendererDocumentOptions {
..Default::default()
},
)
.await
.expect("test HTML page should attach at document commit");
producer
.await
.expect("document-commit HTML producer should finish");
assert!(pending_download.is_none());
assert!(
creation_artifacts.lifecycle_snapshot.load.is_none(),
"document-commit fixture must return before load"
);
page.take_committed_document_post_response_continuation()
.expect("DocumentCommit should defer parser continuation")
.release();
page
}
async fn install_shared_worker_count_probe(
page: &RendererPageHandle,
name: &str,
) -> anyhow::Result<()> {
let source_literal =
serde_json::to_string(SHARED_WORKER_CONNECTION_COUNT_SOURCE).expect("serialize source");
let name_literal = serde_json::to_string(name).expect("serialize shared worker name");
let (reply, _) = page
.run_async_command(RendererPageCommand::EvaluateExpression {
expression: format!(
r#"
(() => {{
globalThis.__lm_shared_worker_probe_messages = [];
globalThis.__lm_shared_worker_probe = new SharedWorker(
"data:text/javascript," + encodeURIComponent({source_literal}),
{name_literal}
);
globalThis.__lm_shared_worker_probe.port.addEventListener("message", event => {{
globalThis.__lm_shared_worker_probe_messages.push(String(event.data));
}});
globalThis.__lm_shared_worker_probe.port.start();
return "installed";
}})()
"#
),
await_promise: false,
})
.await?;
assert_eq!(
renderer_json_value(reply),
Some(serde_json::json!("installed"))
);
Ok(())
}
async fn request_shared_worker_probe_count(page: &RendererPageHandle) -> anyhow::Result<()> {
let (reply, _) = page
.run_async_command(RendererPageCommand::EvaluateExpression {
expression: r#"(() => {
globalThis.__lm_shared_worker_probe.port.postMessage("count");
return "posted";
})()"#
.to_owned(),
await_promise: false,
})
.await?;
assert_eq!(
renderer_json_value(reply),
Some(serde_json::json!("posted"))
);
Ok(())
}
async fn wait_for_shared_worker_probe_messages(
page: &RendererPageHandle,
loader: &ResourceRequestClient,
expected_count: usize,
context: &str,
) -> anyhow::Result<()> {
let expression =
format!("globalThis.__lm_shared_worker_probe_messages?.length >= {expected_count}");
tokio::time::timeout(
Duration::from_secs(5),
page.run_async_command(RendererPageCommand::WaitForScriptTruthy {
expression,
timeout_ms: 5_000,
loader: loader.clone(),
}),
)
.await
.map_err(|_| anyhow::anyhow!("{context}: timed out waiting for SharedWorker message"))?
.map_err(|error| anyhow::anyhow!("{context}: SharedWorker message wait failed: {error}"))?;
Ok(())
}
async fn shared_worker_probe_messages(page: &RendererPageHandle) -> anyhow::Result<String> {
let (reply, _) = page
.run_async_command(RendererPageCommand::EvaluateExpression {
expression: r#"globalThis.__lm_shared_worker_probe_messages.join("|")"#.to_owned(),
await_promise: false,
})
.await?;
renderer_json_value(reply)
.and_then(|value| value.as_str().map(str::to_owned))
.ok_or_else(|| anyhow::anyhow!("expected SharedWorker probe messages string"))
}
async fn runtime_protocol_object_id(
page: &RendererPageHandle,
request: serde_json::Value,
response_id: i64,
) -> anyhow::Result<String> {
let messages = dispatch_runtime_protocol_for_test(page, request).await?;
runtime_protocol_response_by_id(&messages, response_id)
.and_then(|response| response["result"]["result"]["objectId"].as_str())
.map(str::to_owned)
.ok_or_else(|| anyhow::anyhow!("expected Runtime response {response_id} to carry objectId"))
}
async fn dispatch_runtime_protocol_for_test(
page: &RendererPageHandle,
request: serde_json::Value,
) -> anyhow::Result<Vec<serde_json::Value>> {
dispatch_runtime_protocol_with_output_for_test(page, request)
.await
.map(|(messages, _)| messages)
}
async fn dispatch_runtime_protocol_with_output_for_test(
page: &RendererPageHandle,
request: serde_json::Value,
) -> anyhow::Result<(Vec<serde_json::Value>, RendererRuntimeCommandOutput)> {
let raw_json = serde_json::to_string(&request)?;
let output = page
.enqueue_async_command(RendererPageCommand::dispatch_runtime_protocol_message(
None, raw_json,
))
.expect("runtime protocol command should enqueue")
.wait()
.await?;
let (completion, _) = output.into_completion_and_predecessor();
let output = completion.into_runtime_inspector_output().ok_or_else(|| {
anyhow::anyhow!("expected Runtime protocol dispatch to return inspector protocol messages")
})?;
let messages = output
.messages()
.iter()
.cloned()
.map(RendererRuntimeInspectorMessage::into_v8_inspector_message)
.collect();
Ok((messages, output))
}
async fn dispatch_runtime_protocol_with_context_resolution_for_test(
page: &RendererPageHandle,
action: &str,
request: serde_json::Value,
) -> anyhow::Result<Vec<serde_json::Value>> {
let raw_json = serde_json::to_string(&request)?;
let (reply, _) = page
.run_async_command(
RendererPageCommand::dispatch_runtime_protocol_message_with_context_resolution(
None,
action.to_owned(),
raw_json,
),
)
.await?;
match reply {
RendererPageReply::RuntimeInspectorProtocolMessages(messages) => Ok(messages
.into_messages()
.into_iter()
.map(RendererRuntimeInspectorMessage::into_v8_inspector_message)
.collect()),
_ => Err(anyhow::anyhow!(
"expected Runtime protocol dispatch with context resolution to return inspector protocol messages"
)),
}
}
fn runtime_protocol_response_by_id(
messages: &[serde_json::Value],
response_id: i64,
) -> Option<&serde_json::Value> {
messages
.iter()
.find(|message| message.get("id").and_then(serde_json::Value::as_i64) == Some(response_id))
}
async fn runtime_enable_events_for_test(
page: &RendererPageHandle,
) -> anyhow::Result<Vec<serde_json::Value>> {
runtime_enable_events_for_inspector_session_for_test(page, None).await
}
async fn runtime_enable_events_for_inspector_session_for_test(
page: &RendererPageHandle,
inspector_session_id: Option<&str>,
) -> anyhow::Result<Vec<serde_json::Value>> {
let (reply, _) = page
.run_async_command(RendererPageCommand::runtime_enable_events(
inspector_session_id.map(str::to_owned),
))
.await?;
match reply {
RendererPageReply::RuntimeInspectorProtocolMessages(output) => Ok(output
.into_messages()
.into_iter()
.map(runtime_inspector_message_protocol_message_for_test)
.collect()),
_ => Err(anyhow::anyhow!(
"expected RuntimeEnableEvents to return Runtime inspector messages"
)),
}
}
fn runtime_inspector_message_protocol_message_for_test(
message: RendererRuntimeInspectorMessage,
) -> serde_json::Value {
match message {
RendererRuntimeInspectorMessage::Protocol(message) => message.into_value(),
RendererRuntimeInspectorMessage::RuntimeContext(event) => {
runtime_context_restore_event_protocol_message_for_test(event)
}
}
}
fn runtime_context_restore_event_protocol_message_for_test(
event: crate::protocol_types::RuntimeContextRestoreEvent,
) -> serde_json::Value {
match event {
crate::protocol_types::RuntimeContextRestoreEvent::Created(event) => {
let crate::protocol_types::RuntimeExecutionContextRestoreEvent {
context_id,
realm_id,
frame_id,
origin,
name,
is_default,
context_type,
grant_universal_access,
} = event;
let mut aux_data = serde_json::Map::new();
if let Some(frame_id) = frame_id {
aux_data.insert("frameId".to_owned(), serde_json::json!(frame_id));
}
aux_data.insert("isDefault".to_owned(), serde_json::json!(is_default));
aux_data.insert("type".to_owned(), serde_json::json!(context_type));
if let Some(grant_universal_access) = grant_universal_access {
aux_data.insert(
"grantUniversalAccess".to_owned(),
serde_json::json!(grant_universal_access),
);
}
serde_json::json!({
"method": "Runtime.executionContextCreated",
"params": {
"context": {
"id": context_id,
"uniqueId": realm_id,
"origin": origin,
"name": name,
"auxData": serde_json::Value::Object(aux_data),
},
},
})
}
crate::protocol_types::RuntimeContextRestoreEvent::Destroyed(event) => {
let crate::protocol_types::RuntimeExecutionContextRestoreEvent {
context_id,
realm_id,
..
} = event;
serde_json::json!({
"method": "Runtime.executionContextDestroyed",
"params": {
"executionContextId": context_id,
"executionContextUniqueId": realm_id,
},
})
}
crate::protocol_types::RuntimeContextRestoreEvent::Cleared(_event) => {
serde_json::json!({
"method": "Runtime.executionContextsCleared",
"params": {},
})
}
}
}
fn runtime_execution_context_ids(messages: &[serde_json::Value]) -> Vec<i64> {
messages
.iter()
.filter(|message| {
message.get("method") == Some(&serde_json::json!("Runtime.executionContextCreated"))
})
.filter_map(|message| message["params"]["context"]["id"].as_i64())
.collect()
}
fn runtime_execution_context_unique_ids(messages: &[serde_json::Value]) -> Vec<&str> {
messages
.iter()
.filter(|message| {
message.get("method") == Some(&serde_json::json!("Runtime.executionContextCreated"))
})
.filter_map(|message| message["params"]["context"]["uniqueId"].as_str())
.collect()
}
fn runtime_execution_context_by_id(
messages: &[serde_json::Value],
context_id: i64,
) -> Option<&serde_json::Value> {
messages
.iter()
.filter(|message| {
message.get("method") == Some(&serde_json::json!("Runtime.executionContextCreated"))
})
.map(|message| &message["params"]["context"])
.find(|context| context["id"].as_i64() == Some(context_id))
}
fn runtime_default_context_count(messages: &[serde_json::Value]) -> usize {
messages
.iter()
.filter(|message| {
message.get("method") == Some(&serde_json::json!("Runtime.executionContextCreated"))
&& message["params"]["context"]["auxData"]["isDefault"] == serde_json::json!(true)
&& message["params"]["context"]["auxData"]["type"] == serde_json::json!("default")
&& message["params"]["context"]["auxData"]["frameId"]
.as_str()
.is_none()
})
.count()
}
async fn add_runtime_binding_for_test(
page: &RendererPageHandle,
name: &str,
execution_context_name: Option<&str>,
execution_context_id: Option<i64>,
) -> anyhow::Result<()> {
let (reply, _) = page
.run_async_command(RendererPageCommand::add_runtime_binding(
None,
name.to_owned(),
execution_context_name.map(str::to_owned),
execution_context_id,
))
.await?;
match reply {
RendererPageReply::Unit => Ok(()),
_ => Err(anyhow::anyhow!(
"expected AddRuntimeBinding to return unit reply"
)),
}
}
async fn remove_runtime_binding_for_test(
page: &RendererPageHandle,
name: &str,
) -> anyhow::Result<()> {
let (reply, _) = page
.run_async_command(RendererPageCommand::RemoveRuntimeBinding(name.to_owned()))
.await?;
match reply {
RendererPageReply::Unit => Ok(()),
_ => Err(anyhow::anyhow!(
"expected RemoveRuntimeBinding to return unit reply"
)),
}
}
async fn set_stored_document_start_scripts_for_test(
page: &RendererPageHandle,
scripts: Vec<crate::DocumentStartScript>,
) -> anyhow::Result<()> {
let (reply, _) = page
.run_async_command(RendererPageCommand::SetStoredDocumentStartScripts(scripts))
.await?;
match reply {
RendererPageReply::Unit => Ok(()),
_ => Err(anyhow::anyhow!(
"expected SetStoredDocumentStartScripts to return unit reply"
)),
}
}
async fn set_runtime_binding_state_for_test(
page: &RendererPageHandle,
inspector_session_id: Option<String>,
stored_runtime_bindings: Vec<crate::protocol_types::RuntimeBindingRegistration>,
session_runtime_bindings: Vec<crate::protocol_types::RuntimeBindingRegistration>,
) -> anyhow::Result<()> {
let (reply, _) = page
.run_async_command(RendererPageCommand::SetRuntimeBindingState {
inspector_session_id,
stored_runtime_bindings,
session_runtime_bindings,
})
.await?;
match reply {
RendererPageReply::Unit => Ok(()),
_ => Err(anyhow::anyhow!(
"expected SetRuntimeBindingState to return unit reply"
)),
}
}
const SHARED_WORKER_CONNECTION_COUNT_SOURCE: &str = r#"
let connections = 0;
onconnect = (event) => {
connections++;
const port = event.ports[0];
port.onmessage = () => {
port.postMessage(String(connections));
};
port.postMessage(String(connections));
};
"#;
async fn spawn_owner_service_worker_response_sequence(
responses: Vec<(&'static str, &'static str, &'static str)>,
) -> (String, tokio::task::JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner ServiceWorker response sequence server");
let addr = listener
.local_addr()
.expect("owner ServiceWorker response sequence server address");
let server = tokio::spawn(async move {
for (expected_path, content_type, body) in responses {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner ServiceWorker response sequence request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("owner ServiceWorker response sequence request path");
assert_eq!(path, expected_path);
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write owner ServiceWorker response sequence response");
}
});
(format!("http://{addr}"), server)
}
async fn spawn_owner_wake_server_with_content_type(
expected_path: &'static str,
body: &'static str,
content_type: &'static str,
delay: Duration,
) -> (String, tokio::task::JoinHandle<()>) {
spawn_owner_wake_server_with_content_type_and_headers(
expected_path,
body,
content_type,
Vec::new(),
delay,
)
.await
}
async fn spawn_owner_wake_server_with_content_type_and_headers(
expected_path: &'static str,
body: &'static str,
content_type: &'static str,
response_headers: Vec<(&'static str, &'static str)>,
delay: Duration,
) -> (String, tokio::task::JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner wake fetch server");
let addr = listener.local_addr().expect("server local addr");
let server = tokio::spawn(async move {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner wake fetch request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("request path");
assert_eq!(path, expected_path);
if !delay.is_zero() {
tokio::time::sleep(delay).await;
}
let response_headers = response_headers
.into_iter()
.map(|(name, value)| format!("{name}: {value}\r\n"))
.collect::<String>();
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\n{response_headers}Content-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write owner wake fetch response");
});
(format!("http://{addr}"), server)
}
async fn spawn_owner_wake_gated_binary_server_with_content_type(
expected_path: &'static str,
body: Vec<u8>,
content_type: &'static str,
) -> (
String,
oneshot::Receiver<()>,
oneshot::Sender<()>,
tokio::task::JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner wake gated binary fetch server");
let addr = listener.local_addr().expect("server local addr");
let (request_seen_tx, request_seen_rx) = oneshot::channel();
let (release_tx, release_rx) = oneshot::channel();
let server = tokio::spawn(async move {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner wake gated binary fetch request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("request path");
assert_eq!(path, expected_path);
request_seen_tx
.send(())
.expect("signal owner wake gated binary request seen");
release_rx
.await
.expect("wait for owner wake gated binary response release");
let response_head = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
stream
.write_all(response_head.as_bytes())
.await
.expect("write owner wake binary fetch response head");
stream
.write_all(&body)
.await
.expect("write owner wake binary fetch response body");
});
(
format!("http://{addr}"),
request_seen_rx,
release_tx,
server,
)
}
struct OwnerChildModuleGraphServer {
base_url: String,
root_request_seen: oneshot::Receiver<()>,
release_root_response: oneshot::Sender<()>,
dependency_request_seen: oneshot::Receiver<()>,
release_dependency_response: oneshot::Sender<()>,
effect_request_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
struct OwnerMainModuleLivenessServer {
base_url: String,
module_request_seen: oneshot::Receiver<()>,
release_module_response: oneshot::Sender<()>,
effect_request_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
struct OwnerMainModuleReactionLivenessServer {
base_url: String,
module_request_seen: oneshot::Receiver<()>,
release_module_response: oneshot::Sender<()>,
evaluation_started: oneshot::Receiver<()>,
effect_request_seen: oneshot::Receiver<()>,
script_load_event_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
struct OwnerInlineModuleReactionLivenessServer {
base_url: String,
evaluation_started: oneshot::Receiver<()>,
effect_request_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
struct OwnerChildDocumentLivenessServer {
base_url: String,
document_request_seen: oneshot::Receiver<()>,
release_document_response: oneshot::Sender<()>,
effect_request_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
struct OwnerChildClassicLivenessServer {
base_url: String,
source_request_seen: oneshot::Receiver<()>,
release_source_response: oneshot::Sender<()>,
effect_request_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
struct OwnerModulepreloadLivenessServer {
base_url: String,
module_request_seen: oneshot::Receiver<()>,
release_module_response: oneshot::Sender<()>,
effect_request_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
struct OwnerDynamicImportLivenessServer {
base_url: String,
dynamic_root_request_seen: oneshot::Receiver<()>,
release_dynamic_root_response: oneshot::Sender<()>,
effect_request_seen: oneshot::Receiver<()>,
task: tokio::task::JoinHandle<()>,
}
async fn spawn_owner_child_document_liveness_server() -> OwnerChildDocumentLivenessServer {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner child-document liveness server");
let addr = listener
.local_addr()
.expect("child-document liveness server address");
let (document_request_seen_tx, document_request_seen) = oneshot::channel();
let (release_document_response, release_document_response_rx) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let task = tokio::spawn(async move {
let (mut document_stream, _) = listener
.accept()
.await
.expect("accept child document request");
let document_request = read_owner_wake_http_request_head(&mut document_stream).await;
let document_path = document_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("child document request path");
assert_eq!(document_path, "/owner-child-document.html");
document_request_seen_tx
.send(())
.expect("signal child document request");
release_document_response_rx
.await
.expect("wait for child document response release");
let document_body = r#"<!doctype html><script>
parent.__lm_owner_child_document = "committed";
fetch("/owner-child-document-effect");
</script>"#;
let document_response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
document_body.len(),
document_body,
);
document_stream
.write_all(document_response.as_bytes())
.await
.expect("write child document response");
let (mut effect_stream, _) = listener
.accept()
.await
.expect("accept child document effect request");
let effect_request = read_owner_wake_http_request_head(&mut effect_stream).await;
let effect_path = effect_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("child document effect path");
assert_eq!(effect_path, "/owner-child-document-effect");
effect_request_seen_tx
.send(())
.expect("signal child document effect request");
effect_stream
.write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
.await
.expect("write child document effect response");
});
OwnerChildDocumentLivenessServer {
base_url: format!("http://{addr}"),
document_request_seen,
release_document_response,
effect_request_seen,
task,
}
}
async fn spawn_owner_child_classic_liveness_server() -> OwnerChildClassicLivenessServer {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner child-classic liveness server");
let addr = listener
.local_addr()
.expect("child-classic liveness server address");
let (source_request_seen_tx, source_request_seen) = oneshot::channel();
let (release_source_response, release_source_response_rx) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let task = tokio::spawn(async move {
let mut source_request_seen_tx = Some(source_request_seen_tx);
let mut release_source_response_rx = Some(release_source_response_rx);
let mut effect_request_seen_tx = Some(effect_request_seen_tx);
let mut served_source = false;
for _ in 0..2 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner child-classic request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("child-classic request path");
let (status, content_type, body) = match path {
"/owner-child-classic.js" => {
assert!(!served_source, "child classic source must be fetched once");
served_source = true;
source_request_seen_tx
.take()
.expect("child classic source request should occur once")
.send(())
.expect("signal child classic source request");
release_source_response_rx
.take()
.expect("child classic source response gate should be consumed once")
.await
.expect("wait for child classic source response release");
(
"200 OK",
"application/javascript",
r#"parent.__lm_owner_child_classic = "executed";
fetch("/owner-child-classic-effect");"#,
)
}
"/owner-child-classic-effect" => {
assert!(served_source, "classic effect must follow source fetch");
effect_request_seen_tx
.take()
.expect("child classic effect request should occur once")
.send(())
.expect("signal child classic effect request");
("204 No Content", "text/plain", "")
}
path => panic!("unexpected child classic request path: {path}"),
};
let response = format!(
"HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write owner child-classic response");
}
assert!(
served_source,
"child classic source response must be served"
);
});
OwnerChildClassicLivenessServer {
base_url: format!("http://{addr}"),
source_request_seen,
release_source_response,
effect_request_seen,
task,
}
}
async fn spawn_owner_dynamic_import_liveness_server() -> OwnerDynamicImportLivenessServer {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner dynamic-import liveness server");
let addr = listener
.local_addr()
.expect("dynamic-import liveness server address");
let (dynamic_root_request_seen_tx, dynamic_root_request_seen) = oneshot::channel();
let (release_dynamic_root_response, release_dynamic_root_response_rx) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let task = tokio::spawn(async move {
let mut dynamic_root_request_seen_tx = Some(dynamic_root_request_seen_tx);
let mut release_dynamic_root_response_rx = Some(release_dynamic_root_response_rx);
let mut effect_request_seen_tx = Some(effect_request_seen_tx);
let mut served_paths = HashSet::new();
for _ in 0..5 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner dynamic-import request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("dynamic-import request path");
assert!(
served_paths.insert(path.to_owned()),
"dynamic-import fixture must request each resource once: {path}"
);
let (status, content_type, body) = match path {
"/dynamic-owner-entry.js" => (
"200 OK",
"application/javascript",
r#"import("./dynamic-owner-root.js").then(
({ total }) => {
parent.__lm_dynamic_owner_liveness = "fulfilled:" + String(total);
fetch("/dynamic-owner-effect");
},
() => { parent.__lm_dynamic_owner_liveness = "rejected"; }
);"#,
),
"/dynamic-owner-root.js" => {
dynamic_root_request_seen_tx
.take()
.expect("dynamic root request should occur once")
.send(())
.expect("signal dynamic root request");
release_dynamic_root_response_rx
.take()
.expect("dynamic root response gate should be consumed once")
.await
.expect("wait for dynamic root response release");
(
"200 OK",
"application/javascript",
r#"import { left } from "./dynamic-owner-left.js";
import { right } from "./dynamic-owner-right.js";
export const total = left + right;"#,
)
}
"/dynamic-owner-left.js" => (
"200 OK",
"application/javascript",
"export const left = 19;",
),
"/dynamic-owner-right.js" => (
"200 OK",
"application/javascript",
"export const right = 23;",
),
"/dynamic-owner-effect" => {
effect_request_seen_tx
.take()
.expect("dynamic-import effect should occur once")
.send(())
.expect("signal dynamic-import effect request");
("204 No Content", "text/plain", "")
}
path => panic!("unexpected dynamic-import liveness request path: {path}"),
};
let response = format!(
"HTTP/1.1 {status}\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
.expect("write owner dynamic-import response");
}
assert_eq!(served_paths.len(), 5);
});
OwnerDynamicImportLivenessServer {
base_url: format!("http://{addr}"),
dynamic_root_request_seen,
release_dynamic_root_response,
effect_request_seen,
task,
}
}
async fn spawn_owner_modulepreload_liveness_server(
module_path: &'static str,
module_body: &'static str,
effect_path: &'static str,
) -> OwnerModulepreloadLivenessServer {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner modulepreload liveness server");
let addr = listener
.local_addr()
.expect("modulepreload liveness server address");
let (module_request_seen_tx, module_request_seen) = oneshot::channel();
let (release_module_response, release_module_response_rx) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let task = tokio::spawn(async move {
let (mut module_stream, _) = listener
.accept()
.await
.expect("accept modulepreload request");
let module_request = read_owner_wake_http_request_head(&mut module_stream).await;
let observed_module_path = module_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("modulepreload request path");
assert_eq!(
observed_module_path, module_path,
"the modulepreload fetch must be the first externally visible request"
);
module_request_seen_tx
.send(())
.expect("signal modulepreload request");
release_module_response_rx
.await
.expect("wait for modulepreload response release");
let module_response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
module_body.len(),
module_body
);
module_stream
.write_all(module_response.as_bytes())
.await
.expect("write modulepreload response");
let (mut effect_stream, _) = listener
.accept()
.await
.expect("accept modulepreload effect request");
let effect_request = read_owner_wake_http_request_head(&mut effect_stream).await;
let observed_effect_path = effect_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("modulepreload effect request path");
assert_eq!(observed_effect_path, effect_path);
effect_request_seen_tx
.send(())
.expect("signal modulepreload effect request");
effect_stream
.write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
.await
.expect("write modulepreload effect response");
});
OwnerModulepreloadLivenessServer {
base_url: format!("http://{addr}"),
module_request_seen,
release_module_response,
effect_request_seen,
task,
}
}
async fn spawn_owner_main_module_liveness_server(
module_path: &'static str,
module_body: &'static str,
effect_path: &'static str,
) -> OwnerMainModuleLivenessServer {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner main module server");
let addr = listener.local_addr().expect("main module server address");
let (module_request_seen_tx, module_request_seen) = oneshot::channel();
let (release_module_response, release_module_response_rx) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let task = tokio::spawn(async move {
let (mut module_stream, _) = listener.accept().await.expect("accept main module request");
let module_request = read_owner_wake_http_request_head(&mut module_stream).await;
let observed_module_path = module_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("main module request path");
assert_eq!(observed_module_path, module_path);
module_request_seen_tx
.send(())
.expect("signal main module request");
release_module_response_rx
.await
.expect("wait for main module response release");
let module_response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
module_body.len(),
module_body
);
module_stream
.write_all(module_response.as_bytes())
.await
.expect("write main module response");
let (mut effect_stream, _) = listener
.accept()
.await
.expect("accept main module effect request");
let effect_request = read_owner_wake_http_request_head(&mut effect_stream).await;
let observed_effect_path = effect_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("main module effect request path");
assert_eq!(observed_effect_path, effect_path);
effect_request_seen_tx
.send(())
.expect("signal main module effect request");
effect_stream
.write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
.await
.expect("write main module effect response");
});
OwnerMainModuleLivenessServer {
base_url: format!("http://{addr}"),
module_request_seen,
release_module_response,
effect_request_seen,
task,
}
}
async fn spawn_owner_main_module_reaction_liveness_server() -> OwnerMainModuleReactionLivenessServer
{
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner main module-reaction server");
let addr = listener
.local_addr()
.expect("main module-reaction server address");
let (module_request_seen_tx, module_request_seen) = oneshot::channel();
let (release_module_response, release_module_response_rx) = oneshot::channel();
let (evaluation_started_tx, evaluation_started) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let (script_load_event_seen_tx, script_load_event_seen) = oneshot::channel();
let task = tokio::spawn(async move {
let (mut module_stream, _) = listener
.accept()
.await
.expect("accept main TLA module request");
let module_request = read_owner_wake_http_request_head(&mut module_stream).await;
let module_path = module_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("main TLA module request path");
assert_eq!(module_path, "/owner-main-tla-module.js");
module_request_seen_tx
.send(())
.expect("signal main TLA module request");
release_module_response_rx
.await
.expect("wait for main TLA module response release");
let module_body = r#"
globalThis.__lmOwnerMainTlaState = "pending";
const ownerMainTlaGate = new Promise(resolve => {
globalThis.__resolveLmOwnerMainTla = resolve;
});
fetch("/owner-main-tla-evaluation-started");
await ownerMainTlaGate;
globalThis.__lmOwnerMainTlaState = "completed";
fetch("/owner-main-tla-effect");
"#;
let module_response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
module_body.len(),
module_body
);
module_stream
.write_all(module_response.as_bytes())
.await
.expect("write main TLA module response");
let (mut started_stream, _) = listener
.accept()
.await
.expect("accept main TLA evaluation-start request");
let started_request = read_owner_wake_http_request_head(&mut started_stream).await;
let started_path = started_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("main TLA evaluation-start path");
assert_eq!(started_path, "/owner-main-tla-evaluation-started");
evaluation_started_tx
.send(())
.expect("signal main TLA evaluation start");
started_stream
.write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
.await
.expect("write main TLA evaluation-start response");
let mut effect_request_seen_tx = Some(effect_request_seen_tx);
let mut script_load_event_seen_tx = Some(script_load_event_seen_tx);
for _ in 0..2 {
let (mut effect_stream, _) = listener
.accept()
.await
.expect("accept main TLA terminal effect request");
let effect_request = read_owner_wake_http_request_head(&mut effect_stream).await;
let effect_path = effect_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("main TLA terminal effect path");
match effect_path {
"/owner-main-tla-effect" => effect_request_seen_tx
.take()
.expect("main TLA effect should be requested once")
.send(())
.expect("signal main TLA effect request"),
"/owner-main-tla-script-load" => script_load_event_seen_tx
.take()
.expect("main TLA script load should be dispatched once")
.send(())
.expect("signal main TLA script-load request"),
other => panic!("unexpected main TLA terminal effect path: {other}"),
}
effect_stream
.write_all(
b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await
.expect("write main TLA terminal effect response");
}
assert!(
effect_request_seen_tx.is_none() && script_load_event_seen_tx.is_none(),
"main TLA evaluation and parser follow-up must both publish their effects"
);
});
OwnerMainModuleReactionLivenessServer {
base_url: format!("http://{addr}"),
module_request_seen,
release_module_response,
evaluation_started,
effect_request_seen,
script_load_event_seen,
task,
}
}
async fn spawn_owner_inline_module_reaction_liveness_server(
evaluation_started_path: &'static str,
effect_path: &'static str,
) -> OwnerInlineModuleReactionLivenessServer {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner inline module-reaction server");
let addr = listener
.local_addr()
.expect("inline module-reaction server address");
let (evaluation_started_tx, evaluation_started) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let task = tokio::spawn(async move {
for (expected_path, signal) in [
(evaluation_started_path, evaluation_started_tx),
(effect_path, effect_request_seen_tx),
] {
let (mut stream, _) = listener
.accept()
.await
.expect("accept inline module-reaction request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("inline module-reaction request path");
assert_eq!(path, expected_path);
signal
.send(())
.expect("signal inline module-reaction request");
stream
.write_all(
b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await
.expect("write inline module-reaction response");
}
});
OwnerInlineModuleReactionLivenessServer {
base_url: format!("http://{addr}"),
evaluation_started,
effect_request_seen,
task,
}
}
async fn spawn_owner_child_module_graph_server() -> OwnerChildModuleGraphServer {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner child module graph server");
let addr = listener.local_addr().expect("module graph server address");
let (root_request_seen_tx, root_request_seen) = oneshot::channel();
let (release_root_response, release_root_response_rx) = oneshot::channel();
let (dependency_request_seen_tx, dependency_request_seen) = oneshot::channel();
let (release_dependency_response, release_dependency_response_rx) = oneshot::channel();
let (effect_request_seen_tx, effect_request_seen) = oneshot::channel();
let task = tokio::spawn(async move {
let mut served_root = false;
let mut served_dependency = false;
let mut root_request_seen_tx = Some(root_request_seen_tx);
let mut release_root_response_rx = Some(release_root_response_rx);
let mut dependency_request_seen_tx = Some(dependency_request_seen_tx);
let mut release_dependency_response_rx = Some(release_dependency_response_rx);
let mut effect_request_seen_tx = Some(effect_request_seen_tx);
for _ in 0..3 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner child module graph request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("module graph request path");
let (status, content_type, body) = match path {
"/child-owner-module.js" => {
assert!(!served_root, "module root must be fetched once");
served_root = true;
root_request_seen_tx
.take()
.expect("module root request should occur once")
.send(())
.expect("signal module root request");
release_root_response_rx
.take()
.expect("module root response gate should be consumed once")
.await
.expect("wait for module root response release");
(
"200 OK",
"application/javascript",
r#"import "./child-owner-dependency.js";
parent.__lm_owner_child_module_events.push("root");
fetch("/child-owner-module-effect");"#,
)
}
"/child-owner-dependency.js" => {
assert!(
served_root,
"dependency fetch must follow the root response"
);
assert!(!served_dependency, "module dependency must be fetched once");
served_dependency = true;
dependency_request_seen_tx
.take()
.expect("module dependency request should occur once")
.send(())
.expect("signal module dependency request");
release_dependency_response_rx
.take()
.expect("module dependency response gate should be consumed once")
.await
.expect("wait for module dependency response release");
(
"200 OK",
"application/javascript",
r#"parent.__lm_owner_child_module_events.push("dependency");"#,
)
}
"/child-owner-module-effect" => {
assert!(
served_dependency,
"module evaluation effect must follow dependency fetch"
);
effect_request_seen_tx
.take()
.expect("module effect request should occur once")
.send(())
.expect("signal module effect request");
("204 No Content", "text/plain", "")
}
path => panic!("unexpected child module graph request path: {path}"),
};
let response = format!(
"HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write owner child module graph response");
}
assert!(served_root && served_dependency);
});
OwnerChildModuleGraphServer {
base_url: format!("http://{addr}"),
root_request_seen,
release_root_response,
dependency_request_seen,
release_dependency_response,
effect_request_seen,
task,
}
}
async fn spawn_owner_wake_gated_server_with_content_type(
expected_path: &'static str,
body: &'static str,
content_type: &'static str,
) -> (
String,
oneshot::Receiver<()>,
oneshot::Sender<()>,
tokio::task::JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner wake gated fetch server");
let addr = listener.local_addr().expect("server local addr");
let (request_seen_tx, request_seen_rx) = oneshot::channel();
let (release_tx, release_rx) = oneshot::channel();
let server = tokio::spawn(async move {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner wake gated fetch request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("request path");
assert_eq!(path, expected_path);
request_seen_tx
.send(())
.expect("signal owner wake gated request seen");
release_rx
.await
.expect("wait for owner wake gated response release");
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write owner wake gated fetch response");
});
(
format!("http://{addr}"),
request_seen_rx,
release_tx,
server,
)
}
async fn spawn_gated_resource_with_concurrent_effect(
resource_path: &'static str,
resource_body: &'static str,
resource_content_type: &'static str,
effect_path: &'static str,
) -> (
String,
oneshot::Receiver<()>,
oneshot::Receiver<()>,
oneshot::Sender<()>,
tokio::task::JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind gated resource/effect server");
let addr = listener.local_addr().expect("server local addr");
let (resource_seen_tx, resource_seen_rx) = oneshot::channel();
let (effect_seen_tx, effect_seen_rx) = oneshot::channel();
let (release_tx, release_rx) = oneshot::channel();
let server = tokio::spawn(async move {
let (mut resource_stream, _) = listener
.accept()
.await
.expect("accept gated resource request");
let request = read_owner_wake_http_request_head(&mut resource_stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("gated resource request path");
assert_eq!(path, resource_path);
resource_seen_tx
.send(())
.expect("signal gated resource request");
// Keep the resource response parked while the renderer owner admits
// an independent timer turn. Accepting the effect on the same listener
// proves that turn ran; no protocol-output wake is used as a scheduler
// observation surrogate.
let (mut effect_stream, _) = listener
.accept()
.await
.expect("accept concurrent effect request");
let request = read_owner_wake_http_request_head(&mut effect_stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("concurrent effect request path");
assert_eq!(path, effect_path);
effect_seen_tx
.send(())
.expect("signal concurrent effect request");
effect_stream
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok",
)
.await
.expect("write concurrent effect response");
release_rx.await.expect("release gated resource response");
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {resource_content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
resource_body.len(),
resource_body
);
resource_stream
.write_all(response.as_bytes())
.await
.expect("write gated resource response");
});
(
format!("http://{addr}"),
resource_seen_rx,
effect_seen_rx,
release_tx,
server,
)
}
async fn spawn_owner_lifecycle_gated_async_server() -> (
String,
oneshot::Receiver<()>,
oneshot::Receiver<()>,
oneshot::Sender<()>,
tokio::task::JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind owner lifecycle gated server");
let addr = listener.local_addr().expect("server local addr");
let (async_request_seen_tx, async_request_seen_rx) = oneshot::channel();
let (domcontentloaded_request_seen_tx, domcontentloaded_request_seen_rx) = oneshot::channel();
let (release_async_tx, release_async_rx) = oneshot::channel();
let server = tokio::spawn(async move {
let mut async_request_seen_tx = Some(async_request_seen_tx);
let mut domcontentloaded_request_seen_tx = Some(domcontentloaded_request_seen_tx);
let mut release_async_rx = Some(release_async_rx);
let mut handlers = Vec::new();
for _ in 0..2 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept owner lifecycle request");
let request = read_owner_wake_http_request_head(&mut stream).await;
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("request path");
match path {
"/async.js" => {
async_request_seen_tx
.take()
.expect("async script request should occur once")
.send(())
.expect("signal gated async script request");
let release = release_async_rx
.take()
.expect("async response gate should be consumed once");
handlers.push(tokio::spawn(async move {
release
.await
.expect("wait for gated async response release");
let body = "globalThis.__lm_load_target_async_marker = 'executed';";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write gated async script response");
}));
}
"/domcontentloaded-seen" => {
domcontentloaded_request_seen_tx
.take()
.expect("DOMContentLoaded signal request should occur once")
.send(())
.expect("signal observed DOMContentLoaded request");
handlers.push(tokio::spawn(async move {
let response = "HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
stream
.write_all(response.as_bytes())
.await
.expect("write DOMContentLoaded signal response");
}));
}
path => panic!("unexpected owner lifecycle request path: {path}"),
}
}
for handler in handlers {
handler
.await
.expect("owner lifecycle response handler should finish");
}
});
(
format!("http://{addr}"),
async_request_seen_rx,
domcontentloaded_request_seen_rx,
release_async_tx,
server,
)
}
async fn spawn_gated_worker_message_server() -> (
String,
oneshot::Receiver<()>,
oneshot::Sender<()>,
tokio::task::JoinHandle<()>,
) {
const WORKER_SCRIPT: &str = r#"
self.onmessage = event => {
if (event.data === "schedule-late") {
fetch("/stale-worker-message.txt").then(
response => response.text()
).then(
text => postMessage("late:" + text),
error => postMessage("error:" + error.name)
);
postMessage("scheduled");
}
};
postMessage("ready");
"#;
const WORKER_MESSAGE_BODY: &str = "worker-late-body";
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind gated worker message server");
let addr = listener.local_addr().expect("server local addr");
let (request_seen_tx, request_seen_rx) = oneshot::channel();
let (release_tx, release_rx) = oneshot::channel();
let server = tokio::spawn(async move {
let (mut worker_stream, _) = listener
.accept()
.await
.expect("accept worker script request");
let worker_request = read_owner_wake_http_request_head(&mut worker_stream).await;
let worker_path = worker_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("worker script request path");
assert_eq!(worker_path, "/stale-worker.js");
let worker_response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
WORKER_SCRIPT.len(),
WORKER_SCRIPT
);
worker_stream
.write_all(worker_response.as_bytes())
.await
.expect("write worker script response");
let (mut message_stream, _) = listener
.accept()
.await
.expect("accept worker message fetch request");
let message_request = read_owner_wake_http_request_head(&mut message_stream).await;
let message_path = message_request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("worker message request path");
assert_eq!(message_path, "/stale-worker-message.txt");
request_seen_tx
.send(())
.expect("signal worker message fetch request seen");
release_rx
.await
.expect("wait for worker message response release");
let message_response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
WORKER_MESSAGE_BODY.len(),
WORKER_MESSAGE_BODY
);
let _ = message_stream.write_all(message_response.as_bytes()).await;
});
(
format!("http://{addr}"),
request_seen_rx,
release_tx,
server,
)
}
async fn read_owner_wake_http_request_head(stream: &mut tokio::net::TcpStream) -> String {
let mut request = Vec::new();
let mut byte = [0_u8; 1];
loop {
let read = stream
.read(&mut byte)
.await
.expect("read owner wake request byte");
assert_ne!(read, 0, "owner wake request closed before headers ended");
request.push(byte[0]);
if request.ends_with(b"\r\n\r\n") {
return String::from_utf8_lossy(&request).into_owned();
}
}
}
mod extracted;