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::{
Attribute, CustomElementState, Element, html_element_interface_name,
mathml_element_interface_name, svg_element_interface_name,
};
use crate::native::NativeNodeId;
#[test]
fn ordinary_elements_keep_control_state_unmaterialized_until_needed() {
let mut div = Element::new_html("div");
assert!(!div.rare_data.is_materialized());
// Reading default state must not allocate an element-owned rare payload.
assert_eq!(div.scroll_top(), 0.0);
assert!(!div.set_scroll_top(0.0));
assert!(!div.set_scroll_left(0.0));
assert!(!div.set_cryptographic_nonce(None));
assert!(!div.popover_open());
assert!(div.custom_states().is_empty());
assert!(!div.rare_data.is_materialized());
// Unrelated parser/DOM attributes must stay on the common element path.
assert!(div.set_attribute("class".to_owned(), String::new(), None, "card".to_owned(),));
assert!(!div.rare_data.is_materialized());
assert!(div.set_scroll_top(12.0));
assert_eq!(div.scroll_top(), 12.0);
assert!(div.rare_data.is_materialized());
}
#[test]
fn stateful_element_kinds_materialize_control_state_during_construction() {
for local_name in ["input", "textarea", "option", "audio", "video", "script"] {
let element = Element::new_html(local_name);
assert!(
element.rare_data.is_materialized(),
"{local_name} requires initial control state"
);
}
}
#[test]
fn nonce_attribute_materializes_rare_state_without_affecting_unrelated_attributes() {
let mut div = Element::new_html("div");
assert!(div.set_attribute("nonce".to_owned(), String::new(), None, "token".to_owned(),));
assert_eq!(div.cryptographic_nonce(), Some("token"));
assert!(div.rare_data.is_materialized());
assert!(div.remove_attribute("nonce"));
assert_eq!(div.cryptographic_nonce(), None);
}
#[test]
fn cloned_elements_do_not_share_materialized_rare_state() {
let mut original = Element::new_html("div");
assert!(original.set_scroll_top(12.0));
assert!(original.set_custom_element_is_name(Some("fancy-div".to_owned())));
let mut cloned = original.clone();
assert!(cloned.set_scroll_top(24.0));
assert!(cloned.set_custom_element_is_name(Some("other-div".to_owned())));
assert_eq!(original.scroll_top(), 12.0);
assert_eq!(cloned.scroll_top(), 24.0);
assert_eq!(original.custom_element_is_name(), Some("fancy-div"));
assert_eq!(cloned.custom_element_is_name(), Some("other-div"));
}
#[test]
fn custom_element_is_name_uses_and_releases_rare_data() {
let mut button = Element::new_html("button");
assert!(!button.rare_data.is_materialized());
assert!(button.set_custom_element_is_name(Some("fancy-button".to_owned())));
assert_eq!(button.custom_element_is_name(), Some("fancy-button"));
assert!(button.rare_data.is_materialized());
assert!(button.set_custom_element_is_name(None));
assert_eq!(button.custom_element_is_name(), None);
assert!(!button.rare_data.is_materialized());
}
#[test]
fn parser_associated_form_owner_uses_and_releases_rare_data() {
let mut button = Element::new_html("button");
let owner = NativeNodeId::new(42);
assert!(!button.rare_data.is_materialized());
assert!(button.set_parser_associated_form_owner(Some(owner)));
assert_eq!(button.parser_associated_form_owner(), Some(owner));
assert!(button.rare_data.is_materialized());
assert!(button.set_parser_associated_form_owner(None));
assert_eq!(button.parser_associated_form_owner(), None);
assert!(!button.rare_data.is_materialized());
}
#[test]
fn custom_element_state_uses_and_releases_rare_data() {
let mut div = Element::new_html("div");
assert_eq!(div.custom_element_state(), CustomElementState::Uncustomized);
assert!(!div.rare_data.is_materialized());
assert!(div.set_custom_element_state(CustomElementState::Undefined));
assert_eq!(div.custom_element_state(), CustomElementState::Undefined);
assert!(div.rare_data.is_materialized());
assert!(div.set_custom_element_state(CustomElementState::Custom));
assert_eq!(div.custom_element_state(), CustomElementState::Custom);
assert!(div.set_custom_element_state(CustomElementState::Uncustomized));
assert!(!div.rare_data.is_materialized());
}
#[test]
fn custom_element_candidates_materialize_their_initial_state() {
let autonomous = Element::new_html("fancy-card");
assert_eq!(
autonomous.custom_element_state(),
CustomElementState::Undefined
);
assert!(autonomous.rare_data.is_materialized());
let customized_builtin = Element::new(
"button".to_owned(),
"http://www.w3.org/1999/xhtml".to_owned(),
None,
vec![Attribute::new(
"is".to_owned(),
String::new(),
None,
"fancy-button".to_owned(),
)],
);
assert_eq!(
customized_builtin.custom_element_state(),
CustomElementState::Undefined
);
assert!(customized_builtin.rare_data.is_materialized());
}
#[test]
fn template_contents_uses_and_releases_rare_data() {
let mut template = Element::new_html("template");
let contents = NativeNodeId::new(7);
assert_eq!(template.template_contents(), None);
assert!(!template.rare_data.is_materialized());
template.set_template_contents(Some(contents));
assert_eq!(template.template_contents(), Some(contents));
assert!(template.rare_data.is_materialized());
template.set_template_contents(None);
assert_eq!(template.template_contents(), None);
assert!(!template.rare_data.is_materialized());
}
#[test]
fn element_reference_state_is_owned_by_the_content_attribute() {
let mut element = Element::new_html("div");
assert!(element.set_attribute("commandfor".to_owned(), String::new(), None, String::new(),));
element.set_explicit_element_references("commandfor", vec![NativeNodeId::new(7)]);
assert!(!element.set_attribute("commandfor".to_owned(), String::new(), None, String::new(),));
assert_eq!(element.explicit_element_references("commandfor"), None);
element.set_explicit_element_references("commandfor", vec![NativeNodeId::new(8)]);
assert!(element.set_attribute_ns(
"commandfor".to_owned(),
"urn:example".to_owned(),
Some("x".to_owned()),
"foreign".to_owned(),
));
assert_eq!(
element.explicit_element_references("commandfor"),
Some([NativeNodeId::new(8)].as_slice())
);
assert!(element.remove_attribute("commandfor"));
assert_eq!(element.explicit_element_references("commandfor"), None);
assert!(element.set_attribute(
"popovertarget".to_owned(),
String::new(),
None,
String::new(),
));
element.set_explicit_element_references("popovertarget", vec![NativeNodeId::new(9)]);
assert!(!element.set_attribute(
"popovertarget".to_owned(),
String::new(),
None,
String::new(),
));
assert_eq!(element.explicit_element_references("popovertarget"), None);
}
#[test]
fn html_element_interface_name_covers_replay_tags() {
assert_eq!(html_element_interface_name("meta"), "HTMLMetaElement");
assert_eq!(html_element_interface_name("span"), "HTMLSpanElement");
assert_eq!(
html_element_interface_name("tbody"),
"HTMLTableSectionElement"
);
assert_eq!(html_element_interface_name("tr"), "HTMLTableRowElement");
assert_eq!(html_element_interface_name("slot"), "HTMLSlotElement");
assert_eq!(html_element_interface_name("applet"), "HTMLUnknownElement");
assert_eq!(
html_element_interface_name("menuitem"),
"HTMLUnknownElement"
);
assert_eq!(html_element_interface_name("section"), "HTMLElement");
assert_eq!(html_element_interface_name("basefont"), "HTMLElement");
assert_eq!(html_element_interface_name("wbr"), "HTMLElement");
assert_eq!(html_element_interface_name("unknown"), "HTMLUnknownElement");
assert_eq!(html_element_interface_name("hi"), "HTMLUnknownElement");
assert_eq!(html_element_interface_name("x-foo"), "HTMLElement");
}
#[test]
fn svg_element_interface_name_specializes_standard_elements() {
assert_eq!(svg_element_interface_name("a"), "SVGAElement");
assert_eq!(svg_element_interface_name("circle"), "SVGCircleElement");
assert_eq!(svg_element_interface_name("clipPath"), "SVGClipPathElement");
assert_eq!(svg_element_interface_name("defs"), "SVGDefsElement");
assert_eq!(svg_element_interface_name("desc"), "SVGDescElement");
assert_eq!(svg_element_interface_name("ellipse"), "SVGEllipseElement");
assert_eq!(svg_element_interface_name("feBlend"), "SVGFEBlendElement");
assert_eq!(
svg_element_interface_name("feColorMatrix"),
"SVGFEColorMatrixElement"
);
assert_eq!(
svg_element_interface_name("feComposite"),
"SVGFECompositeElement"
);
assert_eq!(
svg_element_interface_name("feConvolveMatrix"),
"SVGFEConvolveMatrixElement"
);
assert_eq!(
svg_element_interface_name("feDiffuseLighting"),
"SVGFEDiffuseLightingElement"
);
assert_eq!(
svg_element_interface_name("feDisplacementMap"),
"SVGFEDisplacementMapElement"
);
assert_eq!(
svg_element_interface_name("feDistantLight"),
"SVGFEDistantLightElement"
);
assert_eq!(
svg_element_interface_name("feDropShadow"),
"SVGFEDropShadowElement"
);
assert_eq!(svg_element_interface_name("feFuncA"), "SVGFEFuncAElement");
assert_eq!(svg_element_interface_name("feFuncB"), "SVGFEFuncBElement");
assert_eq!(svg_element_interface_name("feFuncG"), "SVGFEFuncGElement");
assert_eq!(svg_element_interface_name("feFuncR"), "SVGFEFuncRElement");
assert_eq!(
svg_element_interface_name("feGaussianBlur"),
"SVGFEGaussianBlurElement"
);
assert_eq!(
svg_element_interface_name("feMorphology"),
"SVGFEMorphologyElement"
);
assert_eq!(svg_element_interface_name("feOffset"), "SVGFEOffsetElement");
assert_eq!(
svg_element_interface_name("fePointLight"),
"SVGFEPointLightElement"
);
assert_eq!(
svg_element_interface_name("feSpecularLighting"),
"SVGFESpecularLightingElement"
);
assert_eq!(
svg_element_interface_name("feSpotLight"),
"SVGFESpotLightElement"
);
assert_eq!(
svg_element_interface_name("feTurbulence"),
"SVGFETurbulenceElement"
);
assert_eq!(svg_element_interface_name("filter"), "SVGFilterElement");
assert_eq!(
svg_element_interface_name("foreignObject"),
"SVGForeignObjectElement"
);
assert_eq!(svg_element_interface_name("g"), "SVGGElement");
assert_eq!(svg_element_interface_name("image"), "SVGImageElement");
assert_eq!(svg_element_interface_name("line"), "SVGLineElement");
assert_eq!(
svg_element_interface_name("linearGradient"),
"SVGLinearGradientElement"
);
assert_eq!(svg_element_interface_name("metadata"), "SVGMetadataElement");
assert_eq!(svg_element_interface_name("marker"), "SVGMarkerElement");
assert_eq!(svg_element_interface_name("mask"), "SVGMaskElement");
assert_eq!(svg_element_interface_name("path"), "SVGPathElement");
assert_eq!(svg_element_interface_name("pattern"), "SVGPatternElement");
assert_eq!(svg_element_interface_name("polygon"), "SVGPolygonElement");
assert_eq!(svg_element_interface_name("polyline"), "SVGPolylineElement");
assert_eq!(
svg_element_interface_name("radialGradient"),
"SVGRadialGradientElement"
);
assert_eq!(svg_element_interface_name("rect"), "SVGRectElement");
assert_eq!(svg_element_interface_name("script"), "SVGScriptElement");
assert_eq!(svg_element_interface_name("stop"), "SVGStopElement");
assert_eq!(svg_element_interface_name("svg"), "SVGSVGElement");
assert_eq!(svg_element_interface_name("symbol"), "SVGSymbolElement");
assert_eq!(svg_element_interface_name("text"), "SVGTextElement");
assert_eq!(svg_element_interface_name("textPath"), "SVGTextPathElement");
assert_eq!(svg_element_interface_name("title"), "SVGTitleElement");
assert_eq!(svg_element_interface_name("tspan"), "SVGTSpanElement");
assert_eq!(svg_element_interface_name("use"), "SVGUseElement");
assert_eq!(svg_element_interface_name("view"), "SVGViewElement");
assert_eq!(svg_element_interface_name("style"), "SVGStyleElement");
assert_eq!(svg_element_interface_name("custom"), "SVGElement");
}
#[test]
fn svg_text_content_role_covers_text_tspan_and_text_path() {
for local_name in ["text", "tspan", "textPath"] {
let element = Element::new(
local_name.to_owned(),
"http://www.w3.org/2000/svg".to_owned(),
None,
Vec::new(),
);
assert!(element.is_svg_text_content_element(), "{local_name}");
}
for (namespace, local_name) in [
("http://www.w3.org/2000/svg", "textpath"),
("http://www.w3.org/1999/xhtml", "text"),
] {
let element = Element::new(
local_name.to_owned(),
namespace.to_owned(),
None,
Vec::new(),
);
assert!(
!element.is_svg_text_content_element(),
"{namespace} {local_name}"
);
}
}
#[test]
fn mathml_element_interface_name_uses_mathml_element() {
assert_eq!(mathml_element_interface_name("math"), "MathMLElement");
assert_eq!(mathml_element_interface_name("mrow"), "MathMLElement");
}
#[test]
fn tag_name_matching_uses_qualified_name_for_prefixed_elements() {
let html_prefixed = Element::new(
"aÇ".to_owned(),
"http://www.w3.org/1999/xhtml".to_owned(),
Some("test".to_owned()),
Vec::new(),
);
assert!(html_prefixed.matches_tag_name("test:aÇ"));
assert!(html_prefixed.matches_tag_name("TEST:AÇ"));
assert!(!html_prefixed.matches_tag_name("test:aç"));
assert!(!html_prefixed.matches_tag_name("aÇ"));
let foreign_prefixed = Element::new(
"st".to_owned(),
"urn:moli:test".to_owned(),
Some("te".to_owned()),
Vec::new(),
);
assert!(foreign_prefixed.matches_tag_name("te:st"));
assert!(!foreign_prefixed.matches_tag_name("st"));
assert!(!foreign_prefixed.matches_tag_name("TE:ST"));
}
#[test]
fn set_attribute_preserves_existing_prefix_on_update() {
let mut element = Element::new(
"g".to_owned(),
"http://www.w3.org/2000/svg".to_owned(),
Some("svg".to_owned()),
vec![Attribute::new(
"kind".to_owned(),
"urn:moli:test".to_owned(),
Some("lm".to_owned()),
"before".to_owned(),
)],
);
assert!(element.set_attribute(
"lm:kind".to_owned(),
"urn:moli:test".to_owned(),
Some("other".to_owned()),
"after".to_owned(),
));
let attribute = &element.attributes()[0];
assert_eq!(attribute.prefix(), Some("lm"));
assert_eq!(attribute.name(), "lm:kind");
assert_eq!(attribute.value(), "after");
}
#[test]
fn script_element_state_distinguishes_dynamic_and_parser_created_scripts() {
let dynamic = Element::new_html("script");
assert!(dynamic.script_async());
assert!(!dynamic.script_already_started());
assert!(!dynamic.script_parser_inserted_for_prepare());
let parser_created = Element::new_parser_created(
"script".to_owned(),
"http://www.w3.org/1999/xhtml".to_owned(),
None,
Vec::new(),
);
assert!(!parser_created.script_async());
assert!(!parser_created.script_already_started());
assert!(parser_created.script_parser_inserted_for_prepare());
let dynamic_svg = Element::new(
"script".to_owned(),
"http://www.w3.org/2000/svg".to_owned(),
None,
vec![Attribute::new(
"href".to_owned(),
String::new(),
None,
"/dynamic.js".to_owned(),
)],
);
assert!(dynamic_svg.is_script_element());
assert!(dynamic_svg.script_async());
assert_eq!(dynamic_svg.script_source_attribute(), Some("/dynamic.js"));
let xlink_svg = Element::new(
"script".to_owned(),
"http://www.w3.org/2000/svg".to_owned(),
None,
vec![Attribute::new(
"href".to_owned(),
"http://www.w3.org/1999/xlink".to_owned(),
Some("xlink".to_owned()),
"/legacy.js".to_owned(),
)],
);
assert_eq!(xlink_svg.script_source_attribute(), Some("/legacy.js"));
let parser_created_svg = Element::new_parser_created(
"script".to_owned(),
"http://www.w3.org/2000/svg".to_owned(),
None,
Vec::new(),
);
assert!(!parser_created_svg.script_async());
assert!(parser_created_svg.script_parser_inserted_for_prepare());
}
#[test]
fn parser_created_link_processing_state_is_consumed_at_children_finish() {
let dynamic = Element::new_html("link");
assert!(!dynamic.link_created_by_parser());
let mut parser_created = Element::new_parser_created(
"link".to_owned(),
"http://www.w3.org/1999/xhtml".to_owned(),
None,
Vec::new(),
);
assert!(!parser_created.link_created_by_parser());
assert!(parser_created.begin_parsing_children());
assert!(parser_created.link_created_by_parser());
assert!(parser_created.finish_parsing_link_children());
assert!(!parser_created.link_created_by_parser());
assert!(!parser_created.finish_parsing_link_children());
}
#[test]
fn email_multiple_attribute_resanitizes_dirty_value() {
let mut input = Element::new_html("input");
assert!(input.set_attribute("type".to_owned(), String::new(), None, "email".to_owned()));
assert!(input.set_input_value(" [email protected] , [email protected] "));
assert_eq!(
input.input_value(),
"[email protected] , [email protected]"
);
assert!(input.input_value_dirty());
assert!(input.set_attribute("multiple".to_owned(), String::new(), None, String::new()));
assert_eq!(input.input_value(), "[email protected],[email protected]");
assert!(input.input_value_dirty());
}
#[test]
fn range_input_value_uses_live_min_max_and_step_attributes() {
let attribute = |name: &str, value: &str| {
Attribute::new(name.to_owned(), String::new(), None, value.to_owned())
};
let mut input = Element::new(
"input".to_owned(),
"http://www.w3.org/1999/xhtml".to_owned(),
None,
vec![
attribute("type", "range"),
attribute("min", "0"),
attribute("max", "100"),
attribute("step", "20"),
attribute("value", "40"),
],
);
assert_eq!(input.input_value(), "40");
assert!(input.set_input_value(""));
assert_eq!(input.input_value(), "60");
assert!(input.input_value_dirty());
assert!(input.set_input_value("80"));
assert!(input.set_attribute("max".to_owned(), String::new(), None, "50".to_owned()));
assert_eq!(input.input_value(), "40");
assert!(input.input_value_dirty());
let defaulted = Element::new(
"input".to_owned(),
"http://www.w3.org/1999/xhtml".to_owned(),
None,
vec![
attribute("type", "range"),
attribute("min", "2"),
attribute("max", "6"),
],
);
assert_eq!(defaulted.input_value(), "4");
assert!(!defaulted.input_value_dirty());
}
#[test]
fn range_value_setters_use_element_bounds_and_step_authority() {
let mut input = Element::new_html("input");
for (name, value) in [
("type", "range"),
("min", "100"),
("max", "200"),
("step", "10"),
] {
input.set_attribute(name.into(), String::new(), None, value.into());
}
for (value, expected) in [
("180", "180"),
("185", "190"),
("250", "200"),
("90", "100"),
("invalid", "150"),
] {
input.set_input_value(value);
assert_eq!(input.input_value(), expected);
}
input.set_attribute("step".into(), String::new(), None, "any".into());
input.set_input_value("180.25");
assert_eq!(input.input_value(), "180.25");
}
#[test]
fn parser_input_finalization_preserves_dirty_values_and_skips_other_elements() {
let mut input = Element::new_html("input");
input.set_attribute("type".into(), String::new(), None, "hidden".into());
input.set_attribute("value".into(), String::new(), None, "default".into());
input.set_input_value(" edited\nvalue ");
assert!(!input.resanitize_input_value_after_parser_attributes());
assert_eq!(input.input_value(), " edited\nvalue ");
assert!(input.input_value_dirty());
let mut div = Element::new_html("div");
assert!(!div.resanitize_input_value_after_parser_attributes());
assert!(!div.rare_data.is_materialized());
}
#[test]
fn media_muted_uses_default_attributes_until_the_explicit_setter_runs() {
for kind in ["audio", "video"] {
let mut namespaced = Element::new_html(kind);
namespaced.set_attribute_ns("muted".into(), "urn:custom".into(), None, String::new());
assert!(
!namespaced.media_muted(),
"only the unnamespaced HTML content attribute applies"
);
let mut media = Element::new_html(kind);
assert!(!media.media_muted());
media.set_attribute("muted".into(), String::new(), None, String::new());
assert!(media.media_muted());
assert!(
media.set_media_muted(true),
"replacing the default state is a mute-state change"
);
media.remove_attribute("muted");
assert!(
media.media_muted(),
"an explicit preference overrides attribute removal"
);
assert!(media.set_media_muted(false));
media.set_attribute("muted".into(), String::new(), None, String::new());
assert!(
!media.media_muted(),
"an explicit false overrides the default attribute"
);
let mut initial = Element::new_html(kind);
assert!(initial.set_media_muted(false));
assert!(!initial.set_media_muted(false));
initial.set_attribute("muted".into(), String::new(), None, String::new());
assert!(
!initial.media_muted(),
"an initial equal-value setter must still latch the preference"
);
}
let mut div = Element::new_html("div");
div.set_attribute("muted".into(), String::new(), None, String::new());
assert!(
!div.media_muted(),
"a muted attribute does not make ordinary elements media"
);
}