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 devtools_script_navigation_exact_cursor_rejects_replaced_page_owner_action() {
let mut ctx = crate::testing::TestContext::new_with_target_discovery(false);
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverClassic,
session_id: Some(DevToolsSessionId::from("classic-session-1")),
target_id: None,
browser_context_id: None,
};
let create_outcome = ctx
.conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: true,
},
))
.await;
let create_predecessor = create_outcome.renderer_output_predecessor();
let (create_result, create_events) = create_outcome.into_parts();
assert!(create_events.is_empty());
if let Some(predecessor) = create_predecessor {
ctx.route_direct_command_renderer_predecessor_for_test(predecessor)
.await;
}
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let target_id = create_result.target_id;
ctx.install_navigation_fixture_for_session_owner("about:blank", None)
.await;
let target_context = AutomationContext {
target_id: Some(target_id.clone()),
..context
};
let outcome = ctx
.conn
.execute_automation_command_with_protocol_events(AutomationCommand::EvaluateScript(
DevToolsEvaluateScriptCommand {
context: target_context,
realm_id: None,
world_name: None,
expression: "location.href = 'https://example.test/next'; 'navigation-queued'"
.to_owned(),
await_promise: false,
user_gesture: false,
webdriver_bidi_file_prompt_handler: None,
result_ownership: DevToolsResultOwnership::None,
preserve_remote_metadata: false,
materialize_bidi_script_result: false,
serialization_options: None,
},
))
.await;
let (result, scheduler_events, protocol_events, predecessor) = outcome.into_complete_parts();
let predecessor =
predecessor.expect("script navigation should settle one exact renderer cursor");
let value = expect_script_value_result(
result.expect("script navigation should evaluate"),
"expected script result",
);
assert_eq!(value.value, json!("navigation-queued"));
assert!(
protocol_events.is_empty(),
"producing an owner action must not emit a listener-shaped protocol event: {protocol_events:?}"
);
assert!(
scheduler_events.is_empty(),
"the owner action belongs to the concrete renderer publication, not a command-local side channel"
);
let route = ctx
.conn
.target_session_route_for_target_id(target_id.as_str())
.expect("created target route");
ctx.conn
.runtime_session_owner_slot_mut_for_owner(&crate::conn::CommandOwnerScope::for_route(
route.clone(),
))
.expect("created target runtime slot")
.replace_page_attachment_id_for_test();
let sent_start = ctx.sent.len();
ctx.route_direct_command_renderer_predecessor_for_test(predecessor)
.await;
ctx.wait_for_direct_command_work_completion_for_test("stale script-navigation owner action")
.await;
assert!(
ctx.sent[sent_start..].is_empty(),
"work claimed from a replaced Page must not emit protocol output for the replacement: {:?}",
&ctx.sent[sent_start..]
);
}
#[tokio::test]
async fn page_enable_uses_background_initial_document_through_attached_session() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-page-normal-route")),
target_id: None,
browser_context_id: None,
};
let (first_result, _) =
crate::domains::target::execute_immediate_devtools_target_command_with_protocol_events(
&mut conn,
AutomationCommand::CreateTarget(DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
}),
);
let AutomationResult::CreateTarget(first_result) =
first_result.expect("initial target create should succeed")
else {
panic!("expected create target result");
};
let first_target_id = first_result.target_id;
let (second_result, _) =
crate::domains::target::execute_immediate_devtools_target_command_with_protocol_events(
&mut conn,
AutomationCommand::CreateTarget(DevToolsCreateTargetCommand {
context,
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
}),
);
let AutomationResult::CreateTarget(second_result) =
second_result.expect("background target create should succeed")
else {
panic!("expected create target result");
};
let second_target_id = second_result.target_id;
let background_route = conn
.target_session_route_for_target_id(second_target_id.as_str())
.expect("background target route");
let background_owner = CommandOwnerScope::for_route(background_route.clone());
let pending_initial_document = conn
.start_initial_document_page_ensure_for_owner(&background_owner)
.expect("background target lifecycle ensure should start")
.expect("fresh background target should need an initial document page build");
let completed_initial_document = pending_initial_document
.wait()
.await
.expect("background initial document page build should complete");
conn.complete_initial_document_page_build_for_owner(completed_initial_document)
.await
.expect("background initial document should install on captured owner");
let background_session =
attach_page_session_for_test(&mut conn, second_target_id.as_str()).await;
let raw = serde_json::to_string(&json!({
"id": 1268,
"method": "Page.enable",
"sessionId": background_session
}))
.unwrap();
let pending = match conn.start_command_dispatch(&raw) {
CdpCommandTaskStep::Pending(_) => {
panic!("background Page.enable should not start a pending initial document page build")
}
CdpCommandTaskStep::Complete(outcome) => outcome,
};
let messages = pending.into_parts().0;
assert!(
messages
.iter()
.any(|message| message["id"] == json!(1268) && message.get("error").is_none()),
"Page.enable should complete successfully on the original background owner: {messages:?}"
);
let browser_context = conn.browser_context.as_ref().expect("browser context");
assert_eq!(
browser_context.active_target_id(),
Some(first_target_id.as_str()),
"background Page.enable must not activate or overwrite the active target"
);
assert!(
browser_context
.background_target(second_target_id.as_str())
.is_some_and(|target| target.has_loaded_page()),
"background target should keep its target-lifecycle initial page"
);
assert!(
!browser_context
.active_page_target()
.runtime_slot
.has_loaded_page(),
"Page.enable must not install a page on the active target"
);
}
#[tokio::test]
async fn initial_document_page_ensure_completion_uses_captured_owner() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-initial-owner")),
target_id: None,
browser_context_id: None,
};
let (first_result, _) =
crate::domains::target::execute_immediate_devtools_target_command_with_protocol_events(
&mut conn,
AutomationCommand::CreateTarget(DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
}),
);
let AutomationResult::CreateTarget(first_result) =
first_result.expect("initial target create should succeed")
else {
panic!("expected create target result");
};
let first_target_id = first_result.target_id;
let (second_result, _) =
crate::domains::target::execute_immediate_devtools_target_command_with_protocol_events(
&mut conn,
AutomationCommand::CreateTarget(DevToolsCreateTargetCommand {
context,
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
}),
);
let AutomationResult::CreateTarget(second_result) =
second_result.expect("background target create should succeed")
else {
panic!("expected create target result");
};
let second_target_id = second_result.target_id;
let background_route = conn
.target_session_route_for_target_id(second_target_id.as_str())
.expect("background target route");
let background_owner = CommandOwnerScope::for_route(background_route);
let pending = conn
.start_initial_document_page_ensure_for_owner(&background_owner)
.expect("background initial document page ensure should start")
.expect("background initial document page ensure should pend");
let completed = pending
.wait()
.await
.expect("initial document page build should complete");
conn.complete_initial_document_page_build_for_owner(completed)
.await
.expect("completion should install on captured owner");
let browser_context = conn.browser_context.as_ref().expect("browser context");
assert_eq!(
browser_context.active_target_id(),
Some(first_target_id.as_str()),
"completion must not activate the background target"
);
assert!(
browser_context
.background_target(second_target_id.as_str())
.is_some_and(|target| target.has_loaded_page()),
"completion should install the materialized page on the captured background target"
);
assert!(
!browser_context
.active_page_target()
.runtime_slot
.has_loaded_page(),
"completion must not install the materialized page on the ambient active target"
);
}
#[tokio::test]
async fn stale_initial_document_page_build_does_not_overwrite_committed_page() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-lifecycle-stale-initial")),
target_id: None,
browser_context_id: None,
};
let (create_result, _) =
crate::domains::target::execute_immediate_devtools_target_command_with_protocol_events(
&mut conn,
AutomationCommand::CreateTarget(DevToolsCreateTargetCommand {
context,
url: "about:blank".to_owned(),
browser_context_id: None,
activate: true,
}),
);
let AutomationResult::CreateTarget(_) =
create_result.expect("active target create should succeed")
else {
panic!("expected create target result");
};
let initial_document_owner = CommandOwnerScope::capture(&conn, None);
let pending = conn
.start_initial_document_page_ensure_for_owner(&initial_document_owner)
.expect("target lifecycle ensure should start active initial page")
.expect("fresh initial target should pend active initial document page build");
let real_page_url = "data:text/html,<title>real-page</title>";
let parsed_real_page_url = url::Url::parse(real_page_url).expect("data URL should parse");
let owner = crate::conn::CommandOwnerScope::capture(&conn, None);
let real_page = conn
.load_page_via_runtime_async(real_page_url)
.await
.expect("real navigation page should build");
conn.commit_loaded_navigation_page_for_owner_async(
&owner,
real_page,
crate::conn::LoadedNavigationRendererAttachmentCommit::Prepare(None),
&parsed_real_page_url,
)
.await
.expect("real navigation page owner should exist")
.expect("real navigation page Inspector binding should activate");
let real_page_commit = moli_core::page::RendererMainDocumentCommit {
frame_id: "TID-1".to_owned(),
loader_id: "LOADER-real-page".to_owned(),
url: parsed_real_page_url.to_string(),
unreachable_url: None,
security_origin: "null".to_owned(),
secure_context_type: "InsecureScheme".to_owned(),
document_referrer: None,
timestamp: 0.0,
session_history_position: None,
browsing_context_group: None,
};
conn.commit_loaded_navigation_target_identity_for_owner(
&owner,
&real_page_commit,
&parsed_real_page_url,
)
.expect("real navigation identity should commit");
let attachment_after_real_page = conn
.browser_context
.as_ref()
.expect("browser context")
.page_attachment_id();
let completed = pending
.wait()
.await
.expect("stale initial document page build should complete");
conn.complete_initial_document_page_build_for_owner(completed)
.await
.expect("stale initial document page build should be discarded");
let messages = conn
.dispatch_runtime_helper_protocol_message_for_session_owner_async(
None,
r#"{"id":7001,"method":"Runtime.evaluate","params":{"expression":"document.title","returnByValue":true}}"#,
7001,
)
.await
.expect("replacement Inspector context must survive stale initial Page teardown");
let evaluation = messages
.iter()
.find_map(|message| {
let message = message.clone().into_v8_inspector_message();
(message["id"] == json!(7001)).then_some(message)
})
.expect("replacement evaluation should return a protocol response");
assert_eq!(evaluation["result"]["result"]["value"], json!("real-page"));
let large_frontend_command_id = i32::MAX as u64 + 73;
let large_id_messages = conn
.dispatch_runtime_helper_protocol_message_for_session_owner_async(
None,
&json!({
"id": large_frontend_command_id,
"method": "Runtime.evaluate",
"params": {
"expression": "6 * 7",
"returnByValue": true
}
})
.to_string(),
large_frontend_command_id,
)
.await
.expect("large frontend command id should use an internal renderer call id");
let large_id_evaluation = large_id_messages
.iter()
.find_map(|message| {
let message = message.clone().into_v8_inspector_message();
(message["id"] == json!(large_frontend_command_id)).then_some(message)
})
.expect("renderer response should restore the large frontend command id");
assert_eq!(large_id_evaluation["result"]["result"]["value"], json!(42));
let current_attachment_id = conn
.browser_context
.as_ref()
.and_then(|context| context.loaded_page())
.and_then(moli_core::page::Page::renderer_agent_attachment_id)
.expect("loaded page should have a renderer attachment");
let stale_attachment_id = moli_core::page::RendererAgentAttachmentId::allocate();
let attachment_test_frontend_id = 8_101;
let correlation = conn
.try_register_renderer_call_for_session_owner(
None,
attachment_test_frontend_id,
Some(current_attachment_id),
RendererCommandDescriptor::from_synthesized_payload(
json!({
"id": attachment_test_frontend_id,
"method": "Runtime.evaluate",
"params": { "expression": "1" },
})
.to_string(),
)
.unwrap(),
)
.unwrap()
.correlation();
let response_ready =
|renderer_call_id: moli_page_types::RendererCallId,
attachment_id: moli_core::page::RendererAgentAttachmentId| {
let mut output = moli_core::page::RendererRuntimeCommandOutput::from_inspector_message(
moli_core::page::RendererRuntimeInspectorMessage::protocol(json!({
"id": renderer_call_id.get(),
"result": {}
})),
);
output.bind_renderer_agent_attachment(attachment_id);
RuntimeInspectorResponseReady::new(
attachment_test_frontend_id,
None,
Ok(
moli_core::RendererRuntimeInspectorAsyncCompletion::from_command_output(
renderer_call_id.get(),
output,
),
),
)
};
assert!(
conn.resolve_runtime_inspector_response_ready(response_ready(
correlation.renderer_call_id(),
stale_attachment_id,
))
.is_none(),
"stale attachment response must not consume the pending correlation"
);
assert!(
conn.resolve_runtime_inspector_response_ready(response_ready(
moli_page_types::RendererCallId::new(correlation.renderer_call_id().get() + 1,),
current_attachment_id,
))
.is_none(),
"wrong renderer call id must not consume the pending correlation"
);
let resolved = conn
.resolve_runtime_inspector_response_ready(response_ready(
correlation.renderer_call_id(),
current_attachment_id,
))
.expect("matching session, renderer call, and attachment should resolve");
assert_eq!(
resolved.into_protocol_message_for_typed_runtime_route()["id"],
json!(attachment_test_frontend_id)
);
let browser_context = conn.browser_context.as_ref().expect("browser context");
assert_eq!(
browser_context.page_attachment_id(),
attachment_after_real_page,
"discarding stale initial document build must not replace the current page"
);
assert_eq!(
browser_context
.loaded_page()
.expect("real page should stay installed")
.final_url()
.as_str(),
parsed_real_page_url.as_str(),
"current page should remain the committed navigation page"
);
let initial = browser_context
.active_page_target()
.owner_state
.initial_empty_document_state()
.expect("initial empty document state should remain recorded");
assert!(
initial.exited(),
"real navigation should have exited the initial empty document"
);
assert!(
!initial.materialized(),
"discarded initial build must not mark the exited initial document materialized"
);
}
#[tokio::test]
async fn automation_command_executes_page_navigation_and_reload() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
};
let (create_result, _) = conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
},
))
.await
.into_parts();
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let url = "data:text/html,bidi-nav".to_owned();
let target_id = create_result.target_id.clone();
let (navigate_result, _, _, _) = conn
.execute_automation_command(AutomationCommand::Navigate(DevToolsNavigateCommand {
context: AutomationContext {
target_id: Some(target_id.clone()),
..context.clone()
},
url: url.clone(),
referrer: None,
wait: DevToolsNavigationWait::Load,
}))
.await
.into_complete_parts();
let AutomationResult::Navigate(navigate_result) =
navigate_result.expect("navigate should succeed")
else {
panic!("expected navigate result");
};
assert_eq!(navigate_result.url, url);
let (reload_result, _, _, _) = conn
.execute_automation_command(AutomationCommand::Reload(DevToolsReloadCommand {
context: AutomationContext {
target_id: Some(target_id),
..context
},
ignore_cache: false,
script_to_evaluate_on_load: None,
wait: DevToolsNavigationWait::Load,
}))
.await
.into_complete_parts();
let AutomationResult::Navigate(reload_result) = reload_result.expect("reload should succeed")
else {
panic!("expected reload navigation result");
};
assert_eq!(reload_result.url, url);
}
#[tokio::test]
async fn automation_command_executes_page_navigation_without_cdp_response_sidecar() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
};
let (create_result, _) = conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
},
))
.await
.into_parts();
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let target_context = AutomationContext {
target_id: Some(create_result.target_id),
..context
};
let url = "data:text/html,direct-nav-no-sidecar".to_owned();
let (navigate_result, _scheduler_events, protocol_events, _renderer_output_predecessor) = conn
.execute_automation_command_with_protocol_events(AutomationCommand::Navigate(
DevToolsNavigateCommand {
context: target_context,
url: url.clone(),
referrer: None,
wait: DevToolsNavigationWait::Load,
},
))
.await
.into_complete_parts();
let AutomationResult::Navigate(navigate_result) =
navigate_result.expect("navigate should succeed")
else {
panic!("expected navigate result");
};
assert_eq!(navigate_result.url, url);
assert!(
protocol_events
.iter()
.all(|event| !is_command_response_sidecar_event(event)),
"direct navigation must not emit a command response as a protocol sidecar: {protocol_events:?}"
);
}
#[tokio::test]
async fn automation_command_executes_child_frame_navigation_without_cdp_response_sidecar() {
let mut ctx = crate::testing::TestContext::new_with_target_discovery(false);
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
};
let create_outcome = ctx
.conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
},
))
.await;
let (create_result, _, _, create_predecessor) = create_outcome.into_complete_parts();
if let Some(predecessor) = create_predecessor {
ctx.route_direct_command_renderer_predecessor_for_test(predecessor)
.await;
}
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let target_context = AutomationContext {
target_id: Some(create_result.target_id.clone()),
..context.clone()
};
let parent_url =
"data:text/html,<iframe srcdoc='<p id=\"child\">initial</p>'></iframe>".to_owned();
let parent_outcome = ctx
.conn
.execute_automation_command(AutomationCommand::Navigate(DevToolsNavigateCommand {
context: target_context.clone(),
url: parent_url,
referrer: None,
wait: DevToolsNavigationWait::Load,
}))
.await;
let (parent_result, _, _, parent_predecessor) = parent_outcome.into_complete_parts();
if let Some(predecessor) = parent_predecessor {
ctx.route_direct_command_renderer_predecessor_for_test(predecessor)
.await;
}
parent_result.expect("parent navigation should succeed");
let (frame_tree_result, _) = ctx
.conn
.execute_automation_command(AutomationCommand::GetFrameTree(
DevToolsGetFrameTreeCommand {
context: target_context,
max_depth: None,
},
))
.await
.into_parts();
let AutomationResult::GetFrameTree(frame_tree_result) =
frame_tree_result.expect("frame tree should be readable")
else {
panic!("expected frame tree result");
};
let child_frame_id = frame_tree_result.frame_tree["childFrames"]
.as_array()
.and_then(|child_frames| child_frames.first())
.and_then(|child_frame| child_frame["frame"]["id"].as_str())
.expect("parent navigation should create one child frame")
.to_owned();
ctx.wait_until_scheduler_state("child frame attachment", |conn| {
conn.has_attached_child_frame_id(&child_frame_id)
})
.await;
let child_url = "data:text/html,<p id='child'>updated</p>".to_owned();
let child_outcome = ctx
.conn
.execute_automation_command_with_protocol_events(AutomationCommand::Navigate(
DevToolsNavigateCommand {
context: AutomationContext {
target_id: Some(DevToolsTargetId::from(child_frame_id)),
..context
},
url: child_url.clone(),
referrer: None,
wait: DevToolsNavigationWait::Load,
},
))
.await;
let (navigate_result, _scheduler_events, protocol_events, child_predecessor) =
child_outcome.into_complete_parts();
if let Some(predecessor) = child_predecessor {
ctx.route_direct_command_renderer_predecessor_for_test(predecessor)
.await;
}
let AutomationResult::Navigate(navigate_result) =
navigate_result.expect("child frame navigate should succeed")
else {
panic!("expected navigate result");
};
assert_eq!(navigate_result.url, child_url);
assert!(
protocol_events
.iter()
.all(|event| !is_command_response_sidecar_event(event)),
"direct child-frame navigation must not emit a command response as a protocol sidecar: {protocol_events:?}"
);
}
#[tokio::test]
async fn automation_command_reports_invalid_navigation_without_cdp_response_parser() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
};
let (create_result, _) = conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
},
))
.await
.into_parts();
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let target_context = AutomationContext {
target_id: Some(create_result.target_id),
..context
};
let (navigate_result, _scheduler_events, protocol_events) = conn
.execute_automation_command_with_protocol_events(AutomationCommand::Navigate(
DevToolsNavigateCommand {
context: target_context,
url: "not a valid navigation url".to_owned(),
referrer: None,
wait: DevToolsNavigationWait::Load,
},
))
.await
.into_parts_with_protocol_events();
let error = navigate_result.expect_err("invalid navigate should fail");
assert_eq!(error.kind, DevToolsErrorKind::Internal);
assert_eq!(error.message, "Invalid navigation URL");
assert!(
protocol_events
.iter()
.all(|event| !is_command_response_sidecar_event(event)),
"direct navigation error must not be surfaced as a CDP response sidecar: {protocol_events:?}"
);
}
#[tokio::test]
async fn automation_command_rejects_page_print_to_pdf_without_placeholder_payload() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
};
let (create_result, _) = conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
},
))
.await
.into_parts();
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let target_id = create_result.target_id.clone();
let url = "data:text/html,bidi-print".to_owned();
let (navigate_result, _, _, _) = conn
.execute_automation_command(AutomationCommand::Navigate(DevToolsNavigateCommand {
context: AutomationContext {
target_id: Some(target_id.clone()),
..context.clone()
},
url,
referrer: None,
wait: DevToolsNavigationWait::Load,
}))
.await
.into_complete_parts();
navigate_result.expect("navigate should succeed");
let (print_result, _) = conn
.execute_automation_command(AutomationCommand::PrintToPdf(DevToolsPrintToPdfCommand {
context: AutomationContext {
target_id: Some(target_id),
..context
},
landscape: Some(false),
print_background: Some(true),
scale: Some(1.0),
paper_width: Some(8.5),
paper_height: Some(11.0),
margin_top: Some(0.25),
margin_bottom: Some(0.25),
margin_left: Some(0.25),
margin_right: Some(0.25),
page_ranges: Some("1".to_owned()),
shrink_to_fit: Some(true),
transfer_mode: Some(DevToolsPrintToPdfTransferMode::ReturnAsBase64),
}))
.await
.into_parts();
let error = print_result.expect_err("print should not return a placeholder PDF");
assert_eq!(error.kind, DevToolsErrorKind::Unsupported);
assert_eq!(
error.message,
"Page.printToPDF is not supported: PDF generation is not implemented."
);
}
#[tokio::test]
async fn automation_command_executes_context_viewport_override() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverBidi,
session_id: Some(DevToolsSessionId::from("bidi-session-1")),
target_id: None,
browser_context_id: None,
};
let (create_result, _) = conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
},
))
.await
.into_parts();
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let target_id = create_result.target_id.clone();
let (viewport_result, _) = conn
.execute_automation_command(AutomationCommand::SetViewport(DevToolsSetViewportCommand {
context: AutomationContext {
target_id: Some(target_id.clone()),
..context.clone()
},
browser_context_ids: Vec::new(),
viewport: DevToolsViewportSetting::Dimensions {
width: 800,
height: 600,
},
device_pixel_ratio: DevToolsDevicePixelRatioSetting::Scale(2.0),
screen_width: None,
screen_height: None,
}))
.await
.into_parts();
assert_eq!(
viewport_result.expect("set viewport should succeed"),
AutomationResult::Empty
);
let owner = CommandOwnerScope::capture(&conn, None);
let metrics = conn
.target_session_owner_emulated_device_metrics_for_owner(&owner)
.expect("active target should hold emulated device metrics");
assert_eq!(metrics.width, 800);
assert_eq!(metrics.height, 600);
assert_eq!(metrics.device_scale_factor, 2.0);
let (layout_result, _) = conn
.execute_automation_command(AutomationCommand::GetLayoutMetrics(
DevToolsGetLayoutMetricsCommand {
context: AutomationContext {
target_id: Some(target_id),
..context
},
},
))
.await
.into_parts();
let AutomationResult::LayoutMetrics(layout_metrics) =
layout_result.expect("target layout metrics should succeed")
else {
panic!("expected layout metrics result");
};
assert_eq!(layout_metrics.layout_viewport_width, 800);
assert_eq!(layout_metrics.layout_viewport_height, 600);
assert_eq!(layout_metrics.device_pixel_ratio, 2.0);
}
#[tokio::test]
async fn automation_command_executes_navigation_history_and_traverse() {
let mut conn = CdpConnection::new();
let context = AutomationContext {
protocol: FrontendProtocol::WebDriverClassic,
session_id: Some(DevToolsSessionId::from("classic-session-1")),
target_id: None,
browser_context_id: None,
};
let (create_result, _) = conn
.execute_automation_command(AutomationCommand::CreateTarget(
DevToolsCreateTargetCommand {
context: context.clone(),
url: "about:blank".to_owned(),
browser_context_id: None,
activate: false,
},
))
.await
.into_parts();
let AutomationResult::CreateTarget(create_result) =
create_result.expect("create target should succeed")
else {
panic!("expected create target result");
};
let target_id = create_result.target_id;
let target_context = AutomationContext {
target_id: Some(target_id.clone()),
..context
};
let first_url = "data:text/html,<title>A</title>classic-a".to_owned();
let second_url = "data:text/html,<title>B</title>classic-b".to_owned();
for url in [&first_url, &second_url] {
let (navigate_result, _, _, _) = conn
.execute_automation_command(AutomationCommand::Navigate(DevToolsNavigateCommand {
context: target_context.clone(),
url: (*url).clone(),
referrer: None,
wait: DevToolsNavigationWait::Load,
}))
.await
.into_complete_parts();
navigate_result.expect("navigate should succeed");
}
let (history_result, _) = conn
.execute_automation_command(AutomationCommand::GetNavigationHistory(
DevToolsGetNavigationHistoryCommand {
context: target_context.clone(),
},
))
.await
.into_parts();
let AutomationResult::GetNavigationHistory(history) =
history_result.expect("history should succeed")
else {
panic!("expected navigation history result");
};
assert!(history.current_index > 0);
assert_eq!(history.entries[history.current_index].url, second_url);
let previous = history.entries[history.current_index - 1].clone();
let (traverse_result, _, _, _) = conn
.execute_automation_command(AutomationCommand::TraverseHistory(
DevToolsTraverseHistoryCommand {
context: target_context.clone(),
destination: DevToolsHistoryTraversalDestination::Entry {
entry_id: previous.id,
url: previous.url.clone(),
},
wait: DevToolsNavigationWait::Load,
},
))
.await
.into_complete_parts();
assert!(matches!(
traverse_result.expect("traverse should succeed"),
AutomationResult::TraverseHistory(DevToolsTraverseHistoryResult {
same_document: false
})
));
let (history_result, _) = conn
.execute_automation_command(AutomationCommand::GetNavigationHistory(
DevToolsGetNavigationHistoryCommand {
context: target_context.clone(),
},
))
.await
.into_parts();
let AutomationResult::GetNavigationHistory(history) =
history_result.expect("history after traverse should succeed")
else {
panic!("expected navigation history result after traverse");
};
assert_eq!(history.entries[history.current_index].id, previous.id);
let (delta_result, _, _, _) = conn
.execute_automation_command(AutomationCommand::TraverseHistory(
DevToolsTraverseHistoryCommand {
context: target_context.clone(),
destination: DevToolsHistoryTraversalDestination::Delta(1),
wait: DevToolsNavigationWait::Load,
},
))
.await
.into_complete_parts();
assert!(matches!(
delta_result.expect("delta traverse should succeed"),
AutomationResult::TraverseHistory(DevToolsTraverseHistoryResult {
same_document: false
})
));
let (history_result, _) = conn
.execute_automation_command(AutomationCommand::GetNavigationHistory(
DevToolsGetNavigationHistoryCommand {
context: target_context.clone(),
},
))
.await
.into_parts();
let AutomationResult::GetNavigationHistory(history) =
history_result.expect("history after delta traverse should succeed")
else {
panic!("expected navigation history result after delta traverse");
};
assert_eq!(history.entries[history.current_index].url, second_url);
let (out_of_range_result, _) = conn
.execute_automation_command(AutomationCommand::TraverseHistory(
DevToolsTraverseHistoryCommand {
context: target_context,
destination: DevToolsHistoryTraversalDestination::Delta(1),
wait: DevToolsNavigationWait::Load,
},
))
.await
.into_parts();
let error = out_of_range_result.expect_err("out-of-range delta should fail");
assert_eq!(error.kind, DevToolsErrorKind::NoSuchHistoryEntry);
}