Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::*;
#[test]
fn history_api_url_updates_preserve_scroll_and_focus() {
for method in ["pushState", "replaceState"] {
for destination in ["/more?month=8", "#destination"] {
let mut vm = new_parsed_test_vm(
"https://example.com/profile",
r#"<!doctype html><body style="margin:0;width:3000px;height:5000px">
<input id="focused">
<div id="destination" style="position:absolute;top:3500px">month</div>"#,
);
refresh_layout_for_test(&mut vm);
vm.eval(
r#"focused.focus({preventScroll:true}); scrollTo(120,900);
window.events=[];
for (const type of ['navigate','currententrychange','navigatesuccess'])
navigation.addEventListener(type,()=>events.push(type));
window.position=()=>[scrollX,scrollY,document.scrollingElement.scrollLeft,
document.scrollingElement.scrollTop,document.activeElement.id].join('|');"#,
)
.unwrap();
refresh_layout_for_test(&mut vm);
let layouts = vm.layout_pass_observability_for_test().1;
assert_eq!(
vm.eval(&format!(
"history.{method}({{month:8}},'',{destination:?}); position()+'|'+events.join(',')"
))
.unwrap(),
"120|900|120|900|focused|navigate,currententrychange",
"{method}({destination}) before completion"
);
// History API completion still emits navigatesuccess, but must not
// apply the fragment/top scrolling used by an actual navigation.
assert_eq!(
vm.eval("position()+'|'+events.join(',')").unwrap(),
"120|900|120|900|focused|navigate,currententrychange,navigatesuccess",
"{method}({destination}) after completion"
);
assert_eq!(vm.layout_pass_observability_for_test().1, layouts);
refresh_layout_for_test(&mut vm);
assert_eq!(vm.eval("position()").unwrap(), "120|900|120|900|focused");
}
}
}
#[test]
fn same_document_navigation_dispatches_navigatesuccess() {
let mut vm = new_storage_test_vm("https://example.com/base");
let result = vm
.eval(
r##"
(() => {
globalThis.__lmSameDocumentSuccessLog = [];
navigation.onnavigatesuccess = () => {
globalThis.__lmSameDocumentSuccessLog.push(`success:${location.hash}`);
};
navigation.navigate("#one");
return globalThis.__lmSameDocumentSuccessLog.join("|");
})()
"##,
)
.expect("same-document navigatesuccess probe should evaluate");
assert_eq!(result, "");
let after_microtask = vm
.eval("globalThis.__lmSameDocumentSuccessLog.join('|')")
.expect("same-document navigatesuccess log should evaluate after microtask");
assert_eq!(after_microtask, "success:#one");
}
#[test]
fn same_document_navigation_precommit_redirect_updates_destination() {
let mut vm = new_storage_test_vm("https://example.com/base");
let before_commit = vm
.eval(
r##"
(() => {
globalThis.__lmPrecommitRedirectLog = [];
globalThis.__lmPrecommitRedirectStartLength = navigation.entries().length;
navigation.onnavigate = event => {
event.intercept({
precommitHandler: controller => {
__lmPrecommitRedirectLog.push(`before:${location.hash}:${event.info.flag}:${event.destination.getState().value}`);
controller.redirect("#redirected", {
history: "replace",
info: { flag: "redirected" },
state: { value: 2 }
});
__lmPrecommitRedirectLog.push(`after:${location.hash}:${new URL(event.destination.url).hash}:${event.info.flag}:${event.destination.getState().value}`);
}
});
};
navigation.navigate("#push", {
history: "push",
info: { flag: "initial" },
state: { value: 1 }
});
return `${__lmPrecommitRedirectLog.join("|")}|pending:${location.hash}`;
})()
"##,
)
.expect("precommit redirect probe should evaluate");
assert_eq!(
before_commit,
"before::initial:1|after::#redirected:redirected:2|pending:"
);
assert_eq!(
vm.eval(
r##"`final:${location.hash}:${navigation.entries().length - __lmPrecommitRedirectStartLength}:${navigation.currentEntry.getState().value}`"##
)
.expect("precommit redirect should commit after its Promise boundary"),
"final:#redirected:0:2"
);
}
#[tokio::test]
async fn same_document_navigation_precommit_added_handler_delays_finished() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_storage_test_vm_with_loader("https://example.com/base", &loader);
let setup = vm
.eval(
r##"
(() => {
globalThis.__lmPrecommitAddHandlerLog = [];
navigation.onnavigate = event => {
event.intercept({
precommitHandler: controller => {
controller.addHandler(() => new Promise(resolve => {
setTimeout(() => {
globalThis.__lmPrecommitAddHandlerLog.push("added");
resolve();
}, 0);
}));
},
handler: () => {
globalThis.__lmPrecommitAddHandlerLog.push("handler");
}
});
};
navigation.navigate("#one").finished.then(() => {
globalThis.__lmPrecommitAddHandlerLog.push("finished");
});
return `${location.hash}:${globalThis.__lmPrecommitAddHandlerLog.join("|")}`;
})()
"##,
)
.expect("precommit addHandler setup should evaluate");
assert_eq!(setup, ":");
assert_eq!(
vm.eval("`${location.hash}:${globalThis.__lmPrecommitAddHandlerLog.join('|')}`")
.expect("precommit completion should commit before the added timer"),
"#one:handler"
);
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("precommit added handler timer should drain");
let after_timeout = vm
.eval("globalThis.__lmPrecommitAddHandlerLog.join('|')")
.expect("precommit addHandler log should evaluate");
assert_eq!(after_timeout, "handler|added|finished");
}
#[tokio::test]
async fn window_stop_cancels_pending_precommit_before_commit() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_storage_test_vm_with_loader("https://example.com/base", &loader);
let setup = vm
.eval(
r##"
(() => {
globalThis.__lmStopPrecommitLog = [];
navigation.onnavigate = event => {
event.signal.addEventListener("abort", () => {
globalThis.__lmStopPrecommitLog.push(`abort:${event.signal.reason.name}:${location.search}`);
});
event.intercept({
precommitHandler: () => new Promise(() => {})
});
};
navigation.onnavigateerror = () => {
globalThis.__lmStopPrecommitLog.push(`error:${location.search}`);
};
navigation.onnavigatesuccess = () => {
globalThis.__lmStopPrecommitLog.push("success");
};
const result = navigation.navigate("?blocked");
result.committed.then(
() => globalThis.__lmStopPrecommitLog.push("committed"),
error => globalThis.__lmStopPrecommitLog.push(`committed-rejected:${error.name}`)
);
result.finished.then(
() => globalThis.__lmStopPrecommitLog.push("finished"),
error => globalThis.__lmStopPrecommitLog.push(`finished-rejected:${error.name}`)
);
window.stop();
return `${location.search}:${globalThis.__lmStopPrecommitLog.join("|")}`;
})()
"##,
)
.expect("window.stop pending precommit setup should evaluate");
assert_eq!(setup, ":abort:AbortError:|error:");
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("window.stop pending precommit should drain");
let settled = vm
.eval("globalThis.__lmStopPrecommitLog.join('|')")
.expect("window.stop pending precommit log should evaluate");
assert_eq!(
settled,
"abort:AbortError:|error:|committed-rejected:AbortError|finished-rejected:AbortError"
);
}
#[tokio::test]
async fn same_document_navigation_async_precommit_waits_to_commit() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_storage_test_vm_with_loader("https://example.com/base", &loader);
let setup = vm
.eval(
r##"
(() => {
globalThis.__lmAsyncPrecommitLog = [];
navigation.onnavigate = event => {
event.intercept({
precommitHandler: () => new Promise(resolve => {
setTimeout(() => {
globalThis.__lmAsyncPrecommitLog.push(`precommit:${location.hash}`);
resolve();
}, 0);
}),
handler: () => {
globalThis.__lmAsyncPrecommitLog.push(`handler:${location.hash}`);
}
});
};
const result = navigation.navigate("#one");
result.committed.then(() => globalThis.__lmAsyncPrecommitLog.push(`committed:${location.hash}`));
result.finished.then(() => globalThis.__lmAsyncPrecommitLog.push(`finished:${location.hash}`));
return `${location.hash}:${globalThis.__lmAsyncPrecommitLog.join("|")}`;
})()
"##,
)
.expect("async precommit setup should evaluate");
assert_eq!(setup, ":");
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("async precommit timer should drain");
let after_timeout = vm
.eval("`${location.hash}:${globalThis.__lmAsyncPrecommitLog.join('|')}`")
.expect("async precommit log should evaluate");
assert_eq!(
after_timeout,
"#one:precommit:|handler:#one|committed:#one|finished:#one"
);
}
#[tokio::test]
async fn same_document_navigation_async_precommit_reject_blocks_commit() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_storage_test_vm_with_loader("https://example.com/base", &loader);
let setup = vm
.eval(
r##"
(() => {
globalThis.__lmAsyncPrecommitRejectLog = [];
navigation.onnavigate = event => {
event.intercept({
precommitHandler: () => new Promise((_, reject) => {
setTimeout(() => reject(new Error("blocked")), 0);
}),
handler: () => {
globalThis.__lmAsyncPrecommitRejectLog.push("handler");
}
});
};
navigation.onnavigateerror = () => {
globalThis.__lmAsyncPrecommitRejectLog.push(`error:${location.hash}`);
};
const result = navigation.navigate("#one");
result.committed.catch(error => globalThis.__lmAsyncPrecommitRejectLog.push(`committed:${error.message}:${location.hash}`));
result.finished.catch(error => globalThis.__lmAsyncPrecommitRejectLog.push(`finished:${error.message}:${location.hash}`));
return `${location.hash}:${globalThis.__lmAsyncPrecommitRejectLog.join("|")}`;
})()
"##,
)
.expect("async precommit rejection setup should evaluate");
assert_eq!(setup, ":");
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("async precommit rejection timer should drain");
let after_timeout = vm
.eval("`${location.hash}:${globalThis.__lmAsyncPrecommitRejectLog.join('|')}`")
.expect("async precommit rejection log should evaluate");
assert_eq!(
after_timeout,
":error:|committed:blocked:|finished:blocked:"
);
}
#[tokio::test]
async fn same_document_navigation_finished_resolves_after_microtask() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_storage_test_vm_with_loader("https://example.com/base", &loader);
let before_microtask_checkpoint = vm
.eval(
r##"
(() => {
globalThis.__lmNavigationFinishedOrder = [];
navigation.onnavigatesuccess = () => {
globalThis.__lmNavigationFinishedOrder.push(`success:${location.hash}`);
};
const result = navigation.navigate("#one");
result.committed.then(() => globalThis.__lmNavigationFinishedOrder.push("committed"));
result.finished.then(() => globalThis.__lmNavigationFinishedOrder.push("finished"));
Promise.resolve().then(() => globalThis.__lmNavigationFinishedOrder.push("microtask"));
return globalThis.__lmNavigationFinishedOrder.join("|");
})()
"##,
)
.expect("same-document navigation ordering setup should evaluate");
assert_eq!(before_microtask_checkpoint, "");
let after_microtasks = vm
.eval("globalThis.__lmNavigationFinishedOrder.join('|')")
.expect("same-document navigation ordering log should evaluate after microtasks");
assert_eq!(
after_microtasks,
"success:#one|committed|microtask|finished"
);
}
#[tokio::test]
async fn closed_navigation_source_rejects_task_finished_without_timer_fallback() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_storage_test_vm_with_loader("https://example.com/base", &loader);
vm.eval(
r#"
globalThis.__lmClosedNavigationTaskRoute = [];
navigation.navigate("/next-document");
"queued"
"#,
)
.expect("cross-document navigation should run its unload lifecycle step");
assert!(
!vm.has_ready_timeout(),
"cross-document unload lifecycle must not leave a PageTimer before route retirement"
);
drop(
vm._page_task_residence_for_executor_test
.take()
.expect("Navigation API route-retirement fixture should own one production consumer"),
);
vm.eval(
r##"
navigation.onnavigatesuccess = () => __lmClosedNavigationTaskRoute.push("success");
navigation.onnavigateerror = event => {
__lmClosedNavigationTaskRoute.push("error:" + event.error.name);
};
const result = navigation.navigate("#replacement");
result.committed.then(
() => __lmClosedNavigationTaskRoute.push("committed"),
error => __lmClosedNavigationTaskRoute.push("committed-error:" + error.name),
);
result.finished.then(
() => __lmClosedNavigationTaskRoute.push("finished"),
error => __lmClosedNavigationTaskRoute.push("finished-error:" + error.name),
);
"queued"
"##,
)
.expect("closed Navigation API route should reject instead of falling back");
assert_eq!(
vm.eval("globalThis.__lmClosedNavigationTaskRoute.join('|')")
.expect("closed Navigation API route settlement should be observable"),
"error:AbortError|error:AbortError|committed|finished-error:AbortError",
"the retired cross-document attempt and the rejected replacement attempt should each dispatch one navigateerror"
);
assert!(
!vm.has_ready_timeout(),
"a closed navigation-and-traversal source must not recreate the removed timer transport"
);
}
#[test]
fn same_document_intercept_rejects_finished_and_dispatches_navigateerror() {
let mut vm = new_storage_test_vm("https://example.com/base");
let setup = vm
.eval(
r##"
(() => {
const log = [];
const err = new Error("boom");
navigation.onnavigatesuccess = () => log.push("success");
navigation.onnavigateerror = event => {
log.push("error:" + String(event.error === err));
};
navigation.onnavigate = event => {
event.intercept({ handler: () => Promise.reject(err) });
};
const result = navigation.navigate("#one");
result.committed.then(() => log.push("committed"));
result.finished.then(
() => log.push("finished:fulfilled"),
error => log.push("finished:" + String(error === err))
);
Promise.resolve().then(() => log.push("microtask"));
globalThis.__lmInterceptRejectLog = log;
return log.join("|");
})()
"##,
)
.expect("intercept reject setup should evaluate");
assert_eq!(setup, "");
let after_microtasks = vm
.eval("globalThis.__lmInterceptRejectLog.join('|')")
.expect("intercept reject microtasks should evaluate");
assert_eq!(
after_microtasks,
"error:true|committed|microtask|finished:true"
);
}
#[test]
fn same_document_multiple_intercept_handlers_reject_if_any_handler_rejects() {
let mut vm = new_storage_test_vm("https://example.com/base");
let setup = vm
.eval(
r##"
(() => {
const log = [];
const err = new TypeError("sentinel");
navigation.onnavigatesuccess = () => log.push("success");
navigation.onnavigateerror = event => {
log.push("error:" + String(event.error === err));
};
navigation.onnavigate = event => {
event.intercept();
event.intercept({ handler: () => Promise.reject(err) });
event.intercept({ handler: () => Promise.resolve("ignored") });
};
const result = navigation.navigate("#one");
result.finished.then(
() => log.push("finished:fulfilled"),
error => log.push("finished:" + String(error === err))
);
globalThis.__lmMultipleInterceptRejectLog = log;
return log.join("|");
})()
"##,
)
.expect("multiple intercept rejection setup should evaluate");
assert_eq!(setup, "");
let after_microtasks = vm
.eval("globalThis.__lmMultipleInterceptRejectLog.join('|')")
.expect("multiple intercept rejection microtasks should evaluate");
assert_eq!(after_microtasks, "error:true|finished:true");
}
#[test]
fn navigation_reload_intercept_rejects_finished_and_dispatches_navigateerror() {
let mut vm = new_storage_test_vm("https://example.com/base");
let setup = vm
.eval(
r##"
(() => {
const log = [];
const err = new Error("reload blocked");
const from = navigation.currentEntry;
navigation.oncurrententrychange = event => {
log.push(`change:${event.navigationType}:${event.from === from}`);
};
navigation.onnavigatesuccess = () => log.push("success");
navigation.onnavigateerror = event => {
log.push("error:" + String(event.error === err));
};
navigation.onnavigate = event => {
log.push(`navigate:${event.navigationType}`);
event.intercept({ handler: () => Promise.reject(err) });
};
const result = navigation.reload();
result.committed.then(
value => log.push("committed:" + String(value === navigation.currentEntry)),
() => log.push("committed:rejected")
);
result.finished.then(
() => log.push("finished:fulfilled"),
error => log.push("finished:" + String(error === err))
);
Promise.resolve().then(() => log.push("microtask"));
globalThis.__lmReloadInterceptRejectLog = log;
return log.join("|");
})()
"##,
)
.expect("reload intercept rejection setup should evaluate");
assert_eq!(setup, "navigate:reload|change:reload:true");
let after_microtasks = vm
.eval("globalThis.__lmReloadInterceptRejectLog.join('|')")
.expect("reload intercept rejection microtasks should evaluate");
assert_eq!(
after_microtasks,
"navigate:reload|change:reload:true|error:true|committed:true|microtask|finished:true"
);
}
#[test]
fn navigation_reload_intercept_exposes_transition_during_events() {
let mut vm = new_storage_test_vm("https://example.com/base");
let result = vm
.eval(
r##"
(() => {
const from = navigation.currentEntry;
globalThis.__lmReloadTransitionLog = [];
const record = name => globalThis.__lmReloadTransitionLog.push({
name,
transitionObject: navigation.transition !== null,
transitionBrand: navigation.transition instanceof NavigationTransition,
fromMatches: navigation.transition?.from === from,
navigationType: navigation.transition?.navigationType ?? null
});
navigation.addEventListener("navigate", () => record("navigate"));
navigation.addEventListener("currententrychange", () => record("currententrychange"));
navigation.addEventListener("navigatesuccess", () => record("navigatesuccess"));
navigation.onnavigate = event => event.intercept({
handler() { record("handler"); }
});
const reloadResult = navigation.reload();
return JSON.stringify({
log: globalThis.__lmReloadTransitionLog,
transitionAfterReload: navigation.transition !== null,
committedPromise: typeof reloadResult.committed.then === "function",
finishedPromise: typeof reloadResult.finished.then === "function"
});
})()
"##,
)
.expect("reload intercepted transition probe should evaluate");
assert_eq!(
result,
r##"{"log":[{"name":"navigate","transitionObject":false,"transitionBrand":false,"fromMatches":false,"navigationType":null},{"name":"currententrychange","transitionObject":true,"transitionBrand":true,"fromMatches":true,"navigationType":"reload"},{"name":"handler","transitionObject":true,"transitionBrand":true,"fromMatches":true,"navigationType":"reload"}],"transitionAfterReload":true,"committedPromise":true,"finishedPromise":true}"##
);
let after_microtask = vm
.eval(
r##"JSON.stringify({
log: globalThis.__lmReloadTransitionLog,
transitionAfterReload: navigation.transition
})"##,
)
.expect("reload intercepted transition microtask probe should evaluate");
assert_eq!(
after_microtask,
r##"{"log":[{"name":"navigate","transitionObject":false,"transitionBrand":false,"fromMatches":false,"navigationType":null},{"name":"currententrychange","transitionObject":true,"transitionBrand":true,"fromMatches":true,"navigationType":"reload"},{"name":"handler","transitionObject":true,"transitionBrand":true,"fromMatches":true,"navigationType":"reload"},{"name":"navigatesuccess","transitionObject":true,"transitionBrand":true,"fromMatches":true,"navigationType":"reload"}],"transitionAfterReload":null}"##
);
}
#[test]
fn navigation_state_clone_rejects_dom_nodes_before_document_state() {
let mut vm = new_storage_test_vm("https://example.com/base");
vm.eval(
r##"
(() => {
globalThis.__lmNavigationStateCloneLog = [];
const record = (label, result) => {
result.committed.then(
() => __lmNavigationStateCloneLog.push(`${label}:committed:fulfilled`),
error => __lmNavigationStateCloneLog.push(`${label}:committed:${error && error.name}`)
);
result.finished.then(
() => __lmNavigationStateCloneLog.push(`${label}:finished:fulfilled`),
error => __lmNavigationStateCloneLog.push(`${label}:finished:${error && error.name}`)
);
};
const stateNode = document.createElement("div");
record("active-navigate", navigation.navigate("?node-state", { state: stateNode }));
record("active-reload", navigation.reload({ state: stateNode }));
const host = document.documentElement || document.appendChild(document.createElement("html"));
const frame = document.createElement("iframe");
host.appendChild(frame);
const child = frame.contentWindow;
frame.remove();
record("detached-navigate", child.navigation.navigate("/next", { state: stateNode }));
record("detached-reload", child.navigation.reload({ state: stateNode }));
return "queued";
})()
"##,
)
.expect("navigation state clone rejection setup should evaluate");
let result = vm
.eval("globalThis.__lmNavigationStateCloneLog.join('|')")
.expect("navigation state clone rejection log should evaluate");
assert_eq!(
result,
"active-navigate:committed:DataCloneError|active-navigate:finished:DataCloneError|active-reload:committed:DataCloneError|active-reload:finished:DataCloneError|detached-navigate:committed:DataCloneError|detached-navigate:finished:DataCloneError|detached-reload:committed:DataCloneError|detached-reload:finished:DataCloneError"
);
}
#[tokio::test]
async fn navigation_reload_async_precommit_reject_blocks_commit() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm = new_storage_test_vm_with_loader("https://example.com/base", &loader);
let setup = vm
.eval(
r##"
(() => {
globalThis.__lmReloadPrecommitRejectLog = [];
navigation.onnavigate = event => {
event.intercept({
precommitHandler: () => new Promise((_, reject) => {
setTimeout(() => reject(new Error("reload blocked")), 0);
}),
handler: () => {
globalThis.__lmReloadPrecommitRejectLog.push("handler");
}
});
};
navigation.oncurrententrychange = () => {
globalThis.__lmReloadPrecommitRejectLog.push("change");
};
navigation.onnavigateerror = () => {
globalThis.__lmReloadPrecommitRejectLog.push("error");
};
const result = navigation.reload();
result.committed.then(
() => globalThis.__lmReloadPrecommitRejectLog.push("committed:fulfilled"),
error => globalThis.__lmReloadPrecommitRejectLog.push(`committed:${error.message}`)
);
result.finished.then(
() => globalThis.__lmReloadPrecommitRejectLog.push("finished:fulfilled"),
error => globalThis.__lmReloadPrecommitRejectLog.push(`finished:${error.message}`)
);
return globalThis.__lmReloadPrecommitRejectLog.join("|");
})()
"##,
)
.expect("reload async precommit rejection setup should evaluate");
assert_eq!(setup, "");
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("reload async precommit rejection timer should drain");
let after_timeout = vm
.eval("globalThis.__lmReloadPrecommitRejectLog.join('|')")
.expect("reload async precommit rejection log should evaluate");
assert_eq!(
after_timeout,
"error|committed:reload blocked|finished:reload blocked"
);
}
#[test]
fn same_document_location_intercept_reject_dispatches_navigateerror() {
let mut vm = new_storage_test_vm("https://example.com/base");
let setup = vm
.eval(
r##"
(() => {
const log = [];
const err = new Error("boom");
navigation.onnavigatesuccess = () => log.push("success");
navigation.onnavigateerror = event => {
log.push("error:" + String(event.error === err) + ":" + location.hash);
};
navigation.onnavigate = event => {
event.intercept({ handler: () => Promise.reject(err) });
};
location.href = "#one";
Promise.resolve().then(() => log.push("microtask"));
globalThis.__lmLocationInterceptRejectLog = log;
return log.join("|");
})()
"##,
)
.expect("location intercept reject setup should evaluate");
assert_eq!(setup, "");
let after_microtasks = vm
.eval("globalThis.__lmLocationInterceptRejectLog.join('|')")
.expect("location intercept reject microtasks should evaluate");
assert_eq!(after_microtasks, "error:true:#one|microtask");
}
#[test]
fn same_url_navigation_classifies_fragments_before_interception() {
for (fragment, remove_fragment, same_document) in [
("", false, false),
("#", false, true),
("#fragment", false, true),
("#fragment", true, false),
] {
for history in ["auto", "push", "replace"] {
for action in ["navigate", "intercept", "cancel"] {
let mut vm = new_storage_test_vm(&format!(
"https://same-url-navigation.test/page{fragment}"
));
vm.exec(
&format!(
r#"
const beforeLength = history.length;
const events = [], settled = [];
navigation.addEventListener('navigate', event => {{
events.push([event.navigationType, event.destination.sameDocument, event.hashChange]);
if ({action:?} === 'intercept') event.intercept();
if ({action:?} === 'cancel') event.preventDefault();
}});
const destination = {remove_fragment} ? location.href.split('#')[0] : location.href;
const result = navigation.navigate(destination, {{history: {history:?}}});
for (const name of ['committed', 'finished'])
result[name].then(() => settled.push(name), error => settled.push(name + ':' + error.name));
"#
),
None,
)
.unwrap();
let context = format!("{fragment}/{remove_fragment}/{history}/{action}");
let pushes = history == "push" || (history == "auto" && remove_fragment);
let navigation_type = if pushes { "push" } else { "replace" };
let pending = vm.take_pending_location_navigation_with_seed();
assert_eq!(
pending.is_some(),
!same_document && action == "navigate",
"{context}"
);
if let Some(pending) = pending {
assert_eq!(
pending.url.as_str(),
"https://same-url-navigation.test/page"
);
assert_eq!(
pending
.entry_seed
.unwrap()
.activation
.unwrap()
.navigation_type
.as_deref(),
Some(navigation_type),
"{context}"
);
}
let result = vm
.eval("JSON.stringify({events, settled, delta: history.length - beforeLength})")
.unwrap();
let result: serde_json::Value = serde_json::from_str(&result).unwrap();
let committed = action != "cancel" && (same_document || action == "intercept");
let settled = if action == "cancel" {
serde_json::json!(["committed:AbortError", "finished:AbortError"])
} else if committed {
serde_json::json!(["committed", "finished"])
} else {
serde_json::json!([])
};
assert_eq!(
result,
serde_json::json!({
"events": [[navigation_type, same_document, false]],
"settled": settled,
"delta": i32::from(committed && pushes),
}),
"{context}"
);
}
}
}
}
#[tokio::test]
async fn same_url_navigation_preserves_fragment_documents_in_iframes() {
for (fragment, remove_fragment, same_document) in [
("", false, false),
("#", false, true),
("#fragment", false, true),
("#fragment", true, false),
] {
for history in ["auto", "push", "replace"] {
let request_count = if same_document { 1 } else { 2 };
let server = StaticHttpServer::spawn(request_count).await;
let parent = server.base_url().join("parent").unwrap();
let loader = static_http_loader([]);
let mut vm =
new_storage_page_task_executor_test_vm_with_loader(parent.as_str(), &loader);
let context = format!("{fragment}/{remove_fragment}/{history}");
vm.eval(
r#"
const frame = document.createElement('iframe');
frame.src = '/child'; document.body.append(frame);
const child = frame.contentWindow;
"#,
)
.unwrap();
advance_page_task_executor_until_eval_equals(
&mut vm, &loader,
"(() => { try { return String(child.location.pathname === '/child' && child.document.readyState === 'complete'); } catch { return 'false'; } })()",
"true", &context,
).await;
vm.exec(
&format!(
r#"
child.history.replaceState(null, '', child.location.pathname + {fragment:?});
const originalDocument = child.document;
const beforeLength = child.history.length;
const beforeEntries = child.navigation.entries().length;
const beforeIndex = child.navigation.currentEntry.index;
const events = [], settled = [];
child.navigation.addEventListener('navigate', event =>
events.push([event.navigationType, event.destination.sameDocument, event.hashChange]));
const destination = {remove_fragment} ? child.location.href.split('#')[0] : child.location.href;
const result = child.navigation.navigate(destination, {{history: {history:?}}});
for (const name of ['committed', 'finished'])
result[name].then(() => settled.push(name), error => settled.push(error.name));
"#
),
None,
)
.unwrap();
advance_page_task_executor_until_eval_equals(
&mut vm, &loader,
if same_document {
"String(settled.length === 2)"
} else {
"(() => { try { return String(child.document !== originalDocument && child.document.readyState === 'complete'); } catch { return 'false'; } })()"
},
"true", &context,
).await;
let result = vm
.eval(
r#"JSON.stringify({
sameDocument: originalDocument === child.document,
historyDelta: child.history.length - beforeLength,
entriesDelta: child.navigation.entries().length - beforeEntries,
indexDelta: child.navigation.currentEntry.index - beforeIndex,
events, settled})"#,
)
.unwrap();
let result: serde_json::Value = serde_json::from_str(&result).unwrap();
let pushes = history == "push" || (history == "auto" && remove_fragment);
assert_eq!(
result["sameDocument"],
serde_json::json!(same_document),
"{context}"
);
assert_eq!(
result["events"],
serde_json::json!([[
if pushes { "push" } else { "replace" },
same_document,
false
]]),
"{context}"
);
assert_eq!(
result["settled"],
serde_json::json!(if same_document {
vec!["committed", "finished"]
} else {
vec![]
}),
"{context}"
);
for key in ["historyDelta", "entriesDelta", "indexDelta"] {
assert_eq!(
result[key],
serde_json::json!(i32::from(pushes)),
"{context}/{key}"
);
}
assert_eq!(
server.finish_targets().await,
vec!["/child"; request_count],
"{context}"
);
}
}
}