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::*;
#[tokio::test]
async fn webdriver_classic_script_document_open_returns_replacement_document_elements() {
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"].as_str().unwrap();
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url("<p id='old'>old</p>") }),
)
.await;
let old_element = classic_find_css_element_id(app.clone(), session_id, "#old").await;
let result = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "if (arguments[0].textContent !== 'old') throw new Error('wrong input document'); document.open(); document.write(\"<p id='new'>new</p>\"); document.close(); return document.querySelector('#new');",
"args": [{ CLASSIC_ELEMENT_REFERENCE_KEY: old_element }]
}),
)
.await;
let new_element = result["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("replacement element reference: {result:?}"));
let text = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{new_element}/text"),
)
.await;
assert_eq!(text, json!({ "value": "new" }));
let (status, stale) = classic_request_status_and_json(
app,
Method::GET,
&format!("/session/{session_id}/element/{old_element}/text"),
)
.await;
assert_eq!(status, StatusCode::NOT_FOUND);
assert_eq!(stale["value"]["error"], json!("stale element reference"));
}
#[tokio::test]
async fn webdriver_classic_execute_script_basic_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/execute.py null body, primitive serialization, ending
// comment, and override-listener cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let execute_path = format!("/session/{session_id}/execute/sync");
let (null_body_status, null_body) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!(null),
)
.await;
assert_eq!(null_body_status, StatusCode::BAD_REQUEST);
assert_eq!(null_body["value"]["error"], json!("invalid argument"));
for (label, script, expected) in [
("null", "return null;", json!(null)),
("undefined", "return undefined;", json!(null)),
("true", "return true;", json!(true)),
("false", "return false;", json!(false)),
("number", "return 23;", json!(23)),
("string", "return 'foo';", json!("foo")),
("nul", "return String.fromCharCode(0);", json!("\u{0000}")),
] {
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(response, json!({ "value": expected }), "{label}");
}
let ending_comment = classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": "return 1; // foo",
"args": []
}),
)
.await;
assert_eq!(ending_comment, json!({ "value": 1 }));
let listener_page = classic_data_url(
"<script>window.called=[];window.addEventListener=()=>called.push('Internal addEventListener');window.removeEventListener=()=>called.push('Internal removeEventListener');</script>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": listener_page }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let unload = classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": "return !window.onunload;",
"args": []
}),
)
.await;
assert_eq!(unload, json!({ "value": true }));
let called = classic_request_json_with_body(
app,
Method::POST,
&execute_path,
json!({
"script": "return window.called;",
"args": []
}),
)
.await;
assert_eq!(called, json!({ "value": [] }));
}
#[tokio::test]
async fn webdriver_classic_execute_async_script_basic_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_async_script/execute_async.py null body and primitive
// serialization cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let execute_path = format!("/session/{session_id}/execute/async");
let (null_body_status, null_body) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!(null),
)
.await;
assert_eq!(null_body_status, StatusCode::BAD_REQUEST);
assert_eq!(null_body["value"]["error"], json!("invalid argument"));
for (label, expression, expected) in [
("null", "null", json!(null)),
("undefined", "undefined", json!(null)),
("true", "true", json!(true)),
("false", "false", json!(false)),
("number", "23", json!(23)),
("string", "'foo'", json!("foo")),
("nul", "String.fromCharCode(0)", json!("\u{0000}")),
] {
let script = format!("arguments[arguments.length - 1]({expression});");
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(response, json!({ "value": expected }), "{label}");
}
}
#[tokio::test]
async fn webdriver_classic_execute_script_argument_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/arguments.py null, primitives, collection, and object
// cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let null_response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return [arguments[0] === null, arguments[0]];",
"args": [null]
}),
)
.await;
assert_eq!(null_response, json!({ "value": [true, null] }));
for (label, value, expected_type) in [
("boolean", json!(true), "boolean"),
("number", json!(42), "number"),
("string", json!("foo"), "string"),
("string quote", json!("foo\"bar"), "string"),
("string injection", json!("\"); alert(1); //"), "string"),
(
"special key object",
json!({ "foo-bar": "bar-foo" }),
"object",
),
] {
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return [typeof arguments[0], arguments[0]];",
"args": [value.clone()]
}),
)
.await;
assert_eq!(
response,
json!({ "value": [expected_type, value] }),
"{label}"
);
}
let collection = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return [Array.isArray(arguments[0]), arguments[0]];",
"args": [[1, 2, 3]]
}),
)
.await;
assert_eq!(collection, json!({ "value": [true, [1, 2, 3]] }));
let object = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return [typeof arguments[0], arguments[0]];",
"args": [{ "foo": "bar", "cheese": 23 }]
}),
)
.await;
assert_eq!(
object,
json!({ "value": ["object", { "foo": "bar", "cheese": 23 }] })
);
for key in [
CLASSIC_ELEMENT_REFERENCE_KEY,
CLASSIC_SHADOW_ROOT_REFERENCE_KEY,
CLASSIC_FRAME_REFERENCE_KEY,
CLASSIC_WINDOW_REFERENCE_KEY,
] {
for value in [json!(null), json!(false), json!(42), json!([]), json!({})] {
let mut reference = Map::new();
reference.insert(key.to_owned(), value);
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return true;",
"args": [Value::Object(reference)]
}),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST, "{key}: {response:?}");
assert_eq!(
response["value"]["error"],
json!("invalid argument"),
"{key}: {response:?}"
);
}
}
}
#[tokio::test]
async fn webdriver_classic_execute_async_script_argument_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_async_script/arguments.py null, primitives, collection, and
// object cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let null_response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[arguments.length - 1]([arguments[0] === null, arguments[0]]);",
"args": [null]
}),
)
.await;
assert_eq!(null_response, json!({ "value": [true, null] }));
for (label, value, expected_type) in [
("boolean", json!(true), "boolean"),
("number", json!(42), "number"),
("string", json!("foo"), "string"),
("string quote", json!("foo\"bar"), "string"),
("string injection", json!("\"); alert(1); //"), "string"),
(
"special key object",
json!({ "foo-bar": "bar-foo" }),
"object",
),
] {
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[arguments.length - 1]([typeof arguments[0], arguments[0]]);",
"args": [value.clone()]
}),
)
.await;
assert_eq!(
response,
json!({ "value": [expected_type, value] }),
"{label}"
);
}
let collection = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[arguments.length - 1]([Array.isArray(arguments[0]), arguments[0]]);",
"args": [[1, 2, 3]]
}),
)
.await;
assert_eq!(collection, json!({ "value": [true, [1, 2, 3]] }));
let object = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[arguments.length - 1]([typeof arguments[0], arguments[0]]);",
"args": [{ "foo": "bar", "cheese": 23 }]
}),
)
.await;
assert_eq!(
object,
json!({ "value": ["object", { "foo": "bar", "cheese": 23 }] })
);
for key in [
CLASSIC_ELEMENT_REFERENCE_KEY,
CLASSIC_SHADOW_ROOT_REFERENCE_KEY,
CLASSIC_FRAME_REFERENCE_KEY,
CLASSIC_WINDOW_REFERENCE_KEY,
] {
for value in [json!(null), json!(false), json!(42), json!([]), json!({})] {
let mut reference = Map::new();
reference.insert(key.to_owned(), value);
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[arguments.length - 1](true);",
"args": [Value::Object(reference)]
}),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST, "{key}: {response:?}");
assert_eq!(
response["value"]["error"],
json!("invalid argument"),
"{key}: {response:?}"
);
}
}
}
#[tokio::test]
async fn webdriver_classic_execute_script_collection_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/collections.py arguments, array, array_in_array,
// FileList, HTMLAllCollection, HTMLCollection, HTMLFormControlsCollection,
// HTMLOptionsCollection, and NodeList cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let arguments = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "function func() { return arguments; } return func('foo', 'bar');",
"args": []
}),
)
.await;
assert_eq!(arguments, json!({ "value": ["foo", "bar"] }));
let array = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return [1, 2];",
"args": []
}),
)
.await;
assert_eq!(array, json!({ "value": [1, 2] }));
let array_in_array = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "const arr = [1]; return [arr, arr];",
"args": []
}),
)
.await;
assert_eq!(array_in_array, json!({ "value": [[1], [1]] }));
let first_file = TempPath::new("classic-file-list-foo");
let second_file = TempPath::new("classic-file-list-bar");
fs::write(&first_file.path, b"morn morn").expect("write first FileList upload file");
fs::write(&second_file.path, b"morn morn").expect("write second FileList upload file");
let expected_file_names = [
classic_temp_file_basename(&first_file),
classic_temp_file_basename(&second_file),
];
let file_page = classic_data_url("<input id='upload' type='file' multiple>");
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": file_page }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let upload_id = classic_find_css_element_id(app.clone(), session_id, "#upload").await;
let uploaded = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{upload_id}/value"),
json!({
"text": format!(
"{}\n{}",
first_file.path.to_string_lossy(),
second_file.path.to_string_lossy()
)
}),
)
.await;
assert_eq!(uploaded, json!({ "value": null }));
let file_list = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('input').files;",
"args": []
}),
)
.await;
classic_assert_serialized_file_list_names("FileList", &file_list, &expected_file_names);
let collections_page = classic_data_url(
"<!doctype html><html><head><title>collections</title></head><body>\
<p id='p-1'>foo</p><p id='p-2'>bar</p>\
<form id='form'><input id='input-1'><input id='input-2'></form>\
<select id='select'><option id='option-1'>one</option><option id='option-2'>two</option></select>\
</body></html>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": collections_page }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let p_ids = [
classic_find_css_element_id(app.clone(), session_id, "#p-1").await,
classic_find_css_element_id(app.clone(), session_id, "#p-2").await,
];
let html_collection = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.getElementsByTagName('p');",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app.clone(),
session_id,
"HTMLCollection",
&html_collection,
&p_ids,
)
.await;
let node_list = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelectorAll('p');",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(app.clone(), session_id, "NodeList", &node_list, &p_ids)
.await;
let input_ids = [
classic_find_css_element_id(app.clone(), session_id, "#input-1").await,
classic_find_css_element_id(app.clone(), session_id, "#input-2").await,
];
let form_controls = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.forms[0].elements;",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app.clone(),
session_id,
"HTMLFormControlsCollection",
&form_controls,
&input_ids,
)
.await;
let option_ids = [
classic_find_css_element_id(app.clone(), session_id, "#option-1").await,
classic_find_css_element_id(app.clone(), session_id, "#option-2").await,
];
let options = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('select').options;",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app.clone(),
session_id,
"HTMLOptionsCollection",
&options,
&option_ids,
)
.await;
let all_page = classic_data_url(
"<!doctype html><html><head><meta id='meta'></head><body>\
<p id='all-p-1'>foo</p><p id='all-p-2'>bar</p>\
</body></html>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": all_page }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let document_all_ids = [
classic_find_css_element_id(app.clone(), session_id, "html").await,
classic_find_css_element_id(app.clone(), session_id, "head").await,
classic_find_css_element_id(app.clone(), session_id, "#meta").await,
classic_find_css_element_id(app.clone(), session_id, "body").await,
classic_find_css_element_id(app.clone(), session_id, "#all-p-1").await,
classic_find_css_element_id(app.clone(), session_id, "#all-p-2").await,
];
let document_all = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.all;",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app,
session_id,
"HTMLAllCollection",
&document_all,
&document_all_ids,
)
.await;
}
#[tokio::test]
async fn webdriver_classic_execute_async_script_collection_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_async_script/collections.py arguments, array, array_in_array,
// FileList, HTMLAllCollection, HTMLCollection, HTMLFormControlsCollection,
// HTMLOptionsCollection, and NodeList cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let arguments = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "const resolve = arguments[0]; function func() { return arguments; } resolve(func('foo', 'bar'));",
"args": []
}),
)
.await;
assert_eq!(arguments, json!({ "value": ["foo", "bar"] }));
let array = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0]([1, 2]);",
"args": []
}),
)
.await;
assert_eq!(array, json!({ "value": [1, 2] }));
let array_in_array = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "const arr = [1]; arguments[0]([arr, arr]);",
"args": []
}),
)
.await;
assert_eq!(array_in_array, json!({ "value": [[1], [1]] }));
let first_file = TempPath::new("classic-async-file-list-foo");
let second_file = TempPath::new("classic-async-file-list-bar");
fs::write(&first_file.path, b"morn morn").expect("write first async FileList upload file");
fs::write(&second_file.path, b"morn morn").expect("write second async FileList upload file");
let expected_file_names = [
classic_temp_file_basename(&first_file),
classic_temp_file_basename(&second_file),
];
let file_page = classic_data_url("<input id='upload' type='file' multiple>");
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": file_page }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let upload_id = classic_find_css_element_id(app.clone(), session_id, "#upload").await;
let uploaded = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{upload_id}/value"),
json!({
"text": format!(
"{}\n{}",
first_file.path.to_string_lossy(),
second_file.path.to_string_lossy()
)
}),
)
.await;
assert_eq!(uploaded, json!({ "value": null }));
let file_list = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('input').files);",
"args": []
}),
)
.await;
classic_assert_serialized_file_list_names("async FileList", &file_list, &expected_file_names);
let collections_page = classic_data_url(
"<!doctype html><html><head><title>collections</title></head><body>\
<p id='p-1'>foo</p><p id='p-2'>bar</p>\
<form id='form'><input id='input-1'><input id='input-2'></form>\
<select id='select'><option id='option-1'>one</option><option id='option-2'>two</option></select>\
</body></html>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": collections_page }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let p_ids = [
classic_find_css_element_id(app.clone(), session_id, "#p-1").await,
classic_find_css_element_id(app.clone(), session_id, "#p-2").await,
];
let html_collection = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.getElementsByTagName('p'));",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app.clone(),
session_id,
"async HTMLCollection",
&html_collection,
&p_ids,
)
.await;
let node_list = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelectorAll('p'));",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app.clone(),
session_id,
"async NodeList",
&node_list,
&p_ids,
)
.await;
let input_ids = [
classic_find_css_element_id(app.clone(), session_id, "#input-1").await,
classic_find_css_element_id(app.clone(), session_id, "#input-2").await,
];
let form_controls = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.forms[0].elements);",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app.clone(),
session_id,
"async HTMLFormControlsCollection",
&form_controls,
&input_ids,
)
.await;
let option_ids = [
classic_find_css_element_id(app.clone(), session_id, "#option-1").await,
classic_find_css_element_id(app.clone(), session_id, "#option-2").await,
];
let options = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('select').options);",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app.clone(),
session_id,
"async HTMLOptionsCollection",
&options,
&option_ids,
)
.await;
let all_page = classic_data_url(
"<!doctype html><html><head><meta id='meta'></head><body>\
<p id='all-p-1'>foo</p><p id='all-p-2'>bar</p>\
</body></html>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": all_page }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let document_all_ids = [
classic_find_css_element_id(app.clone(), session_id, "html").await,
classic_find_css_element_id(app.clone(), session_id, "head").await,
classic_find_css_element_id(app.clone(), session_id, "#meta").await,
classic_find_css_element_id(app.clone(), session_id, "body").await,
classic_find_css_element_id(app.clone(), session_id, "#all-p-1").await,
classic_find_css_element_id(app.clone(), session_id, "#all-p-2").await,
];
let document_all = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.all);",
"args": []
}),
)
.await;
classic_assert_web_element_array_eq(
app,
session_id,
"async HTMLAllCollection",
&document_all,
&document_all_ids,
)
.await;
}
#[tokio::test]
async fn webdriver_classic_execute_script_promise_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/promise.py resolve/reject cases. Timeout cases are covered
// by webdriver_classic_execute_sync_honors_script_timeout.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
for (label, script, expected) in [
(
"promise resolve",
"return Promise.resolve('foobar');",
json!("foobar"),
),
(
"promise resolve delayed",
"return new Promise(resolve => setTimeout(() => resolve('foobar'), 10));",
json!("foobar"),
),
(
"promise all resolve",
"return Promise.all([Promise.resolve(1), Promise.resolve(2)]);",
json!([1, 2]),
),
(
"await promise resolve",
"let res = await Promise.resolve('foobar'); return res;",
json!("foobar"),
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(status, StatusCode::OK, "{label}: {response:?}");
assert_eq!(response, json!({ "value": expected }), "{label}");
}
for (label, script) in [
(
"promise reject",
"return Promise.reject(new Error('my error'));",
),
(
"promise reject delayed",
"return new Promise((resolve, reject) => setTimeout(() => reject(new Error('my error')), 10));",
),
(
"promise all reject",
"return Promise.all([Promise.resolve(1), Promise.reject(new Error('error'))]);",
),
(
"await promise reject",
"await Promise.reject(new Error('my error')); return 'foo';",
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR, "{label}");
assert_eq!(
response["value"]["error"],
json!("javascript error"),
"{label}: {response:?}"
);
}
}
#[tokio::test]
async fn webdriver_classic_execute_async_script_promise_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_async_script/promise.py resolve/reject cases. Timeout cases are
// covered by webdriver_classic_execute_async_honors_script_timeout.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
for (label, script, expected) in [
(
"promise resolve",
"let resolve = arguments[0]; resolve(Promise.resolve('foobar'));",
json!("foobar"),
),
(
"promise resolve delayed",
"let resolve = arguments[0]; let promise = new Promise(resolve => setTimeout(() => resolve('foobar'), 10)); resolve(promise);",
json!("foobar"),
),
(
"promise all resolve",
"let resolve = arguments[0]; let promise = Promise.all([Promise.resolve(1), Promise.resolve(2)]); resolve(promise);",
json!([1, 2]),
),
(
"await promise resolve",
"let resolve = arguments[0]; let res = await Promise.resolve('foobar'); resolve(res);",
json!("foobar"),
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(status, StatusCode::OK, "{label}: {response:?}");
assert_eq!(response, json!({ "value": expected }), "{label}");
}
for (label, script) in [
(
"promise reject",
"let resolve = arguments[0]; resolve(Promise.reject(new Error('my error')));",
),
(
"promise reject delayed",
"let resolve = arguments[0]; let promise = new Promise((resolve, reject) => setTimeout(() => reject(new Error('my error')), 10)); resolve(promise);",
),
(
"promise all reject",
"let resolve = arguments[0]; let promise = Promise.all([Promise.resolve(1), Promise.reject(new Error('error'))]); resolve(promise);",
),
(
"await promise reject",
"let resolve = arguments[0]; await Promise.reject(new Error('my error')); resolve('foo');",
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR, "{label}");
assert_eq!(
response["value"]["error"],
json!("javascript error"),
"{label}: {response:?}"
);
}
}
#[tokio::test]
async fn webdriver_classic_execute_script_property_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/properties.py.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url("<input value=foobar>") }),
)
.await;
let content_attribute = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('input').value;",
"args": []
}),
)
.await;
assert_eq!(content_attribute, json!({ "value": "foobar" }));
let idl_page = classic_data_url(
"<input><script>document.querySelector('input').value = 'foobar';</script>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": idl_page }),
)
.await;
let idl_attribute = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('input').value;",
"args": []
}),
)
.await;
assert_eq!(idl_attribute, json!({ "value": "foobar" }));
let element_property_page = classic_data_url(
"<p id='foo'>foo</p><p id='bar'>bar</p>\
<script>document.querySelector('#foo').bar = document.querySelector('#bar');</script>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": element_property_page }),
)
.await;
let bar_id = classic_find_css_element_id(app.clone(), session_id, "#bar").await;
let element_property = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('#foo').bar;",
"args": []
}),
)
.await;
let returned_bar_id = element_property["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("expected WebElement result: {element_property:?}"));
assert_eq!(
returned_bar_id, bar_id,
"script-returned element property should reuse the find-element WebElement id"
);
let same = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{returned_bar_id}/equals/{bar_id}"),
)
.await;
assert_eq!(same, json!({ "value": true }));
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url("<input>") }),
)
.await;
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.querySelector('input').foobar = 'foobar';",
"args": []
}),
)
.await;
let script_property = classic_request_json_with_body(
app,
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('input').foobar;",
"args": []
}),
)
.await;
assert_eq!(script_property, json!({ "value": "foobar" }));
}
#[tokio::test]
async fn webdriver_classic_execute_async_script_property_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_async_script/properties.py.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url("<input value=foobar>") }),
)
.await;
let content_attribute = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('input').value);",
"args": []
}),
)
.await;
assert_eq!(content_attribute, json!({ "value": "foobar" }));
let idl_page = classic_data_url(
"<input><script>document.querySelector('input').value = 'foobar';</script>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": idl_page }),
)
.await;
let idl_attribute = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('input').value);",
"args": []
}),
)
.await;
assert_eq!(idl_attribute, json!({ "value": "foobar" }));
let element_property_page = classic_data_url(
"<p id='foo'>foo</p><p id='bar'>bar</p>\
<script>document.querySelector('#foo').bar = document.querySelector('#bar');</script>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": element_property_page }),
)
.await;
let bar_id = classic_find_css_element_id(app.clone(), session_id, "#bar").await;
let element_property = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('#foo').bar);",
"args": []
}),
)
.await;
let returned_bar_id = element_property["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("expected WebElement result: {element_property:?}"));
let same = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{returned_bar_id}/equals/{bar_id}"),
)
.await;
assert_eq!(same, json!({ "value": true }));
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url("<input>") }),
)
.await;
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.querySelector('input').foobar = 'foobar';",
"args": []
}),
)
.await;
let script_property = classic_request_json_with_body(
app,
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('input').foobar);",
"args": []
}),
)
.await;
assert_eq!(script_property, json!({ "value": "foobar" }));
}
#[tokio::test]
async fn webdriver_classic_execute_script_node_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/node.py top-context node type, web reference, stale
// element, and detached shadow root cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let node_page = classic_data_url(
"<!doctype html><div id='attr' data-kind='v'></div>\
<div id='text-node'><p></p>Lorem</div>\
<div id='comment'><!-- Comment --></div>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": node_page }),
)
.await;
for (label, expression, expected_type, expected_result) in [
(
"attribute",
"document.querySelector('#attr').attributes[0]",
2,
Some(json!({})),
),
(
"text",
"document.querySelector('#text-node').childNodes[1]",
3,
Some(json!({})),
),
(
"comment",
"document.querySelector('#comment').childNodes[0]",
8,
Some(json!({})),
),
("document", "document", 9, None),
("doctype", "document.doctype", 10, Some(json!({}))),
] {
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": format!("const result = {expression}; return {{ result, type: result.nodeType }};"),
"args": []
}),
)
.await;
assert_eq!(
response["value"]["type"],
json!(expected_type),
"{label}: {response:?}"
);
if let Some(expected_result) = expected_result {
assert_eq!(
response["value"]["result"], expected_result,
"{label}: {response:?}"
);
} else {
assert!(
response["value"]["result"].get("location").is_some(),
"{label}: expected serialized document to expose location: {response:?}"
);
}
}
let reference_page = classic_data_url(
"<div id='target'></div><div id='host'></div>\
<script>document.querySelector('#host').attachShadow({ mode: 'open' }).innerHTML = '<span>inside</span>';</script>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": reference_page }),
)
.await;
let target_id = classic_find_css_element_id(app.clone(), session_id, "#target").await;
let element_reference = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('#target');",
"args": []
}),
)
.await;
let returned_target_id = element_reference["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("expected WebElement reference: {element_reference:?}"));
assert_eq!(
returned_target_id, target_id,
"script-returned element should reuse the find-element WebElement id"
);
let same = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{returned_target_id}/equals/{target_id}"),
)
.await;
assert_eq!(same, json!({ "value": true }));
let shadow_reference = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('#host').shadowRoot;",
"args": []
}),
)
.await;
let shadow_id = shadow_reference["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("expected ShadowRoot reference: {shadow_reference:?}"))
.to_owned();
let (detached_shadow_status, detached_shadow) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "const [host, shadowRoot] = arguments; host.remove(); return shadowRoot;",
"args": [
{ CLASSIC_ELEMENT_REFERENCE_KEY: classic_find_css_element_id(app.clone(), session_id, "#host").await },
{ CLASSIC_SHADOW_ROOT_REFERENCE_KEY: shadow_id }
]
}),
)
.await;
assert_eq!(detached_shadow_status, StatusCode::NOT_FOUND);
assert_eq!(
detached_shadow["value"]["error"],
json!("detached shadow root")
);
let stale_page = classic_data_url("<div id='stale'></div>");
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": stale_page }),
)
.await;
let stale_id = classic_find_css_element_id(app.clone(), session_id, "#stale").await;
let (stale_status, stale) = classic_request_status_and_json_with_body(
app,
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "const elem = arguments[0]; elem.remove(); return elem;",
"args": [{ CLASSIC_ELEMENT_REFERENCE_KEY: stale_id }]
}),
)
.await;
assert_eq!(stale_status, StatusCode::NOT_FOUND);
assert_eq!(stale["value"]["error"], json!("stale element reference"));
}
#[tokio::test]
async fn webdriver_classic_execute_async_script_node_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_async_script/node.py top-context node type, web reference, stale
// element, and detached shadow root cases.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let node_page = classic_data_url(
"<!doctype html><div id='attr' data-kind='v'></div>\
<div id='text-node'><p></p>Lorem</div>\
<div id='comment'><!-- Comment --></div>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": node_page }),
)
.await;
for (label, expression, expected_type, expected_result) in [
(
"attribute",
"document.querySelector('#attr').attributes[0]",
2,
Some(json!({})),
),
(
"text",
"document.querySelector('#text-node').childNodes[1]",
3,
Some(json!({})),
),
(
"comment",
"document.querySelector('#comment').childNodes[0]",
8,
Some(json!({})),
),
("document", "document", 9, None),
("doctype", "document.doctype", 10, Some(json!({}))),
] {
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": format!("const resolve = arguments[0]; const result = {expression}; resolve({{ result, type: result.nodeType }});"),
"args": []
}),
)
.await;
assert_eq!(
response["value"]["type"],
json!(expected_type),
"{label}: {response:?}"
);
if let Some(expected_result) = expected_result {
assert_eq!(
response["value"]["result"], expected_result,
"{label}: {response:?}"
);
} else {
assert!(
response["value"]["result"].get("location").is_some(),
"{label}: expected serialized document to expose location: {response:?}"
);
}
}
let reference_page = classic_data_url(
"<div id='target'></div><div id='host'></div>\
<script>document.querySelector('#host').attachShadow({ mode: 'open' }).innerHTML = '<span>inside</span>';</script>",
);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": reference_page }),
)
.await;
let target_id = classic_find_css_element_id(app.clone(), session_id, "#target").await;
let element_reference = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('#target'));",
"args": []
}),
)
.await;
let returned_target_id = element_reference["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("expected WebElement reference: {element_reference:?}"));
let same = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{returned_target_id}/equals/{target_id}"),
)
.await;
assert_eq!(same, json!({ "value": true }));
let shadow_reference = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[0](document.querySelector('#host').shadowRoot);",
"args": []
}),
)
.await;
let shadow_id = shadow_reference["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("expected ShadowRoot reference: {shadow_reference:?}"))
.to_owned();
let (detached_shadow_status, detached_shadow) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "const [host, shadowRoot, resolve] = arguments; host.remove(); resolve(shadowRoot);",
"args": [
{ CLASSIC_ELEMENT_REFERENCE_KEY: classic_find_css_element_id(app.clone(), session_id, "#host").await },
{ CLASSIC_SHADOW_ROOT_REFERENCE_KEY: shadow_id }
]
}),
)
.await;
assert_eq!(detached_shadow_status, StatusCode::NOT_FOUND);
assert_eq!(
detached_shadow["value"]["error"],
json!("detached shadow root")
);
let stale_page = classic_data_url("<div id='stale'></div>");
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": stale_page }),
)
.await;
let stale_id = classic_find_css_element_id(app.clone(), session_id, "#stale").await;
let (stale_status, stale) = classic_request_status_and_json_with_body(
app,
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "const [elem, resolve] = arguments; elem.remove(); resolve(elem);",
"args": [{ CLASSIC_ELEMENT_REFERENCE_KEY: stale_id }]
}),
)
.await;
assert_eq!(stale_status, StatusCode::NOT_FOUND);
assert_eq!(stale["value"]["error"], json!("stale element reference"));
}
#[tokio::test]
async fn webdriver_classic_execute_script_object_and_cyclic_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/{objects.py,cyclic.py}.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
for (label, script, expected) in [
(
"object",
"return { foo: 23, bar: true };",
json!({ "foo": 23, "bar": true }),
),
(
"nested object",
"return { foo: { cheese: 23 }, bar: true };",
json!({ "foo": { "cheese": 23 }, "bar": true }),
),
(
"inherited enumerable object property",
"const proto = { inherited: 2 }; const value = Object.create(proto); value.own = 1; return value;",
json!({ "own": 1, "inherited": 2 }),
),
(
"object toJSON",
"return { toJSON() { return ['foo', 'bar']; } };",
json!(["foo", "bar"]),
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(status, StatusCode::OK, "{label}: {response:?}");
assert_eq!(response, json!({ "value": expected }), "{label}");
}
for (label, script) in [
(
"object toJSON exception",
"return { toJSON() { throw Error('fail'); } };",
),
(
"collection self reference",
"let arr = []; arr.push(arr); return arr;",
),
(
"object self reference",
"let obj = {}; obj.reference = obj; return obj;",
),
(
"collection self reference in object",
"let arr = []; arr.push(arr); return { value: arr };",
),
(
"object self reference in collection",
"let obj = {}; obj.reference = obj; return [obj];",
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(
status,
StatusCode::INTERNAL_SERVER_ERROR,
"{label}: {response:?}"
);
assert_eq!(
response["value"]["error"],
json!("javascript error"),
"{label}: {response:?}"
);
}
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": "data:text/html,<div></div>" }),
)
.await;
let div_id = classic_find_css_element_id(app.clone(), session_id, "div").await;
for (label, script) in [
(
"element self reference",
"let div = document.querySelector('div'); div.reference = div; return div;",
),
(
"element self reference in collection",
"let div = document.querySelector('div'); div.reference = div; return [div];",
),
(
"element self reference in object",
"let div = document.querySelector('div'); div.reference = div; return { foo: div };",
),
] {
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": script,
"args": []
}),
)
.await;
let value = match label {
"element self reference in collection" => response["value"][0].clone(),
"element self reference in object" => response["value"]["foo"].clone(),
_ => response["value"].clone(),
};
let returned_id = value[CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{label}: expected WebElement response: {response:?}"));
let same = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{returned_id}/equals/{div_id}"),
)
.await;
assert_eq!(same, json!({ "value": true }), "{label}");
}
}
#[tokio::test]
async fn webdriver_classic_execute_async_script_object_and_cyclic_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_async_script/{objects.py,cyclic.py}.
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
for (label, script, expected) in [
(
"object",
"arguments[0]({ foo: 23, bar: true });",
json!({ "foo": 23, "bar": true }),
),
(
"nested object",
"arguments[0]({ foo: { cheese: 23 }, bar: true });",
json!({ "foo": { "cheese": 23 }, "bar": true }),
),
(
"inherited enumerable object property",
"const proto = { inherited: 2 }; const value = Object.create(proto); value.own = 1; arguments[0](value);",
json!({ "own": 1, "inherited": 2 }),
),
(
"object toJSON",
"arguments[0]({ toJSON() { return ['foo', 'bar']; } });",
json!(["foo", "bar"]),
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(status, StatusCode::OK, "{label}: {response:?}");
assert_eq!(response, json!({ "value": expected }), "{label}");
}
for (label, script) in [
(
"object toJSON exception",
"arguments[0]({ toJSON() { throw Error('fail'); } });",
),
(
"collection self reference",
"let arr = []; arr.push(arr); arguments[0](arr);",
),
(
"object self reference",
"let obj = {}; obj.reference = obj; arguments[0](obj);",
),
(
"collection self reference in object",
"let arr = []; arr.push(arr); arguments[0]({ value: arr });",
),
(
"object self reference in collection",
"let obj = {}; obj.reference = obj; arguments[0]([obj]);",
),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": script,
"args": []
}),
)
.await;
assert_eq!(
status,
StatusCode::INTERNAL_SERVER_ERROR,
"{label}: {response:?}"
);
assert_eq!(
response["value"]["error"],
json!("javascript error"),
"{label}: {response:?}"
);
}
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": "data:text/html,<div></div>" }),
)
.await;
let div_id = classic_find_css_element_id(app.clone(), session_id, "div").await;
for (label, script) in [
(
"element self reference",
"let div = document.querySelector('div'); div.reference = div; arguments[0](div);",
),
(
"element self reference in collection",
"let div = document.querySelector('div'); div.reference = div; arguments[0]([div]);",
),
(
"element self reference in object",
"let div = document.querySelector('div'); div.reference = div; arguments[0]({ foo: div });",
),
] {
let response = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": script,
"args": []
}),
)
.await;
let value = match label {
"element self reference in collection" => response["value"][0].clone(),
"element self reference in object" => response["value"]["foo"].clone(),
_ => response["value"].clone(),
};
let returned_id = value[CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{label}: expected WebElement response: {response:?}"));
let same = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{returned_id}/equals/{div_id}"),
)
.await;
assert_eq!(same, json!({ "value": true }), "{label}");
}
}
#[tokio::test]
async fn webdriver_classic_timer_dialog_completion_resumes_javascript_return_values() {
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let execute_path = format!("/session/{session_id}/execute/sync");
let alert_text_path = format!("/session/{session_id}/alert/text");
let alert_accept_path = format!("/session/{session_id}/alert/accept");
let alert_dismiss_path = format!("/session/{session_id}/alert/dismiss");
classic_open_dialog_and_wait(
app.clone(),
session_id,
"window.__dialogResults = {}; setTimeout(() => { window.__dialogResults.confirmAccept = confirm('confirm accept'); }, 0); return 'opened';",
"confirm accept",
)
.await;
assert_eq!(
classic_request_json(app.clone(), Method::POST, &alert_accept_path).await,
json!({ "value": null })
);
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": "return window.__dialogResults.confirmAccept;",
"args": []
}),
)
.await,
json!({ "value": true })
);
classic_open_dialog_and_wait(
app.clone(),
session_id,
"setTimeout(() => { window.__dialogResults.confirmDismiss = confirm('confirm dismiss'); }, 0); return 'opened';",
"confirm dismiss",
)
.await;
assert_eq!(
classic_request_json(app.clone(), Method::POST, &alert_dismiss_path).await,
json!({ "value": null })
);
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": "return window.__dialogResults.confirmDismiss;",
"args": []
}),
)
.await,
json!({ "value": false })
);
classic_open_dialog_and_wait(
app.clone(),
session_id,
"setTimeout(() => { window.__dialogResults.promptAccept = prompt('prompt accept', 'default'); }, 0); return 'opened';",
"prompt accept",
)
.await;
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&alert_text_path,
json!({ "text": "entered" })
)
.await,
json!({ "value": null })
);
assert_eq!(
classic_request_json(app.clone(), Method::POST, &alert_accept_path).await,
json!({ "value": null })
);
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": "return window.__dialogResults.promptAccept;",
"args": []
}),
)
.await,
json!({ "value": "entered" })
);
classic_open_dialog_and_wait(
app.clone(),
session_id,
"setTimeout(() => { window.__dialogResults.promptDismiss = prompt('prompt dismiss', 'default'); }, 0); return 'opened';",
"prompt dismiss",
)
.await;
assert_eq!(
classic_request_json(app.clone(), Method::POST, &alert_dismiss_path).await,
json!({ "value": null })
);
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&execute_path,
json!({
"script": "return window.__dialogResults.promptDismiss;",
"args": []
}),
)
.await,
json!({ "value": null })
);
let _ = classic_request_json(app, Method::DELETE, &format!("/session/{session_id}")).await;
}
#[tokio::test]
async fn webdriver_classic_execute_user_prompt_behavior_matches_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/user_prompts.py and execute_async_script/user_prompts.py
// alert/confirm/prompt cases. beforeunload navigation remains covered by
// prompt-neutral navigation/window command tests.
let app = build_router(test_state());
struct ExecutePromptCase {
capability: Option<serde_json::Value>,
script_kind: &'static str,
dialog_script: &'static str,
expect_notify: bool,
expect_closed: bool,
}
let cases = [
ExecutePromptCase {
capability: Some(json!("accept")),
script_kind: "sync",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("accept and notify")),
script_kind: "sync",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("dismiss")),
script_kind: "sync",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("dismiss and notify")),
script_kind: "sync",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("ignore")),
script_kind: "sync",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: false,
},
ExecutePromptCase {
capability: None,
script_kind: "sync",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("accept")),
script_kind: "async",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("accept and notify")),
script_kind: "async",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("dismiss")),
script_kind: "async",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("dismiss and notify")),
script_kind: "async",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ExecutePromptCase {
capability: Some(json!("ignore")),
script_kind: "async",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: false,
},
ExecutePromptCase {
capability: None,
script_kind: "async",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
];
for case in cases {
let session_body = match &case.capability {
Some(capability) => json!({
"capabilities": {
"alwaysMatch": {
"unhandledPromptBehavior": capability
}
}
}),
None => json!({
"capabilities": {
"alwaysMatch": {}
}
}),
};
let session =
classic_request_json_with_body(app.clone(), Method::POST, "/session", session_body)
.await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let url = classic_data_url("<title>execute prompt</title>");
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": url }),
)
.await,
json!({ "value": null })
);
classic_open_dialog_and_wait(app.clone(), session_id, case.dialog_script, "cheese").await;
let execute_path = format!("/session/{session_id}/execute/{}", case.script_kind);
let execute_body = if case.script_kind == "sync" {
json!({
"script": "window.result = 1; return 1;",
"args": []
})
} else {
json!({
"script": "window.result = 1; arguments[arguments.length - 1](1);",
"args": []
})
};
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&execute_path,
execute_body,
)
.await;
if case.expect_notify {
assert_eq!(
status,
StatusCode::INTERNAL_SERVER_ERROR,
"capability {:?} {} response {response:?}",
case.capability,
case.script_kind
);
assert_eq!(response["value"]["error"], json!("unexpected alert open"));
assert_eq!(response["value"]["data"], json!({ "text": "cheese" }));
} else {
assert_eq!(
status,
StatusCode::OK,
"capability {:?} {} response {response:?}",
case.capability,
case.script_kind
);
assert_eq!(response, json!({ "value": 1 }));
}
let alert_text_path = format!("/session/{session_id}/alert/text");
let (alert_status, alert_text) =
classic_request_status_and_json(app.clone(), Method::GET, &alert_text_path).await;
if case.expect_closed {
assert_eq!(alert_status, StatusCode::NOT_FOUND, "{alert_text:?}");
assert_eq!(alert_text["value"]["error"], json!("no such alert"));
} else {
assert_eq!(alert_status, StatusCode::OK, "{alert_text:?}");
assert_eq!(alert_text, json!({ "value": "cheese" }));
assert_eq!(
classic_request_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/alert/dismiss"),
)
.await,
json!({ "value": null })
);
}
let result = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return window.result ?? null;",
"args": []
}),
)
.await;
if case.expect_notify {
assert_eq!(
result,
json!({ "value": null }),
"notified {} command must not run after prompt preflight",
case.script_kind
);
} else {
assert_eq!(
result,
json!({ "value": 1 }),
"non-notifying {} command should run after prompt handling",
case.script_kind
);
}
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
}
}
#[tokio::test]
async fn webdriver_classic_cookie_routes_execute_through_devtools_runtime() {
let (fixture_addr, fixture_server) = spawn_classic_cookie_fixture_server().await;
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let page_url = format!("http://{fixture_addr}/page");
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": page_url }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let added = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/cookie"),
json!({
"cookie": {
"name": "sid",
"value": "abc",
"path": "/",
"httpOnly": true,
"sameSite": "Lax"
}
}),
)
.await;
assert_eq!(added, json!({ "value": null }));
let cookies = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/cookie"),
)
.await;
let cookies = cookies["value"].as_array().expect("cookies");
let sid = cookies
.iter()
.find(|cookie| cookie["name"] == json!("sid"))
.expect("sid cookie");
assert_eq!(sid["value"], json!("abc"));
assert_eq!(sid["httpOnly"], json!(true));
assert_eq!(sid["sameSite"], json!("Lax"));
let named = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/cookie/sid"),
)
.await;
assert_eq!(named["value"]["name"], json!("sid"));
assert_eq!(named["value"]["value"], json!("abc"));
let (missing_status, missing) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/cookie/missing"),
)
.await;
assert_eq!(missing_status, StatusCode::NOT_FOUND);
assert_eq!(missing["value"]["error"], json!("no such cookie"));
let (invalid_status, invalid) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/cookie"),
json!({
"cookie": {
"name": false,
"value": "abc"
}
}),
)
.await;
assert_eq!(invalid_status, StatusCode::BAD_REQUEST);
assert_eq!(invalid["value"]["error"], json!("invalid argument"));
let deleted = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}/cookie/sid"),
)
.await;
assert_eq!(deleted, json!({ "value": null }));
let cookies = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/cookie"),
)
.await;
assert_eq!(cookies["value"], json!([]));
for (name, value) in [("sid", "abc"), ("theme", "dark")] {
let added = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/cookie"),
json!({
"cookie": {
"name": name,
"value": value,
"path": "/"
}
}),
)
.await;
assert_eq!(added, json!({ "value": null }));
}
let deleted = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}/cookie"),
)
.await;
assert_eq!(deleted, json!({ "value": null }));
let cookies = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/cookie"),
)
.await;
assert_eq!(cookies["value"], json!([]));
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
fixture_server.abort();
}