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_hidden_scrollbars_preserve_server_configuration() {
let state = AppState::new_with_storage_partition_and_runtime_config(
"127.0.0.1:9222".parse().unwrap(),
Arc::new(StoragePartitionState::open(None).unwrap()),
protocol_server_test_runtime_config(
protocol_server_test_fetch_config(FetchConfig::default()),
OptionalResourceFetchMask::NONE,
)
.with_scrollbars_hidden(true),
crate::config::DEFAULT_SCREENCAST_INTERVAL_MS,
BrowserInstanceControl::new(),
)
.unwrap();
let app = build_router(state);
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let id = session["value"]["sessionId"].as_str().expect("session id");
let navigated = classic_request_json_with_body(app.clone(),Method::POST,&format!("/session/{id}/url"),json!({
"url":"data:text/html,<!doctype html><body style='margin:0'><div style='width:100vw;height:2000px'></div>"
})).await;
assert_eq!(navigated, json!({"value":null}));
classic_capture_layout(app.clone(), id).await;
let metrics = classic_request_json_with_body(app.clone(),Method::POST,&format!("/session/{id}/execute/sync"),json!({
"script":"return [innerWidth - document.documentElement.clientWidth,document.documentElement.scrollWidth - innerWidth];",
"args":[]
})).await;
assert_eq!(metrics, json!({"value":[0,0]}));
let deleted = classic_request_json(app, Method::DELETE, &format!("/session/{id}")).await;
assert_eq!(deleted, json!({"value":null}));
}
#[tokio::test]
async fn webdriver_classic_element_equality_cases_ported_from_selenium() {
// Ported from Selenium's Python element_equality_tests.py:
// same element found through different locator strategies should compare equal,
// while different elements should not.
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 navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": "data:text/html,<body><div id='one'>one</div></body>"
}),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let body = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "tag name",
"value": "body"
}),
)
.await;
let body_id = body["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.expect("body element id");
let xpath_body = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "xpath",
"value": "//body"
}),
)
.await;
let xpath_body_id = xpath_body["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.expect("xpath body element id");
assert_eq!(
xpath_body_id, body_id,
"the session node reference store should reuse an element id across locator strategies"
);
let div = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "tag name",
"value": "div"
}),
)
.await;
let div_id = div["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.expect("div element id");
let same = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/equals/{xpath_body_id}"),
)
.await;
assert_eq!(same, json!({ "value": true }));
let same_trailing_slash = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/equals/{xpath_body_id}/"),
)
.await;
assert_eq!(same_trailing_slash, json!({ "value": true }));
let different = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/equals/{div_id}"),
)
.await;
assert_eq!(different, json!({ "value": false }));
let (invalid_status, invalid) = classic_request_status_and_json(
app,
Method::GET,
&format!("/session/{session_id}/element/{body_id}/equals/not-a-moli-node"),
)
.await;
assert_eq!(invalid_status, StatusCode::NOT_FOUND);
assert_eq!(invalid["value"]["error"], json!("no such element"));
}
#[tokio::test]
async fn webdriver_classic_execute_script_resolves_webelement_arguments() {
// Mirrors Selenium JavascriptExecutor usage where WebElement arguments are
// exposed to user script as DOM elements, including nested argument shapes.
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 first_url =
classic_data_url("<body><main id='target' data-kind='primary'>Text</main></body>");
let second_url = classic_data_url("<body><main id='target'>Replacement</main></body>");
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": first_url }),
)
.await;
let element_id = classic_find_css_element_id(app.clone(), session_id, "#target").await;
let element_ref = json!({
CLASSIC_ELEMENT_REFERENCE_KEY: element_id.clone(),
});
let sync = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].getAttribute('data-kind') + ':' + arguments[0].textContent;",
"args": [element_ref.clone()]
}),
)
.await;
assert_eq!(sync, json!({ "value": "primary:Text" }));
let nested = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].node.id + ':' + arguments[1][0].textContent;",
"args": [
{ "node": element_ref.clone() },
[element_ref.clone()]
]
}),
)
.await;
assert_eq!(nested, json!({ "value": "target:Text" }));
let async_result = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[arguments.length - 1](arguments[0].id);",
"args": [element_ref.clone()]
}),
)
.await;
assert_eq!(async_result, json!({ "value": "target" }));
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": second_url }),
)
.await;
let (stale_status, stale) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].id;",
"args": [element_ref]
}),
)
.await;
assert_eq!(stale_status, StatusCode::NOT_FOUND);
assert_eq!(stale["value"]["error"], json!("stale element reference"));
let node_id = element_id
.strip_prefix("moli-node-")
.and_then(|value| value.split_once("-element-").map(|(node_id, _)| node_id))
.expect("owner-shaped element id contains node id");
let forged_legacy_ref = json!({
CLASSIC_ELEMENT_REFERENCE_KEY: format!("moli-node-{node_id}"),
});
let (forged_status, forged) = classic_request_status_and_json_with_body(
app,
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].id;",
"args": [forged_legacy_ref]
}),
)
.await;
assert_eq!(forged_status, StatusCode::NOT_FOUND);
assert_eq!(forged["value"]["error"], json!("no such element"));
}
#[tokio::test]
async fn webdriver_classic_execute_script_dom_token_list_case_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// execute_script/collections.py test_dom_token_list.
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 = classic_data_url(r#"<div class="no cheese">foo</div>"#);
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": page_url }),
)
.await;
let element_id = classic_find_css_element_id(app.clone(), session_id, "div").await;
let response = classic_request_json_with_body(
app,
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].classList;",
"args": [{
CLASSIC_ELEMENT_REFERENCE_KEY: element_id,
}]
}),
)
.await;
assert_eq!(response, json!({ "value": ["no", "cheese"] }));
}
#[tokio::test]
async fn webdriver_classic_execute_script_round_trips_shadow_root_references() {
// Ported from the shadow-root cases in Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/execute_script/
// arguments.py and node.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 html = r##"<!doctype html>
<custom-element id="host"></custom-element>
<script>
const host = document.querySelector("#host");
const root = host.attachShadow({ mode: "open" });
root.innerHTML = `<span id="inside">shadow text</span>`;
</script>"##;
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url(html) }),
)
.await;
let returned_shadow = 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 returned_shadow_id = returned_shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("execute returned shadow root reference: {returned_shadow:?}"))
.to_owned();
let host_id = classic_find_css_element_id(app.clone(), session_id, "#host").await;
let element_shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
assert_eq!(
element_shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY],
json!(returned_shadow_id.clone()),
"same ShadowRoot must keep the same WebDriver reference id"
);
let returned_shadow_again = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return document.querySelector('#host').shadowRoot;",
"args": []
}),
)
.await;
assert_eq!(
returned_shadow_again["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY],
json!(returned_shadow_id.clone()),
"repeated execute_script should reuse the same ShadowRoot id"
);
let text_from_shadow_arg = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].querySelector('#inside').textContent;",
"args": [{
CLASSIC_SHADOW_ROOT_REFERENCE_KEY: returned_shadow_id.clone()
}]
}),
)
.await;
assert_eq!(text_from_shadow_arg, json!({ "value": "shadow text" }));
let nested_shadow_arg = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].root.querySelector('#inside').id;",
"args": [{
"root": {
CLASSIC_SHADOW_ROOT_REFERENCE_KEY: returned_shadow_id.clone()
}
}]
}),
)
.await;
assert_eq!(nested_shadow_arg, json!({ "value": "inside" }));
let returned_element = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return arguments[0].querySelector('#inside');",
"args": [{
CLASSIC_SHADOW_ROOT_REFERENCE_KEY: returned_shadow_id.clone()
}]
}),
)
.await;
let returned_element_id = returned_element["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("execute returned element reference: {returned_element:?}"));
let returned_element_text = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{returned_element_id}/text"),
)
.await;
assert_eq!(returned_element_text, json!({ "value": "shadow text" }));
let async_shadow_arg = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/async"),
json!({
"script": "arguments[arguments.length - 1](arguments[0].querySelector('#inside').id);",
"args": [{
CLASSIC_SHADOW_ROOT_REFERENCE_KEY: returned_shadow_id.clone()
}]
}),
)
.await;
assert_eq!(async_shadow_arg, json!({ "value": "inside" }));
let host_id = classic_find_css_element_id(app.clone(), session_id, "#host").await;
let host_ref = json!({
CLASSIC_ELEMENT_REFERENCE_KEY: host_id,
});
let shadow_ref = json!({
CLASSIC_SHADOW_ROOT_REFERENCE_KEY: returned_shadow_id.clone(),
});
let (detached_return_status, detached_return) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "arguments[0].remove(); return arguments[1];",
"args": [host_ref, shadow_ref.clone()]
}),
)
.await;
assert_eq!(
detached_return_status,
StatusCode::NOT_FOUND,
"detached shadow root return response: {detached_return:?}"
);
assert_eq!(
detached_return["value"]["error"],
json!("detached shadow root")
);
let (detached_arg_status, detached_arg) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return true;",
"args": [shadow_ref]
}),
)
.await;
assert_eq!(detached_arg_status, StatusCode::NOT_FOUND);
assert_eq!(
detached_arg["value"]["error"],
json!("detached shadow root")
);
let (invalid_status, invalid) = classic_request_status_and_json_with_body(
app,
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return true;",
"args": [{
CLASSIC_SHADOW_ROOT_REFERENCE_KEY: 42
}]
}),
)
.await;
assert_eq!(invalid_status, StatusCode::BAD_REQUEST);
assert_eq!(invalid["value"]["error"], json!("invalid argument"));
}
#[tokio::test]
async fn webdriver_classic_element_user_prompt_behavior_matches_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// get_element_{attribute,property,css_value,text,tag_name}/user_prompts.py,
// is_element_{enabled,selected}/user_prompts.py,
// get_element_rect/user_prompts.py,
// get_active_element/user_prompts.py, and
// element_{clear,click,send_keys}/user_prompts.py.
let app = build_router(test_state());
struct ElementPromptCase {
capability: Option<serde_json::Value>,
endpoint: &'static str,
dialog_script: &'static str,
expect_notify: bool,
expect_closed: bool,
}
let cases = [
ElementPromptCase {
capability: Some(json!("accept")),
endpoint: "attribute",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("accept and notify")),
endpoint: "property",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("dismiss")),
endpoint: "css",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("dismiss and notify")),
endpoint: "text",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("ignore")),
endpoint: "name",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: false,
},
ElementPromptCase {
capability: None,
endpoint: "enabled",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!({"default": "accept", "prompt": "ignore"})),
endpoint: "selected",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: false,
},
ElementPromptCase {
capability: Some(json!("accept")),
endpoint: "rect",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("ignore")),
endpoint: "rect",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: false,
},
ElementPromptCase {
capability: Some(json!("accept")),
endpoint: "active",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("dismiss")),
endpoint: "clear",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("accept and notify")),
endpoint: "clear",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("accept")),
endpoint: "click",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("dismiss and notify")),
endpoint: "click",
dialog_script: "setTimeout(() => { confirm('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("dismiss")),
endpoint: "send_keys",
dialog_script: "setTimeout(() => { prompt('cheese', 'default'); }, 0); return 'opened';",
expect_notify: false,
expect_closed: true,
},
ElementPromptCase {
capability: Some(json!("ignore")),
endpoint: "send_keys",
dialog_script: "setTimeout(() => { alert('cheese'); }, 0); return 'opened';",
expect_notify: true,
expect_closed: false,
},
];
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(
r#"
<input id="foo" style="display:block;width:120px;height:40px" value="foo">
<p id="text">bar</p>
<input id="checked" type="checkbox" checked>
<input id="active">
<input id="clear" value="foo">
<button id="click" onclick="window.__clicked = true">click</button>
<input id="send" value="">
<script>window.__clicked = false;</script>
"#,
);
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": url }),
)
.await,
json!({ "value": null })
);
classic_capture_layout(app.clone(), session_id).await;
let foo_id = classic_find_css_element_id(app.clone(), session_id, "#foo").await;
let text_id = classic_find_css_element_id(app.clone(), session_id, "#text").await;
let checked_id = classic_find_css_element_id(app.clone(), session_id, "#checked").await;
let clear_id = classic_find_css_element_id(app.clone(), session_id, "#clear").await;
let click_id = classic_find_css_element_id(app.clone(), session_id, "#click").await;
let send_id = classic_find_css_element_id(app.clone(), session_id, "#send").await;
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.getElementById('active').focus(); window.__clicked = false; return 'prepared';",
"args": []
}),
)
.await,
json!({ "value": "prepared" })
);
classic_open_dialog_and_wait(app.clone(), session_id, case.dialog_script, "cheese").await;
let (status, response) = match case.endpoint {
"attribute" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{foo_id}/attribute/id"),
)
.await
}
"property" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{foo_id}/property/id"),
)
.await
}
"css" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{foo_id}/css/display"),
)
.await
}
"text" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{text_id}/text"),
)
.await
}
"name" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{foo_id}/name"),
)
.await
}
"enabled" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{foo_id}/enabled"),
)
.await
}
"selected" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{checked_id}/selected"),
)
.await
}
"rect" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{foo_id}/rect"),
)
.await
}
"active" => {
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/active"),
)
.await
}
"clear" => {
classic_request_status_and_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{clear_id}/clear"),
)
.await
}
"click" => {
classic_request_status_and_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{click_id}/click"),
)
.await
}
"send_keys" => {
classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{send_id}/value"),
json!({ "text": "typed" }),
)
.await
}
endpoint => panic!("unknown element prompt endpoint: {endpoint}"),
};
if case.expect_notify {
assert_eq!(
status,
StatusCode::INTERNAL_SERVER_ERROR,
"capability {:?} endpoint {} response {response:?}",
case.capability,
case.endpoint
);
assert_eq!(response["value"]["error"], json!("unexpected alert open"));
assert_eq!(response["value"]["data"], json!({ "text": "cheese" }));
} else {
assert_eq!(
status,
StatusCode::OK,
"capability {:?} endpoint {} response {response:?}",
case.capability,
case.endpoint
);
match case.endpoint {
"attribute" | "property" => assert_eq!(response, json!({ "value": "foo" })),
"css" => assert_eq!(response, json!({ "value": "block" })),
"text" => assert_eq!(response, json!({ "value": "bar" })),
"name" => assert_eq!(response, json!({ "value": "input" })),
"enabled" | "selected" => assert_eq!(response, json!({ "value": true })),
"rect" => {
let value = &response["value"];
assert_eq!(value["x"].as_f64(), Some(8.0), "{response:?}");
assert_eq!(value["y"].as_f64(), Some(8.0), "{response:?}");
assert_eq!(value["width"].as_f64(), Some(120.0), "{response:?}");
assert_eq!(value["height"].as_f64(), Some(40.0), "{response:?}");
}
"active" => {
let active_id = response["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("active element response: {response:?}"));
let active_property = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{active_id}/property/id"),
)
.await;
assert_eq!(active_property, json!({ "value": "active" }));
}
"clear" | "click" | "send_keys" => {
assert_eq!(response, json!({ "value": null }))
}
endpoint => panic!("unknown successful endpoint: {endpoint}"),
}
}
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 command_ran = !case.expect_notify;
if case.endpoint == "clear" {
let value = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{clear_id}/property/value"),
)
.await;
assert_eq!(
value,
json!({ "value": if command_ran { "" } else { "foo" } })
);
} else if case.endpoint == "click" {
let clicked = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return Boolean(window.__clicked);",
"args": []
}),
)
.await;
assert_eq!(clicked, json!({ "value": command_ran }));
} else if case.endpoint == "send_keys" {
let value = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{send_id}/property/value"),
)
.await;
assert_eq!(
value,
json!({ "value": if command_ran { "typed" } else { "" } })
);
}
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
}
}
#[tokio::test]
async fn webdriver_classic_get_element_tag_name_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// get_element_tag_name/get.py test_no_such_element_with_invalid_value
// and test_get_element_tag_name.
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 (invalid_status, invalid) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/foo/name"),
)
.await;
assert_eq!(invalid_status, StatusCode::NOT_FOUND);
assert_eq!(invalid["value"]["error"], json!("no such element"));
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": "data:text/html,<input id=foo>"
}),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let element = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "css selector",
"value": "input"
}),
)
.await;
let element_id = element["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.expect("input element reference id");
let tag_name = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/name"),
)
.await;
assert_eq!(tag_name, json!({ "value": "input" }));
}
#[tokio::test]
async fn webdriver_classic_get_element_rect_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// get_element_rect/get.py invalid element and rect payload shape cases.
// The response is now backed by the same real layout box model used by
// CDP and CSSOM View.
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 (invalid_status, invalid) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/foo/rect"),
)
.await;
assert_eq!(invalid_status, StatusCode::NOT_FOUND);
assert_eq!(invalid["value"]["error"], json!("no such element"));
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": "data:text/html,<div id=target style='width:120px;height:40px'></div>"
}),
)
.await;
classic_capture_layout(app.clone(), session_id).await;
assert_eq!(navigated, json!({ "value": null }));
let element_id = classic_find_css_element_id(app.clone(), session_id, "#target").await;
let rect = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/rect"),
)
.await;
let value = &rect["value"];
assert_eq!(value["x"].as_f64(), Some(8.0));
assert_eq!(value["y"].as_f64(), Some(8.0));
assert_eq!(value["width"].as_f64(), Some(120.0));
assert_eq!(value["height"].as_f64(), Some(40.0));
}
#[tokio::test]
async fn webdriver_classic_element_state_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// is_element_selected/selected.py checked/option cases and
// is_element_enabled/enabled.py direct form-control enabled/disabled 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");
for endpoint in ["enabled", "selected"] {
let (invalid_status, invalid) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/foo/{endpoint}"),
)
.await;
assert_eq!(invalid_status, StatusCode::NOT_FOUND, "{endpoint}");
assert_eq!(
invalid["value"]["error"],
json!("no such element"),
"{endpoint}"
);
}
let html = concat!(
"<input id=checked type=checkbox checked>",
"<input id=notChecked type=checkbox>",
"<select><option id=notSelected>r-</option><option id=selected selected>r+</option></select>",
"<input id=enabledInput>",
"<input id=disabledInput disabled>",
"<button id=enabledButton></button>",
"<button id=disabledButton disabled></button>",
"<textarea id=enabledTextarea></textarea>",
"<textarea id=disabledTextarea disabled></textarea>",
"<select id=enabledSelect></select>",
"<select id=disabledSelect disabled></select>",
"<select><optgroup id=enabledOptgroup><option id=optionInEnabledOptgroup>og+</option></optgroup></select>",
"<select><optgroup id=disabledOptgroup disabled><option id=optionInDisabledOptgroup>og-</option></optgroup></select>",
"<select id=disabledSelectWithOptions disabled><optgroup id=optgroupInDisabledSelect><option id=optionInDisabledSelect>ds-</option></optgroup></select>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": format!("data:text/html,{html}")
}),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
for (selector, expected) in [
("#checked", true),
("#notChecked", false),
("#selected", true),
("#notSelected", false),
] {
let element_id = classic_find_css_element_id(app.clone(), session_id, selector).await;
let response = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/selected"),
)
.await;
assert_eq!(response, json!({ "value": expected }), "{selector}");
}
for (selector, expected) in [
("#enabledInput", true),
("#disabledInput", false),
("#enabledButton", true),
("#disabledButton", false),
("#enabledTextarea", true),
("#disabledTextarea", false),
("#enabledSelect", true),
("#disabledSelect", false),
("#enabledOptgroup", true),
("#optionInEnabledOptgroup", true),
("#disabledOptgroup", false),
("#optionInDisabledOptgroup", false),
("#disabledSelectWithOptions", false),
("#optgroupInDisabledSelect", false),
("#optionInDisabledSelect", false),
] {
let element_id = classic_find_css_element_id(app.clone(), session_id, selector).await;
let response = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/enabled"),
)
.await;
assert_eq!(response, json!({ "value": expected }), "{selector}");
}
let stale_id = classic_find_css_element_id(app.clone(), session_id, "#enabledInput").await;
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.querySelector('#enabledInput').remove(); return 'removed';",
"args": []
}),
)
.await,
json!({ "value": "removed" })
);
let (stale_status, stale) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{stale_id}/enabled"),
)
.await;
assert_eq!(stale_status, StatusCode::NOT_FOUND, "{stale:?}");
assert_eq!(stale["value"]["error"], json!("stale element reference"));
}
#[tokio::test]
async fn webdriver_classic_get_element_attribute_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// get_element_attribute/get.py normal, boolean attribute, global boolean
// attribute, and anchor href cases. ChromeDriver implements the boolean
// branch in chrome/test/chromedriver/element_commands.cc:
// ExecuteGetElementAttribute.
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 html = concat!(
"<input id='checkbox' type='checkbox'>",
"<input id='checked' type='checkbox' checked>",
"<input id='disabled' disabled='false'>",
"<p id='hidden' hidden>foo</p>",
"<p id='plain'>foo</p>",
"<p id='scoped' itemscope>foo</p>",
"<a id='relative' href='/foo.html'>foo</a>",
"<a id='absolute' href='https://example.test/foo.html'>foo</a>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": classic_data_url(html)
}),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let checkbox_id = classic_find_css_element_id(app.clone(), session_id, "#checkbox").await;
let missing_checked = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{checkbox_id}/attribute/checked"),
)
.await;
assert_eq!(missing_checked, json!({ "value": null }));
let property_only_checked = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.querySelector('#checkbox').checked = true; return document.querySelector('#checkbox').checked;",
"args": []
}),
)
.await;
assert_eq!(property_only_checked, json!({ "value": true }));
let still_missing_checked = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{checkbox_id}/attribute/checked"),
)
.await;
assert_eq!(still_missing_checked, json!({ "value": null }));
for (selector, name) in [
("#checked", "checked"),
("#disabled", "disabled"),
("#hidden", "hidden"),
("#scoped", "itemscope"),
] {
let element_id = classic_find_css_element_id(app.clone(), session_id, selector).await;
let response = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/attribute/{name}"),
)
.await;
assert_eq!(response, json!({ "value": "true" }), "{selector} {name}");
}
let plain_id = classic_find_css_element_id(app.clone(), session_id, "#plain").await;
let absent_hidden = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{plain_id}/attribute/hidden"),
)
.await;
assert_eq!(absent_hidden, json!({ "value": null }));
let relative_id = classic_find_css_element_id(app.clone(), session_id, "#relative").await;
let relative_href = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{relative_id}/attribute/href"),
)
.await;
assert_eq!(relative_href, json!({ "value": "/foo.html" }));
let absolute_id = classic_find_css_element_id(app.clone(), session_id, "#absolute").await;
let absolute_href = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{absolute_id}/attribute/href"),
)
.await;
assert_eq!(
absolute_href,
json!({ "value": "https://example.test/foo.html" })
);
}
#[tokio::test]
async fn webdriver_classic_get_element_property_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// get_element_property/get.py content/IDL attribute, primitive,
// DOMTokenList, WebElement/WebFrame/ShadowRoot/WebWindow, mutated checkbox,
// and anchor href cases. ChromeDriver implements this by evaluating
// `function(elem, name) { return elem[name] }`.
let app = build_router(test_state());
let (fixture_addr, fixture_server) = spawn_classic_frame_fixture_server().await;
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 body_id = classic_find_css_element_id(app.clone(), session_id, "body").await;
let seeded = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": r#"
const parent = document.body;
const div = document.querySelector('#top-main');
const input = document.createElement('input');
input.id = 'property-input';
input.value = 'foobar';
document.body.appendChild(input);
const box = document.createElement('input');
box.id = 'property-checkbox';
box.type = 'checkbox';
document.body.appendChild(box);
const classes = document.createElement('div');
classes.id = 'property-classes';
classes.className = 'no cheese';
document.body.appendChild(classes);
const host = document.createElement('div');
host.id = 'property-host';
host.attachShadow({ mode: 'open' }).innerHTML = '<span>shadow</span>';
document.body.appendChild(host);
const link = document.createElement('a');
link.id = 'property-link';
link.href = '/foo.html';
document.body.appendChild(link);
parent.__string = 'foobar';
parent.__number = 42;
parent.__array = [];
parent.__object = {};
parent.__null = null;
parent.__undefined = undefined;
parent.__element = div;
parent.__frame = document.querySelector('#child').contentWindow;
parent.__shadowRoot = host.shadowRoot;
parent.__window = document.defaultView;
return 'seeded';
"#,
"args": []
}),
)
.await;
assert_eq!(seeded, json!({ "value": "seeded" }));
classic_capture_layout(app.clone(), session_id).await;
for (property, expected) in [
("__string", json!("foobar")),
("__number", json!(42)),
("__array", json!([])),
("__object", json!({})),
("__null", json!(null)),
("__undefined", json!(null)),
("doesNotExist", json!(null)),
] {
let response = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/property/{property}"),
)
.await;
assert_eq!(response, json!({ "value": expected }), "{property}");
}
let input_id = classic_find_css_element_id(app.clone(), session_id, "#property-input").await;
let content_attribute_value = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{input_id}/property/value"),
)
.await;
assert_eq!(content_attribute_value, json!({ "value": "foobar" }));
let updated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.querySelector('#property-input').value = 'bar'; return document.querySelector('#property-input').value;",
"args": []
}),
)
.await;
assert_eq!(updated, json!({ "value": "bar" }));
let idl_attribute_value = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{input_id}/property/value"),
)
.await;
assert_eq!(idl_attribute_value, json!({ "value": "bar" }));
let classes_id =
classic_find_css_element_id(app.clone(), session_id, "#property-classes").await;
let class_list = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{classes_id}/property/classList"),
)
.await;
assert_eq!(class_list, json!({ "value": ["no", "cheese"] }));
let element_reference = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/property/__element"),
)
.await;
assert!(
element_reference["value"][CLASSIC_ELEMENT_REFERENCE_KEY].is_string(),
"element property should return a WebElement reference: {element_reference:?}"
);
let frame_reference = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/property/__frame"),
)
.await;
assert!(
frame_reference["value"][CLASSIC_FRAME_REFERENCE_KEY].is_string(),
"frame property should return a WebFrame reference: {frame_reference:?}"
);
let shadow_root_reference = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/property/__shadowRoot"),
)
.await;
assert!(
shadow_root_reference["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY].is_string(),
"shadowRoot property should return a ShadowRoot reference: {shadow_root_reference:?}"
);
let window_reference = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{body_id}/property/__window"),
)
.await;
assert!(
window_reference["value"][CLASSIC_WINDOW_REFERENCE_KEY].is_string(),
"window property should return a WebWindow reference: {window_reference:?}"
);
let checkbox_id =
classic_find_css_element_id(app.clone(), session_id, "#property-checkbox").await;
let clicked = classic_request_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{checkbox_id}/click"),
)
.await;
assert_eq!(clicked, json!({ "value": null }));
let checked_property = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{checkbox_id}/property/checked"),
)
.await;
assert_eq!(checked_property, json!({ "value": true }));
let link_id = classic_find_css_element_id(app.clone(), session_id, "#property-link").await;
let href_property = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{link_id}/property/href"),
)
.await;
assert_eq!(
href_property,
json!({ "value": format!("http://{fixture_addr}/foo.html") })
);
fixture_server.abort();
}
#[tokio::test]
async fn webdriver_classic_shadow_root_cases_ported_from_chromium_wpt() {
// Ported from Chromium's WPT checkout:
// third_party/blink/web_tests/external/wpt/webdriver/tests/classic/
// get_element_shadow_root/get.py and find_element(s)_from_shadow_root/find.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 html = r##"<!doctype html>
<div id="host"></div>
<div id="closed-host"></div>
<div id="outside" class="item">outside</div>
<select id="select-no-shadow"></select>
<video id="video-no-shadow"></video>
<script>
const root = document.querySelector("#host").attachShadow({ mode: "open" });
root.innerHTML = `
<main id="shadow-main">
<input id="inside" class="item" value="shadow">
<button id="button" class="item">Press</button>
<a id="link" href="#docs">Docs</a>
</main>`;
const closedRoot = document.querySelector("#closed-host").attachShadow({ mode: "closed" });
closedRoot.innerHTML = `<span id="closed-inside">closed text</span>`;
</script>"##;
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": classic_data_url(html)
}),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let host_id = classic_find_css_element_id(app.clone(), session_id, "#host").await;
let (shadow_status, shadow) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
assert_eq!(
shadow_status,
StatusCode::OK,
"shadow root response: {shadow}"
);
let shadow_id = shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("shadow root reference id: {shadow:?}"))
.to_owned();
let inside = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/element"),
json!({
"using": "css selector",
"value": "#inside"
}),
)
.await;
let inside_id = inside["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("shadow child element reference id: {inside:?}"));
let inside_tag = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{inside_id}/name"),
)
.await;
assert_eq!(inside_tag, json!({ "value": "input" }));
let buttons = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/elements"),
json!({
"using": "class name",
"value": "item"
}),
)
.await;
assert_eq!(
buttons["value"].as_array().expect("shadow elements").len(),
2
);
let link = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/element"),
json!({
"using": "link text",
"value": "Docs"
}),
)
.await;
assert!(link["value"][CLASSIC_ELEMENT_REFERENCE_KEY].is_string());
let closed_host_id = classic_find_css_element_id(app.clone(), session_id, "#closed-host").await;
let (closed_shadow_status, closed_shadow) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{closed_host_id}/shadow"),
)
.await;
assert_eq!(
closed_shadow_status,
StatusCode::OK,
"closed shadow root response: {closed_shadow}"
);
let closed_shadow_id = closed_shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("closed shadow root reference id: {closed_shadow:?}"))
.to_owned();
let closed_inside = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{closed_shadow_id}/element"),
json!({
"using": "css selector",
"value": "#closed-inside"
}),
)
.await;
let closed_inside_id = closed_inside["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("closed shadow child element reference id: {closed_inside:?}"));
let closed_inside_text = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{closed_inside_id}/text"),
)
.await;
assert_eq!(closed_inside_text, json!({ "value": "closed text" }));
let (outside_status, outside) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/element"),
json!({
"using": "css selector",
"value": "#outside"
}),
)
.await;
assert_eq!(outside_status, StatusCode::NOT_FOUND);
assert_eq!(outside["value"]["error"], json!("no such element"));
let none = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/elements"),
json!({
"using": "css selector",
"value": "#outside"
}),
)
.await;
assert_eq!(none, json!({ "value": [] }));
for selector in ["#outside", "#select-no-shadow", "#video-no-shadow"] {
let element_id = classic_find_css_element_id(app.clone(), session_id, selector).await;
let (no_shadow_status, no_shadow) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/shadow"),
)
.await;
assert_eq!(no_shadow_status, StatusCode::NOT_FOUND, "{selector}");
assert_eq!(
no_shadow["value"]["error"],
json!("no such shadow root"),
"{selector}: {no_shadow:?}"
);
}
let _ = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.querySelector('#host').remove();",
"args": []
}),
)
.await;
let (detached_status, detached) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/element"),
json!({
"using": "css selector",
"value": "#inside"
}),
)
.await;
assert_eq!(detached_status, StatusCode::NOT_FOUND);
assert_eq!(detached["value"]["error"], json!("detached shadow root"));
}
#[tokio::test]
async fn webdriver_classic_shadow_root_find_edges_ported_from_chromium_wpt() {
// Ported from Chromium/WPT webdriver/tests/classic/find_element_from_shadow_root/find.py
// and find_elements_from_shadow_root/find.py strategy, nested shadow root,
// and implicit wait 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 html = r##"<!doctype html>
<div id="open-host"></div>
<div id="closed-host"></div>
<script>
function buildShadow(host, mode) {
const root = host.attachShadow({ mode });
root.innerHTML = `
<section>
<a id="linkText" href="#docs">full link text</a>
<inner-host id="inner"></inner-host>
</section>`;
const inner = root.querySelector("inner-host");
inner.attachShadow({ mode }).innerHTML =
`<a id="nestedLink" href="#nested">nested link text</a>`;
}
buildShadow(document.querySelector("#open-host"), "open");
buildShadow(document.querySelector("#closed-host"), "closed");
</script>"##;
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url(html) }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
for host_selector in ["#open-host", "#closed-host"] {
let host_id = classic_find_css_element_id(app.clone(), session_id, host_selector).await;
let shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
let shadow_id = shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{host_selector} shadow id: {shadow:?}"))
.to_owned();
for (using, value) in [
("css selector", "#linkText"),
("link text", "full link text"),
("partial link text", "link text"),
("tag name", "a"),
("xpath", "//a"),
] {
let found = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/element"),
json!({
"using": using,
"value": value
}),
)
.await;
let found_id = found["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{host_selector} {using}={value} response: {found:?}"));
let text = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{found_id}/text"),
)
.await;
assert_eq!(
text,
json!({ "value": "full link text" }),
"{host_selector} {using}={value}"
);
}
let partials = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/elements"),
json!({
"using": "partial link text",
"value": "link text"
}),
)
.await;
assert_eq!(
partials["value"]
.as_array()
.expect("partial link elements")
.len(),
1,
"{host_selector} partial link elements: {partials:?}"
);
let inner_host = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/element"),
json!({
"using": "css selector",
"value": "inner-host"
}),
)
.await;
let inner_host_id = inner_host["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{host_selector} inner host: {inner_host:?}"));
let nested_shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{inner_host_id}/shadow"),
)
.await;
let nested_shadow_id = nested_shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{host_selector} nested shadow id: {nested_shadow:?}"));
let nested = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{nested_shadow_id}/element"),
json!({
"using": "css selector",
"value": "#nestedLink"
}),
)
.await;
let nested_id = nested["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{host_selector} nested link: {nested:?}"));
let nested_text = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{nested_id}/text"),
)
.await;
assert_eq!(
nested_text,
json!({ "value": "nested link text" }),
"{host_selector} nested shadow text"
);
}
let timeouts = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/timeouts"),
json!({ "implicit": 1000 }),
)
.await;
assert_eq!(timeouts, json!({ "value": null }));
let open_host_id = classic_find_css_element_id(app.clone(), session_id, "#open-host").await;
let open_shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{open_host_id}/shadow"),
)
.await;
let open_shadow_id = open_shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("open shadow id for implicit wait: {open_shadow:?}"));
let armed = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "setTimeout(() => { const input = document.createElement('input'); input.id = 'delayed'; document.querySelector('#open-host').shadowRoot.appendChild(input); }, 300); return 'armed';",
"args": []
}),
)
.await;
assert_eq!(armed, json!({ "value": "armed" }));
let delayed = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{open_shadow_id}/element"),
json!({
"using": "css selector",
"value": "#delayed"
}),
)
.await;
assert!(
delayed["value"][CLASSIC_ELEMENT_REFERENCE_KEY].is_string(),
"implicit wait should find delayed shadow child: {delayed:?}"
);
}
#[tokio::test]
async fn webdriver_classic_shadow_root_find_argument_edges_ported_from_chromium_wpt() {
// Ported from Chromium/WPT webdriver/tests/classic/find_element_from_shadow_root/find.py
// and find_elements_from_shadow_root/find.py request parsing and shadow-root id 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 html = r##"<!doctype html>
<div id="host"></div>
<script>
document.querySelector("#host")
.attachShadow({ mode: "open" })
.innerHTML = `<input id="inside" value="shadow">`;
</script>"##;
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url(html) }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let host_id = classic_find_css_element_id(app.clone(), session_id, "#host").await;
let shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
let shadow_id = shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("shadow root id for argument edges: {shadow:?}"));
for suffix in ["element", "elements"] {
let path = format!("/session/{session_id}/shadow/{shadow_id}/{suffix}");
let (null_status, null_body) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&path,
json!(null),
)
.await;
assert_eq!(
null_status,
StatusCode::BAD_REQUEST,
"{suffix} null body: {null_body:?}"
);
assert_eq!(null_body["value"]["error"], json!("invalid argument"));
let (element_id_status, element_id_response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{host_id}/{suffix}"),
json!({
"using": "css selector",
"value": "input"
}),
)
.await;
assert_eq!(
element_id_status,
StatusCode::NOT_FOUND,
"{suffix} element id as shadow root id: {element_id_response:?}"
);
assert_eq!(
element_id_response["value"]["error"],
json!("no such shadow root")
);
for shadow_root_id in ["foo", "true", "null", "1", "[]", "{}"] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_root_id}/{suffix}"),
json!({
"using": "css selector",
"value": "input"
}),
)
.await;
assert_eq!(
status,
StatusCode::NOT_FOUND,
"{suffix} invalid shadow id {shadow_root_id}: {response:?}"
);
assert_eq!(response["value"]["error"], json!("no such shadow root"));
}
for using in [
json!("a"),
json!(true),
json!(null),
json!(1),
json!([]),
json!({}),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&path,
json!({
"using": using,
"value": "input"
}),
)
.await;
assert_eq!(
status,
StatusCode::BAD_REQUEST,
"{suffix} invalid using: {response:?}"
);
assert_eq!(response["value"]["error"], json!("invalid argument"));
}
for value in [json!(null), json!([]), json!({})] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&path,
json!({
"using": "css selector",
"value": value
}),
)
.await;
assert_eq!(
status,
StatusCode::BAD_REQUEST,
"{suffix} invalid selector value: {response:?}"
);
assert_eq!(response["value"]["error"], json!("invalid argument"));
}
}
}
#[tokio::test]
async fn webdriver_classic_shadow_root_link_text_edges_ported_from_chromium_wpt() {
// Ported from Chromium/WPT webdriver/tests/classic/find_element_from_shadow_root/find.py
// and find_elements_from_shadow_root/find.py link text and partial link text 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");
for (using, document, value) in [
(
"link text",
r##"<a id="target" href="#">link text</a>"##,
"link text",
),
(
"link text",
r##"<a id="target" href="#"> link text </a>"##,
"link text",
),
(
"link text",
r##"<a id="target" href="#">link<br>text</a>"##,
"link\ntext",
),
(
"link text",
r##"<a id="target" href="#">link&text</a>"##,
"link&text",
),
(
"link text",
r##"<a id="target" href="#">LINK TEXT</a>"##,
"LINK TEXT",
),
(
"link text",
r##"<a id="target" href="#" style="text-transform: uppercase">link text</a>"##,
"LINK TEXT",
),
(
"partial link text",
r##"<a id="target" href="#">partial link text</a>"##,
"link",
),
(
"partial link text",
r##"<a id="target" href="#"> partial link text </a>"##,
"link",
),
(
"partial link text",
r##"<a id="target" href="#">partial link text</a>"##,
"k t",
),
(
"partial link text",
r##"<a id="target" href="#">partial link<br>text</a>"##,
"k\nt",
),
(
"partial link text",
r##"<a id="target" href="#">partial link&text</a>"##,
"k&t",
),
(
"partial link text",
r##"<a id="target" href="#">PARTIAL LINK TEXT</a>"##,
"LINK",
),
(
"partial link text",
r##"<a id="target" href="#" style="text-transform: uppercase">partial link text</a>"##,
"LINK",
),
] {
let html = format!(
r##"<!doctype html>
<div id="host"></div>
<script>
document.querySelector("#host").attachShadow({{ mode: "open" }}).innerHTML =
`<div><a id="not-wanted" href="#">not wanted</a><br>{document}</div>`;
</script>"##
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url(&html) }),
)
.await;
classic_capture_layout(app.clone(), session_id).await;
assert_eq!(navigated, json!({ "value": null }));
let host_id = classic_find_css_element_id(app.clone(), session_id, "#host").await;
let shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
let shadow_id = shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("shadow id for {using}={value:?}: {shadow:?}"));
let found = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/element"),
json!({
"using": using,
"value": value
}),
)
.await;
let found_id = found["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{using}={value:?} should find target: {found:?}"));
let found_attribute = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{found_id}/attribute/id"),
)
.await;
assert_eq!(
found_attribute,
json!({ "value": "target" }),
"{using}={value:?} find element should return target"
);
let found_many = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/shadow/{shadow_id}/elements"),
json!({
"using": using,
"value": value
}),
)
.await;
let found_many = found_many["value"]
.as_array()
.unwrap_or_else(|| panic!("{using}={value:?} should return element list"));
assert_eq!(
found_many.len(),
1,
"{using}={value:?} find elements should return one target: {found_many:?}"
);
let found_many_id = found_many[0][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("{using}={value:?} element list item: {found_many:?}"));
let found_many_attribute = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{found_many_id}/attribute/id"),
)
.await;
assert_eq!(
found_many_attribute,
json!({ "value": "target" }),
"{using}={value:?} find elements should return target"
);
}
}
#[tokio::test]
async fn webdriver_classic_shadow_root_owner_context_errors_ported_from_chromium_wpt() {
// Ported from Chromium/WPT webdriver/tests/classic/get_element_shadow_root/get.py
// and find_element(s)_from_shadow_root/find.py owner-context and stale cases.
let app = build_router(test_state());
let (fixture_addr, fixture_server) = spawn_classic_frame_fixture_server().await;
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"]
.as_str()
.expect("classic session id");
let window_path = format!("/session/{session_id}/window");
let frame_path = format!("/session/{session_id}/frame");
let original_handle = classic_request_json(app.clone(), Method::GET, &window_path).await;
let original_handle = original_handle["value"]
.as_str()
.expect("original window handle")
.to_owned();
let html = r##"<!doctype html>
<div id="host"></div>
<script>
document.querySelector("#host")
.attachShadow({ mode: "open" })
.innerHTML = `<input id="inside" value="shadow">`;
</script>"##;
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url(html) }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let host_id = classic_find_css_element_id(app.clone(), session_id, "#host").await;
let shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
let shadow_id = shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("top shadow root id: {shadow:?}"))
.to_owned();
let new_window = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/window/new"),
json!({ "type": "tab" }),
)
.await;
let new_handle = new_window["value"]["handle"]
.as_str()
.expect("new window handle")
.to_owned();
let switched = classic_request_json_with_body(
app.clone(),
Method::POST,
&window_path,
json!({ "handle": new_handle }),
)
.await;
assert_eq!(switched, json!({ "value": null }));
let (other_window_get_shadow_status, other_window_get_shadow) =
classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
assert_eq!(other_window_get_shadow_status, StatusCode::NOT_FOUND);
assert_eq!(
other_window_get_shadow["value"]["error"],
json!("no such element")
);
for path in [
format!("/session/{session_id}/shadow/{shadow_id}/element"),
format!("/session/{session_id}/shadow/{shadow_id}/elements"),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&path,
json!({
"using": "css selector",
"value": "input"
}),
)
.await;
assert_eq!(status, StatusCode::NOT_FOUND, "{path}: {response:?}");
assert_eq!(response["value"]["error"], json!("no such shadow root"));
}
let switched_back = classic_request_json_with_body(
app.clone(),
Method::POST,
&window_path,
json!({ "handle": original_handle }),
)
.await;
assert_eq!(switched_back, json!({ "value": null }));
let removed = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.querySelector('#host').remove(); return 'removed';",
"args": []
}),
)
.await;
assert_eq!(removed, json!({ "value": "removed" }));
let (stale_host_status, stale_host) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{host_id}/shadow"),
)
.await;
assert_eq!(
stale_host_status,
StatusCode::NOT_FOUND,
"stale host shadow response: {stale_host:?}"
);
assert_eq!(
stale_host["value"]["error"],
json!("stale element reference")
);
let page_url = format!("http://{fixture_addr}/shadow-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 frame_id = classic_find_css_element_id(app.clone(), session_id, "#shadow-child").await;
let switched_frame = classic_request_json_with_body(
app.clone(),
Method::POST,
&frame_path,
json!({
"id": {
CLASSIC_ELEMENT_REFERENCE_KEY: frame_id
}
}),
)
.await;
assert_eq!(switched_frame, json!({ "value": null }));
let child_host_id =
classic_find_css_element_id(app.clone(), session_id, "#child-closed-host").await;
let child_shadow = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{child_host_id}/shadow"),
)
.await;
let child_shadow_id = child_shadow["value"][CLASSIC_SHADOW_ROOT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("child shadow root id: {child_shadow:?}"))
.to_owned();
let parent = classic_request_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/frame/parent"),
)
.await;
assert_eq!(parent, json!({ "value": null }));
let (other_frame_get_shadow_status, other_frame_get_shadow) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{child_host_id}/shadow"),
)
.await;
assert_eq!(other_frame_get_shadow_status, StatusCode::NOT_FOUND);
assert_eq!(
other_frame_get_shadow["value"]["error"],
json!("no such element")
);
for path in [
format!("/session/{session_id}/shadow/{child_shadow_id}/element"),
format!("/session/{session_id}/shadow/{child_shadow_id}/elements"),
] {
let (status, response) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&path,
json!({
"using": "css selector",
"value": "#child-closed-inside"
}),
)
.await;
assert_eq!(status, StatusCode::NOT_FOUND, "{path}: {response:?}");
assert_eq!(response["value"]["error"], json!("no such shadow root"));
}
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
fixture_server.abort();
}
#[tokio::test]
async fn webdriver_classic_page_screenshot_publishes_layout_and_element_clip_remains_unsupported() {
// Ported from Selenium py/test/selenium/webdriver/common/takes_screenshots_tests.py:
// test_get_screenshot_as_base64, test_get_screenshot_as_png and
// test_get_element_screenshot.
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 html = r#"<!doctype html>
<main>
<p id="multiline">line one<br>line two</p>
</main>"#;
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": classic_data_url(html)
}),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let (page_status, page_screenshot) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/screenshot"),
)
.await;
assert_eq!(page_status, StatusCode::OK);
let bytes = BASE64_STANDARD
.decode(page_screenshot["value"].as_str().expect("PNG base64"))
.expect("valid base64");
assert!(bytes.starts_with(b"\x89PNG\r\n\x1a\n"));
assert!(u32::from_be_bytes(bytes[16..20].try_into().unwrap()) > 0);
assert!(u32::from_be_bytes(bytes[20..24].try_into().unwrap()) > 0);
let element = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "css selector",
"value": "#multiline"
}),
)
.await;
let element_id = element["value"][CLASSIC_ELEMENT_REFERENCE_KEY]
.as_str()
.unwrap_or_else(|| panic!("element lookup should return a classic element: {element:?}"));
let (element_status, element_screenshot) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/screenshot"),
)
.await;
assert_eq!(element_status, StatusCode::METHOD_NOT_ALLOWED);
assert_eq!(
element_screenshot["value"]["error"],
json!("unsupported operation")
);
assert_eq!(
element_screenshot["value"]["message"],
json!("Page.captureScreenshot is not supported: renderer screenshots are not implemented.")
);
let (missing_status, missing) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/moli-node-999999/screenshot"),
)
.await;
assert_eq!(missing_status, StatusCode::NOT_FOUND);
assert_eq!(missing["value"]["error"], json!("no such element"));
}
#[tokio::test]
async fn webdriver_classic_get_element_text_cases_ported_from_selenium() {
// Reduced from Selenium py/test/selenium/webdriver/common/text_handling_tests.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 html = r#"
<p id="oneline">A single line of text</p>
<p id="hiddenline" style="visibility: hidden">A hidden line of text</p>
<div id="multiline">
<p>A div containing</p>
More than one line of text<br>
<div>and block level elements</div>
</div>
<span id="span">An inline element</span>
<p id="lotsofspaces">This line has lots
of spaces.
</p>
<p id="nbsp">This line has a non-breaking space</p>
<p id="nbspandspaces">This line has a non-breaking space and spaces</p>
<p id="privateuse"> private use text</p>
<p id="inline">This <span id="inlinespan"> line has <em>text</em> </span> within elements that are meant to be displayed inline</p>
<div id="twoblocks"><p>Some text</p><p>Some more text</p></div>
<label id="labelforusername" for="username">
Username: <input id="username" type="text" name="username">
<script>document.getElementById('username').value = 'Michael';</script>
</label>
<div id="visible-wrapper">visible <span style="display: none">hidden</span><span>text</span></div>
<div id="capitalize-space" style="text-transform: capitalize">foo bar</div>
<div id="capitalize-dash" style="text-transform: capitalize">foo-bar</div>
<div id="capitalize-underscore" style="text-transform: capitalize">foo_bar</div>
<div id="capitalize-accent" style="text-transform: capitalize">foo bár</div>
<div id="slot-custom-visible">cheese</div>
<div id="slot-custom-outside">cheese</div>
<div id="slot-custom-hidden">cheese</div>
<div id="slot-default-visible"></div>
<div id="slot-default-outside"></div>
<div id="slot-default-hidden"></div>
<script>
function setShadow(id, innerHTML) {
document.getElementById(id).attachShadow({ mode: "open" }).innerHTML = innerHTML;
}
setShadow("slot-custom-visible", "<slot><span>foo</span>bar</slot>");
setShadow("slot-custom-outside", "<slot><span>foo</span></slot>bar");
setShadow("slot-custom-hidden", "<slot><span style='display: none'>foo</span>bar</slot>");
setShadow("slot-default-visible", "<slot><span>foo</span>bar</slot>");
setShadow("slot-default-outside", "<slot><span>foo</span></slot>bar");
setShadow("slot-default-hidden", "<slot><span style='display: none'>foo</span>bar</slot>");
</script>
<div id="empty"></div>
<p id="spaces"> </p>
"#;
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": classic_data_url(html) }),
)
.await,
json!({ "value": null })
);
for (selector, expected) in [
("#oneline", "A single line of text"),
(
"#multiline",
"A div containing\nMore than one line of text\nand block level elements",
),
("#lotsofspaces", "This line has lots of spaces."),
("#nbsp", "This line has a non-breaking space"),
(
"#nbspandspaces",
"This line has a non-breaking space and spaces",
),
("#privateuse", "\u{E000} private use text"),
(
"#inline",
"This line has text within elements that are meant to be displayed inline",
),
("#inlinespan", "line has text"),
("#span", "An inline element"),
("#twoblocks", "Some text\nSome more text"),
("#labelforusername", "Username:"),
("#visible-wrapper", "visible text"),
("#capitalize-space", "Foo Bar"),
("#capitalize-dash", "Foo-Bar"),
("#capitalize-underscore", "Foo_bar"),
("#capitalize-accent", "Foo B\u{00e1}r"),
("#slot-custom-visible", "cheese"),
("#slot-custom-outside", "cheesebar"),
("#slot-custom-hidden", "cheese"),
("#slot-default-visible", "foobar"),
("#slot-default-outside", "foobar"),
("#slot-default-hidden", "bar"),
("#hiddenline", ""),
("#empty", ""),
("#spaces", ""),
] {
let element_id = classic_find_css_element_id(app.clone(), session_id, selector).await;
let response = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/text"),
)
.await;
assert_eq!(response, json!({ "value": expected }), "{selector}");
}
}
#[tokio::test]
async fn webdriver_classic_clear_element_cases_ported_from_selenium() {
// Ported from Selenium py/test/selenium/webdriver/common/clear_tests.py
// and common/src/web/readOnlyPage.html.
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 html = concat!(
"<input id='writableTextInput' type='text' value='Test'>",
"<input id='readOnlyTextInput' type='text' readonly value='Test'>",
"<input id='textInputNotEnabled' type='text' disabled value='Test'>",
"<textarea id='writableTextArea'>This is a sample text area which is supposed to be cleared</textarea>",
"<textarea id='textAreaReadOnly' readonly>text area which is not supposed to be cleared</textarea>",
"<textarea id='textAreaNotEnabled' disabled>text area which is not supposed to be cleared</textarea>",
"<div id='content-editable' contenteditable='true'><h1>This</h1><h2>is a</h2><p>contentEditable area</p></div>",
"<button id='not-clearable'>button</button>",
"<script>",
"window.__clearEvents=[];",
"for (const id of ['writableTextInput','writableTextArea']) {",
" const element = document.getElementById(id);",
" for (const type of ['input','change']) {",
" element.addEventListener(type, event => window.__clearEvents.push(`${id}:${event.type}:${event.composed}:${element.value}`));",
" }",
"}",
"</script>",
);
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({
"url": format!("data:text/html,{html}")
}),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
for selector in ["#writableTextInput", "#writableTextArea"] {
let element_id = classic_find_css_element_id(app.clone(), session_id, selector).await;
let cleared = classic_request_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{element_id}/clear"),
)
.await;
assert_eq!(cleared, json!({ "value": null }), "{selector}");
let value = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/property/value"),
)
.await;
assert_eq!(value, json!({ "value": "" }), "{selector}");
}
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return window.__clearEvents.join('|');",
"args": []
}),
)
.await,
json!({ "value": "writableTextInput:input:true:|writableTextInput:change:false:|writableTextArea:input:true:|writableTextArea:change:false:" })
);
let editable_id =
classic_find_css_element_id(app.clone(), session_id, "#content-editable").await;
let cleared = classic_request_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{editable_id}/clear"),
)
.await;
assert_eq!(cleared, json!({ "value": null }));
let editable_text = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{editable_id}/text"),
)
.await;
assert_eq!(editable_text, json!({ "value": "" }));
for selector in [
"#readOnlyTextInput",
"#textInputNotEnabled",
"#textAreaReadOnly",
"#textAreaNotEnabled",
"#not-clearable",
] {
let element_id = classic_find_css_element_id(app.clone(), session_id, selector).await;
let (status, response) = classic_request_status_and_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{element_id}/clear"),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST, "{selector}");
assert_eq!(
response["value"]["error"],
json!("invalid element state"),
"{selector}"
);
}
}
#[tokio::test]
async fn webdriver_classic_active_element_uses_current_browsing_context() {
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 = "data:text/html,<body id='top-body'><input id='top-input'><iframe id='child' srcdoc=\"<body id='child-body'><input id='child-input' autofocus></body>\"></iframe></body>";
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 (active_status, active) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/active"),
)
.await;
assert_eq!(active_status, StatusCode::OK, "{active:?}");
let active_id = active["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.unwrap_or_else(|| panic!("active element should return body: {active:?}"));
let active_tag = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{active_id}/name"),
)
.await;
assert_eq!(active_tag, json!({ "value": "body" }));
let focused = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.getElementById('top-input').focus(); return document.activeElement.id;",
"args": []
}),
)
.await;
assert_eq!(focused, json!({ "value": "top-input" }));
let active = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/active/"),
)
.await;
let active_id = active["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.unwrap_or_else(|| panic!("focused input should be active: {active:?}"));
let active_property = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{active_id}/property/id"),
)
.await;
assert_eq!(active_property, json!({ "value": "top-input" }));
let frame_id = classic_find_css_element_id(app.clone(), session_id, "#child").await;
let switched = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/frame"),
json!({
"id": {
"element-6066-11e4-a52e-4f735466cecf": frame_id
}
}),
)
.await;
assert_eq!(switched, json!({ "value": null }));
let child_focused = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "document.getElementById('child-input').focus(); return document.activeElement.id;",
"args": []
}),
)
.await;
assert_eq!(child_focused, json!({ "value": "child-input" }));
let (active_status, active) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/active"),
)
.await;
assert_eq!(active_status, StatusCode::OK, "{active:?}");
let active_id = active["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.unwrap_or_else(|| panic!("child frame active element should return input: {active:?}"));
let active_property = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{active_id}/property/id"),
)
.await;
assert_eq!(active_property, json!({ "value": "child-input" }));
}
#[tokio::test]
async fn webdriver_classic_css_value_uses_current_browsing_context() {
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 = "data:text/html,<body><main id='top' style='display:flex;width:123px'></main><iframe id='child' srcdoc=\"<main id='inside' style='display:grid;width:321px'></main>\"></iframe></body>";
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 top_id = classic_find_css_element_id(app.clone(), session_id, "#top").await;
let top_display = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{top_id}/css/display"),
)
.await;
assert_eq!(top_display, json!({ "value": "flex" }));
let top_width = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{top_id}/css/width/"),
)
.await;
assert_eq!(top_width, json!({ "value": "123px" }));
let unknown = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{top_id}/css/not-a-property"),
)
.await;
assert_eq!(unknown, json!({ "value": "" }));
let frame_id = classic_find_css_element_id(app.clone(), session_id, "#child").await;
let switched = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/frame"),
json!({
"id": {
"element-6066-11e4-a52e-4f735466cecf": frame_id
}
}),
)
.await;
assert_eq!(switched, json!({ "value": null }));
let child_id = classic_find_css_element_id(app.clone(), session_id, "#inside").await;
let child_display = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{child_id}/css/display"),
)
.await;
assert_eq!(child_display, json!({ "value": "grid" }));
let child_width = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{child_id}/css/width"),
)
.await;
assert_eq!(child_width, json!({ "value": "321px" }));
}
#[tokio::test]
async fn webdriver_classic_click_respects_dom_first_and_real_layout_policies() {
for policy in [LayoutPolicy::Mock, LayoutPolicy::OnDemand] {
let state = AppState::new_with_storage_partition_and_runtime_config(
"127.0.0.1:9222".parse().unwrap(),
Arc::new(StoragePartitionState::open(None).unwrap()),
NavigationRuntimeConfig::new(
protocol_server_test_fetch_config(FetchConfig::default()),
OptionalResourceFetchMask::NONE,
true,
policy,
),
crate::config::DEFAULT_SCREENCAST_INTERVAL_MS,
BrowserInstanceControl::new(),
)
.unwrap();
let app = build_router(state);
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
let session_id = session["value"]["sessionId"].as_str().unwrap();
let navigated = classic_request_json_with_body(
app.clone(), Method::POST, &format!("/session/{session_id}/url"),
json!({"url": "data:text/html,<button id='target'>go</button><script>window.events=[];for(const type of ['pointerdown','mousedown','mouseup','click'])target.addEventListener(type,e=>events.push(e.type));</script>"}),
).await;
if policy.uses_real_layout() {
classic_capture_layout(app.clone(), session_id).await;
}
assert_eq!(navigated, json!({"value": null}));
let element_id = classic_find_css_element_id(app.clone(), session_id, "#target").await;
let clicked = classic_request_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{element_id}/click"),
)
.await;
assert_eq!(clicked, json!({"value": null}), "{policy:?}");
let observed = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({"script": "return window.events;", "args": []}),
)
.await;
let expected = match policy {
LayoutPolicy::Mock => json!(["click"]),
LayoutPolicy::OnDemand => json!(["pointerdown", "mousedown", "mouseup", "click"]),
};
assert_eq!(observed["value"], expected, "{policy:?}");
classic_request_json_with_body(
app.clone(), Method::POST, &format!("/session/{session_id}/url"),
json!({"url": "data:text/html,<input id='origin'><input id='target'><script>document.getElementById('origin').focus();</script>"}),
).await;
if policy.uses_real_layout() {
classic_capture_layout(app.clone(), session_id).await;
}
let target = classic_find_css_element_id(app.clone(), session_id, "#target").await;
assert_eq!(
classic_request_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{target}/click"),
)
.await,
json!({"value":null})
);
assert_eq!(
classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/actions"),
json!({"actions":[{"type":"key","id":"keyboard","actions":[
{"type":"keyDown","value":"x"},{"type":"keyUp","value":"x"}
]}]}),
)
.await,
json!({"value":null})
);
let focused = classic_request_json_with_body(
app.clone(), Method::POST, &format!("/session/{session_id}/execute/sync"),
json!({"script":"return [document.activeElement.id,document.getElementById('origin').value,document.getElementById('target').value];","args":[]}),
).await;
assert_eq!(focused["value"], json!(["target", "", "x"]), "{policy:?}");
classic_request_json(app, Method::DELETE, &format!("/session/{session_id}")).await;
}
}
#[tokio::test]
async fn webdriver_classic_element_click_uses_shared_dom_geometry_and_input() {
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 url = "data:text/html,<button id='target' onclick='window.__clicked = true'>go</button><script>window.events=[];for(const type of ['pointerdown','mousedown','focus','mouseup','click'])target.addEventListener(type,e=>events.push([e.type,e.isTrusted]));</script>";
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": url }),
)
.await;
assert_eq!(navigated, json!({ "value": null }));
let element = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "css selector",
"value": "#target"
}),
)
.await;
let element_id = element["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.expect("element reference id");
let (cold_status, cold) = classic_request_status_and_json(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{element_id}/click"),
)
.await;
assert_eq!(cold_status, StatusCode::OK);
assert_eq!(cold, json!({ "value": null }));
let clicked_state = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return [Boolean(window.__clicked),document.activeElement.id,window.events];",
"args": []
}),
)
.await;
assert_eq!(
clicked_state,
json!({ "value": [true, "target", [
["pointerdown", true], ["mousedown", true], ["focus", true],
["mouseup", true], ["click", true]
]] })
);
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
}
#[tokio::test]
async fn webdriver_classic_element_send_keys_uses_shared_input() {
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 url = "data:text/html,<input id='field' value=''>";
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": url }),
)
.await;
classic_capture_layout(app.clone(), session_id).await;
assert_eq!(navigated, json!({ "value": null }));
let element = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "css selector",
"value": "#field"
}),
)
.await;
let element_id = element["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.expect("element reference id");
let sent = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element/{element_id}/value"),
json!({ "text": "typed" }),
)
.await;
assert_eq!(sent, json!({ "value": null }));
let value = classic_request_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{element_id}/property/value"),
)
.await;
assert_eq!(value, json!({ "value": "typed" }));
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
}
#[tokio::test]
async fn webdriver_classic_actions_element_origin_uses_real_geometry() {
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 url = "data:text/html,<script>window.__classicWheel=null;document.addEventListener('wheel',function(event){window.__classicWheel={type:event.type,deltaX:event.deltaX,deltaY:event.deltaY,clientX:event.clientX,clientY:event.clientY};});</script><button id='target' onclick='window.__classicClicked=true'>go</button><div id='wheel' style='width:200px;height:200px'>wheel-target</div>";
let navigated = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/url"),
json!({ "url": url }),
)
.await;
classic_capture_layout(app.clone(), session_id).await;
assert_eq!(navigated, json!({ "value": null }));
let button = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "css selector",
"value": "#target"
}),
)
.await;
let button_id = button["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.expect("button element reference id");
let wheel_target = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/element"),
json!({
"using": "css selector",
"value": "#wheel"
}),
)
.await;
let wheel_target_id = wheel_target["value"]["element-6066-11e4-a52e-4f735466cecf"]
.as_str()
.expect("wheel element reference id");
let (clicked_status, clicked) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/actions"),
json!({
"actions": [{
"type": "pointer",
"id": "mouse",
"parameters": { "pointerType": "mouse" },
"actions": [
{
"type": "pointerMove",
"origin": { "element-6066-11e4-a52e-4f735466cecf": button_id },
"x": 0,
"y": 0
},
{ "type": "pointerDown", "button": 0 },
{ "type": "pointerUp", "button": 0 }
]
}]
}),
)
.await;
assert_eq!(clicked_status, StatusCode::OK, "response: {clicked:?}");
assert_eq!(clicked, json!({ "value": null }));
let clicked_state = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return Boolean(window.__classicClicked);",
"args": []
}),
)
.await;
assert_eq!(clicked_state, json!({ "value": true }));
let (scrolled_status, scrolled) = classic_request_status_and_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/actions"),
json!({
"actions": [{
"type": "wheel",
"id": "wheel",
"actions": [{
"type": "scroll",
"origin": { "element-6066-11e4-a52e-4f735466cecf": wheel_target_id },
"x": 1,
"y": 2,
"deltaX": 7,
"deltaY": 13
}]
}]
}),
)
.await;
assert_eq!(scrolled_status, StatusCode::OK, "response: {scrolled:?}");
assert_eq!(scrolled, json!({ "value": null }));
let wheel = classic_request_json_with_body(
app.clone(),
Method::POST,
&format!("/session/{session_id}/execute/sync"),
json!({
"script": "return window.__classicWheel;",
"args": []
}),
)
.await;
assert_eq!(wheel["value"]["type"], json!("wheel"));
assert_eq!(wheel["value"]["deltaX"], json!(7));
assert_eq!(wheel["value"]["deltaY"], json!(13));
assert!(wheel["value"]["clientX"].is_number(), "wheel: {wheel:?}");
assert!(wheel["value"]["clientY"].is_number(), "wheel: {wheel:?}");
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
}
#[tokio::test]
async fn webdriver_classic_element_reference_is_not_found_after_tab_switch() {
// Ported from Chromium/WPT webdriver/tests/classic/switch_to_window/switch.py
// test_element_not_found_after_tab_switch.
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 window_path = format!("/session/{session_id}/window");
let new_window_path = format!("/session/{session_id}/window/new");
let page_url = classic_data_url("<p id='a'>foo</p>");
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 paragraph_id = classic_find_css_element_id(app.clone(), session_id, "p").await;
let created = classic_request_json_with_body(
app.clone(),
Method::POST,
&new_window_path,
json!({ "type": "tab" }),
)
.await;
let new_handle = created["value"]["handle"]
.as_str()
.expect("new window handle")
.to_owned();
let switched = classic_request_json_with_body(
app.clone(),
Method::POST,
&window_path,
json!({ "handle": new_handle }),
)
.await;
assert_eq!(switched, json!({ "value": null }));
let (attribute_status, attribute) = classic_request_status_and_json(
app.clone(),
Method::GET,
&format!("/session/{session_id}/element/{paragraph_id}/attribute/id"),
)
.await;
assert_eq!(attribute_status, StatusCode::NOT_FOUND, "{attribute:?}");
assert_eq!(attribute["value"]["error"], json!("no such element"));
let _ = classic_request_json(
app.clone(),
Method::DELETE,
&format!("/session/{session_id}"),
)
.await;
}