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 top_level_history_back_delegates_to_the_browser_history_controller() {
let url = "https://browser-owned-history.test/current";
let mut vm = new_storage_test_vm(url);
vm.eval("history.back(); 'queued'")
.expect("hidden renderer bookkeeping entry should delegate to the browser");
assert!(!vm.has_pending_location_navigation());
assert_eq!(
vm.take_pending_top_level_history_traversal()
.expect("browser-owned back traversal request")
.delta,
-1
);
vm.install_navigation_bootstrap_entry(Some(moli_page_types::initial_navigation_history_seed(
false, url,
)));
assert_eq!(
vm.eval("String(history.length)")
.expect("single renderer-visible history entry"),
"1"
);
vm.eval("history.back(); 'queued'")
.expect("unknown browser-side back entry should queue");
assert!(!vm.has_pending_location_navigation());
assert_eq!(
vm.take_pending_top_level_history_traversal()
.expect("browser-owned back traversal request")
.delta,
-1
);
vm.eval("history.forward(); 'queued'")
.expect("unknown browser-side forward entry should queue");
assert_eq!(
vm.take_pending_top_level_history_traversal()
.expect("browser-owned forward traversal request")
.delta,
1
);
}
#[test]
fn top_level_navigation_intents_keep_one_last_writer_state() {
let url = "https://browser-owned-history.test/current";
let mut vm = new_storage_test_vm(url);
vm.install_navigation_bootstrap_entry(Some(moli_page_types::initial_navigation_history_seed(
false, url,
)));
vm.eval("history.back(); location.assign('/location-wins'); 'queued'")
.expect("location navigation should replace the history traversal intent");
assert!(vm.take_pending_top_level_history_traversal().is_none());
assert_eq!(
vm.take_pending_location_navigation_with_seed()
.expect("location navigation intent")
.url
.as_str(),
"https://browser-owned-history.test/location-wins"
);
vm.eval("location.assign('/history-loses-location'); history.forward(); 'queued'")
.expect("history traversal should replace the location navigation intent");
assert!(!vm.has_pending_location_navigation());
assert_eq!(
vm.take_pending_top_level_history_traversal()
.expect("history traversal intent")
.delta,
1
);
}
#[tokio::test]
async fn browser_owned_history_traversal_checks_active_source_sandbox() {
use moli_session_history::{
JointSessionHistory, SessionHistoryContextId, SessionHistoryEntry, SessionHistoryPosition,
};
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
let url = "https://browser-owned-history.test/current";
let restricted = "allow-scripts allow-same-origin";
let permitted = "allow-scripts allow-same-origin allow-top-navigation";
for (initial, changed, allowed) in [
(None, Some(restricted), true),
(Some(permitted), Some(restricted), true),
(Some(restricted), None, false),
(Some(restricted), Some(permitted), false),
] {
let mut vm = new_storage_page_task_executor_test_vm_with_loader(url, &loader);
let mut seed = moli_page_types::initial_navigation_history_seed(false, url);
let mut traversable = JointSessionHistory::new(SessionHistoryPosition::new(1, 3).unwrap());
traversable.attach(
SessionHistoryContextId::ROOT,
None,
SessionHistoryEntry {
key: seed.entries[0].key.clone(),
document: seed.entries[0].document_id.clone(),
},
);
seed.session_history.traversable = Some(Box::new(traversable));
vm.install_navigation_bootstrap_entry(Some(seed));
let initial = serde_json::to_string(&initial).unwrap();
let changed = serde_json::to_string(&changed).unwrap();
vm.eval(&format!(
r#"
globalThis.frame = document.createElement('iframe');
if ({initial} !== null) frame.setAttribute('sandbox', {initial});
(document.body || document.documentElement || document).appendChild(frame);
frame.contentWindow;
"#
))
.unwrap();
vm.drain_ready_page_task_executor_turns_for_setup(&loader, 128)
.await
.unwrap();
vm.eval(&format!(
"if ({changed} === null) frame.removeAttribute('sandbox'); else frame.setAttribute('sandbox', {changed});"
))
.unwrap();
{
let mut host = vm._context_host.borrow_mut();
let model = host.session_histories.get_mut(None);
// Both destinations exist in browser history but have no renderer ROOT entry.
for delta in [-1, 1] {
let step = model.step_by_delta(delta).unwrap();
assert!(
!model
.entries_at(step)
.unwrap()
.contains_key(&SessionHistoryContextId::ROOT)
);
}
}
for (call, delta) in [
("back()", -1),
("forward()", 1),
("go(-1)", -1),
("go(1)", 1),
] {
vm.eval(&format!("frame.contentWindow.history.{call}"))
.unwrap();
let pending = vm
.take_pending_top_level_history_traversal()
.map(|pending| pending.delta);
assert_eq!(
pending,
allowed.then_some(delta),
"initial={initial}, changed={changed}, call={call}"
);
}
// A method borrowed from the child still uses its top-level History receiver.
vm.eval("frame.contentWindow.history.back.call(history)")
.unwrap();
assert_eq!(
vm.take_pending_top_level_history_traversal().unwrap().delta,
-1
);
}
}
#[test]
fn traversal_factories_apply_webidl_boundaries() {
let mut vm = new_parsed_test_vm(
"https://traversal-webidl.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.createElement("div");
const child = document.createElement("span");
root.appendChild(child);
document.body.appendChild(root);
const out = [];
const filter = { acceptNode() { return NodeFilter.FILTER_ACCEPT; } };
const iterator = document.createNodeIterator(
root,
{ valueOf() { out.push("iterator-show"); return NodeFilter.SHOW_ELEMENT; } },
filter
);
out.push(iterator.whatToShow === NodeFilter.SHOW_ELEMENT);
out.push(iterator.filter === filter);
const walker = document.createTreeWalker(root, undefined, null);
out.push(walker.whatToShow === NodeFilter.SHOW_ALL);
out.push(walker.filter === null);
const checks = [];
function record(label, callback) {
try {
callback();
checks.push(`${label}:no`);
} catch (error) {
checks.push(`${label}:${error.name}`);
}
}
record("iterator-missing-root", () => document.createNodeIterator());
record("iterator-symbol-show", () => document.createNodeIterator(root, Symbol()));
record("iterator-throw-show", () => document.createNodeIterator(root, { valueOf() { throw new RangeError("show"); } }));
record("iterator-primitive-filter", () => document.createNodeIterator(root, NodeFilter.SHOW_ALL, 7));
record("walker-missing-root", () => document.createTreeWalker());
record("walker-symbol-show", () => document.createTreeWalker(root, Symbol()));
record("walker-bad-root", () => document.createTreeWalker(undefined));
return `${out.join(",")}|${checks.join(",")}`;
})()
"#,
)
.expect("traversal factory WebIDL boundary probe should evaluate");
assert_eq!(
result,
"iterator-show,true,true,true,true|iterator-missing-root:TypeError,iterator-symbol-show:TypeError,iterator-throw-show:RangeError,iterator-primitive-filter:TypeError,walker-missing-root:TypeError,walker-symbol-show:TypeError,walker-bad-root:TypeError"
);
}
#[test]
fn traversal_node_filter_constants_and_current_node_setter_match_webidl() {
let mut vm = new_parsed_test_vm(
"https://traversal-node-filter-current-node.test/",
"<!doctype html><html><body><div id='root'><span></span></div></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.createElement("div");
root.appendChild(document.createElement("p"));
document.body.appendChild(root);
const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
const constants = [
NodeFilter.FILTER_ACCEPT,
NodeFilter.FILTER_REJECT,
NodeFilter.FILTER_SKIP,
NodeFilter.SHOW_ALL,
NodeFilter.SHOW_ELEMENT,
NodeFilter.SHOW_TEXT,
typeof NodeFilter === "function"
].join(",");
const setterErrors = [];
for (const value of [null, {}, window]) {
try {
walker.currentNode = value;
setterErrors.push("no");
} catch (error) {
setterErrors.push(error.name);
}
}
walker.currentNode = root.firstChild;
return [
constants,
setterErrors.join(","),
walker.currentNode === root.firstChild
].join("|");
})()
"#,
)
.expect("traversal constants and currentNode setter checks should evaluate");
assert_eq!(
result,
"1,2,3,4294967295,1,4,true|TypeError,TypeError,TypeError|true"
);
}
#[test]
fn node_filter_global_property_and_constants_are_declared() {
let mut vm = new_parsed_test_vm(
"https://node-filter-declared-surface.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const constants = [
["FILTER_ACCEPT", 1],
["FILTER_REJECT", 2],
["FILTER_SKIP", 3],
["SHOW_ALL", 0xFFFFFFFF],
["SHOW_ELEMENT", 0x1],
["SHOW_ATTRIBUTE", 0x2],
["SHOW_TEXT", 0x4],
["SHOW_CDATA_SECTION", 0x8],
["SHOW_ENTITY_REFERENCE", 0x10],
["SHOW_ENTITY", 0x20],
["SHOW_PROCESSING_INSTRUCTION", 0x40],
["SHOW_COMMENT", 0x80],
["SHOW_DOCUMENT", 0x100],
["SHOW_DOCUMENT_TYPE", 0x200],
["SHOW_DOCUMENT_FRAGMENT", 0x400],
["SHOW_NOTATION", 0x800]
];
const globalDescriptor = Object.getOwnPropertyDescriptor(globalThis, "NodeFilter");
const constantShape = (name, expected) => {
const descriptor = Object.getOwnPropertyDescriptor(NodeFilter, name);
return [
name,
descriptor && descriptor.value,
descriptor && descriptor.value === expected,
descriptor && descriptor.enumerable,
descriptor && descriptor.writable,
descriptor && descriptor.configurable
].join(":");
};
return JSON.stringify({
global: [
typeof globalDescriptor.value,
globalDescriptor.enumerable,
globalDescriptor.writable,
globalDescriptor.configurable,
globalDescriptor.value === NodeFilter
].join(":"),
constants: constants.map(([name, value]) => constantShape(name, value)),
keys: Object.keys(NodeFilter),
windowKeyVisible: Object.keys(window).includes("NodeFilter"),
prototypeIsFunction: Object.getPrototypeOf(NodeFilter) === Function.prototype,
hasPrototypeProperty: Object.hasOwn(NodeFilter, "prototype"),
name: NodeFilter.name,
length: NodeFilter.length,
callThrows: (() => { try { NodeFilter(); return false; } catch (error) { return error instanceof TypeError; } })(),
constructThrows: (() => { try { new NodeFilter(); return false; } catch (error) { return error instanceof TypeError; } })()
});
})()
"#,
)
.expect("NodeFilter declaration surface probe should evaluate");
assert_eq!(
result,
r#"{"global":"function:false:true:true:true","constants":["FILTER_ACCEPT:1:true:true:false:false","FILTER_REJECT:2:true:true:false:false","FILTER_SKIP:3:true:true:false:false","SHOW_ALL:4294967295:true:true:false:false","SHOW_ELEMENT:1:true:true:false:false","SHOW_ATTRIBUTE:2:true:true:false:false","SHOW_TEXT:4:true:true:false:false","SHOW_CDATA_SECTION:8:true:true:false:false","SHOW_ENTITY_REFERENCE:16:true:true:false:false","SHOW_ENTITY:32:true:true:false:false","SHOW_PROCESSING_INSTRUCTION:64:true:true:false:false","SHOW_COMMENT:128:true:true:false:false","SHOW_DOCUMENT:256:true:true:false:false","SHOW_DOCUMENT_TYPE:512:true:true:false:false","SHOW_DOCUMENT_FRAGMENT:1024:true:true:false:false","SHOW_NOTATION:2048:true:true:false:false"],"keys":["FILTER_ACCEPT","FILTER_REJECT","FILTER_SKIP","SHOW_ALL","SHOW_ELEMENT","SHOW_ATTRIBUTE","SHOW_TEXT","SHOW_CDATA_SECTION","SHOW_ENTITY_REFERENCE","SHOW_ENTITY","SHOW_PROCESSING_INSTRUCTION","SHOW_COMMENT","SHOW_DOCUMENT","SHOW_DOCUMENT_TYPE","SHOW_DOCUMENT_FRAGMENT","SHOW_NOTATION"],"windowKeyVisible":false,"prototypeIsFunction":true,"hasPrototypeProperty":false,"name":"NodeFilter","length":0,"callThrows":true,"constructThrows":true}"#
);
}
#[test]
fn traversal_filter_object_requires_callable_accept_node_during_traversal() {
let mut vm = new_parsed_test_vm(
"https://traversal-filter-object-webidl.test/",
"<!doctype html><html><body><div id='root'><span></span></div></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.getElementById("root");
const missing = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {});
const nonCallable = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
{ acceptNode: "no" }
);
const getterError = { name: "getter" };
const throwingGetter = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
{ get acceptNode() { throw getterError; } }
);
const thrown = [];
for (const walker of [missing, nonCallable]) {
try {
walker.firstChild();
thrown.push("no");
} catch (error) {
thrown.push(error.name);
}
thrown.push(walker.currentNode === root);
}
try {
throwingGetter.firstChild();
thrown.push("no");
} catch (error) {
thrown.push(error === getterError);
}
thrown.push(throwingGetter.currentNode === root);
return thrown.join("|");
})()
"#,
)
.expect("traversal filter object WebIDL checks should evaluate");
assert_eq!(result, "TypeError|true|TypeError|true|true|true");
}
#[test]
fn traversal_filter_uses_webidl_callback_interface_invocation_semantics() {
let mut vm = new_parsed_test_vm(
"https://traversal-filter-callback-interface.test/",
"<!doctype html><html><body><div id='root'><span id='a'></span><span id='b'></span></div></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.getElementById("root");
let callableThis = "unset";
let forbiddenOperationCalls = 0;
function callableFilter() {
"use strict";
callableThis = this;
// Web IDL converts the callback result to unsigned short.
return 0x10001;
}
callableFilter.acceptNode = () => {
forbiddenOperationCalls++;
throw new Error("callable branch must ignore acceptNode");
};
const iterator = document.createNodeIterator(
root,
NodeFilter.SHOW_ELEMENT,
callableFilter
);
const callableAccepted = iterator.nextNode() === root;
let getterCalls = 0;
let objectReceiver = false;
const objectFilter = {
get acceptNode() {
getterCalls++;
return function() {
objectReceiver = this === objectFilter;
return NodeFilter.FILTER_ACCEPT;
};
}
};
const walker = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
objectFilter
);
const first = walker.nextNode();
const second = walker.nextNode();
const replaceable = {
acceptNode() {
throw new Error("registration-time operation snapshot");
}
};
const replacementWalker = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
replaceable
);
replaceable.acceptNode = () => NodeFilter.FILTER_ACCEPT;
const replacementAccepted =
replacementWalker.firstChild() === root.firstChild;
const revocable = Proxy.revocable(
() => NodeFilter.FILTER_ACCEPT,
{}
);
const proxyWalker = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
revocable.proxy
);
const proxyAccepted = proxyWalker.firstChild() === root.firstChild;
revocable.revoke();
let revokedProxyThrew = false;
try {
proxyWalker.nextSibling();
} catch (error) {
revokedProxyThrew = error instanceof TypeError;
}
const conversionError = { source: "return conversion" };
const abrupt = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
() => ({
valueOf() {
throw conversionError;
}
})
);
let preservedConversionError = false;
try {
abrupt.firstChild();
} catch (error) {
preservedConversionError = error === conversionError;
}
return [
callableAccepted,
callableThis === undefined,
forbiddenOperationCalls,
first && first.id,
second && second.id,
getterCalls,
objectReceiver,
replacementAccepted,
proxyAccepted,
revokedProxyThrew,
preservedConversionError,
abrupt.currentNode === root
].join("|");
})()
"#,
)
.expect("NodeFilter callback-interface semantics should evaluate");
assert_eq!(result, "true|true|0|a|b|2|true|true|true|true|true|true");
}
#[test]
fn traversal_filter_uses_callback_relevant_realm_and_exact_window_lifetime() {
let mut vm = new_parsed_test_vm(
"https://traversal-filter-realm.test/",
"<!doctype html><html><body><div id='root'><span></span></div></body></html>",
);
vm.eval(
r#"
(() => {
const iframe = document.createElement("iframe");
iframe.srcdoc = "<!doctype html><html><body></body></html>";
document.body.appendChild(iframe);
globalThis.__nodeFilterRealmFrame = iframe;
return "ready";
})()
"#,
)
.expect("cross-Realm NodeFilter setup should evaluate");
vm.drain_pending_child_frame_work_for_test();
let result = vm
.eval(
r#"
(() => {
const other = globalThis.__nodeFilterRealmFrame.contentWindow;
const root = document.getElementById("root");
const missingOperation = new other.Object();
const missingWalker = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
missingOperation
);
let relevantTypeError = false;
try {
missingWalker.firstChild();
} catch (error) {
relevantTypeError =
error instanceof other.TypeError && !(error instanceof TypeError);
}
globalThis.__nodeFilterExpectedRealm = other;
globalThis.__nodeFilterCallFacts = [];
const crossRealmCallable = other.Function(
"node",
`"use strict";
parent.__nodeFilterCallFacts = [
this === undefined,
globalThis === parent.__nodeFilterExpectedRealm,
node.localName
];
return 1;`
);
const callableWalker = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
crossRealmCallable
);
const accepted = callableWalker.firstChild();
return [
relevantTypeError,
missingWalker.currentNode === root,
accepted && accepted.localName,
...globalThis.__nodeFilterCallFacts
].join("|");
})()
"#,
)
.expect("cross-Realm NodeFilter invocation should evaluate");
assert_eq!(result, "true|true|span|true|true|span");
}
#[test]
fn traversal_filter_false_and_zero_are_not_accept() {
let mut vm = new_parsed_test_vm(
"https://traversal-filter-coercion.test/",
"<!doctype html><html><body><div id='root'><span id='a'></span><span id='b'></span></div></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.getElementById("root");
const out = [];
const falseIterator = document.createNodeIterator(
root,
NodeFilter.SHOW_ELEMENT,
() => false
);
out.push(falseIterator.nextNode() === null);
out.push(falseIterator.referenceNode === root);
out.push(falseIterator.pointerBeforeReferenceNode === true);
const zeroWalker = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
() => 0
);
out.push(zeroWalker.firstChild() === null);
out.push(zeroWalker.currentNode === root);
const trueIterator = document.createNodeIterator(
root,
NodeFilter.SHOW_ELEMENT,
() => true
);
out.push(trueIterator.nextNode() === root);
return out.join(",");
})()
"#,
)
.expect("traversal filter coercion checks should evaluate");
assert_eq!(result, "true,true,true,true,true,true");
}
#[test]
fn traversal_sibling_walk_descends_through_non_reject_filter_results() {
let mut vm = new_parsed_test_vm(
"https://traversal-sibling-filter.test/",
"<!doctype html><html><body><div id='root'><p><span>skip</span></p><section>target</section></div></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.getElementById("root");
const walker = document.createTreeWalker(
root,
NodeFilter.SHOW_ALL,
node => node.nodeType === Node.TEXT_NODE
);
walker.currentNode = root.firstChild;
const next = walker.nextSibling();
return [
next && next.nodeType,
next && next.data,
walker.currentNode === next
].join("|");
})()
"#,
)
.expect("TreeWalker sibling non-reject descent check should evaluate");
assert_eq!(result, "3|target|true");
}
#[test]
fn traversal_filter_from_removed_child_window_throws_before_callback() {
let mut vm = new_parsed_test_vm(
"https://traversal-detached-child-filter.test/",
"<!doctype html><html><body><div></div></body></html>",
);
vm.eval(
r#"
(() => {
const iframe = document.createElement("iframe");
iframe.srcdoc = `<script>
function createIterator() {
function filter() {
iterator.dummyFilterCalled = true;
return true;
}
const iterator = parent.document.createNodeIterator(parent.document.body, NodeFilter.SHOW_ELEMENT, filter);
iterator.dummyFilterCalled = false;
return iterator;
}
<\/script>`;
document.body.appendChild(iframe);
globalThis.__traversalChildFrame = iframe;
return "ready";
})()
"#,
)
.expect("detached child filter setup should evaluate");
vm.drain_pending_child_frame_work_for_test();
let result = vm
.eval(
r#"
(() => {
const iframe = globalThis.__traversalChildFrame;
const iterator = iframe.contentWindow.createIterator();
iframe.remove();
let threw = false;
try {
iterator.nextNode();
} catch (error) {
threw = true;
}
return [
iframe.contentWindow === null,
threw,
iterator.dummyFilterCalled
].join("|");
})()
"#,
)
.expect("detached child filter traversal should evaluate");
assert_eq!(result, "true|true|false");
}
#[test]
fn traversal_filter_ignores_public_child_context_marker_spoof() {
let mut vm = new_parsed_test_vm(
"https://traversal-filter-marker-spoof.test/",
"<!doctype html><html><body><div id='root'><p></p></div></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const doc = document;
const root = doc.createElement("div");
root.appendChild(doc.createElement("p"));
doc.body.appendChild(root);
window.__moliChildBrowsingContextHandle = 999999;
let calls = 0;
const iterator = doc.createNodeIterator(root, NodeFilter.SHOW_ELEMENT, {
acceptNode() {
calls++;
return NodeFilter.FILTER_ACCEPT;
}
});
let threw = false;
let first = null;
try {
first = iterator.nextNode();
} catch (error) {
threw = true;
}
delete window.__moliChildBrowsingContextHandle;
return [threw, first === root, calls].join("|");
})()
"#,
)
.expect("public child context marker spoof check should evaluate");
assert_eq!(result, "false|true|1");
}
#[test]
fn node_iterator_reference_tracks_removed_subtree() {
let mut vm = new_parsed_test_vm(
"https://node-iterator-removal.test/",
"<!doctype html><html><body><div id='root'><section id='a'><em id='x'></em></section><p id='b'></p></div></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.getElementById("root");
const a = document.getElementById("a");
const x = document.getElementById("x");
const b = document.getElementById("b");
const out = [];
const afterReference = document.createNodeIterator(root);
afterReference.nextNode(); // root, pointer after
afterReference.nextNode(); // a, pointer after
afterReference.nextNode(); // x, pointer after
out.push(afterReference.referenceNode === x);
a.remove();
out.push(afterReference.referenceNode === root);
out.push(afterReference.pointerBeforeReferenceNode === false);
out.push(afterReference.nextNode() === b);
root.insertBefore(a, b);
const beforeReference = document.createNodeIterator(root);
beforeReference.nextNode(); // root, pointer after
beforeReference.nextNode(); // a, pointer after
beforeReference.previousNode(); // a, pointer before
out.push(beforeReference.referenceNode === a);
out.push(beforeReference.pointerBeforeReferenceNode === true);
a.remove();
out.push(beforeReference.referenceNode === b);
out.push(beforeReference.pointerBeforeReferenceNode === true);
out.push(beforeReference.nextNode() === b);
return out.join(",");
})()
"#,
)
.expect("node iterator removal tracking checks should evaluate");
assert_eq!(result, "true,true,true,true,true,true,true,true,true");
}
#[test]
fn tree_walker_previous_node_handles_regrafted_current_node() {
let mut vm = new_parsed_test_vm(
"https://tree-walker-regraft.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const doc = document.createElement("div");
const head = document.createElement("head");
const title = document.createElement("title");
const body = document.createElement("body");
const p = document.createElement("p");
doc.appendChild(head);
head.appendChild(title);
doc.appendChild(body);
body.appendChild(p);
const walker = document.createTreeWalker(body, NodeFilter.SHOW_ALL, null);
doc.removeChild(body);
const out = [];
out.push(walker.lastChild() === p);
doc.appendChild(p);
out.push(walker.previousNode() === title);
p.appendChild(body);
out.push(walker.nextNode() === p);
out.push(walker.nextNode() === body);
out.push(walker.previousNode() === null);
return out.join(",");
})()
"#,
)
.expect("tree walker regraft checks should evaluate");
assert_eq!(result, "true,true,true,true,true");
}
#[test]
fn traversal_filter_errors_and_node_filter_surface_match_webidl() {
let mut vm = new_parsed_test_vm(
"https://traversal-filter-errors.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.createElement("div");
const child = document.createElement("span");
root.appendChild(child);
document.body.appendChild(root);
const out = [
"FILTER_ACCEPT" in NodeFilter,
NodeFilter.FILTER_ACCEPT === 1,
NodeFilter.SHOW_ALL === 0xFFFFFFFF,
Object.getPrototypeOf(NodeFilter) === Function.prototype,
typeof NodeFilter === "function"
];
function record(label, callback) {
try {
callback();
out.push(`${label}:no`);
} catch (error) {
out.push(`${label}:${error.name}`);
}
}
const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null);
record("current-null", () => { walker.currentNode = null; });
out.push(walker.currentNode === root);
const missing = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {});
record("missing-acceptNode", () => missing.firstChild());
out.push(missing.currentNode === root);
const nonCallable = document.createTreeWalker(
root,
NodeFilter.SHOW_ELEMENT,
{ acceptNode: "no" }
);
record("noncallable-acceptNode", () => nonCallable.firstChild());
out.push(nonCallable.currentNode === root);
return out.join(",");
})()
"#,
)
.expect("traversal filter error probe should evaluate");
assert_eq!(
result,
"true,true,true,true,true,current-null:TypeError,true,missing-acceptNode:TypeError,true,noncallable-acceptNode:TypeError,true"
);
}
#[test]
fn traversal_from_live_root_preserves_adopted_detached_wrapper_identity() {
let mut vm = new_parsed_test_vm(
"https://traversal-adopted-detached.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const source = new Document();
const first = source.createCDATASection("first");
const second = source.createCDATASection("second");
const parent = document.createElement("p");
parent.appendChild(first);
parent.appendChild(second);
document.body.appendChild(parent);
const filterIdentities = [];
const iterator = document.createNodeIterator(
document,
NodeFilter.SHOW_CDATA_SECTION,
node => {
filterIdentities.push(node === first || node === second);
return NodeFilter.FILTER_ACCEPT;
}
);
const firstResult = iterator.nextNode();
const secondResult = iterator.nextNode();
const walkerFilterIdentities = [];
const walker = document.createTreeWalker(
document,
NodeFilter.SHOW_CDATA_SECTION,
node => {
walkerFilterIdentities.push(node === first || node === second);
return NodeFilter.FILTER_ACCEPT;
}
);
const firstWalked = walker.nextNode();
const secondWalked = walker.nextNode();
return [
parent.firstChild === first,
parent.lastChild === second,
firstResult === first,
secondResult === second,
iterator.referenceNode === second,
filterIdentities.length === 2 && filterIdentities.every(Boolean),
firstWalked === first,
secondWalked === second,
walker.currentNode === second,
walkerFilterIdentities.length === 2 && walkerFilterIdentities.every(Boolean)
].join(",");
})()
"#,
)
.expect("adopted detached traversal wrapper identity probe should evaluate");
assert_eq!(result, "true,true,true,true,true,true,true,true,true,true");
}
#[test]
fn traversal_results_preserve_foreign_wrapper_identity() {
let mut vm = new_parsed_test_vm(
"https://traversal-foreign.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const doc = new DOMParser().parseFromString(
"<html><body><div id='r'><span id='a'></span><span id='b'></span></div></body></html>",
"text/html"
);
const root = doc.getElementById("r");
const a = doc.getElementById("a");
const b = doc.getElementById("b");
const out = [];
const iter = document.createNodeIterator(root, NodeFilter.SHOW_ELEMENT, null);
out.push(iter.root === root);
out.push(iter.referenceNode === root);
const n1 = iter.nextNode();
out.push(n1 === root);
const n2 = iter.nextNode();
out.push(n2 === a);
const n3 = iter.nextNode();
out.push(n3 === b);
out.push(iter.referenceNode === b);
const p = iter.previousNode();
out.push(p === b);
const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null);
out.push(walker.root === root);
out.push(walker.currentNode === root);
const fc = walker.firstChild();
out.push(fc === a);
out.push(walker.currentNode === a);
const ns = walker.nextSibling();
out.push(ns === b);
const par = walker.parentNode();
out.push(par === root);
return out.join(",");
})()
"#,
)
.expect("foreign-root traversal identity probe should evaluate");
assert_eq!(
result,
"true,true,true,true,true,true,true,true,true,true,true,true,true"
);
}
#[test]
fn traversal_foreign_materialization_preserves_source_tree_and_removal_cursors() {
let mut vm = new_parsed_test_vm(
"https://traversal-foreign-removal.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const foreignDoc = document.implementation.createHTMLDocument("");
const p1 = foreignDoc.createElement("p");
p1.appendChild(foreignDoc.createTextNode("one"));
const p2 = foreignDoc.createElement("p");
p2.appendChild(foreignDoc.createTextNode("two"));
foreignDoc.body.appendChild(p1);
foreignDoc.body.appendChild(p2);
const sourceProbe = document.createNodeIterator(p1, NodeFilter.SHOW_ALL, null);
sourceProbe.nextNode();
sourceProbe.nextNode();
const sourceStillLinked =
p1.parentNode === foreignDoc.body &&
foreignDoc.body.firstChild === p1 &&
p1.nextSibling === p2;
const docIterator = document.createNodeIterator(foreignDoc, NodeFilter.SHOW_ALL, null);
for (let i = 0; i < 8; i++) docIterator.nextNode();
foreignDoc.body.removeChild(p1);
const docCursorAdjusted =
docIterator.referenceNode === foreignDoc.body &&
docIterator.pointerBeforeReferenceNode === false;
const childIterator = document.createNodeIterator(p2, NodeFilter.SHOW_ALL, null);
childIterator.nextNode();
childIterator.nextNode();
const text = p2.firstChild;
p2.removeChild(text);
const childCursorAdjusted =
childIterator.referenceNode === p2 &&
childIterator.pointerBeforeReferenceNode === false;
return [sourceStillLinked, docCursorAdjusted, childCursorAdjusted].join(",");
})()
"#,
)
.expect("foreign traversal removal probe should evaluate");
assert_eq!(result, "true,true,true");
}
#[test]
fn node_iterator_filter_runs_incrementally_per_step() {
let mut vm = new_parsed_test_vm(
"https://node-iterator-incremental.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r#"
(() => {
const root = document.createElement("div");
root.id = "r";
for (const id of ["a", "b", "c"]) {
const child = document.createElement("span");
child.id = id;
root.appendChild(child);
}
document.body.appendChild(root);
const calls = [];
const iterator = document.createNodeIterator(
root,
NodeFilter.SHOW_ELEMENT,
{
acceptNode(node) {
calls.push(node.id);
return NodeFilter.FILTER_ACCEPT;
}
}
);
const first = iterator.nextNode();
const firstCalls = calls.slice();
const second = iterator.nextNode();
const secondCalls = calls.slice();
calls.length = 0;
const previous = iterator.previousNode();
return [
first.id,
firstCalls.join(","),
second.id,
secondCalls.join(","),
previous.id,
calls.join(",")
].join("|");
})()
"#,
)
.expect("NodeIterator incremental filter probe should evaluate");
assert_eq!(result, "r|r|a|r,a|a|a");
}
#[test]
fn node_iterator_reference_node_updates_before_removing_subtree() {
let mut vm = new_parsed_test_vm(
"https://node-iterator-removal.test/",
"<!doctype html><html><body></body></html>",
);
let result = vm
.eval(
r##"
(() => {
const out = [];
{
const root = document.createElement("div");
root.innerHTML = "<section id='a'><span id='b'></span></section><p id='c'></p>";
document.body.appendChild(root);
const a = root.querySelector("#a");
const b = root.querySelector("#b");
const iter = document.createNodeIterator(root, NodeFilter.SHOW_ELEMENT);
iter.nextNode();
iter.nextNode();
iter.nextNode();
if (iter.referenceNode !== b || iter.pointerBeforeReferenceNode) {
return "setup-after";
}
a.remove();
out.push(`after:${iter.referenceNode === root}:${iter.pointerBeforeReferenceNode}`);
root.remove();
}
{
const root = document.createElement("div");
root.innerHTML = "<section id='a'><span id='b'></span></section><p id='c'></p>";
document.body.appendChild(root);
const a = root.querySelector("#a");
const b = root.querySelector("#b");
const c = root.querySelector("#c");
const iter = document.createNodeIterator(root, NodeFilter.SHOW_ELEMENT);
iter.nextNode();
iter.nextNode();
iter.nextNode();
iter.previousNode();
if (iter.referenceNode !== b || !iter.pointerBeforeReferenceNode) {
return "setup-before-next";
}
a.remove();
out.push(`before-next:${iter.referenceNode === c}:${iter.pointerBeforeReferenceNode}`);
root.remove();
}
{
const root = document.createElement("div");
root.innerHTML = "<section id='a'><span id='b'></span></section>";
document.body.appendChild(root);
const a = root.querySelector("#a");
const b = root.querySelector("#b");
const iter = document.createNodeIterator(root, NodeFilter.SHOW_ELEMENT);
iter.nextNode();
iter.nextNode();
iter.nextNode();
iter.previousNode();
if (iter.referenceNode !== b || !iter.pointerBeforeReferenceNode) {
return "setup-before-none";
}
a.remove();
out.push(`before-none:${iter.referenceNode === root}:${iter.pointerBeforeReferenceNode}`);
root.remove();
}
{
const outer = document.createElement("div");
outer.innerHTML = "<section id='a'><span id='b'></span></section>";
document.body.appendChild(outer);
const root = outer.querySelector("#a");
const b = outer.querySelector("#b");
const iter = document.createNodeIterator(root, NodeFilter.SHOW_ELEMENT);
iter.nextNode();
iter.nextNode();
if (iter.referenceNode !== b || iter.pointerBeforeReferenceNode) {
return "setup-ancestor-root";
}
outer.remove();
out.push(`ancestor-root:${iter.referenceNode === b}:${iter.pointerBeforeReferenceNode}`);
}
return out.join("|");
})()
"##,
)
.expect("NodeIterator removal fixup probe should evaluate");
assert_eq!(
result,
"after:true:false|before-next:true:true|before-none:true:false|ancestor-root:true:false"
);
}
#[test]
fn tree_walker_uses_child_document_wrappers_for_child_document_roots() {
let mut vm = new_storage_test_vm("https://traversal-child-realm.test/");
let result = vm
.eval(
r#"
(() => {
const iframe = document.createElement("iframe");
iframe.srcdoc = "<!DOCTYPE html>";
(document.body || document.documentElement || document).appendChild(iframe);
const walker = document.createTreeWalker(
iframe.contentDocument,
NodeFilter.SHOW_ELEMENT
);
const next = walker.nextNode();
const iterator = document.createNodeIterator(
iframe.contentDocument,
NodeFilter.SHOW_ELEMENT
);
const iteratorElement = iterator.nextNode();
let acceptNodeNode;
const filtered = document.createTreeWalker(
iframe.contentDocument,
NodeFilter.SHOW_ELEMENT,
{
acceptNode(node) {
acceptNodeNode = node;
return NodeFilter.FILTER_ACCEPT;
}
}
);
const filteredNext = filtered.nextNode();
return [
next && next.localName,
walker.currentNode === next,
walker.currentNode instanceof iframe.contentWindow.Node,
iteratorElement && iteratorElement.localName,
iteratorElement instanceof iframe.contentWindow.Node,
filteredNext && filteredNext.localName,
acceptNodeNode && acceptNodeNode.localName,
acceptNodeNode instanceof iframe.contentWindow.Node,
filtered.currentNode instanceof iframe.contentWindow.Node
].join("|");
})()
"#,
)
.expect("child document TreeWalker realm probe should evaluate");
assert_eq!(result, "html|true|true|html|true|html|html|true|true");
}
#[tokio::test]
async fn interrupted_intercepted_traversal_rejects_finished_after_commit() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm =
new_storage_page_task_executor_test_vm_with_loader("https://example.com/base", &loader);
let setup = vm
.eval(
r##"
(() => {
globalThis.__lmInterruptedTraversal = { log: [] };
navigation.navigate("#one");
navigation.onnavigate = event => event.intercept();
navigation.oncurrententrychange = event => {
if (event.navigationType === "traverse") {
globalThis.__lmInterruptedTraversal.log.push(`change:${location.hash}`);
navigation.navigate("#two");
}
};
const result = navigation.back();
result.committed.then(
() => globalThis.__lmInterruptedTraversal.log.push(`committed:${location.hash}`),
error => globalThis.__lmInterruptedTraversal.log.push(`committed-rejected:${error.name}`)
);
result.finished.then(
() => globalThis.__lmInterruptedTraversal.log.push("finished"),
error => globalThis.__lmInterruptedTraversal.log.push(`finished-rejected:${error.name}:${location.hash}`)
);
return globalThis.__lmInterruptedTraversal.log.join("|");
})()
"##,
)
.expect("interrupted traversal setup should evaluate");
assert_eq!(setup, "");
assert!(
vm.run_one_history_traversal_executor_turn(&loader)
.await
.expect("queued interrupted traversal should run")
);
let settled = vm
.eval("globalThis.__lmInterruptedTraversal.log.join('|')")
.expect("interrupted traversal settlement should evaluate");
assert_eq!(
settled,
"change:|committed:#two|finished-rejected:AbortError:#two"
);
}
#[tokio::test]
async fn traversal_intercept_settlement_promise_ignores_prototype_setter_spoof() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm =
new_storage_page_task_executor_test_vm_with_loader("https://example.com/base", &loader);
let setup = vm
.eval(
r##"
(() => {
globalThis.__lmTraversalPrivatePayload = { log: [] };
const log = globalThis.__lmTraversalPrivatePayload.log;
const record = name => log.push(`${name}:${location.hash}`);
Object.defineProperties(Object.prototype, {
__lmTraversalInterceptActive: { configurable: true, value: false },
__lmTraversalInterceptUrl: { configurable: true, value: "spoof-url" },
__lmTraversalInterceptPromise: {
configurable: true,
get() {
record("prototype-promise-get");
return undefined;
},
set() {
record("prototype-promise-set");
}
}
});
record(`spoof:${Object.prototype.__lmTraversalInterceptActive}:${Object.prototype.__lmTraversalInterceptUrl}`);
navigation.navigate("#one");
navigation.onnavigate = event => {
record(`navigate:${event.navigationType}`);
if (event.navigationType === "traverse") {
event.intercept({
handler() {
record("handler");
return new Promise(resolve => setTimeout(() => {
record("handler-timeout");
resolve("done");
}, 0));
}
});
}
};
const result = navigation.back();
result.committed.then(
entry => log.push(`committed:${location.hash}:${entry.index}`),
error => log.push(`committed-rejected:${error.name}`)
);
result.finished.then(
entry => log.push(`finished:${location.hash}:${entry.index}`),
error => log.push(`finished-rejected:${error.name}:${location.hash}`)
);
return log.join("|");
})()
"##,
)
.expect("traversal intercept private payload setup should evaluate");
assert_eq!(setup, "spoof:false:spoof-url:");
assert!(
vm.run_one_history_traversal_executor_turn(&loader)
.await
.expect("queued intercepted traversal should run")
);
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("traversal intercept handler timer should drain");
let settled = vm
.eval("globalThis.__lmTraversalPrivatePayload.log.join('|')")
.expect("traversal intercept private payload log should evaluate");
assert_eq!(
settled,
"spoof:false:spoof-url:|navigate:traverse:#one|handler:|committed::0|handler-timeout:|finished::0"
);
}
#[tokio::test]
async fn closed_history_traversal_route_rejects_navigation_promises_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##"history.pushState(null, "", "#one"); "created""##)
.expect("history route-retirement fixture should create an entry");
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("entry-creation fixture timers should drain");
drop(
vm._page_task_residence_for_executor_test
.take()
.expect("history route-retirement fixture should own one production consumer"),
);
vm.eval(
r#"
globalThis.__lmClosedHistoryRoute = [];
const result = navigation.back();
result.committed.catch(error => __lmClosedHistoryRoute.push("committed:" + error.name));
result.finished.catch(error => __lmClosedHistoryRoute.push("finished:" + error.name));
"queued"
"#,
)
.expect("closed history route should reject instead of falling back");
assert_eq!(
vm.eval("__lmClosedHistoryRoute.join('|')")
.expect("closed history route rejections should settle"),
"committed:AbortError|finished:AbortError"
);
assert!(
!vm.has_ready_timeout(),
"a closed history source must not recreate the removed timer transport"
);
}
#[tokio::test]
async fn history_back_calls_from_default_and_isolated_world_preserve_each_step() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
for isolated_calls in [[false, false], [false, true], [true, false], [true, true]] {
let mut vm =
new_storage_page_task_executor_test_vm_with_loader("https://example.com/base", &loader);
vm.eval(
r##"
history.pushState(null, "", "#one");
history.pushState(null, "", "#two");
globalThis.traversed = [];
addEventListener("popstate", () => traversed.push(location.hash));
"created"
"##,
)
.expect("multi-realm history fixture should create entries");
vm.advance_timers_until_deadline_for_test(&loader)
.await
.expect("multi-realm entry-creation timers should drain");
let isolated_context_id = vm
.create_isolated_world("history-traversal-owner", false)
.expect("history traversal isolated world should be created");
for (script, destinations) in [
("history.back(); 'queued'", ["#one", ""]),
("history.forward(); 'queued'", ["#one", "#two"]),
] {
for isolated in isolated_calls {
if isolated {
vm.eval_in_isolated_context(isolated_context_id, script)
} else {
vm.eval(script)
}
.expect("each realm should queue its own traversal");
}
assert!(
!vm.has_ready_timeout(),
"neither realm should route history traversal through PageTimer"
);
for destination in destinations {
assert!(
vm.run_one_history_traversal_executor_turn(&loader)
.await
.expect("each queued traversal should run")
);
assert_eq!(
vm.eval("location.hash")
.expect("each queued traversal should preserve its destination"),
destination,
"isolated calls: {isolated_calls:?}, script: {script}"
);
}
assert!(
!vm.run_one_history_traversal_executor_turn(&loader)
.await
.expect("history source should be drained after both traversals")
);
}
assert_eq!(
vm.eval("traversed.join('|')")
.expect("each step should dispatch popstate on the owning Window"),
"#one||#one|#two",
"isolated calls: {isolated_calls:?}"
);
}
}