Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::*;
use crate::native::DomHost;
fn test_url() -> url::Url {
url::Url::parse("https://serialization.test/").expect("test URL")
}
fn scripting_enabled(_: NativeNodeId) -> bool {
true
}
#[test]
fn html_serializers_share_the_complete_void_element_set() {
let mut dom = NativeDom::new_html(test_url());
let container = dom.create_element("div");
let mut expected = String::new();
let mut void_elements = Vec::new();
for local_name in [
"area", "base", "basefont", "bgsound", "br", "col", "embed", "frame", "hr", "img", "input",
"keygen", "link", "meta", "param", "source", "track", "wbr",
] {
let element = dom.create_element(local_name);
let ignored_child = dom.create_element("span");
assert!(dom.append_child(element, ignored_child));
assert_eq!(dom.outer_html(element), Some(format!("<{local_name}>")));
assert_eq!(dom.inner_html(element).as_deref(), Some(""));
assert!(dom.append_child(container, element));
expected.push_str(&format!("<{local_name}>"));
void_elements.push(element);
}
assert_eq!(
dom.inner_html(container).as_deref(),
Some(expected.as_str())
);
let foreign_param = dom
.create_element_ns(Some("http://www.w3.org/2000/svg"), "param")
.expect("SVG element");
assert_eq!(
dom.outer_html(foreign_param).as_deref(),
Some("<param></param>")
);
let mut host = DomHost::from_dom(dom);
let param = host.create_element("param");
assert!(host.append_child(container, param));
assert_eq!(
host.get_html(container, &scripting_enabled, false, &[])
.as_deref(),
Some(format!("{expected}<param>").as_str())
);
for element in void_elements {
assert_eq!(
host.get_html(element, &scripting_enabled, false, &[])
.as_deref(),
Some("")
);
}
}
#[test]
fn html_text_serialization_uses_the_actual_parent_and_scripting_mode() {
let mut dom = NativeDom::new_html(test_url());
let container = dom.create_element("main");
let mut cases = Vec::new();
for (local_name, literal_with_scripting, literal_without_scripting) in [
("style", true, true),
("script", true, true),
("xmp", true, true),
("iframe", true, true),
("noembed", true, true),
("noframes", true, true),
("plaintext", true, true),
("noscript", true, false),
("textarea", false, false),
("title", false, false),
("div", false, false),
] {
let element = dom.create_element(local_name);
let text = dom.create_text_node("<&");
assert!(dom.append_child(element, text));
assert!(dom.append_child(container, element));
cases.push((
element,
local_name,
literal_with_scripting,
literal_without_scripting,
));
}
for &(element, _, literal_with_scripting, literal_without_scripting) in &cases {
assert_eq!(
dom.inner_html_with_scripting_enabled(element, true)
.as_deref(),
Some(if literal_with_scripting {
"<&"
} else {
"<&"
})
);
assert_eq!(
dom.inner_html_with_scripting_enabled(element, false)
.as_deref(),
Some(if literal_without_scripting {
"<&"
} else {
"<&"
})
);
}
let host = DomHost::from_dom(dom);
for &(element, local_name, literal_with_scripting, literal_without_scripting) in &cases {
for (scripting_enabled, literal) in [
(true, literal_with_scripting),
(false, literal_without_scripting),
] {
let scripting_enabled_for_node = |_: NativeNodeId| scripting_enabled;
let contents = if literal { "<&" } else { "<&" };
assert_eq!(
host.get_html_with_shadow_root_registry_attribute_policy(
element,
&scripting_enabled_for_node,
false,
&[],
None,
)
.as_deref(),
Some(contents),
"children-only serialization diverged for {local_name}"
);
assert_eq!(
host.outer_html_with_shadow_roots(
element,
&scripting_enabled_for_node,
crate::native::ShadowRootInclusion::None,
None,
),
Some(format!("<{local_name}>{contents}</{local_name}>")),
"node serialization diverged for {local_name}"
);
}
}
}
#[test]
fn html_serialization_queries_scripting_state_for_each_noscript_text_node() {
let mut host = DomHost::from_dom(NativeDom::new_html(test_url()));
let container = host.create_element("main");
let enabled_noscript = host.create_element("noscript");
let enabled_text = host.create_text_node("<enabled&>");
let disabled_noscript = host.create_element("noscript");
let disabled_text = host.create_text_node("<disabled&>");
assert!(host.append_child(enabled_noscript, enabled_text));
assert!(host.append_child(disabled_noscript, disabled_text));
assert!(host.append_child(container, enabled_noscript));
assert!(host.append_child(container, disabled_noscript));
let scripting_enabled_for_node = |node| node == enabled_text;
let expected = concat!(
"<noscript><enabled&></noscript>",
"<noscript><disabled&></noscript>"
);
assert_eq!(
host.get_html_with_shadow_root_registry_attribute_policy(
container,
&scripting_enabled_for_node,
false,
&[],
None,
)
.as_deref(),
Some(expected)
);
assert_eq!(
host.outer_html_with_shadow_roots(
container,
&scripting_enabled_for_node,
crate::native::ShadowRootInclusion::None,
None,
),
Some(format!("<main>{expected}</main>"))
);
}
#[test]
fn bounded_outer_html_stops_before_exceeding_the_output_limit() {
let mut dom = NativeDom::new_html(test_url());
let element = dom.create_element("div");
let expected = "<div></div>";
assert_eq!(
dom.outer_html_with_limit(element, expected.len()),
Ok(Some(expected.to_owned()))
);
assert_eq!(
dom.outer_html_with_limit(element, expected.len() - 1),
Err(HtmlSerializationLimitExceeded {
max_bytes: expected.len() - 1,
})
);
}
#[test]
fn html_serializers_apply_attribute_serialized_name_rules() {
let mut dom = NativeDom::new_html(test_url());
let container = dom.create_element("section");
let element = dom
.create_element_ns(Some("urn:element"), "div")
.expect("namespaced element");
assert!(dom.set_attribute_ns(
element,
Some("http://www.w3.org/XML/1998/namespace"),
Some("alternate"),
"lang",
"en-us",
));
assert!(dom.set_attribute_ns(
element,
Some("http://www.w3.org/2000/xmlns/"),
None,
"binding",
"urn:binding",
));
assert!(dom.set_attribute_ns(
element,
Some("http://www.w3.org/2000/xmlns/"),
None,
"xmlns",
"urn:default",
));
assert!(dom.set_attribute_ns(
element,
Some("http://www.w3.org/1999/xlink"),
Some("alternate"),
"href",
"target",
));
assert!(dom.set_attribute_ns(element, Some("urn:custom"), Some("p"), "attr", "value",));
assert!(dom.append_child(container, element));
let expected = concat!(
"<div xml:lang=\"en-us\" xmlns:binding=\"urn:binding\" ",
"xmlns=\"urn:default\" xlink:href=\"target\" p:attr=\"value\"></div>"
);
assert_eq!(dom.inner_html(container).as_deref(), Some(expected));
let host = DomHost::from_dom(dom);
assert_eq!(
host.get_html(container, &scripting_enabled, false, &[])
.as_deref(),
Some(expected)
);
}
#[test]
fn html_serializers_escape_non_breaking_spaces_in_attribute_values() {
let mut dom = NativeDom::new_html(test_url());
let container = dom.create_element("span");
let element = dom.create_element("a");
assert!(dom.set_attribute(element, "b", "&\"\u{a0}<>"));
assert!(dom.append_child(container, element));
let expected = r#"<a b="&" <>"></a>"#;
assert_eq!(dom.outer_html(element).as_deref(), Some(expected));
assert_eq!(dom.inner_html(container).as_deref(), Some(expected));
let host = DomHost::from_dom(dom);
assert_eq!(
host.get_html(container, &scripting_enabled, false, &[])
.as_deref(),
Some(expected)
);
}
#[test]
fn html_serializers_escape_adopted_cdata_as_text() {
const SVG_NAMESPACE: &str = "http://www.w3.org/2000/svg";
const XMLNS_NAMESPACE: &str = "http://www.w3.org/2000/xmlns/";
let mut xml_dom = NativeDom::new_xml(test_url());
let xml_svg = xml_dom
.create_element_ns(Some(SVG_NAMESPACE), "svg")
.expect("XML SVG element");
assert!(
xml_dom.set_attribute_ns(xml_svg, Some(XMLNS_NAMESPACE), None, "xmlns", SVG_NAMESPACE,)
);
let xml_cdata = xml_dom.create_cdata_section("<img>&");
assert!(xml_dom.append_child(xml_svg, xml_cdata));
assert_eq!(
xml_dom.outer_html(xml_svg).as_deref(),
Some(r#"<svg xmlns="http://www.w3.org/2000/svg"><![CDATA[<img>&]]></svg>"#)
);
let mut html_dom = NativeDom::new_html(test_url());
let html_svg = html_dom
.create_element_ns(Some(SVG_NAMESPACE), "svg")
.expect("HTML-document SVG element");
assert!(html_dom.set_attribute_ns(
html_svg,
Some(XMLNS_NAMESPACE),
None,
"xmlns",
SVG_NAMESPACE,
));
let adopted_cdata = html_dom.create_cdata_section("<img>&");
assert!(html_dom.append_child(html_svg, adopted_cdata));
assert_eq!(
html_dom.outer_html(html_svg).as_deref(),
Some(r#"<svg xmlns="http://www.w3.org/2000/svg"><img>&</svg>"#)
);
let host = DomHost::from_dom(html_dom);
assert_eq!(
host.get_html(html_svg, &scripting_enabled, false, &[])
.as_deref(),
Some("<img>&")
);
}