Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
//! Declarative tool regressions and Chromium form schema cases.
use super::*;
#[test]
fn web_mcp_declarative_fills_current_choices_after_earlier_field_events() {
for (control, input, mutation, expected) in [
(
"<select name=choice><option value=a>A</option><option value=b>B</option></select>",
"'b'",
"form.elements.choice.innerHTML='<option value=a>A</option><option value=b>B</option>'",
r#"{"selected":["b"],"events":["input","change"]}"#,
),
(
"<select name=choice multiple><option value=a>A</option><option value=b>B</option></select>",
"['b']",
"form.elements.choice.innerHTML='<option value=a>A</option><option value=b>B</option>'",
r#"{"selected":["b"],"events":["input","change"]}"#,
),
(
"<input name=choice type=checkbox value=a><input name=choice type=checkbox value=b>",
"['b']",
"form.elements.choice[1].value='c'",
r#"{"selected":[],"events":["change","change"]}"#,
),
(
"<input name=choice type=radio value=a checked><input name=choice type=radio value=b>",
"'b'",
"form.elements.choice[1].value='c'",
r#"{"selected":["a"],"events":[]}"#,
),
] {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(&format!(r#"
document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=trigger>{control}</form>';
globalThis.form=document.querySelector('form');
globalThis.probe='pending';
const events=[];
form.elements.trigger.addEventListener('input', () => {{{mutation}}});
for (const type of ['input','change']) form.addEventListener(type, event => {{
if (event.target.name==='choice') events.push(type);
}});
form.addEventListener('submit', event => {{
event.preventDefault();
const controls=Array.from(form.elements).filter(control=>control.name==='choice');
const selected=controls[0].tagName==='SELECT'
? Array.from(controls[0].selectedOptions, option=>option.value)
: controls.filter(control=>control.checked).map(control=>control.value);
event.respondWith({{selected,events}});
}});
"#)).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(&format!("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{trigger:'changed',choice:{input}}})).then(value=>probe=value,error=>probe=error.name)")).unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("probe").unwrap(),
expected,
"{control}"
);
}
}
#[test]
fn web_mcp_declarative_rejects_invalid_tool_names_on_discovery_and_mutation() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
for (const name of ['valid','', 'bad name','non_ascii_😀','x'.repeat(129)]) {
const form=document.createElement('form');form.setAttribute('toolname',name);form.setAttribute('tooldescription','Tool');document.body.append(form);
}
globalThis.result='pending';
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(
"document.modelContext.getTools().then(tools=>result=tools.map(tool=>tool.name).join('|'))",
)
.unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("result").unwrap(),
"valid"
);
vm.eval("document.querySelector('form').setAttribute('toolname','invalid name')")
.unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval("document.modelContext.getTools().then(tools=>result=tools.length)")
.unwrap();
assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "0");
}
#[test]
fn web_mcp_declarative_numeric_schema_uses_effective_bounds_and_decimal_steps() {
for (attributes, expected) in [
(
"type=number min=0.3 step=0.1",
serde_json::json!({"type":"number","minimum":0.3,"multipleOf":0.1}),
),
(
"type=range min=200 max=10",
serde_json::json!({"type":"number","minimum":200,"maximum":200,"multipleOf":1}),
),
(
"type=range value=0.5",
serde_json::json!({"type":"number","minimum":0,"maximum":100}),
),
("type=number step=AnY", serde_json::json!({"type":"number"})),
(
"type=range step=AnY",
serde_json::json!({"type":"number","minimum":0,"maximum":100}),
),
(
"type=number min=+2 max=+3 step=+0.1",
serde_json::json!({"type":"number","multipleOf":1}),
),
(
"type=number min=0.0000000001 step=1",
serde_json::json!({"type":"number","minimum":0.0000000001}),
),
] {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(&format!("document.body.innerHTML='<form toolname=schema tooldescription=Schema><input name=value {attributes}></form>';globalThis.result=null;")).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval("document.modelContext.getTools().then(([tool])=>result=tool.inputSchema.properties.value)").unwrap();
let actual = vm
.eval_after_selected_page_tasks("JSON.stringify(result)")
.unwrap();
assert_eq!(
serde_json::from_str::<serde_json::Value>(&actual).unwrap(),
expected,
"{attributes}"
);
}
}
#[test]
fn web_mcp_declarative_unchanged_values_do_not_dispatch_input_events() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=text value=original><textarea name=area>original</textarea><input name=check type=checkbox checked><input name=radio type=radio value=on checked><select name=choice><option value=a selected>A</option><option value=b>B</option></select><input name=number type=number value=2></form>';
const form=document.querySelector('form');const events=[];
for (const type of ['input','change']) form.addEventListener(type,event=>events.push(event.target.name+':'+type));
form.addEventListener('submit',event=>{event.preventDefault();event.respondWith(events)});
globalThis.result='pending';
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'original',area:'original',check:true,radio:'on',choice:'a',number:2})).then(value=>result=value,error=>result=error.name)"#).unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("result").unwrap(),
r#"["check:change","radio:change"]"#
);
}
#[test]
fn web_mcp_declarative_converts_numbers_and_rejects_invalid_booleans_before_filling() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=value><input name=checked type=checkbox></form>';
globalThis.form=document.querySelector('form');
form.addEventListener('submit',event=>{event.preventDefault();event.respondWith(form.elements.value.value)});
globalThis.result='pending';
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{value:0.001953125})).then(value=>result=value,error=>result=error.name)").unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("result").unwrap(),
"0.00195313"
);
vm.eval("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{value:'changed',checked:0.5})).then(value=>result=value,error=>result=error.name)").unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("result+'|'+form.elements.value.value")
.unwrap(),
"UnknownError|0.00195313"
);
}
#[test]
fn web_mcp_declarative_document_open_discards_stale_registration_tasks() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(
r#"document.body.innerHTML = '<form toolname="old" tooldescription="Old form"></form>'"#,
)
.unwrap();
// Replace the document before its initial form registration task runs.
vm.eval(r#"
document.open();
document.write('<!doctype html><body><form toolname="new" tooldescription="New form" toolautosubmit></form>');
document.close();
globalThis.result = 'pending';
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"document.modelContext.getTools().then(tools => result = tools.map(tool => tool.name).join('|'))"#).unwrap();
assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "new");
}
#[test]
fn web_mcp_declarative_fills_controls_and_responds_in_the_form_realm() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
globalThis.frame = document.createElement('iframe');
document.body.append(frame);
frame.contentWindow.eval(`
document.body.innerHTML = '<form toolname="fill" tooldescription="Fill controls" toolautosubmit><input name="text"><input name="number" type="number"><input name="checked" type="checkbox"><select name="selected"><option>a</option><option>b</option></select><textarea name="area"></textarea></form>';
const form = document.querySelector('form');
const events = [];
for (const type of ['input','change']) form.addEventListener(type,e=>events.push(e.target.name+':'+type));
form.addEventListener('submit',e=>{
e.preventDefault();
e.respondWith(Promise.resolve({agent:e.agentInvoked,realm:e instanceof SubmitEvent,
text:form.elements.text.value,number:form.elements.number.value,
checked:form.elements.checked.checked,selected:form.elements.selected.value,
area:form.elements.area.value,events}));
});
`);
globalThis.result = 'pending';
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,
{text:'hello',number:42,checked:true,selected:'b',area:'world'})).then(value=>result=value,e=>result=e.name)"#).unwrap();
let result = vm.eval_after_selected_page_tasks("result").unwrap();
let result: serde_json::Value = serde_json::from_str(&result).unwrap();
assert_eq!(result["agent"], true);
assert_eq!(result["realm"], true);
assert_eq!(result["text"], "hello");
assert_eq!(result["number"], "42");
assert_eq!(result["checked"], true);
assert_eq!(result["selected"], "b");
assert_eq!(result["area"], "world");
assert_eq!(result["events"].as_array().unwrap().len(), 10);
}
#[test]
fn web_mcp_declarative_uses_native_range_bounds_and_text_sanitization() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=amount type=range min=100 max=200 step=10 value=150><input name=text><textarea name=area></textarea></form>';
const form=document.querySelector('form');
form.addEventListener('submit',event=>{
event.preventDefault();event.respondWith({amount:Number(form.elements.amount.value),text:form.elements.text.value,area:form.elements.area.value});
});
globalThis.result='pending';
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{amount:180,text:'x\ny',area:'a\r\nb\rc'})).then(value=>result=value,error=>result=error.name)"#).unwrap();
let result = vm.eval_after_selected_page_tasks("result").unwrap();
assert_eq!(
serde_json::from_str::<serde_json::Value>(&result).unwrap(),
serde_json::json!({"amount":180,"text":"xy","area":"a\nb\nc"})
);
}
#[test]
fn web_mcp_declarative_rejects_sanitized_empty_values_before_filling() {
// Chromium's ValidateTextData/ValidateNumberData check the native input
// sanitizer before applying any of the supplied parameters.
for (kind, initial, invalid) in [
("text", "original", "\r\n"),
("search", "original", "\n"),
("password", "original", "\r"),
("tel", "original", "\n"),
("url", "https://tools.test/", " \t\n"),
("email", "[email protected]", " \t\n"),
("number", "12", "not a number"),
("date", "2024-02-29", "2025-02-29"),
("datetime-local", "2024-02-29T12:30", "2024-02-29T25:00"),
("month", "2024-02", "2024-13"),
("week", "2024-W01", "2024-W00"),
("time", "12:30", "25:00"),
] {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(&format!(
r#"
document.body.innerHTML='<form toolname=atomic tooldescription=Atomic toolautosubmit><input name=first value=original><input name=typed type={kind} value="{initial}"></form>';
globalThis.form=document.querySelector('form');
globalThis.events=[];
for (const type of ['input','change','submit']) form.addEventListener(type,event=>{{
events.push(type);
if (type==='submit') {{event.preventDefault();event.respondWith('submitted');}}
}});
globalThis.result='pending';
"#
))
.unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(&format!(
r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{first:'changed',typed:{}}})).then(value=>result=value,error=>result=error.name)"#,
serde_json::to_string(invalid).unwrap()
))
.unwrap();
let result = vm
.eval_after_selected_page_tasks(
"JSON.stringify([result,form.elements.first.value,form.elements.typed.value,events])",
)
.unwrap();
assert_eq!(
serde_json::from_str::<serde_json::Value>(&result).unwrap(),
serde_json::json!(["UnknownError", "original", initial, []]),
"input type={kind}"
);
}
}
#[test]
fn web_mcp_declarative_range_accepts_nonempty_values_using_native_sanitization() {
for value in [serde_json::json!("invalid"), serde_json::json!(true)] {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=text value=original><input name=amount type=range min=100 max=200 step=10 value=100></form>';
globalThis.form=document.querySelector('form');
form.addEventListener('submit',event=>{event.preventDefault();event.respondWith(form.elements.amount.value)});
globalThis.result='pending';
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(&format!(
r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{amount:{value}}})).then(value=>result=value,error=>result=error.name)"#
)).unwrap();
assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "150");
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'changed',amount:''})).then(value=>result=value,error=>result=error.name)"#).unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks(
"result+'|'+form.elements.text.value+'|'+form.elements.amount.value"
)
.unwrap(),
"UnknownError|original|150"
);
}
}
#[test]
fn web_mcp_declarative_select_uses_native_option_values_and_first_duplicate() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><select name=single><option value=dup>first</option><option value=dup selected>second</option><option value=empty></option><option> a\n \t b </option></select><select name=multiple multiple><option value=dup>first</option><option value=dup>second</option></select></form>';
globalThis.form=document.querySelector('form');
globalThis.schema=null;
globalThis.result='pending';
form.addEventListener('submit',event=>{event.preventDefault();event.respondWith({index:form.elements.single.selectedIndex,multiple:Array.from(form.elements.multiple.options,option=>option.selected)})});
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"document.modelContext.getTools().then(([tool])=>{schema=tool.inputSchema;return document.modelContext.executeTool(tool,{single:'dup',multiple:['dup']})}).then(value=>result=value,error=>result=error.name)"#).unwrap();
let result = vm.eval_after_selected_page_tasks("result").unwrap();
assert_eq!(
serde_json::from_str::<serde_json::Value>(&result).unwrap(),
serde_json::json!({"index":0,"multiple":[true,true]})
);
let schema: serde_json::Value =
serde_json::from_str(&vm.eval("JSON.stringify(schema)").unwrap()).unwrap();
assert_eq!(
schema["properties"]["single"]["enum"],
serde_json::json!(["dup", "dup", "empty", "a b"])
);
assert_eq!(schema["properties"]["single"]["anyOf"][2]["title"], "");
assert_eq!(
schema["properties"]["single"]["anyOf"][3]["title"],
" a\n \t b "
);
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{single:'a b'})).then(value=>result=value,error=>result=error.name)"#).unwrap();
let result = vm.eval_after_selected_page_tasks("result").unwrap();
assert_eq!(
serde_json::from_str::<serde_json::Value>(&result).unwrap()["index"],
3
);
}
#[test]
fn web_mcp_declarative_manual_confirmation_reset_and_response_guards() {
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
document.body.innerHTML = '<form toolname="confirm" tooldescription="Confirmation"><input name="query"><button>Submit</button></form>';
globalThis.form = document.querySelector('form');
globalThis.probe = [];
form.addEventListener('submit',e=>{
probe.push(e.agentInvoked);
try {e.respondWith('before prevention')} catch(error) {probe.push(error.name)}
e.preventDefault();
if (e.agentInvoked) {e.respondWith('confirmed');globalThis.savedEvent=e;}
});
form.requestSubmit();
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{query:'hello'})).then(value=>probe.push(value));"#).unwrap();
assert_eq!(vm.eval_after_selected_page_tasks("form.querySelector('input').value+'|'+(document.activeElement===form.querySelector('button'))").unwrap(),"hello|true");
vm.eval("form.querySelector('button').click()").unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"
try {savedEvent.respondWith('late')} catch(error) {probe.push(error.name)}
document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{query:'reset'})).catch(error=>probe.push(error.name));
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval("form.reset()").unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("probe.join('|')")
.unwrap(),
"false|InvalidStateError|true|InvalidStateError|confirmed|InvalidStateError|UnknownError"
);
}
#[test]
fn web_mcp_declarative_validates_all_arguments_before_mutation_and_preserves_response_after_unregister()
{
let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");
vm.eval(r#"
document.body.innerHTML = '<form toolname="atomic" tooldescription="Atomic fill" toolautosubmit><input name="text" value="original"><select name="choice"><option>a</option></select></form>';
globalThis.form = document.querySelector('form');
globalThis.probe = [];
form.addEventListener('submit',e=>{e.preventDefault();e.respondWith(new Promise(resolve=>globalThis.finish=resolve))});
"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'changed',choice:'invalid'})).catch(error=>probe.push(error.name));"#).unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("probe.join('|')+'|'+form.elements.text.value")
.unwrap(),
"UnknownError|original"
);
vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'changed'})).then(()=>probe.push('late'),error=>probe.push(error.name));"#).unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval("form.remove()").unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval("finish('late result')").unwrap();
assert_eq!(
vm.eval_after_selected_page_tasks("probe.join('|')")
.unwrap(),
"UnknownError|late"
);
}
#[test]
fn web_mcp_chromium_form_schema_cases() {
let fixtures: serde_json::Value = serde_json::from_str(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../moli-wpt-compat/fixtures/wpt/upstream/webmcp/declarative/chromium-form-schema-cases.json"
))).unwrap();
let mut failures = Vec::new();
for case in fixtures["cases"].as_array().unwrap() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
let mut vm = new_parsed_page_task_executor_test_vm(
"https://tools.test/",
case["html"].as_str().unwrap(),
&loader,
);
vm.eval("undefined").unwrap();
vm.eval_after_selected_page_tasks("undefined").unwrap();
vm.eval("globalThis.schema = null; document.modelContext.getTools().then(tools => schema = JSON.stringify(tools[0].inputSchema))").unwrap();
let actual = vm.eval_after_selected_page_tasks("schema").unwrap();
let expected = vm
.eval(&format!(
"JSON.stringify(JSON.parse({}))",
serde_json::to_string(&case["expected_json"]).unwrap()
))
.unwrap();
if actual != expected {
failures.push(format!(
"{}\nactual: {actual}\nexpected: {expected}",
case["name"]
));
}
}
assert!(failures.is_empty(), "{}", failures.join("\n"));
}