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 moli_test_support as support;
use super::{
Browser, FetchDeadline, FetchedDocument, NavigationEngine, NavigationPageStorageHandles,
NavigationResourceStorageHandles, RawDocumentFetchPolicy, RenderedDomWaitUntil,
external_raw_document_body_from_streaming_response_with_body_eof_observer,
};
use crate::{
RendererOutputItem, RendererOutputResidenceIdentity, RendererOutputTransportMessage,
RendererOutputTransportReceiver, RendererOwnerAction,
page::{
DocumentNodeClientRectResolution, Page, PendingPageCommand,
PendingSubresourceContinueOutcome, PendingSubresourceFetchInfo,
RendererDocumentQuerySelectorNode, RendererDocumentQuerySelectorResolution,
RendererRuntimeInspectorMessage, SubresourceResourceType, SubresourceResponseWaitCriteria,
},
renderer::RendererPageCommand,
renderer::{PageId, RendererOwnerCommand, RendererOwnerHandle, materialize_page_created_reply},
runtime::BrowserConfig as AppConfig,
};
use anyhow::{Context, Result, anyhow};
use moli_browser_profile::{BrowserProfileLock, BrowserProfilePaths, load_profile_manifest};
use moli_cookie_jar::new_shared_browser_cookie_store;
use moli_fetch::{
BrowserNavigationRequestKind, FetchCancelHandle, FetchConfig, Request, ResponseHead,
StreamingRawResponse,
};
use moli_page_types::{LayoutPolicy, OptionalResourceFetchMask};
use moli_renderer_v8::new_shared_web_storage_store;
use std::{
fs,
path::PathBuf,
sync::Arc,
time::{Duration, SystemTime, UNIX_EPOCH},
};
use support::FixtureServer;
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
sync::{Mutex, oneshot},
task::JoinHandle,
};
use url::Url;
fn browser_navigation_request(url: &str) -> Result<Request> {
Ok(Request::get(url)?.with_request_origin(moli_url::WebOrigin::Opaque))
}
#[test]
fn browser_clone_keeps_shared_renderer_and_fetch_owners_live_after_source_drop() -> Result<()> {
let browser = Browser::new(AppConfig::default())?;
let expected_runtime_id = browser
.resource_request_client()
.resource_runtime_diagnostics()
.runtime_id;
let expected_renderer_owner_id = browser.js_runtime.renderer_owner_id_for_diagnostics();
let clone = browser.clone();
drop(browser);
assert_eq!(
clone
.resource_request_client()
.resource_runtime_diagnostics()
.runtime_id,
expected_runtime_id
);
assert_eq!(
clone.js_runtime.renderer_owner_id_for_diagnostics(),
expected_renderer_owner_id
);
Ok(())
}
#[tokio::test]
async fn external_raw_bridge_drop_after_body_eof_cancels_pending_fetch_completion() -> Result<()> {
let (body_tx, body_rx) = tokio::sync::mpsc::unbounded_channel();
body_tx.send(b"complete body".to_vec())?;
drop(body_tx);
let cancel_handle = FetchCancelHandle::new();
let (mut fetch_completion_tx, fetch_completion_rx) = oneshot::channel();
let response = StreamingRawResponse::new_with_head(
ResponseHead {
status_text: None,
final_url: Url::parse("https://bridge.test/document")?,
status: 200,
headers: vec![("content-type".to_owned(), b"text/html".to_vec())],
request_cookie_report: None,
cookie_set_reports: Vec::new(),
redirected: false,
redirect_chain: Vec::new(),
from_cache: false,
negotiated_http_version: None,
},
body_rx,
cancel_handle.clone(),
fetch_completion_rx,
);
let (body_eof_tx, body_eof_rx) = oneshot::channel();
let outward = external_raw_document_body_from_streaming_response_with_body_eof_observer(
response,
Some(body_eof_tx),
);
body_eof_rx
.await
.context("external bridge should observe body EOF before fetch completion")?;
assert!(
!fetch_completion_tx.is_closed(),
"the test must hold fetch completion pending at the EOF barrier"
);
drop(outward);
fetch_completion_tx.closed().await;
assert!(
cancel_handle.is_cancelled(),
"dropping the external bridge in the EOF-to-completion window must cancel the fetch"
);
Ok(())
}
async fn recv_subresource_fetch_pause_for_page(
output_rx: &mut RendererOutputTransportReceiver,
page: &Page,
) -> Result<PendingSubresourceFetchInfo> {
let owner_local_host_id = page.renderer_owner_local_host_id();
let page_id = page.renderer_page_id();
tokio::time::timeout(Duration::from_secs(2), async {
loop {
let message = output_rx
.recv()
.await
.context("renderer output transport closed before Fetch pause")?;
let RendererOutputTransportMessage::Publication(publication) = message else {
continue;
};
if !matches!(
publication.cursor().stream().residence(),
RendererOutputResidenceIdentity::Page {
owner_local_host_id: output_owner,
page_id: output_page,
} if output_owner == owner_local_host_id && output_page == page_id
) {
continue;
}
if let Some(info) =
publication
.records()
.iter()
.find_map(|record| match record.item() {
RendererOutputItem::OwnerAction(
RendererOwnerAction::SubresourceFetchPause { info, .. },
) => Some(info.as_ref().clone()),
_ => None,
})
{
return Ok(info);
}
}
})
.await
.context("timed out waiting for concrete subresource Fetch pause")?
}
async fn query_selector_node_from_live_document(
page: &mut Page,
selector: &str,
) -> Result<Option<RendererDocumentQuerySelectorNode>> {
let pending = page.start_document_query_selector_for_document(selector.to_owned(), false)?;
let completion = pending.wait().await?;
match page.finish_document_query_selector(completion)? {
RendererDocumentQuerySelectorResolution::Found(nodes) => Ok(nodes.into_iter().next()),
RendererDocumentQuerySelectorResolution::MissingRoot => Ok(None),
RendererDocumentQuerySelectorResolution::InvalidSelector(message) => {
Err(anyhow!("invalid selector {selector:?}: {message}"))
}
}
}
async fn resolve_runtime_object_for_backend_node_id(
page: &mut Page,
backend_node_id: u32,
execution_context_id: Option<i64>,
object_group: Option<&str>,
) -> Result<crate::page::DocumentNodeRuntimeObjectResolution> {
let pending = page.start_resolve_runtime_object_for_backend_node_id_in_inspector_session(
None,
backend_node_id,
execution_context_id,
object_group,
)?;
let completion = pending.wait().await?;
page.finish_resolve_runtime_object_for_backend_node_id(completion)
}
#[tokio::test(flavor = "multi_thread")]
async fn page_creation_diagnostics_include_default_runtime_context_event() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: Url = server.url("/runtime-context-diagnostics").parse()?;
let html = "<!doctype html><html><body>ok</body></html>".to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url.clone(),
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let (handle, page_state, diagnostics, artifacts, pending_download) =
renderer_owner.materialize_page_created_reply_parts(reply)?;
assert!(pending_download.is_none());
let _page = Page::from_attached_handle(handle, page_state);
let default_context = diagnostics
.initial_runtime_realms
.iter()
.find(|realm| realm.is_default && realm.context_type == "default")
.context("page creation should report the default runtime context")?;
assert!(default_context.context_id > 0);
assert_eq!(default_context.name, page_url.as_str());
assert!(
default_context
.realm_id
.as_deref()
.is_some_and(|id| !id.is_empty()),
"page creation should expose the native V8 realm id"
);
assert_eq!(
artifacts.active_document.page_id,
artifacts.lifecycle_snapshot.frame.page_id
);
assert_eq!(artifacts.active_epoch, artifacts.lifecycle_snapshot.epoch);
assert_eq!(
artifacts
.initial_lifecycle_events
.iter()
.map(|event| event.kind)
.collect::<Vec<_>>(),
vec![
crate::page::RendererDocumentLifecycleEventKind::Started {
reason: crate::page::RendererLifecycleStartReason::InitialDocument,
},
crate::page::RendererDocumentLifecycleEventKind::Milestone(
crate::page::RendererDocumentLifecycleMilestone::DomContentLoaded,
),
crate::page::RendererDocumentLifecycleEventKind::Milestone(
crate::page::RendererDocumentLifecycleMilestone::Load,
),
]
);
assert!(artifacts.lifecycle_snapshot.dom_content_loaded.is_some());
assert!(artifacts.lifecycle_snapshot.load.is_some());
assert!(
artifacts
.initial_lifecycle_events
.windows(2)
.all(|events| events[0].sequence < events[1].sequence
&& events[0].timestamp_micros <= events[1].timestamp_micros)
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn page_creation_diagnostics_fence_initial_runtime_observable_output() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: Url = server.url("/runtime-observable-diagnostics").parse()?;
let html = "<!doctype html><script>console.warn('creation warning')</script>".to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url.clone(),
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let (handle, page_state, diagnostics, _artifacts, pending_download) =
renderer_owner.materialize_page_created_reply_parts(reply)?;
assert!(pending_download.is_none());
let _page = Page::from_attached_handle(handle, page_state);
assert!(
diagnostics.renderer_output_predecessor.is_some(),
"page creation must fence the concrete Page-stream batch containing initial console output"
);
server.shutdown().await;
Ok(())
}
struct TempProfileDir {
path: PathBuf,
}
#[test]
fn browser_without_profile_does_not_create_indexeddb_sibling_for_http_cache() -> Result<()> {
let profile = TempProfileDir::new("no-profile-indexeddb");
let cache_dir = profile.path.join("http-cache");
let indexeddb_dir = profile.path.join("indexeddb");
let mut config = AppConfig::default();
config
.fetch_mut()
.set_http_cache_dir(Some(cache_dir.to_string_lossy().into_owned()));
let browser = Browser::new(config)?;
drop(browser);
assert!(
!indexeddb_dir.exists(),
"no-profile Browser::new should keep IndexedDB in memory, not create {}",
indexeddb_dir.display()
);
Ok(())
}
impl TempProfileDir {
fn new(name: &str) -> Self {
let nonce = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("system clock should be after epoch")
.as_nanos();
let path = std::env::temp_dir().join(format!(
"moli-profile-{name}-{}-{nonce}",
std::process::id()
));
Self { path }
}
}
impl Drop for TempProfileDir {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.path);
}
}
fn indexed_db_origin_file(root: &std::path::Path, origin: &str) -> 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}");
}
root.join(format!("{encoded}.json"))
}
fn indexed_db_origin_exists(root: &std::path::Path, origin: &str) -> bool {
if indexed_db_origin_file(root, origin).exists() {
return true;
}
let Ok(entries) = fs::read_dir(root) else {
return false;
};
entries.filter_map(|entry| entry.ok()).any(|entry| {
let path = entry.path();
if !path.is_file() || path.extension().and_then(|ext| ext.to_str()) != Some("json") {
return false;
}
let Ok(bytes) = fs::read(path) else {
return false;
};
serde_json::from_slice::<serde_json::Value>(&bytes)
.ok()
.and_then(|value| {
value
.get("origin")
.and_then(serde_json::Value::as_str)
.map(str::to_owned)
})
.as_deref()
== Some(origin)
})
}
fn first_party_storage_key_for_url(url: &Url) -> String {
moli_storage_key::MoliStorageKey::first_party_from_url(url, None).serialized_storage_key()
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_about_blank_case_variants_materialize_empty_documents() -> Result<()> {
let browser = Browser::new(AppConfig::default())?;
for raw_url in [
"about:blank",
"about:BLANK",
"about:Blank#fragment",
"ABOUT:bLaNk?query#fragment",
] {
let expected_url = Url::parse(raw_url)?;
let mut page = browser
.fetch_with_wait_until(raw_url, RenderedDomWaitUntil::Load, Duration::from_secs(1))
.await?;
assert_eq!(page.requested_url(), &expected_url, "{raw_url}");
assert_eq!(page.final_url(), &expected_url, "{raw_url}");
assert_eq!(page.status(), 200, "{raw_url}");
assert_eq!(
page.evaluate_runtime_expression_async("document.URL")
.await?,
serde_json::json!({"type": "string", "value": expected_url.as_str()}),
"{raw_url}"
);
assert_eq!(
page.evaluate_runtime_expression_async("document.readyState")
.await?,
serde_json::json!({"type": "string", "value": "complete"}),
"{raw_url}"
);
}
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_fetch_rejects_file_navigation_without_reading_local_file() -> Result<()> {
let browser = Browser::new(AppConfig::default())?;
let error = browser
.fetch_with_wait_until(
"file:///moli-policy-must-not-open",
RenderedDomWaitUntil::Load,
Duration::from_secs(1),
)
.await
.expect_err("hosted Browser::fetch must not receive local file capability");
assert_eq!(
error.to_string(),
"Navigation to a local file URL requires an explicitly granted browser capability."
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_done_does_not_wait_for_future_interval_timers() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = tokio::time::timeout(
Duration::from_secs(2),
browser.fetch_with_wait_until(
&server.url("/runtime/future-interval-done"),
RenderedDomWaitUntil::Done,
Duration::from_millis(500),
),
)
.await
.context("fetch wait_until Done should not wait for future interval ticks")??;
assert_eq!(
page.evaluate_runtime_expression_async("document.body.dataset.ready")
.await?,
serde_json::json!({"type": "string", "value": "yes"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_allow_http_error_materializes_error_status_pages() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let not_found_url = server.url("/net/upstream/xhr/404");
let server_error_url = server.url("/net/upstream/xhr/500");
let default_error = browser
.fetch(¬_found_url)
.await
.expect_err("default fetch should reject HTTP error statuses");
assert!(
default_error.to_string().contains("404 Not Found"),
"{default_error:?}"
);
let mut not_found_page = browser.fetch_allow_http_error(¬_found_url).await?;
assert_eq!(not_found_page.status(), 404);
assert_eq!(
not_found_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "Not Found"})
);
let mut server_error_page = browser
.fetch_allow_http_error_with_wait_until(
&server_error_url,
RenderedDomWaitUntil::Load,
Duration::from_secs(1),
)
.await?;
assert_eq!(server_error_page.status(), 500);
assert_eq!(
server_error_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "Internal Server Error"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_fetch_main_resource_navigation_uses_service_worker_response() -> Result<()> {
let (base_url, requests, server) = spawn_main_resource_service_worker_server().await?;
let browser = Browser::new(AppConfig::default())?;
let mut registration_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/register.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
browser
.wait_for_script_truthy(
&mut registration_page,
"String(globalThis.__mainResourceSwReady).startsWith('ready:')",
Duration::from_secs(5),
)
.await?;
let ready_state = registration_page
.evaluate_runtime_expression_async("String(globalThis.__mainResourceSwReady)")
.await?;
assert_eq!(
ready_state,
serde_json::json!({"type": "string", "value": "ready:true"})
);
let mut controlled_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/controlled.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(controlled_page.status(), 200);
assert_eq!(
controlled_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "sw-main:document:navigate"})
);
let mut fallback_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/fallback.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(
fallback_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "network fallback"})
);
let mut preload_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_page.status(), 200);
assert_eq!(
preload_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "preload:200:preload:core-preload:network-preload-body"})
);
let mut preload_headers_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-headers.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_headers_page.status(), 200);
assert_eq!(
preload_headers_page
.evaluate_runtime_expression_async(
r#"
(() => {
const headers = JSON.parse(document.body.textContent);
return JSON.stringify({
preload: headers["SERVICE-WORKER-NAVIGATION-PRELOAD"],
upgrade: headers["UPGRADE-INSECURE-REQUESTS"]
});
})()
"#
)
.await?,
serde_json::json!({
"type": "string",
"value": "{\"preload\":[\"core-preload\"],\"upgrade\":[\"1\"]}"
})
);
let mut preload_gzip_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-gzip.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_gzip_page.status(), 200);
assert_eq!(
preload_gzip_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "Hello World"})
);
let mut preload_chunked_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-chunked.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_chunked_page.status(), 200);
assert_eq!(
preload_chunked_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "0123456789"})
);
let mut preload_cookie_lax_first_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-cookie-lax.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_cookie_lax_first_page.status(), 200);
assert_eq!(
preload_cookie_lax_first_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "0"})
);
let mut preload_cookie_lax_second_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-cookie-lax.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_cookie_lax_second_page.status(), 200);
assert_eq!(
preload_cookie_lax_second_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "1"})
);
let mut preload_cookie_strict_first_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-cookie-strict.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_cookie_strict_first_page.status(), 200);
assert_eq!(
preload_cookie_strict_first_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "0"})
);
let mut preload_cookie_strict_second_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-cookie-strict.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_cookie_strict_second_page.status(), 200);
assert_eq!(
preload_cookie_strict_second_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "1"})
);
let mut preload_empty_body_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-empty-body.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_empty_body_page.status(), 200);
assert_eq!(
preload_empty_body_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "[]"})
);
let mut preload_broken_unused_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-broken-body-unused.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_broken_unused_page.status(), 200);
assert_eq!(
preload_broken_unused_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "PASS: preloadResponse resolved"})
);
let mut preload_redirect_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-redirect.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_redirect_page.status(), 200);
assert_eq!(
preload_redirect_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({
"type": "string",
"value": format!(
"preload-redirect:0:opaqueredirect:false:{base_url}/app/preload-redirect.html:"
)
})
);
let mut preload_redirect_direct_body_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-redirect-direct-body.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(
preload_redirect_direct_body_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "BODY"})
);
let mut preload_redirect_follow_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-redirect-follow.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(
preload_redirect_follow_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "redirected\n"})
);
let mut preload_redirect_to_scope_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-redirect-to-scope.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(
preload_redirect_to_scope_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "redirected\n"})
);
let mut preload_body_error_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-body-error.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_body_error_page.status(), 200);
assert_eq!(
preload_body_error_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({
"type": "string",
"value": "{\"hasResponse\":true,\"status\":200,\"body\":null,\"bodyError\":{\"name\":\"TypeError\",\"message\":\"The service worker navigation preload request failed due to a network error. This may have been an actual network error, or caused by the browser simulating offline to see if the page works offline: see https://w3c.github.io/manifest/#installability-signals\",\"isTypeError\":true}}"
})
);
let mut preload_cancel_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/preload-cancel.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
assert_eq!(preload_cancel_page.status(), 200);
assert_eq!(
preload_cancel_page
.evaluate_runtime_expression_async("document.body.textContent")
.await?,
serde_json::json!({"type": "string", "value": "preload cancel handled"})
);
browser
.wait_for_script_truthy(
&mut preload_cancel_page,
"String(globalThis.__preloadCancelProbe).startsWith('{')",
Duration::from_secs(5),
)
.await?;
assert_eq!(
preload_cancel_page
.evaluate_runtime_expression_async("String(globalThis.__preloadCancelProbe)")
.await?,
serde_json::json!({
"type": "string",
"value": "{\"name\":\"NetworkError\",\"message\":\"The service worker navigation preload request was cancelled before 'preloadResponse' settled. If you intend to use 'preloadResponse', use waitUntil() or respondWith() to wait for the promise to settle.\",\"isDomException\":true}"
})
);
server.abort();
let requests = requests.lock().await.clone();
assert!(
requests
.iter()
.filter(|request| request_path(request).as_deref() == Some("/app/controlled.html"))
.all(|request| request_has_navigation_preload_header(request, "core-preload")),
"controlled main resource should only hit network as a navigation preload request, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(
|request| request_path(request).as_deref() == Some("/app/fallback.html")
&& !request_has_navigation_preload_header(request, "core-preload")
),
"fallback main resource should return to network after the preload request, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(
|request| request_path(request).as_deref() == Some("/app/preload.html")
&& request_has_navigation_preload_header(request, "core-preload")
),
"navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(
|request| request_path(request).as_deref() == Some("/app/preload-headers.html")
&& request_has_navigation_preload_header(request, "core-preload")
&& request_has_header_value(request, "Upgrade-Insecure-Requests", "1")
),
"preload headers path should include navigation preload and upgrade-insecure headers, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(
|request| request_path(request).as_deref() == Some("/app/preload-gzip.html")
&& request_has_navigation_preload_header(request, "core-preload")
),
"gzip navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(
|request| request_path(request).as_deref() == Some("/app/preload-chunked.html")
&& request_has_navigation_preload_header(request, "core-preload")
),
"chunked navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/app/preload-cookie-lax.html")
&& request_has_navigation_preload_header(request, "core-preload")
&& request_has_header_containing(request, "Cookie", "preload_lax=1")),
"same-site Lax cookie navigation preload should send the stored cookie on the second visit, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/app/preload-cookie-strict.html")
&& request_has_navigation_preload_header(request, "core-preload")
&& request_has_header_containing(request, "Cookie", "preload_strict=1")),
"same-site Strict cookie navigation preload should send the stored cookie on the second visit, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/app/preload-empty-body.html")
&& request_has_navigation_preload_header(request, "core-preload")),
"empty-body navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/app/preload-broken-body-unused.html")
&& request_has_navigation_preload_header(request, "core-preload")),
"broken-body navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(
|request| request_path(request).as_deref() == Some("/app/preload-redirect.html")
&& request_has_navigation_preload_header(request, "core-preload")
),
"redirect navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/app/preload-redirect-direct-body.html")
&& request_has_navigation_preload_header(request, "core-preload")),
"direct no-location redirect-body navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/app/preload-redirect-follow.html")
&& request_has_navigation_preload_header(request, "core-preload")),
"direct Location redirect navigation preload should issue an initial network request with the configured header, requests: {requests:?}"
);
for path in [
"/app/preload-redirect-to-scope.html",
"/app/preload-redirect-to-scope-2.html",
"/app/preload-redirect-to-scope-3.html",
] {
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref() == Some(path)
&& request_has_navigation_preload_header(request, "core-preload")),
"same-scope redirect hop {path} should issue a navigation preload request with the configured header, requests: {requests:?}"
);
}
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/outside/preload-redirected.html")
&& !request_has_navigation_preload_header(request, "core-preload")),
"direct Location redirect should follow the internal redirect to network without a preload header outside the controlled scope, requests: {requests:?}"
);
assert!(
requests
.iter()
.any(|request| request_path(request).as_deref()
== Some("/app/preload-body-error.html")
&& request_has_navigation_preload_header(request, "core-preload")),
"body-error navigation preload should issue a network request with the configured header, requests: {requests:?}"
);
assert!(
requests
.iter()
.all(|request| request_path(request).as_deref() != Some("/app/preload-final.html")),
"navigation preload must expose the redirect response instead of following to the final URL, requests: {requests:?}"
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_dir_persists_local_storage_but_not_session_storage() -> Result<()> {
let server = FixtureServer::spawn().await?;
let profile = TempProfileDir::new("localstorage");
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
{
let browser = Browser::new(config.clone())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let write = page
.evaluate_runtime_expression_async(
"localStorage.clear(); sessionStorage.clear(); localStorage.setItem('persisted', 'yes'); sessionStorage.setItem('ephemeral', 'yes'); 'ok'",
)
.await?;
assert_eq!(write["value"], serde_json::json!("ok"));
}
let profile_paths = BrowserProfilePaths::new(&profile.path);
let profile_json = fs::read_to_string(&profile_paths.local_storage_path)
.context("expected localStorage profile json to be written")?;
assert!(
profile_json.contains("\"persisted\"") && profile_json.contains("\"yes\""),
"profile localStorage file should contain persisted key: {profile_json}"
);
let browser = Browser::new(config)?;
let mut page = browser.fetch(&server.url("/static")).await?;
let read = page
.evaluate_runtime_expression_async(
"`${localStorage.getItem('persisted')}|${String(sessionStorage.getItem('ephemeral'))}`",
)
.await?;
assert_eq!(read["value"], serde_json::json!("yes|null"));
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_dir_persists_storage_bucket_names() -> Result<()> {
let server = FixtureServer::spawn().await?;
let profile = TempProfileDir::new("storage-buckets");
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
let page_url = server.url("/static");
let page_url = Url::parse(&page_url)?;
let storage_key = first_party_storage_key_for_url(&page_url);
let page_url = page_url.to_string();
{
let browser = Browser::new(config.clone())?;
let mut page = browser.fetch(&page_url).await?;
let write = page
.evaluate_runtime_expression_with_await_async(
r#"
(async () => {
await navigator.storageBuckets.open("bucket-b");
await navigator.storageBuckets.open("bucket-a");
return (await navigator.storageBuckets.keys()).join("|");
})()
"#,
true,
)
.await?;
assert_eq!(write["value"], serde_json::json!("bucket-a|bucket-b"));
}
let profile_paths = BrowserProfilePaths::new(&profile.path);
let bucket_json = fs::read_to_string(&profile_paths.storage_buckets_path)
.context("expected Storage Buckets profile json to be written")?;
let persisted: serde_json::Value = serde_json::from_str(&bucket_json)?;
assert_eq!(persisted["version"], serde_json::json!(5));
assert_eq!(persisted["nextBucketId"], serde_json::json!(3));
let bucket_a_id = persisted["origins"][storage_key.as_str()]["bucket-a"]["bucketId"]
.as_u64()
.context("expected bucket-a to have a persistent bucket ID")?;
let bucket_b_id = persisted["origins"][storage_key.as_str()]["bucket-b"]["bucketId"]
.as_u64()
.context("expected bucket-b to have a persistent bucket ID")?;
assert_ne!(bucket_a_id, 0);
assert_ne!(bucket_b_id, 0);
assert_ne!(bucket_a_id, bucket_b_id);
let browser = Browser::new(config)?;
let mut page = browser.fetch(&page_url).await?;
let read = page
.evaluate_runtime_expression_with_await_async(
r#"
(async () => (await navigator.storageBuckets.keys()).join("|"))()
"#,
true,
)
.await?;
assert_eq!(read["value"], serde_json::json!("bucket-a|bucket-b"));
let reopened: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&profile_paths.storage_buckets_path)?)?;
assert_eq!(
reopened["origins"][storage_key.as_str()]["bucket-a"]["bucketId"],
serde_json::json!(bucket_a_id)
);
assert_eq!(
reopened["origins"][storage_key.as_str()]["bucket-b"]["bucketId"],
serde_json::json!(bucket_b_id)
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_dir_persists_storage_bucket_indexeddb_separately() -> Result<()> {
let server = FixtureServer::spawn().await?;
let profile = TempProfileDir::new("storage-bucket-indexeddb");
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
let page_url = server.url("/static");
let page_url = Url::parse(&page_url)?;
let origin = page_url.origin().ascii_serialization();
let storage_key = first_party_storage_key_for_url(&page_url);
let page_url = page_url.to_string();
{
let browser = Browser::new(config.clone())?;
let mut page = browser.fetch(&page_url).await?;
let write = page
.evaluate_runtime_expression_with_await_async(
r#"
(async () => {
const bucket = await navigator.storageBuckets.open("idbbucket");
const db = await new Promise((resolve, reject) => {
const open = bucket.indexedDB.open("bucket-db", 1);
open.onerror = () => reject(`open:${open.error && open.error.name}`);
open.onupgradeneeded = () => {
open.result.createObjectStore("kv");
};
open.onsuccess = () => resolve(open.result);
});
await new Promise((resolve, reject) => {
const tx = db.transaction("kv", "readwrite");
tx.objectStore("kv").put("bucket-value", "key");
tx.onerror = () => reject(`tx:${tx.error && tx.error.name}`);
tx.oncomplete = resolve;
});
db.close();
return "stored";
})()
"#,
true,
)
.await?;
assert_eq!(write["value"], serde_json::json!("stored"));
}
let profile_paths = BrowserProfilePaths::new(&profile.path);
let bucket_json: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&profile_paths.storage_buckets_path)?)?;
let bucket_id = bucket_json["origins"][storage_key.as_str()]["idbbucket"]["bucketId"]
.as_u64()
.and_then(moli_storage_service::StorageBucketId::new)
.context("expected idbbucket to have a persistent bucket ID")?;
let bucket_storage_key =
crate::storage::storage_bucket_indexed_db_storage_key(&storage_key, bucket_id);
assert!(
indexed_db_origin_exists(&profile_paths.indexeddb_root, &bucket_storage_key),
"bucket IndexedDB should write under its bucket storage key"
);
assert!(
!indexed_db_origin_exists(&profile_paths.indexeddb_root, &origin),
"bucket IndexedDB should not write under the origin-wide IndexedDB key"
);
let browser = Browser::new(config)?;
let mut page = browser.fetch(&page_url).await?;
let read = page
.evaluate_runtime_expression_with_await_async(
r#"
(async () => {
const bucket = await navigator.storageBuckets.open("idbbucket");
const bucketValue = await new Promise((resolve, reject) => {
const open = bucket.indexedDB.open("bucket-db", 1);
open.onerror = () => reject(`bucket-open:${open.error && open.error.name}`);
open.onupgradeneeded = () => reject("bucket-missing");
open.onsuccess = () => {
const db = open.result;
const tx = db.transaction("kv", "readonly");
const get = tx.objectStore("kv").get("key");
get.onerror = () => reject(`bucket-get:${get.error && get.error.name}`);
get.onsuccess = () => {
const value = get.result;
db.close();
resolve(value);
};
};
});
const globalState = await new Promise((resolve, reject) => {
const open = indexedDB.open("bucket-db", 1);
let upgraded = false;
open.onerror = () => reject(`global-open:${open.error && open.error.name}`);
open.onupgradeneeded = () => {
upgraded = true;
open.result.createObjectStore("kv");
};
open.onsuccess = () => {
open.result.close();
resolve(upgraded ? "missing" : "leaked");
};
});
return `${bucketValue}|${globalState}`;
})()
"#,
true,
)
.await?;
assert_eq!(read["value"], serde_json::json!("bucket-value|missing"));
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_dir_prunes_expired_storage_bucket_indexeddb_on_open() -> Result<()> {
let server = FixtureServer::spawn().await?;
let profile = TempProfileDir::new("storage-bucket-expired-indexeddb");
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
let page_url = server.url("/static");
let page_url = Url::parse(&page_url)?;
let storage_key = first_party_storage_key_for_url(&page_url);
let page_url = page_url.to_string();
let bucket_name = "expired-idbbucket";
{
let browser = Browser::new(config.clone())?;
let mut page = browser.fetch(&page_url).await?;
let write = page
.evaluate_runtime_expression_with_await_async(
r#"
(async () => {
const bucket = await navigator.storageBuckets.open("expired-idbbucket", {
expires: Date.now() + 60000
});
const db = await new Promise((resolve, reject) => {
const open = bucket.indexedDB.open("bucket-db", 1);
open.onerror = () => reject(`open:${open.error && open.error.name}`);
open.onupgradeneeded = () => {
open.result.createObjectStore("kv");
};
open.onsuccess = () => resolve(open.result);
});
await new Promise((resolve, reject) => {
const tx = db.transaction("kv", "readwrite");
tx.objectStore("kv").put("expired-bucket-value", "key");
tx.onerror = () => reject(`tx:${tx.error && tx.error.name}`);
tx.oncomplete = resolve;
});
db.close();
return "stored";
})()
"#,
true,
)
.await?;
assert_eq!(write["value"], serde_json::json!("stored"));
}
let profile_paths = BrowserProfilePaths::new(&profile.path);
let mut bucket_json: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&profile_paths.storage_buckets_path)?)?;
let bucket_id = bucket_json["origins"][storage_key.as_str()][bucket_name]["bucketId"]
.as_u64()
.and_then(moli_storage_service::StorageBucketId::new)
.context("expected expired bucket to have a persistent bucket ID")?;
let bucket_storage_key =
crate::storage::storage_bucket_indexed_db_storage_key(&storage_key, bucket_id);
assert!(
indexed_db_origin_exists(&profile_paths.indexeddb_root, &bucket_storage_key),
"bucket IndexedDB should exist before profile-open pruning"
);
bucket_json["origins"][storage_key.as_str()][bucket_name]["expires"] = serde_json::json!(0.0);
fs::write(
&profile_paths.storage_buckets_path,
serde_json::to_vec_pretty(&bucket_json)?,
)?;
{
let browser = Browser::new(config)?;
drop(browser);
}
assert!(
!indexed_db_origin_exists(&profile_paths.indexeddb_root, &bucket_storage_key),
"profile-open pruning should remove expired bucket IndexedDB backing"
);
let pruned_json: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&profile_paths.storage_buckets_path)?)?;
assert!(
pruned_json["origins"]
.get(storage_key.as_str())
.and_then(|buckets| buckets.get(bucket_name))
.is_none(),
"profile-open pruning should remove expired bucket metadata"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_dir_persists_storage_bucket_cache_entries() -> Result<()> {
let server = FixtureServer::spawn().await?;
let profile = TempProfileDir::new("storage-bucket-cache");
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
let page_url = server.url("/static");
{
let browser = Browser::new(config.clone())?;
let mut page = browser.fetch(&page_url).await?;
let write = page
.evaluate_runtime_expression_with_await_async(
r#"
(async () => {
const bucket = await navigator.storageBuckets.open("cachebucket");
const cache = await bucket.caches.open("receipts");
await cache.put("receipt.txt", new Response("profile cache body", {
status: 202,
statusText: "Accepted",
headers: [["x-profile-cache", "hit"]]
}));
const estimate = await bucket.estimate();
return estimate.usageDetails.caches > 0;
})()
"#,
true,
)
.await?;
assert_eq!(write["value"], serde_json::json!(true));
}
let profile_paths = BrowserProfilePaths::new(&profile.path);
assert!(
profile_paths.cache_storage_root.exists(),
"StorageBucket CacheStorage root should be profile-backed"
);
let browser = Browser::new(config)?;
let mut page = browser.fetch(&page_url).await?;
let read = page
.evaluate_runtime_expression_with_await_async(
r#"
(async () => {
const bucket = await navigator.storageBuckets.open("cachebucket");
const cache = await bucket.caches.open("receipts");
const matched = await cache.match("receipt.txt");
const missing = await cache.match("missing.txt");
const estimate = await bucket.estimate();
return JSON.stringify({
keys: await bucket.caches.keys(),
status: matched.status,
statusText: matched.statusText,
header: matched.headers.get("x-profile-cache"),
text: await matched.text(),
missing: typeof missing,
cacheUsage: estimate.usageDetails.caches > 0
});
})()
"#,
true,
)
.await?;
assert_eq!(
read["value"],
serde_json::json!(
r#"{"keys":["receipts"],"status":202,"statusText":"Accepted","header":"hit","text":"profile cache body","missing":"undefined","cacheUsage":true}"#
)
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_dir_initializes_profile_manifest() -> Result<()> {
let profile = TempProfileDir::new("manifest");
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
let profile_paths = BrowserProfilePaths::new(&profile.path);
{
let browser = Browser::new(config)?;
drop(browser);
}
let manifest = load_profile_manifest(&profile_paths)?;
assert_eq!(
manifest.version,
moli_browser_profile::PROFILE_MANIFEST_VERSION
);
assert_eq!(manifest.partitions.len(), 1);
let partition = &manifest.partitions[0];
assert_eq!(
partition.id,
moli_browser_profile::DEFAULT_PROFILE_PARTITION_ID
);
assert_eq!(partition.root, "partitions/default");
assert_eq!(
partition.cookies.path.as_deref(),
Some("partitions/default/cookies.json")
);
assert_eq!(
partition.local_storage.path.as_deref(),
Some("partitions/default/localstorage.json")
);
assert_eq!(partition.session_storage.path, None);
assert_eq!(
partition.storage_buckets.path.as_deref(),
Some("partitions/default/storage-buckets.json")
);
assert_eq!(
partition.service_worker_resources.path.as_deref(),
Some("partitions/default/service-worker-resources.json")
);
assert_eq!(
partition.cache_storage.path.as_deref(),
Some("partitions/default/cache-storage")
);
assert_eq!(
partition.indexed_db.path.as_deref(),
Some("partitions/default/indexeddb")
);
assert_eq!(
partition.http_cache.path.as_deref(),
Some("partitions/default/http-cache")
);
Ok(())
}
#[test]
fn browser_profile_dir_supplies_default_http_cache_root_without_overriding_explicit_cache()
-> Result<()> {
let profile = TempProfileDir::new("partition-http-cache");
let explicit_cache = TempProfileDir::new("explicit-http-cache");
let profile_paths = BrowserProfilePaths::new(&profile.path);
let mut default_config = AppConfig::default();
default_config.set_profile_dir(Some(profile.path.clone()));
let browser = Browser::new(default_config)?;
assert_eq!(
browser.config().fetch().http_cache_dir(),
Some(profile_paths.http_cache_root.to_string_lossy().as_ref())
);
drop(browser);
let mut explicit_config = AppConfig::default();
explicit_config.set_profile_dir(Some(profile.path.clone()));
explicit_config
.fetch_mut()
.set_http_cache_dir(Some(explicit_cache.path.to_string_lossy().into_owned()));
let browser = Browser::new(explicit_config)?;
assert_eq!(
browser.config().fetch().http_cache_dir(),
Some(explicit_cache.path.to_string_lossy().as_ref())
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_dir_refuses_second_writer_until_first_browser_drops() -> Result<()> {
let profile = TempProfileDir::new("writer-lock");
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
let first = Browser::new(config.clone())?;
let error = Browser::new(config.clone()).expect_err("second profile writer should fail");
let error_chain = format!("{error:?}");
assert!(error_chain.contains("already locked"), "error: {error:?}");
drop(first);
let second = Browser::new(config)?;
drop(second);
Ok(())
}
#[test]
fn browser_profile_lock_refuses_browser_start_when_external_guard_is_held() -> Result<()> {
let profile = TempProfileDir::new("external-lock");
let paths = BrowserProfilePaths::new(&profile.path);
let _lock = BrowserProfileLock::acquire(&paths)?;
let mut config = AppConfig::default();
config.set_profile_dir(Some(profile.path.clone()));
let error = Browser::new(config).expect_err("held profile lock should reject Browser::new");
let error_chain = format!("{error:?}");
assert!(error_chain.contains("already locked"), "error: {error:?}");
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn navigation_engine_keeps_network_runtime_when_web_storage_changes() -> Result<()> {
let mut engine = NavigationEngine::new();
let cookie_store = new_shared_browser_cookie_store();
let session_storage_store = new_shared_web_storage_store();
let first_store = new_shared_web_storage_store();
let second_store = new_shared_web_storage_store();
let url = Url::parse("http://example.test/")?;
let mut first_page = engine
.build_inline_html_document_page_with_storage_best_effort_async(
NavigationPageStorageHandles::new(
cookie_store.clone(),
first_store,
session_storage_store.clone(),
None,
None,
),
url.clone(),
None,
"<!doctype html><html><body>first</body></html>".to_owned(),
Vec::new(),
Vec::new(),
Default::default(),
false,
Default::default(),
None,
false,
Vec::new(),
false,
None,
)
.await?
.page;
first_page
.evaluate_runtime_expression_async("localStorage.clear(); localStorage.setItem('ctx', 'a')")
.await?;
let first_resource_runtime_id = engine
.resource_request_client()
.expect("first page should initialize the resource runtime")
.resource_runtime_diagnostics()
.runtime_id;
let mut second_page = engine
.build_inline_html_document_page_with_storage_best_effort_async(
NavigationPageStorageHandles::new(
cookie_store,
second_store,
session_storage_store,
None,
None,
),
url,
None,
"<!doctype html><html><body>second</body></html>".to_owned(),
Vec::new(),
Vec::new(),
Default::default(),
false,
Default::default(),
None,
false,
Vec::new(),
false,
None,
)
.await?
.page;
assert_eq!(
engine
.resource_request_client()
.expect("second page should retain the resource runtime")
.resource_runtime_diagnostics()
.runtime_id,
first_resource_runtime_id,
"changing only Web Storage identity must not rebuild the browser network runtime",
);
assert_eq!(
second_page
.evaluate_runtime_expression_async("String(localStorage.getItem('ctx'))")
.await?,
serde_json::json!({"type": "string", "value": "null"})
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn navigation_engine_bypasses_service_worker_for_main_resource() -> Result<()> {
let (base_url, requests, server) = spawn_main_resource_service_worker_server().await?;
let browser = Browser::new(AppConfig::default())?;
let mut registration_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/register.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
browser
.wait_for_script_truthy(
&mut registration_page,
"String(globalThis.__mainResourceSwReady).startsWith('ready:')",
Duration::from_secs(5),
)
.await?;
let mut engine = NavigationEngine::new_with_fetch_config_and_browser_context_access(
FetchConfig::default(),
browser._lifetime_owner.browser_context_owner.owner_access(),
OptionalResourceFetchMask::NONE,
true,
)?;
engine.set_bypass_service_worker(true);
let navigation = engine
.fetch_navigation_streaming_raw_response_with_storage_async(
NavigationResourceStorageHandles::new(
browser.partition.cookie_store(),
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
None,
BrowserNavigationRequestKind::Navigate,
false,
None,
None,
"GET",
&format!("{base_url}/app/controlled.html"),
None,
Vec::new().into(),
None,
)
.await?;
assert!(
navigation.reserved_service_worker_client.is_some(),
"bypass should retain an uncontrolled client reservation for document commit"
);
assert!(
navigation.fetch_result.request_observation().is_some(),
"the bypassed main resource should retain direct network transport metadata"
);
let response = navigation
.fetch_result
.into_response()
.into_lossy_materialized_text_response()
.await?;
assert_eq!(response.status, 200);
assert_eq!(
response.body_text(),
"<!doctype html><body>network controlled</body>"
);
server.abort();
let requests = requests.lock().await.clone();
assert!(
requests.iter().any(|request| {
request_path(request).as_deref() == Some("/app/controlled.html")
&& !request_has_navigation_preload_header(request, "core-preload")
}),
"bypassed main resource should use a direct network request, requests: {requests:?}"
);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn navigation_engine_service_worker_main_resource_has_no_network_transport_metadata()
-> Result<()> {
let (base_url, _requests, server) = spawn_main_resource_service_worker_server().await?;
let browser = Browser::new(AppConfig::default())?;
let mut registration_page = browser
.fetch_allow_http_error_with_wait_until(
&format!("{base_url}/app/register.html"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
browser
.wait_for_script_truthy(
&mut registration_page,
"String(globalThis.__mainResourceSwReady).startsWith('ready:')",
Duration::from_secs(5),
)
.await?;
let mut engine = NavigationEngine::new_with_fetch_config_and_browser_context_access(
FetchConfig::default(),
browser._lifetime_owner.browser_context_owner.owner_access(),
OptionalResourceFetchMask::NONE,
true,
)?;
let navigation = engine
.fetch_navigation_streaming_raw_response_with_storage_async(
NavigationResourceStorageHandles::new(
browser.partition.cookie_store(),
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
None,
BrowserNavigationRequestKind::Navigate,
false,
None,
None,
"GET",
&format!("{base_url}/app/controlled.html"),
None,
Vec::new().into(),
None,
)
.await?;
assert!(
navigation.fetch_result.request_observation().is_none(),
"a Service Worker synthetic response must not look like a network-service raw callback"
);
let response = navigation
.fetch_result
.into_response()
.into_lossy_materialized_text_response()
.await?;
assert_eq!(response.status, 200);
assert_eq!(
response.body_text(),
"<!doctype html><body>sw-main:document:navigate</body>"
);
server.abort();
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn browser_profile_indexeddb_root_is_page_local_when_default_changes() -> Result<()> {
let server = FixtureServer::spawn().await?;
let profile_a = TempProfileDir::new("indexeddb-a");
let profile_b = TempProfileDir::new("indexeddb-b");
let mut config_a = AppConfig::default();
config_a.set_profile_dir(Some(profile_a.path.clone()));
let mut config_b = AppConfig::default();
config_b.set_profile_dir(Some(profile_b.path.clone()));
let browser_a = Browser::new(config_a)?;
let _browser_b = Browser::new(config_b)?;
let page_url = server.url("/static");
let origin = Url::parse(&page_url)?.origin().ascii_serialization();
let mut page = browser_a.fetch(&page_url).await?;
page.evaluate_runtime_expression_async(
r#"
(() => {
globalThis.__indexedDbRootResult = "pending";
const open = indexedDB.open("app", 1);
open.onerror = () => {
globalThis.__indexedDbRootResult = `open-error:${open.error && open.error.name}`;
};
open.onupgradeneeded = () => {
open.result.createObjectStore("kv");
};
open.onsuccess = () => {
open.result.close();
globalThis.__indexedDbRootResult = "ok";
};
return "scheduled";
})()
"#,
)
.await?;
browser_a
.wait_for_script_truthy(
&mut page,
"globalThis.__indexedDbRootResult === 'ok'",
Duration::from_secs(2),
)
.await?;
let profile_paths_a = BrowserProfilePaths::new(&profile_a.path);
let profile_paths_b = BrowserProfilePaths::new(&profile_b.path);
let storage_key = first_party_storage_key_for_url(&Url::parse(&format!("{origin}/"))?);
assert!(
indexed_db_origin_exists(&profile_paths_a.indexeddb_root, &storage_key),
"browser A page should write IndexedDB under browser A profile"
);
assert!(
!indexed_db_origin_exists(&profile_paths_b.indexeddb_root, &storage_key),
"browser B default root should not receive browser A page writes"
);
server.shutdown().await;
Ok(())
}
async fn wait_for_renderer_owner_state(
renderer_owner: &RendererOwnerHandle,
mut ready: impl FnMut(&RendererOwnerHandle) -> bool,
context: &str,
) {
tokio::time::timeout(Duration::from_secs(1), async {
loop {
if ready(renderer_owner) {
return;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap_or_else(|_| panic!("{context}; final owner state len={}", renderer_owner.len()));
}
async fn wait_for_renderer_owner_page_removed(
renderer_owner: &RendererOwnerHandle,
page_id: PageId,
context: &str,
) {
wait_for_renderer_owner_state(
renderer_owner,
|renderer_owner| renderer_owner.record(page_id).is_none(),
context,
)
.await;
}
async fn assert_unrelated_evaluate_runs_while_wait_command_is_pending(
page: &mut Page,
pending_wait: PendingPageCommand,
marker: &str,
) -> Result<()> {
let expression = format!("document.body.dataset.{marker} = 'ok'; 'ok'");
let value = tokio::time::timeout(
Duration::from_secs(2),
page.evaluate_runtime_expression_async(&expression),
)
.await
.context("unrelated evaluate timed out behind a pending wait command")??;
assert_eq!(value["value"], serde_json::json!("ok"));
drop(pending_wait);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn networkidle_times_out_while_intercepted_fetch_request_is_paused() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let (output_tx, mut output_rx) = crate::renderer_output_transport_channel();
browser
.js_runtime
.set_renderer_output_transport_sender(output_tx);
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.set_fetch_subresource_interception_async(true, Some(SubresourceResourceType::Fetch))
.await?;
page.evaluate_runtime_expression_async(
"fetch('/wait-until-data').then(r => r.text()).then(text => { document.body.setAttribute('data-state', text); }); 'scheduled';",
)
.await?;
let error = page
.wait_for_network_idle(
&browser.resource_request_client(),
Duration::from_millis(100),
)
.await
.unwrap_err();
assert!(error.to_string().contains("timed out"));
let _pending = recv_subresource_fetch_pause_for_page(&mut output_rx, &page).await?;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn networkidle_recovers_after_continuing_intercepted_fetch_request() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let (output_tx, mut output_rx) = crate::renderer_output_transport_channel();
browser
.js_runtime
.set_renderer_output_transport_sender(output_tx);
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.set_fetch_subresource_interception_async(true, Some(SubresourceResourceType::Fetch))
.await?;
page.evaluate_runtime_expression_async(
"fetch('/wait-until-data').then(r => r.text()).then(text => { document.body.setAttribute('data-state', text); }); 'scheduled';",
)
.await?;
let pending = recv_subresource_fetch_pause_for_page(&mut output_rx, &page).await?;
let outcome = page
.continue_pending_subresource_fetch_async(
pending.internal_id,
None,
None,
None,
None,
false,
false,
)
.await?;
assert!(matches!(
outcome,
PendingSubresourceContinueOutcome::Started
));
page.wait_for_network_idle(&browser.resource_request_client(), Duration::from_secs(2))
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-state=\"settled\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_selector_finds_late_element_via_renderer_wait_loop() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-delayed-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let node = browser
.wait_for_selector(&mut page, "#late", Duration::from_secs(2))
.await?;
assert_eq!(
query_selector_node_from_live_document(&mut page, "#late")
.await?
.map(|node| node.backend_node_id),
Some(node.backend_node_id)
);
assert!(crate::page::is_renderer_backend_node_id(
node.backend_node_id
));
assert!(page.serialize_html_async().await?.contains("id=\"late\""));
assert!(page.serialize_html_async().await?.contains("settled"));
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_selector_observes_attribute_mutation() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.evaluate_runtime_expression_async(
"setTimeout(() => { document.body.classList.add('ready'); }, 50); 'scheduled';",
)
.await?;
let node = browser
.wait_for_selector(&mut page, "body.ready", Duration::from_secs(2))
.await?;
assert_eq!(
query_selector_node_from_live_document(&mut page, "body.ready")
.await?
.map(|node| node.backend_node_id),
Some(node.backend_node_id)
);
assert!(crate::page::is_renderer_backend_node_id(
node.backend_node_id
));
assert!(
page.serialize_html_async()
.await?
.contains("<body class=\"ready\">")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_selector_times_out_for_missing_selector() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let error = browser
.wait_for_selector(&mut page, "#does-not-exist", Duration::from_millis(150))
.await
.unwrap_err();
assert!(
error
.to_string()
.contains("timed out waiting for selector `#does-not-exist`")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_selector_cancellation_restores_entry_for_close() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let canceled = tokio::time::timeout(
Duration::from_millis(150),
browser.wait_for_selector(&mut page, "#never-appears", Duration::from_secs(5)),
)
.await;
assert!(
canceled.is_err(),
"selector wait should be cancelled by the test timeout"
);
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after cancelled selector wait should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_deadline_spans_lifecycle_selector_and_script_without_reset() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let started = std::time::Instant::now();
let deadline = FetchDeadline::new(Duration::from_millis(600))?;
let fetched = browser
.fetch_request_document_allow_http_error_with_wait_until_deadline(
browser_navigation_request(&server.url("/static"))?,
RenderedDomWaitUntil::Load,
deadline,
RawDocumentFetchPolicy::Materialize,
)
.await?;
let FetchedDocument::Page(mut page) = fetched else {
panic!("static HTML fixture unexpectedly produced a raw document");
};
let page_id = page.renderer_page_id();
browser
.wait_for_selector_with_deadline(&mut page, "body", deadline)
.await?;
tokio::time::sleep(Duration::from_millis(300)).await;
let error = browser
.wait_for_script_truthy_with_deadline(&mut page, "false", deadline)
.await
.unwrap_err();
assert!(
error
.chain()
.any(|cause| cause.to_string().contains("timed out")),
"unexpected deadline error: {error:?}"
);
assert!(
started.elapsed() < Duration::from_millis(800),
"the script phase appears to have received a fresh timeout: elapsed={:?}",
started.elapsed()
);
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
assert!(
renderer_owner.record(page_id).is_none(),
"a deadline-cancelled wait must return the Page owner entry for close"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn best_effort_page_readiness_consumes_only_the_remaining_fetch_deadline() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
for (wait_until, path, expected_html) in [
(
RenderedDomWaitUntil::NetworkIdle,
"/wait-until-slow-interval-fetch",
"data-state=\"init\"",
),
(
RenderedDomWaitUntil::DomStable,
"/wait-until-slow-interval-dom-mutation",
"id=\"mutation-count\"",
),
] {
// The main response costs 500 ms. Readiness must receive only the
// roughly 500 ms left in this one-second plan, not a fresh second.
let deadline = FetchDeadline::new(Duration::from_secs(1))?;
let started = std::time::Instant::now();
let fetched = browser
.fetch_request_document_allow_http_error_with_wait_until_deadline(
browser_navigation_request(&server.url(path))?,
wait_until,
deadline,
RawDocumentFetchPolicy::Materialize,
)
.await?;
let elapsed = started.elapsed();
let FetchedDocument::Page(mut page) = fetched else {
panic!("HTML fixture unexpectedly produced a raw document");
};
let page_id = page.renderer_page_id();
assert!(
elapsed < Duration::from_millis(1_300),
"{wait_until:?} appears to have restarted its timeout after the slow main response: {elapsed:?}"
);
assert!(
page.serialize_html_async().await?.contains(expected_html),
"the best-effort Page must remain usable after {wait_until:?} expires"
);
let post_wait_started = std::time::Instant::now();
let error = browser
.wait_for_selector_with_deadline(&mut page, "#never-appears", deadline)
.await
.unwrap_err();
assert!(
error
.chain()
.any(|cause| cause.to_string().contains("timed out")),
"unexpected exhausted-deadline error: {error:?}"
);
assert!(
post_wait_started.elapsed() < Duration::from_millis(200),
"a post-readiness selector must not receive a fresh timeout"
);
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
assert!(
renderer_owner.record(page_id).is_none(),
"best-effort deadline cancellation must return the Page entry for close"
);
}
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn page_fetch_wait_until_apis_do_not_restart_best_effort_timeout() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
for (wait_until, path) in [
(
RenderedDomWaitUntil::NetworkIdle,
"/wait-until-slow-interval-fetch",
),
(
RenderedDomWaitUntil::DomStable,
"/wait-until-slow-interval-dom-mutation",
),
] {
let started = std::time::Instant::now();
let page = browser
.fetch_with_wait_until(&server.url(path), wait_until, Duration::from_secs(1))
.await?;
assert!(
started.elapsed() < Duration::from_millis(1_300),
"the Page-returning {wait_until:?} API appears to have started a fresh timeout"
);
page.close_async().await?;
}
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn best_effort_readiness_does_not_soften_a_base_lifecycle_timeout() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
for wait_until in [
RenderedDomWaitUntil::NetworkIdle,
RenderedDomWaitUntil::DomStable,
] {
// No Page exists at 200 ms because the main response itself takes
// 500 ms. Best effort applies only after the Load/DCL base boundary.
let started = std::time::Instant::now();
let error = browser
.fetch_request_document_allow_http_error_with_wait_until(
browser_navigation_request(&server.url("/wait-until-slow-static"))?,
wait_until,
Duration::from_millis(200),
)
.await
.unwrap_err();
assert!(
error
.chain()
.any(|cause| cause.to_string().contains("timed out")),
"unexpected base lifecycle error: {error:?}"
);
assert!(
started.elapsed() < Duration::from_millis(400),
"{wait_until:?} incorrectly softened or extended the base lifecycle timeout"
);
}
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_selector_wait_allows_unrelated_evaluate_while_pending() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let pending_wait = page.start_page_command(RendererPageCommand::WaitForSelector {
selector: "#never-appears".to_owned(),
timeout_ms: 10_000,
loader: browser.resource_request_client(),
})?;
assert_unrelated_evaluate_runs_while_wait_command_is_pending(
&mut page,
pending_wait,
"selectorWaitProbe",
)
.await?;
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_selector_reports_invalid_selector_errors() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let error = browser
.wait_for_selector(&mut page, "div[", Duration::from_secs(2))
.await
.unwrap_err();
assert!(
error
.to_string()
.contains("wait_for_selector `div[` failed inside renderer")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_observes_delayed_fetch_state_change() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-delayed-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
browser
.wait_for_script_truthy(
&mut page,
"document.body.getAttribute('data-state') === 'settled'",
Duration::from_secs(2),
)
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-state=\"settled\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_advances_slow_runtime_script_started_from_domcontentloaded()
-> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-domcontentloaded-runtime-script-very-slow"),
RenderedDomWaitUntil::DomContentLoaded,
Duration::from_secs(5),
)
.await?;
assert!(
!page
.serialize_html_async()
.await?
.contains("id=\"late-dcl-script-very-slow\"")
);
browser
.wait_for_script_truthy(
&mut page,
"document.querySelector('#late-dcl-script-very-slow') !== null",
Duration::from_secs(7),
)
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("id=\"late-dcl-script-very-slow\"")
);
assert!(
page.serialize_html_async()
.await?
.contains(">script-loaded-very-slow<")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_observes_attribute_mutation() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.evaluate_runtime_expression_async(
"setTimeout(() => { document.body.dataset.ready = 'yes'; }, 50); 'scheduled';",
)
.await?;
browser
.wait_for_script_truthy(
&mut page,
"document.body.dataset.ready === 'yes'",
Duration::from_secs(2),
)
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-ready=\"yes\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_page_delay_advances_runtime_work() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.evaluate_runtime_expression_async(
"setTimeout(() => { document.body.dataset.delayReady = 'yes'; }, 50); 'scheduled';",
)
.await?;
browser
.wait_for_page_delay(&mut page, Duration::from_millis(100))
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-delay-ready=\"yes\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn standalone_page_turn_follows_post_load_cookie_reload() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/location-nav/post-load-cookie-reload-challenge"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
browser
.wait_for_page_delay(&mut page, Duration::from_millis(400))
.await?;
let html = page.serialize_html_async().await?;
assert!(
html.contains("post-load-cookie-reload=done"),
"standalone owner left the post-load reload pending: {html}"
);
assert!(
html.contains("data-final-script=\"done\""),
"observer command ran before the replacement document committed: {html}"
);
assert!(
!html.contains("post-load-cookie-reload=source"),
"challenge document survived its post-load reload: {html}"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn standalone_selector_observes_replacement_document_before_load() -> Result<()> {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.context("bind replacement document commit fixture")?;
let addr = listener
.local_addr()
.context("read replacement document commit fixture address")?;
let (blocking_script_requested_tx, blocking_script_requested_rx) = oneshot::channel();
let blocking_script_requested_tx = Arc::new(Mutex::new(Some(blocking_script_requested_tx)));
let (release_blocking_script_tx, release_blocking_script_rx) = oneshot::channel();
let release_blocking_script_rx = Arc::new(Mutex::new(Some(release_blocking_script_rx)));
let server = tokio::spawn(async move {
loop {
let (mut stream, _) = match listener.accept().await {
Ok(connection) => connection,
Err(_) => break,
};
let blocking_script_requested_tx = blocking_script_requested_tx.clone();
let release_blocking_script_rx = release_blocking_script_rx.clone();
tokio::spawn(async move {
let request = match read_http_request_head(&mut stream).await {
Ok(request) => request,
Err(_) => return,
};
let path = request_path(&request).unwrap_or_else(|| "/".to_owned());
if path == "/replacement-document-blocking.js" {
if let Some(requested) = blocking_script_requested_tx.lock().await.take() {
let _ = requested.send(());
}
if let Some(release) = release_blocking_script_rx.lock().await.take() {
let _ = release.await;
}
let body = "document.documentElement.dataset.finalScript = 'done';";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes()).await;
return;
}
let replacement = request_has_header_containing(
&request,
"Cookie",
"replacement_document_commit=1",
);
let (body, document_header) = if replacement {
(
concat!(
"<!doctype html><html><body>",
"<main id=\"replacement-target\">replacement</main>",
"<script src=\"/replacement-document-blocking.js\"></script>",
"</body></html>"
),
"replacement",
)
} else {
(
"<!doctype html><html><body><main id=\"source-target\">source</main></body></html>",
"source",
)
};
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nX-Fixture-Document: {document_header}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes()).await;
});
}
});
let browser = Browser::new(AppConfig::default())?;
let url = format!("http://127.0.0.1:{}/replacement-document", addr.port());
let mut page = browser
.fetch_with_wait_until(&url, RenderedDomWaitUntil::Load, Duration::from_secs(5))
.await?;
let initial_view = page.handle_for_testing().renderer_page_view_async().await?;
let pending_selector = page.start_page_command(RendererPageCommand::WaitForSelector {
selector: "#replacement-target".to_owned(),
timeout_ms: 5_000,
loader: browser.resource_request_client(),
})?;
page.evaluate_runtime_expression_async(
"setTimeout(() => { document.cookie = 'replacement_document_commit=1; path=/'; location.reload(); }, 0); 'scheduled';",
)
.await?;
tokio::time::timeout(Duration::from_secs(2), blocking_script_requested_rx)
.await
.context("replacement document did not request its parser-blocking script")?
.context("replacement document fixture dropped the script-request signal")?;
let selector_completion = tokio::time::timeout(Duration::from_secs(2), pending_selector.wait())
.await
.context("selector remained blocked behind replacement load")??;
assert!(matches!(
page.finish_page_command(selector_completion),
crate::renderer::RendererPageReply::DocumentQuerySelectorNode(_)
));
let committed_view = page.handle_for_testing().renderer_page_view_async().await?;
assert_ne!(committed_view.vm_creation_id, initial_view.vm_creation_id);
assert!(committed_view.view_generation > initial_view.view_generation);
assert_eq!(committed_view.page_state.requested_url.as_str(), url);
assert_eq!(committed_view.page_state.status, 200);
assert!(
committed_view
.page_state
.headers
.iter()
.any(|(name, value)| {
name.eq_ignore_ascii_case("X-Fixture-Document") && value == b"replacement"
})
);
release_blocking_script_tx
.send(())
.map_err(|()| anyhow!("blocking script response was no longer waiting"))?;
browser
.wait_for_script_truthy(
&mut page,
"document.documentElement.dataset.finalScript === 'done' && document.readyState === 'complete'",
Duration::from_secs(5),
)
.await?;
page.close_async().await?;
server.abort();
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn standalone_no_document_response_keeps_current_document() -> Result<()> {
let (base_url, server) = spawn_non_document_navigation_server().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&format!("{base_url}/source"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let initial_view = page.handle_for_testing().renderer_page_view_async().await?;
for path in ["/no-document", "/reset-content"] {
let expression = format!(
"location.assign({}); 'requested'",
serde_json::to_string(path)?
);
let value = page.evaluate_runtime_expression_async(&expression).await?;
assert_eq!(value["value"], serde_json::json!("requested"));
let settled_view = page.handle_for_testing().renderer_page_view_async().await?;
assert_eq!(settled_view.vm_creation_id, initial_view.vm_creation_id);
assert_eq!(
settled_view.page_state.requested_url,
initial_view.page_state.requested_url
);
assert_eq!(
page.evaluate_runtime_expression_async("location.href")
.await?["value"],
serde_json::json!(initial_view.page_state.requested_url.as_str())
);
assert!(
page.serialize_html_async()
.await?
.contains("source-document")
);
}
page.close_async().await?;
server.abort();
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn standalone_precommit_navigation_failure_keeps_current_document() -> Result<()> {
let (base_url, server) = spawn_non_document_navigation_server().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&format!("{base_url}/source"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let initial_view = page.handle_for_testing().renderer_page_view_async().await?;
let unused_listener = TcpListener::bind("127.0.0.1:0").await?;
let unavailable_url = format!("http://{}/unavailable", unused_listener.local_addr()?);
drop(unused_listener);
let expression = format!(
"location.assign({}); 'requested'",
serde_json::to_string(&unavailable_url)?
);
let error = page
.evaluate_runtime_expression_async(&expression)
.await
.expect_err("connection failure should reject the navigation initiator");
assert!(
error.to_string().contains("Cannot navigate")
|| error.to_string().contains("curl request failed")
|| error.to_string().contains("connect")
|| error.to_string().contains("Connection"),
"unexpected navigation failure: {error:#}"
);
let settled_view = page.handle_for_testing().renderer_page_view_async().await?;
assert_eq!(settled_view.vm_creation_id, initial_view.vm_creation_id);
assert_eq!(
page.evaluate_runtime_expression_async("location.href")
.await?["value"],
serde_json::json!(initial_view.page_state.requested_url.as_str())
);
assert!(
page.serialize_html_async()
.await?
.contains("source-document")
);
page.close_async().await?;
server.abort();
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn standalone_download_response_keeps_current_document() -> Result<()> {
let (base_url, server) = spawn_non_document_navigation_server().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&format!("{base_url}/source"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let initial_view = page.handle_for_testing().renderer_page_view_async().await?;
page.evaluate_runtime_expression_async("location.assign('/download'); 'requested'")
.await?;
let settled_view = page.handle_for_testing().renderer_page_view_async().await?;
assert_eq!(settled_view.vm_creation_id, initial_view.vm_creation_id);
assert_eq!(
page.evaluate_runtime_expression_async("location.href")
.await?["value"],
serde_json::json!(initial_view.page_state.requested_url.as_str())
);
assert!(
page.serialize_html_async()
.await?
.contains("source-document")
);
page.close_async().await?;
server.abort();
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_awaits_promise_result() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.evaluate_runtime_expression_async(
"globalThis.__waitTruthy = new Promise(resolve => setTimeout(() => resolve(true), 50)); 'scheduled';",
)
.await?;
browser
.wait_for_script_truthy(&mut page, "globalThis.__waitTruthy", Duration::from_secs(2))
.await?;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_invokes_function_predicate_each_poll() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.evaluate_runtime_expression_async("globalThis.__waitPredicateCalls = 0")
.await?;
browser
.wait_for_script_truthy(
&mut page,
"globalThis.__waitPredicateCalls += 1, globalThis.__waitPredicateCalls >= 2",
Duration::from_secs(2),
)
.await?;
let expression_calls = page
.evaluate_runtime_expression_async("globalThis.__waitPredicateCalls")
.await?["value"]
.as_f64()
.expect("expression call count should be numeric");
assert!(
expression_calls >= 2.0,
"comma expression changed meaning inside the predicate wrapper: {expression_calls}"
);
page.evaluate_runtime_expression_async("globalThis.__waitPredicateCalls = 0")
.await?;
browser
.wait_for_script_truthy(
&mut page,
"() => ++globalThis.__waitPredicateCalls >= 2",
Duration::from_secs(2),
)
.await?;
let calls = page
.evaluate_runtime_expression_async("globalThis.__waitPredicateCalls")
.await?["value"]
.as_f64()
.expect("predicate call count should be numeric");
assert!(calls >= 2.0, "function predicate was not polled: {calls}");
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_wakes_after_async_wasm_compile_tasks() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
page.evaluate_runtime_expression_async(
r#"
globalThis.__wasmCompileDone = false;
(async () => {
const bytes = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0]);
for (let index = 0; index < 5; index += 1) {
await WebAssembly.compile(bytes);
}
globalThis.__wasmCompileDone = true;
})();
"scheduled";
"#,
)
.await?;
browser
.wait_for_script_truthy(
&mut page,
"globalThis.__wasmCompileDone === true",
Duration::from_millis(300),
)
.await?;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_times_out_for_false_expression_and_function_predicate() -> Result<()>
{
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
for predicate in ["false", "() => false", "async () => false"] {
let error = browser
.wait_for_script_truthy(&mut page, predicate, Duration::from_millis(150))
.await
.unwrap_err();
assert!(
error
.to_string()
.contains("timed out waiting for script to become truthy"),
"unexpected error for `{predicate}`: {error:#}"
);
}
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_cancellation_restores_entry_for_close() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let canceled = tokio::time::timeout(
Duration::from_millis(150),
browser.wait_for_script_truthy(&mut page, "false", Duration::from_secs(5)),
)
.await;
assert!(
canceled.is_err(),
"script truthy wait should be cancelled by the test timeout"
);
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after cancelled script-truthy wait should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_script_truthy_reports_invalid_expression_errors() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let error = browser
.wait_for_script_truthy(&mut page, "(() => {", Duration::from_secs(2))
.await
.unwrap_err();
assert!(
error
.to_string()
.contains("wait_for_script_truthy `(() => {` failed inside renderer")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_script_truthy_wait_allows_unrelated_evaluate_while_pending() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let pending_wait = page.start_page_command(RendererPageCommand::WaitForScriptTruthy {
expression: "false".to_owned(),
timeout_ms: 10_000,
loader: browser.resource_request_client(),
})?;
assert_unrelated_evaluate_runs_while_wait_command_is_pending(
&mut page,
pending_wait,
"scriptTruthyWaitProbe",
)
.await?;
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_network_idle_waits_for_delayed_fetch_completion() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-delayed-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
browser
.wait_for_page_network_idle(&mut page, Duration::from_secs(2))
.await?;
assert!(page.serialize_html_async().await?.contains("id=\"late\""));
assert!(
page.serialize_html_async()
.await?
.contains("data-state=\"settled\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_subresource_response_wait_allows_unrelated_evaluate_while_pending() -> Result<()>
{
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let pending_wait =
page.start_page_command(RendererPageCommand::WaitForSubresourceResponse {
criteria: SubresourceResponseWaitCriteria {
url_contains: Some("/never-matches-this-response".to_owned()),
..SubresourceResponseWaitCriteria::default()
},
timeout_ms: 10_000,
loader: browser.resource_request_client(),
})?;
assert_unrelated_evaluate_runs_while_wait_command_is_pending(
&mut page,
pending_wait,
"subresourceResponseWaitProbe",
)
.await?;
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn window_fetch_returns_before_slow_network_response() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let started = std::time::Instant::now();
let value = page
.evaluate_runtime_expression_async(
"fetch('/wait-until-slow-data').then(r => r.text()).then(text => { document.body.setAttribute('data-fetch-state', text); }); document.body.setAttribute('data-fetch-returned', '1'); 'returned';",
)
.await?;
assert_eq!(value["value"], serde_json::json!("returned"));
assert!(
started.elapsed() < Duration::from_millis(200),
"fetch() should return a promise without waiting for the network response"
);
assert!(
page.serialize_html_async()
.await?
.contains("data-fetch-returned=\"1\"")
);
browser
.wait_for_page_network_idle(&mut page, Duration::from_secs(2))
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-fetch-state=\"settled-slow\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn async_xhr_send_returns_before_slow_network_response() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/static"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let started = std::time::Instant::now();
let value = page
.evaluate_runtime_expression_async(
"const xhr = new XMLHttpRequest(); xhr.open('GET', '/wait-until-slow-data'); xhr.onload = () => { document.body.setAttribute('data-xhr-state', xhr.responseText); }; xhr.send(); document.body.setAttribute('data-xhr-returned', '1'); 'returned';",
)
.await?;
assert_eq!(value["value"], serde_json::json!("returned"));
assert!(
started.elapsed() < Duration::from_millis(200),
"async XMLHttpRequest.send() should not wait for the network response"
);
assert!(
page.serialize_html_async()
.await?
.contains("data-xhr-returned=\"1\"")
);
browser
.wait_for_page_network_idle(&mut page, Duration::from_secs(2))
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-xhr-state=\"settled-slow\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_network_idle_times_out_on_interval_fetch_page() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-interval-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let error = browser
.wait_for_page_network_idle(&mut page, Duration::from_millis(700))
.await
.unwrap_err();
assert!(
error
.to_string()
.contains("timed out waiting for networkidle")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_networkidle_timeout_restores_entry_for_close() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-interval-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let error = browser
.wait_for_page_network_idle(&mut page, Duration::from_millis(700))
.await
.unwrap_err();
assert!(
error
.to_string()
.contains("timed out waiting for networkidle")
);
assert!(
renderer_owner.record(page_id).is_some(),
"networkidle timeout should restore the owner-local page entry"
);
page.close_async().await?;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after networkidle timeout should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_networkidle_cancellation_restores_entry_for_close() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-interval-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let canceled = tokio::time::timeout(
Duration::from_millis(150),
browser.wait_for_page_network_idle(&mut page, Duration::from_secs(5)),
)
.await;
assert!(
canceled.is_err(),
"networkidle wait should be cancelled by the test timeout"
);
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after cancelled networkidle wait should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_networkidle_cancellation_allows_detached_drop_cleanup() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-interval-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let canceled = tokio::time::timeout(
Duration::from_millis(150),
browser.wait_for_page_network_idle(&mut page, Duration::from_secs(5)),
)
.await;
assert!(
canceled.is_err(),
"networkidle wait should be cancelled by the test timeout"
);
drop(page);
wait_for_renderer_owner_page_removed(
&renderer_owner,
page_id,
"dropping page after cancelled networkidle wait should eventually remove the owner entry",
)
.await;
assert!(
renderer_owner.record(page_id).is_none(),
"detached drop cleanup after cancelled networkidle wait should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_domstable_timeout_restores_entry_for_close() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-interval-dom-mutation"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let error = browser
.wait_for_page_dom_stable(&mut page, Duration::from_millis(700))
.await
.unwrap_err();
assert!(
error
.to_string()
.contains("timed out waiting for domstable")
);
assert!(
renderer_owner.record(page_id).is_some(),
"domstable timeout should restore the owner-local page entry"
);
page.close_async().await?;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after domstable timeout should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_domstable_cancellation_restores_entry_for_close() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-interval-dom-mutation"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let canceled = tokio::time::timeout(
Duration::from_millis(150),
browser.wait_for_page_dom_stable(&mut page, Duration::from_secs(5)),
)
.await;
assert!(
canceled.is_err(),
"domstable wait should be cancelled by the test timeout"
);
tokio::time::timeout(Duration::from_secs(3), page.close_async()).await??;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after cancelled domstable wait should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_domstable_wait_parks_entry_while_pending() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-interval-dom-mutation"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
let page_id = page.renderer_page_id();
let mut wait_future =
Box::pin(browser.wait_for_page_dom_stable(&mut page, Duration::from_secs(5)));
tokio::select! {
result = &mut wait_future => panic!("domstable unexpectedly completed before the interval page became stable: {result:?}"),
_ = tokio::time::sleep(Duration::from_millis(150)) => {}
}
wait_for_renderer_owner_state(
&renderer_owner,
|renderer_owner| renderer_owner.record(page_id).is_some(),
"pending domstable wait should park the page entry back in the owner store",
)
.await;
drop(wait_future);
tokio::time::timeout(Duration::from_secs(1), page.close_async()).await??;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after cancelled parked domstable wait should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn wait_for_network_idle_resets_quiet_window_when_new_fetch_starts() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch_with_wait_until(
&server.url("/wait-until-staggered-fetch"),
RenderedDomWaitUntil::Load,
Duration::from_secs(5),
)
.await?;
browser
.wait_for_page_network_idle(&mut page, Duration::from_secs(2))
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-first=\"settled\"")
);
assert!(
page.serialize_html_async()
.await?
.contains("data-second=\"settled-second\"")
);
assert!(
page.serialize_html_async()
.await?
.contains("id=\"late-second\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_registers_page_in_renderer_registry_until_page_is_dropped() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
assert_eq!(renderer_owner.len(), 0);
let page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let record = renderer_owner
.record(page_id)
.expect("page should be registered");
assert_eq!(record.requested_url, server.url("/static").parse()?);
assert_eq!(record.final_url, page.final_url().clone());
assert_eq!(record.status, 200);
assert_eq!(renderer_owner.len(), 1);
drop(page);
wait_for_renderer_owner_page_removed(
&renderer_owner,
page_id,
"dropping page should eventually remove the renderer owner entry",
)
.await;
assert!(renderer_owner.record(page_id).is_none());
assert_eq!(renderer_owner.len(), 0);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_registers_page_in_renderer_registry_until_page_is_closed_async() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
assert_eq!(renderer_owner.len(), 0);
let page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
assert!(
renderer_owner.record(page_id).is_some(),
"page should be registered before explicit close"
);
assert_eq!(renderer_owner.len(), 1);
page.close_async().await?;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit async close should remove the owner entry immediately"
);
assert_eq!(renderer_owner.len(), 0);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn location_navigation_keeps_same_renderer_page_id() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page = browser
.fetch(&server.url("/location-nav/assign-source"))
.await?;
let page_id = page.renderer_page_id();
let record = renderer_owner
.record(page_id)
.expect("page should remain registered");
assert_eq!(page.final_url().path(), "/location-nav/target");
assert_eq!(page.final_url().query(), Some("from=assign"));
assert_eq!(record.final_url, page.final_url().clone());
assert_eq!(record.requested_url, page.requested_url().clone());
drop(page);
wait_for_renderer_owner_page_removed(
&renderer_owner,
page_id,
"dropping navigated page should eventually remove the renderer owner entry",
)
.await;
assert!(renderer_owner.record(page_id).is_none());
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn location_navigation_refreshes_owner_vm_incarnation_for_dispatch() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser
.fetch(&server.url("/location-nav/assign-source"))
.await?;
assert_eq!(page.final_url().path(), "/location-nav/target");
assert_eq!(
page.evaluate_runtime_expression_async("location.pathname")
.await?,
serde_json::json!({"type": "string", "value": "/location-nav/target"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_create_page_command_produces_page() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let request = browser_navigation_request(&server.url("/static"))?;
let requested_url = request.url.clone();
let response = browser.resource_request_client().fetch(request).await?;
let (response_head, response_body) = response.into_text_parts();
let create_page_request = renderer_owner.build_create_html_page_request(
requested_url.clone(),
None,
false,
0,
response_head.status,
response_head.headers,
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
response_head.final_url,
response_body,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
assert_eq!(
renderer_owner.len(),
1,
"owner create-page should register the page before the reply is consumed"
);
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
assert_eq!(page.requested_url(), &requested_url);
assert_eq!(page.status(), 200);
assert_eq!(page.final_url().path(), "/static");
let creation_artifacts = page
.take_page_creation_artifacts()
.expect("directly materialized page should retain creation artifacts");
assert_eq!(
creation_artifacts.active_document.page_id.as_u64(),
page.page_id()
);
assert!(!creation_artifacts.initial_lifecycle_events.is_empty());
assert!(page.take_page_creation_artifacts().is_none());
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_runs_common_page_commands() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let request = browser_navigation_request(&server.url("/static"))?;
let requested_url = request.url.clone();
let response = browser.resource_request_client().fetch(request).await?;
let (response_head, response_body) = response.into_text_parts();
let create_page_request = renderer_owner.build_create_html_page_request(
requested_url,
None,
false,
0,
response_head.status,
response_head.headers,
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
response_head.final_url,
response_body,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
assert_eq!(
page.evaluate_runtime_expression_async("1 + 2").await?,
serde_json::json!({"type": "number", "value": 3, "description": "3"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn page_runtime_evaluation_can_return_json_compatible_objects_by_value() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let by_value = page
.evaluate_runtime_expression_by_value_async("({ title: 'Moli', count: 2 })")
.await?;
assert_eq!(
by_value["value"],
serde_json::json!({ "title": "Moli", "count": 2 })
);
let by_reference = page
.evaluate_runtime_expression_async("({ title: 'Moli' })")
.await?;
assert!(by_reference.get("objectId").is_some());
assert!(by_reference.get("value").is_none());
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn async_page_command_snapshot_follow_can_adopt_pending_location_navigation() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let _ = page
.evaluate_runtime_expression_with_await_async(
"location.assign('/location-nav/target?from=async-eval')",
false,
)
.await?;
assert_eq!(page.final_url().path(), "/location-nav/target");
assert_eq!(page.final_url().query(), Some("from=async-eval"));
assert!(
page.serialize_html_async()
.await?
.contains("location-target=async-eval")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn async_page_command_snapshot_follows_chained_location_navigation() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let _ = page
.evaluate_runtime_expression_with_await_async(
"location.assign('/location-nav/chain-source')",
false,
)
.await?;
assert_eq!(page.final_url().path(), "/location-nav/target");
assert_eq!(page.final_url().query(), Some("from=chain-mid"));
assert!(
page.serialize_html_async()
.await?
.contains("location-target=chain-mid")
);
assert!(!page.serialize_html_async().await?.contains("chain-source"));
assert!(
!page
.serialize_html_async()
.await?
.contains("<main id=\"mid\">chain-mid</main>")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn async_page_command_snapshot_rejects_chained_location_navigation_loop() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let error = match page
.evaluate_runtime_expression_with_await_async(
"location.assign('/location-nav/loop-a')",
false,
)
.await
{
Ok(_) => panic!("location navigation loop should fail"),
Err(error) => error,
};
let error_message = format!("{error:#}");
assert!(
error_message.contains("too many chained location navigations"),
"unexpected error: {error:#}"
);
assert!(
renderer_owner.record(page_id).is_some(),
"failed navigation follow should restore the owner-local page entry"
);
page.close_async().await?;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after failed navigation follow should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_networkidle_rejects_chained_location_navigation_loop_and_restores_entry()
-> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let _ = page
.evaluate_runtime_expression_with_await_async(
"setTimeout(() => location.assign('/location-nav/loop-a'), 0)",
false,
)
.await?;
let error = match browser
.wait_for_page_network_idle(&mut page, Duration::from_secs(5))
.await
{
Ok(_) => panic!("location navigation loop should fail during live networkidle wait"),
Err(error) => error,
};
let error_message = format!("{error:#}");
assert!(
error_message.contains("too many chained location navigations"),
"unexpected error: {error:#}"
);
assert!(
renderer_owner.record(page_id).is_some(),
"failed live networkidle navigation follow should restore the owner-local page entry"
);
page.close_async().await?;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after failed live networkidle follow should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_networkidle_follows_chained_location_navigation() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let _ = page
.evaluate_runtime_expression_with_await_async(
"setTimeout(() => location.assign('/location-nav/chain-source'), 0)",
false,
)
.await?;
browser
.wait_for_page_network_idle(&mut page, Duration::from_secs(5))
.await?;
assert_eq!(page.final_url().path(), "/location-nav/target");
assert_eq!(page.final_url().query(), Some("from=chain-mid"));
assert!(
page.serialize_html_async()
.await?
.contains("location-target=chain-mid")
);
assert!(!page.serialize_html_async().await?.contains("chain-source"));
assert!(
!page
.serialize_html_async()
.await?
.contains("<main id=\"mid\">chain-mid</main>")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_domstable_rejects_chained_location_navigation_loop_and_restores_entry()
-> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let _ = page
.evaluate_runtime_expression_with_await_async(
"setTimeout(() => location.assign('/location-nav/loop-a'), 0)",
false,
)
.await?;
let error = match browser
.wait_for_page_dom_stable(&mut page, Duration::from_secs(5))
.await
{
Ok(_) => panic!("location navigation loop should fail during live domstable wait"),
Err(error) => error,
};
let error_message = format!("{error:#}");
assert!(
error_message.contains("too many chained location navigations"),
"unexpected error: {error:#}"
);
assert!(
renderer_owner.record(page_id).is_some(),
"failed live domstable navigation follow should restore the owner-local page entry"
);
page.close_async().await?;
assert!(
renderer_owner.record(page_id).is_none(),
"explicit close after failed live domstable follow should remove the page entry"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn live_page_domstable_follows_chained_location_navigation() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let _ = page
.evaluate_runtime_expression_with_await_async(
"setTimeout(() => location.assign('/location-nav/chain-source'), 0)",
false,
)
.await?;
browser
.wait_for_page_dom_stable(&mut page, Duration::from_secs(5))
.await?;
assert_eq!(page.final_url().path(), "/location-nav/target");
assert_eq!(page.final_url().query(), Some("from=chain-mid"));
assert!(
page.serialize_html_async()
.await?
.contains("location-target=chain-mid")
);
assert!(!page.serialize_html_async().await?.contains("chain-source"));
assert!(
!page
.serialize_html_async()
.await?
.contains("<main id=\"mid\">chain-mid</main>")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_tracks_page_command_epoch_progress() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
assert_eq!(
renderer_owner.command_epoch(page_id),
Some(0),
"freshly adopted pages should start with command epoch 0"
);
let _ = page.evaluate_runtime_expression_async("1 + 2").await?;
assert_eq!(
renderer_owner.command_epoch(page_id),
Some(1),
"first page command should advance owner-side command epoch"
);
let _ = page.runtime_enable_events_async().await?;
assert_eq!(
renderer_owner.command_epoch(page_id),
Some(2),
"subsequent page commands should keep advancing owner-side command epoch"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn page_html_serializes_on_demand_from_renderer_owner() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let initial_html = page.serialize_html_async().await?;
assert!(initial_html.contains("<html"));
let _ = page
.evaluate_runtime_expression_async(
"document.body.innerHTML = '<main id=\"owner-slot-state\">updated</main>'; true",
)
.await?;
let updated_html = page.serialize_html_async().await?;
assert!(updated_html.contains("owner-slot-state"));
assert!(updated_html.contains("updated"));
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_reuses_shared_local_host_for_pages_on_same_owner() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let page_a = browser.fetch(&server.url("/static")).await?;
let page_b = browser
.fetch(&server.url("/location-nav/assign-source"))
.await?;
let handle_a = page_a.handle_for_testing();
let handle_b = page_b.handle_for_testing();
assert!(
handle_a.shares_local_host(&handle_b),
"pages created by the same renderer owner on the same thread should share one local host"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_does_not_share_local_host_across_owners() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser_a = Browser::new(AppConfig::default())?;
let browser_b = Browser::new(AppConfig::default())?;
let page_a = browser_a.fetch(&server.url("/static")).await?;
let page_b = browser_b
.fetch(&server.url("/location-nav/assign-source"))
.await?;
let handle_a = page_a.handle_for_testing();
let handle_b = page_b.handle_for_testing();
assert!(
!handle_a.shares_local_host(&handle_b),
"pages created by different renderer owners should not share one local host"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_can_create_isolated_world_on_older_page_after_second_page_exists()
-> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page_a = browser.fetch(&server.url("/static")).await?;
let _page_b = browser
.fetch(&server.url("/location-nav/assign-source"))
.await?;
let world_id = page_a
.create_isolated_world_async("reactivated-world", false)
.await?;
assert!(
page_a
.has_isolated_execution_context_id_async(world_id)
.await?
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_can_evaluate_on_older_page_after_second_page_exists() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page_a = browser.fetch(&server.url("/static")).await?;
let _page_b = browser
.fetch(&server.url("/location-nav/assign-source"))
.await?;
assert_eq!(
page_a.evaluate_runtime_expression_async("1 + 1").await?,
serde_json::json!({"type": "number", "value": 2, "description": "2"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn dropping_page_only_removes_its_entry_from_shared_local_host() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_a = browser.fetch(&server.url("/static")).await?;
let page_b = browser
.fetch(&server.url("/location-nav/assign-source"))
.await?;
let page_a_id = page_a.renderer_page_id();
let page_b_id = page_b.renderer_page_id();
assert_eq!(renderer_owner.len(), 2);
drop(page_a);
wait_for_renderer_owner_state(
&renderer_owner,
|renderer_owner| {
renderer_owner.record(page_a_id).is_none()
&& renderer_owner.record(page_b_id).is_some()
&& renderer_owner.len() == 1
},
"dropping one shared-host page should eventually remove only that page entry",
)
.await;
assert!(
renderer_owner.record(page_a_id).is_none(),
"dropping one page should remove its owner entry"
);
assert!(
renderer_owner.record(page_b_id).is_some(),
"dropping one shared-host page should keep the other page registered"
);
assert_eq!(renderer_owner.len(), 1);
drop(page_b);
wait_for_renderer_owner_state(
&renderer_owner,
|renderer_owner| renderer_owner.is_empty(),
"dropping the last shared-host page should eventually empty the renderer owner table",
)
.await;
assert_eq!(renderer_owner.len(), 0);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_recreates_local_host_after_last_page_drops() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let page_a = browser.fetch(&server.url("/static")).await?;
let host_instance_a = page_a
.handle_for_testing()
.host_instance_key_async()
.await?;
drop(page_a);
wait_for_renderer_owner_state(
&browser.js_runtime.renderer_owner_handle(),
|renderer_owner| renderer_owner.is_empty(),
"dropping the last page should eventually release the current renderer owner host",
)
.await;
let page_b = browser
.fetch(&server.url("/location-nav/assign-source"))
.await?;
let host_instance_b = page_b
.handle_for_testing()
.host_instance_key_async()
.await?;
assert_ne!(
host_instance_a, host_instance_b,
"dropping the last page should let the local runtime recreate a fresh host instance"
);
drop(page_b);
server.shutdown().await;
Ok(())
}
#[tokio::test]
async fn aborting_async_page_command_restores_local_host_entry() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let loader = browser.resource_request_client();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let renderer_owner = browser.js_runtime.renderer_owner_handle();
{
let future = page.wait_for_script_truthy(&loader, "false", Duration::from_millis(100));
tokio::pin!(future);
tokio::select! {
result = &mut future => panic!("wait_for_script_truthy unexpectedly completed early: {result:?}"),
_ = tokio::time::sleep(std::time::Duration::from_millis(5)) => {}
}
}
assert!(
renderer_owner.record(page_id).is_some(),
"dropping an in-flight async page command should restore the page entry into the shared local host"
);
let value = page.evaluate_runtime_expression_async("1 + 1").await?;
assert_eq!(value["value"], 2);
drop(page);
server.shutdown().await;
Ok(())
}
#[cfg(debug_assertions)]
#[tokio::test]
async fn panicking_async_page_command_restores_local_host_entry() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let error = page
.panic_renderer_command_for_testing()
.await
.expect_err("test panic command should surface as a page command error");
assert!(
error
.to_string()
.contains("panicked before restoring its page entry"),
"unexpected panic command error: {error:#}"
);
assert!(
renderer_owner.record(page_id).is_some(),
"a panicking spawned local task should restore the page entry into the shared local host"
);
let value = page.evaluate_runtime_expression_async("1 + 1").await?;
assert_eq!(value["value"], 2);
drop(page);
server.shutdown().await;
Ok(())
}
#[cfg(debug_assertions)]
#[tokio::test]
async fn panicking_wait_for_selector_restores_local_host_entry() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let loader = browser.resource_request_client();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let error = page
.panic_wait_for_selector_for_testing(&loader)
.await
.expect_err("test selector wait panic should surface as a page command error");
assert!(
error
.to_string()
.contains("panicked before restoring its page entry"),
"unexpected selector wait panic error: {error:#}"
);
assert!(
renderer_owner.record(page_id).is_some(),
"a panicking wait-for-selector local task should restore the page entry into the shared local host"
);
let value = page.evaluate_runtime_expression_async("1 + 1").await?;
assert_eq!(value["value"], 2);
drop(page);
server.shutdown().await;
Ok(())
}
#[cfg(debug_assertions)]
#[tokio::test]
async fn panicking_wait_for_script_truthy_restores_local_host_entry() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let loader = browser.resource_request_client();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let error = page
.panic_wait_for_script_truthy_for_testing(&loader)
.await
.expect_err("test script wait panic should surface as a page command error");
assert!(
error
.to_string()
.contains("panicked before restoring its page entry"),
"unexpected script wait panic error: {error:#}"
);
assert!(
renderer_owner.record(page_id).is_some(),
"a panicking wait-for-script-truthy local task should restore the page entry into the shared local host"
);
let value = page.evaluate_runtime_expression_async("1 + 1").await?;
assert_eq!(value["value"], 2);
drop(page);
server.shutdown().await;
Ok(())
}
#[tokio::test]
async fn renderer_page_testing_handle_page_state_refresh_works_on_current_thread_runtime()
-> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let page = browser.fetch(&server.url("/static")).await?;
let handle = page.handle_for_testing();
let page_state = handle.current_page_state_async().await?;
let view = handle.renderer_page_view_async().await?;
let _owner_slot = handle.owner_slot_async().await?;
let _host_instance_key = handle.host_instance_key_async().await?;
assert_eq!(page_state.requested_url, page.requested_url().clone());
assert_eq!(page_state.status, page.status());
assert_eq!(view.page_id.as_u64(), page.page_id());
assert_eq!(view.page_state.requested_url, page.requested_url().clone());
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_removed_page_releases_last_page_state() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
let _ = page
.evaluate_runtime_expression_async(
"document.body.innerHTML = '<main id=\"removed-owner-slot-state\">removed</main>'; true",
)
.await?;
let page_state = page.handle_for_testing().current_page_state_async().await?;
let page_state_weak = Arc::downgrade(&page_state);
drop(page_state);
page.close_async().await?;
assert!(renderer_owner.record(page_id).is_none());
assert!(
page_state_weak.upgrade().is_none(),
"removed-page tombstones must not retain the full page state"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_clears_in_flight_command_after_successful_dispatch() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
assert_eq!(renderer_owner.in_flight_command_epoch(page_id), None);
let _ = page.evaluate_runtime_expression_async("1 + 2").await?;
assert_eq!(
renderer_owner.in_flight_command_epoch(page_id),
None,
"successful page commands should still clear owner-side in-flight bookkeeping"
);
assert_eq!(
renderer_owner.command_epoch(page_id),
Some(1),
"successful page commands should advance owner-side command epoch"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_rejects_commands_for_removed_page() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
renderer_owner.remove_page_for_testing(page_id);
let error = page
.evaluate_runtime_expression_async("1 + 2")
.await
.expect_err("removed pages should not keep dispatching through the owner surface");
assert!(
error
.to_string()
.contains("renderer owner no longer tracks active page"),
"unexpected error: {error:#}"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn page_renderer_page_record_returns_error_for_removed_owner_entry() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page = browser.fetch(&server.url("/static")).await?;
let handle = page.handle_for_testing();
let page_id = page.renderer_page_id();
renderer_owner.remove_page_for_testing(page_id);
let error = handle
.current_page_state_async()
.await
.expect_err("removed owner entry should fail page-view refresh");
assert!(
error
.to_string()
.contains("failed to refresh renderer owner page view"),
"unexpected error: {error:#}"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_does_not_revive_removed_page_from_plain_view_refresh() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page = browser.fetch(&server.url("/static")).await?;
let handle = page.handle_for_testing();
let page_id = page.renderer_page_id();
let page_view = handle
.renderer_page_view_async()
.await
.expect("renderer owner should provide current page view for testing");
renderer_owner.remove_page_for_testing(page_id);
let error = renderer_owner
.refresh_page_view_for_testing(page_view)
.expect_err("removed pages should not be reactivated by plain view refresh");
assert!(
error
.to_string()
.contains("renderer owner no longer tracks active page"),
"unexpected error: {error:#}"
);
assert!(
renderer_owner.record(page_id).is_none(),
"removed page metadata should remain inactive after failed refresh"
);
assert_eq!(renderer_owner.len(), 0);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_rejects_stale_page_view_refresh_generation() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let mut page = browser.fetch(&server.url("/static")).await?;
let handle = page.handle_for_testing();
let stale_view = handle
.renderer_page_view_async()
.await
.expect("renderer owner should provide current page view for testing");
let _ = page.evaluate_runtime_expression_async("1 + 2").await?;
let error = renderer_owner
.refresh_page_view_for_testing(stale_view)
.expect_err("owner should reject stale page-view refresh generations");
assert!(
error
.to_string()
.contains("renderer owner received stale page view refresh"),
"unexpected error: {error:#}"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_remove_unknown_page_keeps_never_tracked_state() -> Result<()> {
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let unknown_page_id = crate::renderer::PageId::new_for_testing(999_999);
renderer_owner.remove_page_for_testing(unknown_page_id);
let error = renderer_owner
.refresh_page_view_for_testing(crate::renderer::RendererPageView {
page_id: unknown_page_id,
vm_creation_id: 0,
view_generation: 0,
page_state: std::sync::Arc::new(crate::renderer::RendererPageState {
snapshot_revision: Default::default(),
requested_url: Url::parse("https://example.com/requested")?,
navigation_initiator_url: None,
navigation_redirected: false,
navigation_redirect_count: 0,
navigation_redirect_chain: Vec::new(),
final_url: Url::parse("https://example.com/final")?,
document_title: String::new(),
document_activity: Default::default(),
status: 200,
headers: Vec::new(),
idle_override: None,
service_worker_client_id: 0,
document_isolate_identity: 0,
dedicated_worker_running_worker_isolate_count: 0,
performance_metric_snapshot: Default::default(),
script_execution: Arc::new(crate::page::ScriptExecutionReport::default()),
}),
})
.expect_err("removing an unknown page should not create a removed tombstone");
assert!(
error
.to_string()
.contains("renderer owner has never tracked page"),
"unexpected error: {error:#}"
);
assert!(renderer_owner.record(unknown_page_id).is_none());
assert_eq!(renderer_owner.len(), 0);
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn page_drop_removes_owner_entry_via_bound_slot() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page = browser.fetch(&server.url("/static")).await?;
let page_id = page.renderer_page_id();
assert_eq!(renderer_owner.len(), 1);
assert!(
renderer_owner.record(page_id).is_some(),
"fetched page should register an active owner entry before drop"
);
drop(page);
wait_for_renderer_owner_state(
&renderer_owner,
|renderer_owner| renderer_owner.is_empty() && renderer_owner.record(page_id).is_none(),
"dropping page should eventually remove its bound-slot owner entry",
)
.await;
assert_eq!(
renderer_owner.len(),
0,
"dropping page should remove its owner entry through the bound slot"
);
assert!(
renderer_owner.record(page_id).is_none(),
"dropped page should no longer expose an active owner record"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_rejects_slot_owned_by_another_renderer() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser_a = Browser::new(AppConfig::default())?;
let browser_b = Browser::new(AppConfig::default())?;
let renderer_owner_b = browser_b.js_runtime.renderer_owner_handle();
let page = browser_a.fetch(&server.url("/static")).await?;
let handle = page.handle_for_testing();
let foreign_slot = handle.owner_slot_async().await?;
let error = renderer_owner_b
.refresh_page_view_on_slot_for_testing(
&foreign_slot,
handle
.renderer_page_view_async()
.await
.expect("renderer owner should provide current page view for testing"),
)
.expect_err("owner should reject slot belonging to another renderer");
assert!(
error
.to_string()
.contains("renderer owner does not own slot"),
"unexpected error: {error:#}"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_runs_runtime_protocol_commands() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let request = browser_navigation_request(&server.url("/static"))?;
let response = browser.resource_request_client().fetch(request).await?;
let (response_head, response_body) = response.into_text_parts();
let create_page_request = renderer_owner.build_create_html_page_request(
server.url("/static").parse()?,
None,
false,
0,
response_head.status,
response_head.headers,
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
response_head.final_url,
response_body,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
let runtime_messages = page.runtime_enable_events_async().await?;
assert!(
!runtime_messages.is_empty(),
"runtime enable should emit at least one event-like message"
);
let world_id = page
.create_isolated_world_async("test-world", false)
.await?;
assert!(
page.has_isolated_execution_context_id_async(world_id)
.await?
);
page.add_runtime_binding_async("testBinding", None, None)
.await?;
let binding_type = page
.evaluate_runtime_expression_async("typeof globalThis.testBinding")
.await?;
assert_eq!(binding_type["value"], serde_json::json!("function"));
page.remove_runtime_binding_async("testBinding").await?;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_runs_document_start_commands() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let request = browser_navigation_request(&server.url("/static"))?;
let response = browser.resource_request_client().fetch(request).await?;
let (response_head, response_body) = response.into_text_parts();
let create_page_request = renderer_owner.build_create_html_page_request(
server.url("/static").parse()?,
None,
false,
0,
response_head.status,
response_head.headers,
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
response_head.final_url,
response_body,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
page.run_page_surface_override_script_async(
"document.body.setAttribute('data-doc-start', 'ran');",
)
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-doc-start=\"ran\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_with_document_start_script_keeps_bootstrap_bridge_safe_for_core_window_reads()
-> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(
AppConfig::default().with_document_start_script("window.__docStartBridgeOk = 'ok';"),
)?;
let mut page = browser.fetch(&server.url("/static")).await?;
assert_eq!(
page.evaluate_runtime_expression_async("window.__docStartBridgeOk")
.await?,
serde_json::json!({"type": "string", "value": "ok"})
);
assert_eq!(
page.evaluate_runtime_expression_async("location.href")
.await?,
serde_json::json!({"type": "string", "value": server.url("/static")})
);
assert_eq!(
page.evaluate_runtime_expression_async("typeof navigator.userAgent")
.await?,
serde_json::json!({"type": "string", "value": "string"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_document_start_keeps_live_document_html_surface_stable() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default().with_document_start_script(
r#"
const snap = () => JSON.stringify({
ctor: document.constructor && document.constructor.name,
tag: Object.prototype.toString.call(document),
contentType: document.contentType
});
window.__docStartShape = snap();
document.addEventListener("DOMContentLoaded", () => {
window.__docDomContentLoadedShape = snap();
});
window.addEventListener("load", () => {
window.__docLoadShape = snap();
});
"#,
))?;
let mut page = browser.fetch(&server.url("/static")).await?;
let expected = serde_json::json!({
"type": "string",
"value": r#"{"ctor":"HTMLDocument","tag":"[object HTMLDocument]","contentType":"text/html"}"#
});
assert_eq!(
page.evaluate_runtime_expression_async("window.__docStartShape")
.await?,
expected
);
assert_eq!(
page.evaluate_runtime_expression_async("window.__docDomContentLoadedShape")
.await?,
expected
);
assert_eq!(
page.evaluate_runtime_expression_async("window.__docLoadShape")
.await?,
expected
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_streaming_chunked_html_parses_incrementally_across_utf8_boundaries() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let page = browser
.fetch(&server.url("/streaming/chunked-html"))
.await?;
assert!(page.serialize_html_async().await?.contains("naive-你好"));
assert!(
page.serialize_html_async()
.await?
.contains("data-stream-script=\"seen\"")
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn canvas_get_context_reuses_same_context_object_and_state() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let mut page = browser.fetch(&server.url("/static")).await?;
let value = page
.evaluate_runtime_expression_async(
"(() => { const canvas = document.createElement('canvas'); const first = canvas.getContext('2d'); first.fillStyle = 'red'; const second = canvas.getContext('2d'); return JSON.stringify([first === second, second.fillStyle, canvas.getContext('webgl') === null]); })()",
)
.await?;
assert_eq!(
value,
serde_json::json!({"type": "string", "value": "[true,\"#ff0000\",true]"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_runs_input_commands() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: url::Url = server.url("/input-commands").parse()?;
let html = r#"
<!doctype html>
<html>
<body style="margin:0">
<button id="mouse" style="position:absolute;left:0;top:0;width:80px;height:40px"
onclick="document.body.dataset.clicked='yes'">mouse</button>
<div id="touch" style="position:absolute;left:0;top:50px;width:80px;height:40px"
ontouchstart="document.body.dataset.touched='yes'">touch</div>
<input id="field" style="position:absolute;left:0;top:100px;width:120px;height:24px"
onkeydown="document.body.dataset.key=event.key">
</body>
</html>
"#
.to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url,
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
let _ = page
.dispatch_mouse_event_at_point_async(10.0, 10.0, "mousedown", 0, None, 0.0, 0.0)
.await?;
let _ = page
.dispatch_touch_event_at_point_async(10.0, 60.0, "touchstart", false)
.await?;
page.evaluate_runtime_expression_async("document.getElementById('field').focus(); 'focused';")
.await?;
assert!(page.insert_text_into_active_control_async("abc").await?);
assert_eq!(
page.evaluate_runtime_expression_async("document.getElementById('field').value")
.await?,
serde_json::json!({"type": "string", "value": "abc"})
);
assert!(
page.dispatch_key_event_async("keydown", "Enter", "Enter", "", 0, false, false)
.await?
);
assert_eq!(
page.evaluate_runtime_expression_async("document.body.dataset.key || ''")
.await?,
serde_json::json!({"type": "string", "value": "Enter"})
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_runs_input_query_commands() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default().with_layout_policy(LayoutPolicy::OnDemand))?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: url::Url = server.url("/input-query-commands").parse()?;
let html = r#"
<!doctype html>
<html>
<body style="margin:0">
<input id="field" style="position:absolute;left:12px;top:8px;width:120px;height:24px" value="seed">
</body>
</html>
"#
.to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url,
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
let capture = page.start_capture_screenshot()?;
let captured = capture.wait().await?;
page.finish_capture_screenshot(captured)?;
let input_backend_node_id = query_selector_node_from_live_document(&mut page, "#field")
.await?
.expect("input node should exist")
.backend_node_id;
let rect_pending = page.start_client_rect_for_backend_node_id(input_backend_node_id)?;
let rect_completion = rect_pending.wait().await?;
let rect = match page
.finish_client_rect_for_backend_node_id(rect_completion)?
.expect("input rect should be available")
{
DocumentNodeClientRectResolution::Found(rect) => rect,
DocumentNodeClientRectResolution::FoundNonElement(_) => {
panic!("input node should be an element")
}
DocumentNodeClientRectResolution::NotElement => {
panic!("input node should be an element")
}
};
assert_eq!(rect.left, 12.0);
assert_eq!(rect.top, 8.0);
assert_eq!(rect.width, 120.0);
assert_eq!(rect.height, 24.0);
let _ = page.runtime_enable_events_async().await?;
let default_context_id = page
.default_execution_context_id_async()
.await?
.expect("default execution context should exist");
assert_eq!(
page.evaluate_runtime_expression_in_execution_context_with_await_async(
default_context_id,
"1 + 4",
false,
)
.await?,
serde_json::json!({"type": "number", "value": 5, "description": "5"})
);
let isolated_world_id = page
.create_isolated_world_async("query-world", false)
.await?;
assert!(
page.has_isolated_execution_context_id_async(isolated_world_id)
.await?
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_reports_real_client_rect_for_positioned_node() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default().with_layout_policy(LayoutPolicy::OnDemand))?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: url::Url = server.url("/input-query-geometry").parse()?;
let html = r#"
<!doctype html>
<html>
<body style="margin:0">
<div id="target"
style="position:absolute;left:12px;top:8px;width:120px;height:24px;margin:0;padding:0;border:none;background:#c00"></div>
</body>
</html>
"#
.to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url,
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
let capture = page.start_capture_screenshot()?;
let captured = capture.wait().await?;
page.finish_capture_screenshot(captured)?;
let target_backend_node_id = query_selector_node_from_live_document(&mut page, "#target")
.await?
.expect("target div should exist")
.backend_node_id;
let rect_pending = page.start_client_rect_for_backend_node_id(target_backend_node_id)?;
let rect_completion = rect_pending.wait().await?;
let rect = match page
.finish_client_rect_for_backend_node_id(rect_completion)?
.expect("target rect should be available")
{
DocumentNodeClientRectResolution::Found(rect) => rect,
DocumentNodeClientRectResolution::FoundNonElement(_) => {
panic!("target node should be an element")
}
DocumentNodeClientRectResolution::NotElement => {
panic!("target node should be an element")
}
};
let assert_close = |actual: f64, expected: f64, label: &str| {
let delta = (actual - expected).abs();
assert!(
delta <= 0.01,
"{label} expected {expected}, got {actual} (delta {delta})"
);
};
assert_close(rect.left, 12.0, "left");
assert_close(rect.top, 8.0, "top");
assert_close(rect.right, 132.0, "right");
assert_close(rect.bottom, 32.0, "bottom");
assert_close(rect.width, 120.0, "width");
assert_close(rect.height, 24.0, "height");
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_resolves_backend_node_runtime_object() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: url::Url = server.url("/object-resolution-commands").parse()?;
let html = r#"
<!doctype html>
<html>
<body>
<div id="target">ok</div>
</body>
</html>
"#
.to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url,
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
let backend_node_id = query_selector_node_from_live_document(&mut page, "#target")
.await?
.context("target div should exist")?
.backend_node_id;
let _ = page.runtime_enable_events_async().await?;
let execution_context_id = page
.default_execution_context_id_async()
.await?
.context("default execution context should exist")?;
let resolved_object = resolve_runtime_object_for_backend_node_id(
&mut page,
backend_node_id,
Some(execution_context_id),
Some("roundtrip"),
)
.await?;
let resolved_object = match resolved_object {
crate::page::DocumentNodeRuntimeObjectResolution::Found(value) => {
value.into_protocol_value()
}
crate::page::DocumentNodeRuntimeObjectResolution::MissingContext => {
return Err(anyhow!(
"document node resolution unexpectedly lost its context"
));
}
crate::page::DocumentNodeRuntimeObjectResolution::MissingNode => {
return Err(anyhow!(
"document node should resolve back to a runtime object"
));
}
};
assert_eq!(resolved_object["type"], serde_json::json!("object"));
resolved_object["objectId"]
.as_str()
.context("resolved runtime object should carry an objectId")?;
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn runtime_object_resolve_uses_live_backend_node_for_stale_snapshot_path() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: url::Url = server.url("/object-resolution-live-node-id").parse()?;
let html = r#"
<!doctype html>
<html>
<body>
<div id="target">target</div>
</body>
</html>
"#
.to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url,
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
let backend_node_id = query_selector_node_from_live_document(&mut page, "#target")
.await?
.context("target div should exist")?
.backend_node_id;
let _ = page.runtime_enable_events_async().await?;
let execution_context_id = page
.default_execution_context_id_async()
.await?
.context("default execution context should exist")?;
let mutation = serde_json::json!({
"id": 91,
"method": "Runtime.evaluate",
"params": {
"expression": "const target = document.getElementById('target'); const inserted = document.createElement('div'); inserted.id = 'inserted'; target.before(inserted); 'mutated';",
"returnByValue": true
}
});
let mutation_pending =
page.start_runtime_protocol_message(serde_json::to_string(&mutation)?)?;
let mutation_completion = mutation_pending.wait().await?;
let resolved_object = resolve_runtime_object_for_backend_node_id(
&mut page,
backend_node_id,
Some(execution_context_id),
Some("stale-path-probe"),
)
.await?;
let resolved_object = match resolved_object {
crate::page::DocumentNodeRuntimeObjectResolution::Found(value) => {
value.into_protocol_value()
}
crate::page::DocumentNodeRuntimeObjectResolution::MissingContext => {
return Err(anyhow!(
"document node resolution unexpectedly lost its context"
));
}
crate::page::DocumentNodeRuntimeObjectResolution::MissingNode => {
return Err(anyhow!(
"document node should resolve back to a runtime object"
));
}
};
let object_id = resolved_object["objectId"]
.as_str()
.context("resolved runtime object should carry an objectId")?;
let _mutation_messages = page.finish_runtime_protocol_message(mutation_completion)?;
let call = serde_json::json!({
"id": 92,
"method": "Runtime.callFunctionOn",
"params": {
"objectId": object_id,
"functionDeclaration": "function () { return this.id; }",
"returnByValue": true
}
});
let messages = page
.dispatch_runtime_protocol_message_async(&serde_json::to_string(&call)?)
.await?;
let response =
runtime_protocol_response_by_id(&messages, 92).context("callFunctionOn should respond")?;
assert_eq!(
response["result"]["result"]["value"],
serde_json::json!("target"),
"backend-node runtime object resolution must follow the live node, not the stale document path"
);
server.shutdown().await;
Ok(())
}
fn runtime_protocol_response_by_id(
messages: &[RendererRuntimeInspectorMessage],
response_id: i64,
) -> Option<&serde_json::Value> {
messages.iter().find_map(|message| match message {
RendererRuntimeInspectorMessage::Protocol(value)
if value.get("id").and_then(serde_json::Value::as_i64) == Some(response_id) =>
{
Some(value.value())
}
_ => None,
})
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_runs_inline_stylesheet_commands() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let page_url: url::Url = server.url("/stylesheet-commands").parse()?;
let html = r#"
<!doctype html>
<html>
<head>
<style id="sheet">#target { display: block; }</style>
</head>
<body>
<div id="target" style="width:120px;height:24px">styled text</div>
</body>
</html>
"#
.to_owned();
let create_page_request = renderer_owner.build_create_html_page_request(
page_url.clone(),
None,
false,
0,
200,
vec![],
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
page_url,
html,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
let style_sheet_inventory_pending = page.start_style_sheet_inventory_for_document()?;
let style_sheet_inventory_completion = style_sheet_inventory_pending.wait().await?;
let style_sheet_id = page
.finish_style_sheet_inventory_for_document(style_sheet_inventory_completion)?
.added
.into_iter()
.find(|header| header.is_inline)
.map(|header| header.style_sheet_id)
.context("inline stylesheet header should be available")?;
let target_backend_node_id = query_selector_node_from_live_document(&mut page, "#target")
.await?
.expect("target div should exist")
.backend_node_id;
let computed_before_pending =
page.start_computed_style_properties_for_backend_node_id(target_backend_node_id)?;
let computed_before_completion = computed_before_pending.wait().await?;
let computed_before = page
.finish_computed_style_properties(computed_before_completion)?
.unwrap_or_default();
let display_before = computed_before
.iter()
.find(|(name, _)| name == "display")
.map(|(_, value)| value.clone())
.expect("computed display should exist before stylesheet edit");
let width_before = computed_before
.iter()
.find(|(name, _)| name == "width")
.map(|(_, value)| value.clone())
.expect("computed width should exist before stylesheet edit");
let height_before = computed_before
.iter()
.find(|(name, _)| name == "height")
.map(|(_, value)| value.clone())
.expect("computed height should exist before stylesheet edit");
assert_eq!(display_before, "block");
assert_eq!(width_before, "120px");
assert_eq!(height_before, "24px");
let payload_before_pending =
page.start_style_sheet_payload_for_style_sheet_id(&style_sheet_id)?;
let payload_before_completion = payload_before_pending.wait().await?;
assert_eq!(
page.finish_style_sheet_payload(payload_before_completion)?
.expect("inline stylesheet payload should be available")
.text,
"#target { display: block; }"
);
let edit_pending = page.start_set_inline_style_sheet_text_for_style_sheet_id(
&style_sheet_id,
"#target { display: none; }",
)?;
let edit_completion = edit_pending.wait().await?;
assert!(page.finish_set_inline_style_sheet_text(edit_completion)?);
let payload_after_pending =
page.start_style_sheet_payload_for_style_sheet_id(&style_sheet_id)?;
let payload_after_completion = payload_after_pending.wait().await?;
assert_eq!(
page.finish_style_sheet_payload(payload_after_completion)?
.expect("inline stylesheet payload should still be available")
.text,
"#target { display: none; }"
);
server.shutdown().await;
Ok(())
}
#[tokio::test(flavor = "multi_thread")]
async fn renderer_owner_created_page_runs_subresource_interception_commands() -> Result<()> {
let server = FixtureServer::spawn().await?;
let browser = Browser::new(AppConfig::default())?;
let (output_tx, mut output_rx) = crate::renderer_output_transport_channel();
browser
.js_runtime
.set_renderer_output_transport_sender(output_tx);
let renderer_owner = browser.js_runtime.renderer_owner_handle();
let request = browser_navigation_request(&server.url("/static"))?;
let requested_url = request.url.clone();
let response = browser.resource_request_client().fetch(request).await?;
let (response_head, response_body) = response.into_text_parts();
let create_page_request = renderer_owner.build_create_html_page_request(
requested_url,
None,
false,
0,
response_head.status,
response_head.headers,
&browser.resource_request_client(),
moli_renderer_v8::RendererWebStorageHandles::new(
browser.partition.web_storage_store(),
browser.partition.session_storage_store(),
),
response_head.final_url,
response_body,
vec![],
vec![],
vec![],
Default::default(),
false,
Vec::new(),
false,
None,
super::PageVmInitStage::Load,
);
let reply = renderer_owner
.dispatch_command(RendererOwnerCommand::CreateHtmlPage(create_page_request))
.await?;
let mut page = materialize_page_created_reply(&renderer_owner, reply)?;
page.set_fetch_subresource_interception_async(true, Some(SubresourceResourceType::Fetch))
.await?;
page.evaluate_runtime_expression_async(
"fetch('/wait-until-data').then(r => r.text()).then(text => { document.body.setAttribute('data-state', text); }); 'scheduled';",
)
.await?;
let pending = recv_subresource_fetch_pause_for_page(&mut output_rx, &page).await?;
let outcome = page
.continue_pending_subresource_fetch_async(
pending.internal_id,
None,
None,
None,
None,
false,
false,
)
.await?;
assert!(matches!(
outcome,
PendingSubresourceContinueOutcome::Started
));
page.wait_for_network_idle(&browser.resource_request_client(), Duration::from_secs(2))
.await?;
assert!(
page.serialize_html_async()
.await?
.contains("data-state=\"settled\"")
);
server.shutdown().await;
Ok(())
}
async fn spawn_main_resource_service_worker_server()
-> Result<(String, Arc<Mutex<Vec<String>>>, JoinHandle<()>)> {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.context("bind main-resource service worker test server")?;
let addr = listener
.local_addr()
.context("main-resource service worker test server addr")?;
let requests = Arc::new(Mutex::new(Vec::new()));
let requests_for_server = requests.clone();
let server = tokio::spawn(async move {
loop {
let (mut stream, _) = match listener.accept().await {
Ok(connection) => connection,
Err(_) => break,
};
let requests = requests_for_server.clone();
tokio::spawn(async move {
let request = match read_http_request_head(&mut stream).await {
Ok(request) => request,
Err(_) => return,
};
let path = request_path(&request).unwrap_or_else(|| "/".to_owned());
let preload_header_value = request
.lines()
.find_map(|line| {
line.split_once(':').and_then(|(name, value)| {
name.eq_ignore_ascii_case("Service-Worker-Navigation-Preload")
.then(|| value.trim().to_owned())
})
})
.unwrap_or_else(|| "missing".to_owned());
requests.lock().await.push(request.clone());
if path == "/app/preload-cancel.html" && preload_header_value != "missing" {
let mut buf = [0_u8; 1024];
while matches!(stream.read(&mut buf).await, Ok(n) if n != 0) {}
return;
}
if path == "/app/preload-headers.html" && preload_header_value != "missing" {
let mut headers: std::collections::BTreeMap<String, Vec<String>> =
std::collections::BTreeMap::new();
for line in request.lines().skip(1) {
let Some((name, value)) = line.split_once(':') else {
continue;
};
headers
.entry(name.trim().to_ascii_uppercase())
.or_default()
.push(value.trim().to_owned());
}
let body = serde_json::to_string(&headers)
.expect("preload request headers should serialize");
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
let _ = stream.write_all(response.as_bytes()).await;
return;
}
if path == "/app/preload-gzip.html" && preload_header_value != "missing" {
let body = [
31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 243, 72, 205, 201, 201, 87, 8, 207, 47,
202, 73, 1, 0, 86, 177, 23, 74, 11, 0, 0, 0,
];
let response_head = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=UTF-8\r\nContent-Encoding: gzip\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
let _ = stream.write_all(response_head.as_bytes()).await;
let _ = stream.write_all(&body).await;
return;
}
if path == "/app/preload-chunked.html" && preload_header_value != "missing" {
let response_head = concat!(
"HTTP/1.1 200 OK\r\n",
"Content-Type: text/html; charset=UTF-8\r\n",
"Transfer-Encoding: chunked\r\n",
"Connection: close\r\n",
"\r\n"
);
let _ = stream.write_all(response_head.as_bytes()).await;
for digit in 0..10 {
let chunk = format!("1\r\n{digit}\r\n");
let _ = stream.write_all(chunk.as_bytes()).await;
}
let _ = stream.write_all(b"0\r\n\r\n").await;
return;
}
if path == "/app/preload-cookie-lax.html" && preload_header_value != "missing" {
let response =
navigation_preload_cookie_response(&request, "preload_lax", "Lax");
let _ = stream.write_all(response.as_bytes()).await;
return;
}
if path == "/app/preload-cookie-strict.html" && preload_header_value != "missing" {
let response =
navigation_preload_cookie_response(&request, "preload_strict", "Strict");
let _ = stream.write_all(response.as_bytes()).await;
return;
}
if path == "/app/preload-empty-body.html" && preload_header_value != "missing" {
let response = concat!(
"HTTP/1.1 200 OK\r\n",
"Content-Type: text/html\r\n",
"Content-Length: 0\r\n",
"Connection: close\r\n",
"\r\n"
);
let _ = stream.write_all(response.as_bytes()).await;
return;
}
if path == "/app/preload-broken-body-unused.html"
&& preload_header_value != "missing"
{
let response = concat!(
"HTTP/1.1 200 OK\r\n",
"Content-Type: text/html\r\n",
"Content-Length: 64\r\n",
"Connection: close\r\n",
"\r\n",
"partial unused preload body"
);
let _ = stream.write_all(response.as_bytes()).await;
return;
}
if path == "/app/preload-body-error.html" && preload_header_value != "missing" {
let response = concat!(
"HTTP/1.1 200 OK\r\n",
"Content-Type: text/html\r\n",
"Content-Length: 64\r\n",
"Connection: close\r\n",
"\r\n",
"partial preload body"
);
let _ = stream.write_all(response.as_bytes()).await;
return;
}
if path == "/app/preload-redirect-direct-body.html"
&& preload_header_value != "missing"
{
let body = "<body>BODY</body>";
let response = format!(
"HTTP/1.1 302 Found\r\nContent-Type: text/html\r\nCustom-Header: hello\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes()).await;
return;
}
let (status, content_type, body) = main_resource_service_worker_response(&path);
let extra_headers = match path.as_str() {
"/app/preload.html" => {
format!("X-Network: preload\r\nX-Seen-Preload: {preload_header_value}\r\n")
}
"/app/preload-redirect.html" => {
format!(
"Location: /app/preload-final.html\r\nX-Seen-Preload: {preload_header_value}\r\n"
)
}
"/app/preload-redirect-follow.html" => {
"Location: /outside/preload-redirected.html\r\n".to_owned()
}
"/app/preload-redirect-to-scope.html" => {
"Location: /app/preload-redirect-to-scope-2.html\r\n".to_owned()
}
"/app/preload-redirect-to-scope-2.html" => {
"Location: /app/preload-redirect-to-scope-3.html\r\n".to_owned()
}
"/app/preload-redirect-to-scope-3.html" => {
"Location: /outside/preload-redirected.html\r\n".to_owned()
}
_ => String::new(),
};
let response = format!(
"HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\n{extra_headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes()).await;
});
}
});
Ok((
format!("http://127.0.0.1:{}", addr.port()),
requests,
server,
))
}
async fn spawn_non_document_navigation_server() -> Result<(String, JoinHandle<()>)> {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.context("bind no-Document navigation fixture")?;
let addr = listener
.local_addr()
.context("read no-Document navigation fixture address")?;
let server = tokio::spawn(async move {
loop {
let (mut stream, _) = match listener.accept().await {
Ok(connection) => connection,
Err(_) => break,
};
tokio::spawn(async move {
let request = match read_http_request_head(&mut stream).await {
Ok(request) => request,
Err(_) => return,
};
if request_path(&request).as_deref() == Some("/no-document") {
let _ = stream
.write_all(
b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await;
return;
}
if request_path(&request).as_deref() == Some("/reset-content") {
let _ = stream
.write_all(
b"HTTP/1.1 205 Reset Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
)
.await;
return;
}
if request_path(&request).as_deref() == Some("/download") {
let body = "download";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Disposition: attachment; filename=fixture.txt\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes()).await;
return;
}
let body = "<!doctype html><body><main id=\"source-document\">source</main></body>";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes()).await;
});
}
});
Ok((format!("http://127.0.0.1:{}", addr.port()), server))
}
fn request_path(request: &str) -> Option<String> {
request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.map(ToOwned::to_owned)
}
fn request_has_navigation_preload_header(request: &str, expected_value: &str) -> bool {
request_has_header_value(request, "Service-Worker-Navigation-Preload", expected_value)
}
fn request_has_header_value(request: &str, expected_name: &str, expected_value: &str) -> bool {
request.lines().any(|line| {
line.split_once(':').is_some_and(|(name, value)| {
name.eq_ignore_ascii_case(expected_name) && value.trim() == expected_value
})
})
}
fn request_has_header_containing(request: &str, expected_name: &str, expected_value: &str) -> bool {
request.lines().any(|line| {
line.split_once(':').is_some_and(|(name, value)| {
name.eq_ignore_ascii_case(expected_name) && value.contains(expected_value)
})
})
}
fn navigation_preload_cookie_response(request: &str, cookie_name: &str, same_site: &str) -> String {
let body = if request_has_header_containing(request, "Cookie", &format!("{cookie_name}=1")) {
"1"
} else {
"0"
};
format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nSet-Cookie: {cookie_name}=1; Path=/app; SameSite={same_site}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
}
async fn read_http_request_head(stream: &mut tokio::net::TcpStream) -> Result<String> {
let mut bytes = Vec::new();
let mut buf = [0_u8; 1];
while !bytes.ends_with(b"\r\n\r\n") {
let read = stream
.read(&mut buf)
.await
.context("read service worker test request")?;
if read == 0 {
break;
}
bytes.push(buf[0]);
if bytes.len() > 16 * 1024 {
return Err(anyhow!("service worker test request head too large"));
}
}
String::from_utf8(bytes).context("service worker test request should be utf-8")
}
fn main_resource_service_worker_response(path: &str) -> (&'static str, &'static str, &'static str) {
match path {
"/app/register.html" => (
"200 OK",
"text/html",
r#"<!doctype html><script>
globalThis.__mainResourceSwReady = "pending";
(async () => {
const registration = await navigator.serviceWorker.register("worker.js", { scope: "./" });
await navigator.serviceWorker.ready;
await registration.navigationPreload.setHeaderValue("core-preload");
await registration.navigationPreload.enable();
globalThis.__mainResourceSwReady =
"ready:" + String(Boolean(navigator.serviceWorker.controller));
})().catch(error => {
globalThis.__mainResourceSwReady = "error:" + error.name + ":" + error.message;
});
</script>"#,
),
"/app/worker.js" => (
"200 OK",
"text/javascript",
r#"let preloadCancelProbe = Promise.resolve(null);
let preloadCancelProbeResolve = null;
function resetPreloadCancelProbe() {
preloadCancelProbe = new Promise(resolve => {
preloadCancelProbeResolve = resolve;
});
}
resetPreloadCancelProbe();
self.addEventListener("install", event => {
event.waitUntil(self.skipWaiting());
});
self.addEventListener("activate", event => {
event.waitUntil(clients.claim());
});
self.addEventListener("message", event => {
if (event.data !== "preload-cancel-error") {
return;
}
event.waitUntil(preloadCancelProbe.then(result => {
event.source.postMessage(JSON.stringify(result));
}));
});
self.addEventListener("fetch", event => {
const url = new URL(event.request.url);
if (url.pathname === "/app/controlled.html") {
event.respondWith(new Response(
"<!doctype html><body>sw-main:" +
event.request.destination + ":" + event.request.mode +
"</body>",
{ headers: { "Content-Type": "text/html" } }
));
} else if (url.pathname === "/app/preload.html") {
event.respondWith((async () => {
const preload = await event.preloadResponse;
return new Response(
"<!doctype html><body>preload:" +
preload.status + ":" +
preload.headers.get("x-network") + ":" +
preload.headers.get("x-seen-preload") + ":" +
await preload.text() +
"</body>",
{ headers: { "Content-Type": "text/html" } }
);
})());
} else if (url.pathname === "/app/preload-headers.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-gzip.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-chunked.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-cookie-lax.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-cookie-strict.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-empty-body.html") {
event.respondWith((async () => {
const preload = await event.preloadResponse;
return new Response(
"<!doctype html><body>[" + await preload.text() + "]</body>",
{ headers: { "Content-Type": "text/html" } }
);
})());
} else if (url.pathname === "/app/preload-broken-body-unused.html") {
event.respondWith(event.preloadResponse.then(
_ => new Response(
"<!doctype html><body>PASS: preloadResponse resolved</body>",
{ headers: { "Content-Type": "text/html" } }
),
_ => new Response(
"<!doctype html><body>FAIL: preloadResponse rejected</body>",
{ headers: { "Content-Type": "text/html" } }
)
));
} else if (url.pathname === "/app/preload-redirect.html") {
event.respondWith((async () => {
const preload = await event.preloadResponse;
return new Response(
"<!doctype html><body>preload-redirect:" +
preload.status + ":" +
preload.type + ":" +
preload.redirected + ":" +
preload.url + ":" +
await preload.text() +
"</body>",
{ headers: { "Content-Type": "text/html" } }
);
})());
} else if (url.pathname === "/app/preload-redirect-direct-body.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-redirect-follow.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-redirect-to-scope.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-redirect-to-scope-2.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-redirect-to-scope-3.html") {
event.respondWith(event.preloadResponse);
} else if (url.pathname === "/app/preload-body-error.html") {
event.respondWith((async () => {
const preload = await event.preloadResponse;
let body = null;
let bodyError = null;
try {
body = await preload.text();
} catch (error) {
bodyError = {
name: error && error.name,
message: error && error.message,
isTypeError: error instanceof TypeError
};
}
return new Response(
"<!doctype html><body>" +
JSON.stringify({
hasResponse: preload instanceof Response,
status: preload.status,
body,
bodyError
}) +
"</body>",
{ headers: { "Content-Type": "text/html" } }
);
})());
} else if (url.pathname === "/app/preload-cancel.html") {
resetPreloadCancelProbe();
event.preloadResponse.catch(error => {
preloadCancelProbeResolve({
name: error && error.name,
message: error && error.message,
isDomException: error instanceof DOMException
});
});
event.respondWith(new Response(`<!doctype html><script>
globalThis.__preloadCancelProbe = "pending";
navigator.serviceWorker.onmessage = event => {
globalThis.__preloadCancelProbe = event.data;
};
(async () => {
await navigator.serviceWorker.ready;
const controller = navigator.serviceWorker.controller;
if (!controller) {
globalThis.__preloadCancelProbe = "missing-controller";
return;
}
controller.postMessage("preload-cancel-error");
})().catch(error => {
globalThis.__preloadCancelProbe = "error:" + error.name + ":" + error.message;
});
</script><body>preload cancel handled</body>`,
{ headers: { "Content-Type": "text/html" } }
));
}
});
"#,
),
"/app/controlled.html" => (
"200 OK",
"text/html",
"<!doctype html><body>network controlled</body>",
),
"/app/fallback.html" => (
"200 OK",
"text/html",
"<!doctype html><body>network fallback</body>",
),
"/app/preload.html" => ("200 OK", "text/plain", "network-preload-body"),
"/app/preload-redirect.html" => ("302 Found", "text/plain", ""),
"/app/preload-redirect-follow.html" => ("302 Found", "text/plain", ""),
"/app/preload-redirect-to-scope.html" => ("302 Found", "text/plain", ""),
"/app/preload-redirect-to-scope-2.html" => ("302 Found", "text/plain", ""),
"/app/preload-redirect-to-scope-3.html" => ("302 Found", "text/plain", ""),
"/app/preload-final.html" => ("200 OK", "text/plain", "preload-final-body"),
"/outside/preload-redirected.html" => (
"200 OK",
"text/html",
"<!doctype html><body>redirected\n</body>",
),
_ => ("404 Not Found", "text/plain", "not found"),
}
}