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::*;
use moli_protocol::version;
#[test]
fn protocol_server_constructor_preserves_optional_resource_fetch_policy() {
let partition = Arc::new(StoragePartitionState::open(None).unwrap());
let mask = OptionalResourceFetchMask::FONT
| OptionalResourceFetchMask::VIDEO
| OptionalResourceFetchMask::TEXT_TRACK;
let server = ProtocolServer::new_with_storage_partition_fetch_config_and_resource_loading(
ServerConfig::default(),
partition,
FetchConfig::default(),
mask,
true,
);
assert_eq!(
server
.navigation_runtime_config
.optional_resource_fetch_mask(),
mask
);
}
#[test]
fn protocol_server_constructor_preserves_subframe_loading_policy() {
let partition = Arc::new(StoragePartitionState::open(None).unwrap());
let server = ProtocolServer::new_with_storage_partition_fetch_config_and_resource_loading(
ServerConfig::default(),
partition,
FetchConfig::default(),
OptionalResourceFetchMask::NONE,
false,
);
assert!(!server.navigation_runtime_config.subframe_loading_enabled());
}
#[test]
fn merge_cookie_profiles_replaces_existing_cookie_by_storage_key() {
let mut cookies = vec![stored_cookie("sid", "old"), stored_cookie("theme", "dark")];
merge_cookie_profiles(
&mut cookies,
vec![stored_cookie("sid", "new"), stored_cookie("extra", "1")],
);
assert_eq!(cookies.len(), 3);
assert_eq!(
cookies
.iter()
.find(|cookie| cookie.name == "sid")
.map(|cookie| cookie.value.as_str()),
Some("new")
);
assert_eq!(
cookies
.iter()
.find(|cookie| cookie.name == "theme")
.map(|cookie| cookie.value.as_str()),
Some("dark")
);
assert_eq!(
cookies
.iter()
.find(|cookie| cookie.name == "extra")
.map(|cookie| cookie.value.as_str()),
Some("1")
);
}
#[test]
fn commit_cookie_profile_removes_initial_cookie_missing_from_final_snapshot() {
let deleted = stored_cookie("sid", "old");
let mut cookies = vec![deleted.clone(), stored_cookie("theme", "dark")];
commit_cookie_profile(
&mut cookies,
CookieProfileCommit::new(vec![deleted], vec![stored_cookie("theme", "dark")]),
);
assert_eq!(cookies.len(), 1);
assert_eq!(cookies[0].name, "theme");
}
#[test]
fn commit_cookie_profile_preserves_concurrent_update_when_session_deleted_stale_cookie() {
let initial = stored_cookie("sid", "old");
let concurrent = stored_cookie("sid", "newer");
let mut cookies = vec![concurrent];
commit_cookie_profile(
&mut cookies,
CookieProfileCommit::new(vec![initial], Vec::new()),
);
assert_eq!(cookies.len(), 1);
assert_eq!(cookies[0].name, "sid");
assert_eq!(cookies[0].value, "newer");
}
#[test]
fn commit_cookie_profile_merges_final_updates_and_drops_expired_cookies() {
let mut expired = stored_cookie("expired", "gone");
expired.expires = Some(time::OffsetDateTime::now_utc() - time::Duration::days(1));
let mut cookies = vec![
stored_cookie("sid", "old"),
stored_cookie("theme", "dark"),
expired.clone(),
];
commit_cookie_profile(
&mut cookies,
CookieProfileCommit::new(
vec![stored_cookie("sid", "old")],
vec![
stored_cookie("sid", "new"),
stored_cookie("extra", "1"),
expired,
],
),
);
assert_eq!(
cookies
.iter()
.find(|cookie| cookie.name == "sid")
.map(|cookie| cookie.value.as_str()),
Some("new")
);
assert_eq!(
cookies
.iter()
.find(|cookie| cookie.name == "theme")
.map(|cookie| cookie.value.as_str()),
Some("dark")
);
assert!(cookies.iter().any(|cookie| cookie.name == "extra"));
assert!(!cookies.iter().any(|cookie| cookie.name == "expired"));
}
#[test]
fn shared_cookie_profile_merge_and_save_writes_cache_file() -> anyhow::Result<()> {
let path = std::env::temp_dir().join(format!(
"moli-cdp-cookie-profile-{}-{}.json",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos()
));
let profile = SharedCookieProfile::new(vec![stored_cookie("sid", "old")], vec![path.clone()]);
profile.merge_and_save(vec![stored_cookie("sid", "new")])?;
let loaded = cookie_cache::load_cookie_cache(&path)?;
let _ = std::fs::remove_file(&path);
assert_eq!(loaded.len(), 1);
assert_eq!(loaded[0].name, "sid");
assert_eq!(loaded[0].value, "new");
Ok(())
}
#[test]
fn shared_cookie_profile_partition_backing_uses_storage_partition() -> anyhow::Result<()> {
let profile = TempDir::new("shared-cookie-profile-partition");
let paths = BrowserProfilePaths::new(&profile.path);
let partition = Arc::new(StoragePartitionState::open(Some(&profile.path))?);
partition.import_cookies(vec![stored_cookie("sid", "old")])?;
let profile = SharedCookieProfile::from_storage_partition(partition.clone());
let initial_cookies = profile.snapshot();
profile.commit_and_save(CookieProfileCommit::new(
initial_cookies,
vec![stored_cookie("sid", "new")],
))?;
let partition_cookies = partition.cookies()?;
assert_eq!(partition_cookies.len(), 1);
assert_eq!(partition_cookies[0].value, "new");
let persisted = cookie_cache::load_cookie_cache(&paths.cookies_path)?;
assert_eq!(persisted.len(), 1);
assert_eq!(persisted[0].value, "new");
Ok(())
}
#[test]
fn app_state_storage_partition_backing_derives_initial_partition_from_owner() -> anyhow::Result<()>
{
let partition = Arc::new(StoragePartitionState::open(None)?);
let state = AppState::new_with_storage_partition(
"127.0.0.1:9222".parse().expect("test addr"),
partition.clone(),
FetchConfig::default(),
OptionalResourceFetchMask::NONE,
true,
)?;
let initial_storage_partition =
state.initial_storage_partition(vec![stored_cookie("owner-cookie", "owner-value")]);
let mut conn =
moli_protocol::CdpConnection::new_with_initial_storage_partition(initial_storage_partition);
assert!(conn.snapshot_profile_backed_cookies().is_none());
conn.install_default_browser_target();
let cookies = conn.snapshot_profile_backed_cookies().unwrap();
assert_eq!(cookies.len(), 1);
assert_eq!(cookies[0].name, "owner-cookie");
assert_eq!(cookies[0].value, "owner-value");
Ok(())
}
#[tokio::test]
async fn discovery_endpoints_accept_trailing_slashes() {
let version = request_json("/json/version").await;
assert_eq!(version, request_json("/json/version/").await);
assert_eq!(
version["webSocketDebuggerUrl"],
json!("ws://127.0.0.1:9222/devtools/browser/moli-browser")
);
assert_eq!(version["Browser"], json!(version::PRODUCT));
assert_eq!(version["Moli-Version"], json!(version::MOLI_VERSION));
assert_eq!(
version["Protocol-Version"],
json!(version::PROTOCOL_VERSION)
);
assert_eq!(
version["User-Agent"],
json!(FetchConfig::DEFAULT_USER_AGENT)
);
assert_eq!(version["V8-Version"], json!(version::js_version()));
assert_eq!(version["WebKit-Version"], json!(version::WEBKIT_VERSION));
let list = request_json("/json").await;
assert_eq!(list, request_json("/json/list").await);
assert_eq!(list, request_json("/json/list/").await);
assert_eq!(
list[0]["webSocketDebuggerUrl"],
json!("ws://127.0.0.1:9222/devtools/page/moli-default")
);
assert_eq!(list[0]["description"], json!(""));
assert_eq!(
list[0]["devtoolsFrontendUrl"],
json!("/devtools/inspector.html?ws=127.0.0.1:9222/devtools/page/moli-default")
);
assert_eq!(list[0]["id"], json!(DEFAULT_TARGET_ID));
assert_eq!(list[0]["title"], json!(""));
assert_eq!(list[0]["type"], json!("page"));
assert_eq!(list[0]["url"], json!(DEFAULT_TARGET_URL));
let protocol = request_json("/json/protocol").await;
assert_eq!(protocol, request_json("/json/protocol/").await);
assert_eq!(protocol["version"]["major"], json!("1"));
assert_eq!(protocol["version"]["minor"], json!("3"));
assert!(protocol["domains"].is_array());
assert_eq!(
request_status("/json/new").await,
StatusCode::METHOD_NOT_ALLOWED
);
for path in [
"/json/",
"/json//",
"/json/version//",
"//json/version/",
"///json/version///",
] {
assert_eq!(request_status(path).await, StatusCode::NOT_FOUND, "{path}");
}
assert_eq!(version, request_json("/json/version/?query=%2F//").await);
for path in [
"/session//",
"/session/probe/cookie//",
"/json/activate//",
"/devtools/page//",
"/session//url/",
] {
assert_eq!(
request_status_with_method(Method::OPTIONS, path).await,
StatusCode::METHOD_NOT_ALLOWED,
"empty capture in {path}"
);
}
let new_target = request_json_with_method(
Method::PUT,
"/json/new/?about%3Ablank%23trailing-slash-target",
)
.await;
assert_ne!(new_target["id"], json!(DEFAULT_TARGET_ID));
assert!(
new_target["webSocketDebuggerUrl"]
.as_str()
.is_some_and(|url| url.ends_with(new_target["id"].as_str().unwrap_or_default()))
);
assert_eq!(
new_target["url"],
json!("about:blank#trailing-slash-target")
);
assert_eq!(
new_target["title"],
json!("about:blank#trailing-slash-target")
);
assert_eq!(
request_json_with_method(Method::PUT, "/json/new").await["url"],
json!(DEFAULT_TARGET_URL)
);
assert_eq!(
request_status("/json/activate/moli-default").await,
StatusCode::OK
);
assert_eq!(
request_status("/json/activate/missing").await,
StatusCode::NOT_FOUND
);
assert_eq!(
request_status("/json/close/moli-default").await,
StatusCode::OK
);
assert_eq!(
request_status("/json/close/missing").await,
StatusCode::NOT_FOUND
);
assert_eq!(request_status("/cdp").await, StatusCode::NOT_FOUND);
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
assert_eq!(
rejected_websocket_status(format!("ws://{cdp_addr}/devtools/browser/missing")).await,
StatusCode::NOT_FOUND.as_u16()
);
assert_eq!(
rejected_websocket_status(format!("ws://{cdp_addr}/devtools/page/missing")).await,
StatusCode::NOT_FOUND.as_u16()
);
protocol_server.abort();
}
#[tokio::test]
async fn browser_websocket_supports_puppeteer_browser_target_session() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to browser cdp websocket");
let discover = send_cdp_command(
&mut socket,
1,
"Target.setDiscoverTargets",
None,
json!({ "discover": true, "filter": [{}] }),
)
.await;
let browser_target = discover
.iter()
.find(|message| {
message["method"] == json!("Target.targetCreated")
&& message["params"]["targetInfo"]["type"] == json!("browser")
})
.expect("catch-all discovery should report the browser target");
let browser_target_id = browser_target["params"]["targetInfo"]["targetId"]
.as_str()
.expect("browser target id")
.to_owned();
let attach = send_cdp_command(
&mut socket,
2,
"Target.attachToTarget",
None,
json!({ "targetId": browser_target_id, "flatten": true }),
)
.await;
let browser_session_id = attach
.iter()
.find(|message| message["id"] == json!(2_u64))
.and_then(|message| message["result"]["sessionId"].as_str())
.expect("browser target session id")
.to_owned();
assert!(attach.iter().any(|message| {
message["method"] == json!("Target.attachedToTarget")
&& message["params"]["sessionId"] == json!(browser_session_id)
&& message["params"]["targetInfo"]["targetId"] == json!(browser_target_id)
}));
let version = send_cdp_command(
&mut socket,
3,
"Browser.getVersion",
Some(&browser_session_id),
json!({}),
)
.await;
let version_response = version
.iter()
.find(|message| message["id"] == json!(3_u64))
.expect("Browser.getVersion response");
assert_eq!(version_response["sessionId"], json!(browser_session_id));
assert!(version_response["result"]["product"].is_string());
socket.close(None).await.expect("close browser websocket");
protocol_server.abort();
}
#[tokio::test]
async fn browser_websocket_exposes_same_default_target_as_json_list() {
let list = request_json("/json/list").await;
assert_eq!(list[0]["id"], json!(DEFAULT_TARGET_ID));
assert_eq!(list[0]["url"], json!(DEFAULT_TARGET_URL));
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
))
.await
.expect("connect to browser cdp websocket");
let discover = send_cdp_command(
&mut socket,
1,
"Target.setDiscoverTargets",
None,
json!({
"discover": true,
"filter": [{ "type": "page" }]
}),
)
.await;
assert!(
discover
.iter()
.any(|message| message["id"] == json!(1_u64) && message["result"] == json!({})),
"Target.setDiscoverTargets should succeed: {discover:?}"
);
let get_targets = send_cdp_command(&mut socket, 2, "Target.getTargets", None, json!({})).await;
let response = get_targets
.iter()
.find(|message| message["id"] == json!(2_u64))
.expect("Target.getTargets response");
let target_infos = response["result"]["targetInfos"]
.as_array()
.expect("Target.getTargets targetInfos");
assert_eq!(target_infos.len(), 1);
assert_eq!(target_infos[0]["targetId"], json!(DEFAULT_TARGET_ID));
assert_eq!(target_infos[0]["url"], json!(DEFAULT_TARGET_URL));
assert_eq!(target_infos[0]["attached"], json!(false));
let target_created = get_targets
.iter()
.chain(discover.iter())
.find(|message| message["method"] == json!("Target.targetCreated"))
.expect("Target.setDiscoverTargets should report the existing default page target");
assert_eq!(
target_created["params"]["targetInfo"]["targetId"],
json!(DEFAULT_TARGET_ID)
);
let attach = send_cdp_command(
&mut socket,
3,
"Target.attachToTarget",
None,
json!({
"targetId": DEFAULT_TARGET_ID,
"flatten": true
}),
)
.await;
let session_id = attach
.iter()
.find(|message| message["id"] == json!(3_u64))
.and_then(|message| message["result"]["sessionId"].as_str())
.expect("default target sessionId")
.to_owned();
let _ = send_cdp_command(
&mut socket,
4,
"Target.setAutoAttach",
None,
json!({
"autoAttach": true,
"waitForDebuggerOnStart": false,
"flatten": true
}),
)
.await;
let get_targets_after_auto_attach =
send_cdp_command(&mut socket, 5, "Target.getTargets", None, json!({})).await;
let response = get_targets_after_auto_attach
.iter()
.find(|message| message["id"] == json!(5_u64))
.expect("Target.getTargets response after auto-attach");
let target_infos = response["result"]["targetInfos"]
.as_array()
.expect("Target.getTargets targetInfos after auto-attach");
assert_eq!(target_infos.len(), 1);
assert_eq!(target_infos[0]["targetId"], json!(DEFAULT_TARGET_ID));
assert_eq!(target_infos[0]["attached"], json!(true));
assert!(
!get_targets_after_auto_attach.iter().any(|message| {
message["method"] == json!("Target.targetCreated")
&& message["params"]["targetInfo"]["targetId"] != json!(DEFAULT_TARGET_ID)
}),
"browser-use startup sequence must not create a second page target: {get_targets_after_auto_attach:?}"
);
let _ = send_cdp_command(
&mut socket,
6,
"Runtime.enable",
Some(&session_id),
json!({}),
)
.await;
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
async fn chromium_devtools_json_list_accepts_non_get_methods_and_for_tab() {
let list = request_json("/json").await;
let tab_list = request_json("/json/list?for_tab").await;
// Ported from Chromium DevToolsHttpHandlerTest.TestJsonList: list
// discovery is not method-gated. Chromium's remote-device discovery asks
// for tab targets explicitly so its frontend can auto-attach the current
// page below a stable tab root.
assert_eq!(request_json_with_method(Method::PUT, "/json").await, list);
assert_eq!(
request_json_with_method(Method::PUT, "/json/list").await,
list
);
assert_eq!(
request_json_with_method(Method::PUT, "/json/list?for_tab").await,
tab_list
);
assert_eq!(list[0]["type"], json!("page"));
assert_eq!(
list[0]["webSocketDebuggerUrl"],
json!("ws://127.0.0.1:9222/devtools/page/moli-default")
);
assert_eq!(tab_list.as_array().map(Vec::len), Some(2));
assert!(tab_list.as_array().is_some_and(|targets| {
targets.iter().any(|target| {
target["id"] == json!(DEFAULT_TARGET_ID) && target["type"] == json!("page")
})
}));
let tab = tab_list
.as_array()
.and_then(|targets| {
targets
.iter()
.find(|target| target["id"] == json!(DEFAULT_TAB_TARGET_ID))
})
.expect("for_tab discovery should add the stable tab target");
assert_eq!(tab["type"], json!("tab"));
assert_eq!(
tab["devtoolsFrontendUrl"],
json!("/devtools/inspector.html?ws=127.0.0.1:9222/devtools/page/moli-default-tab")
);
assert_eq!(
tab["webSocketDebuggerUrl"],
json!("ws://127.0.0.1:9222/devtools/page/moli-default-tab")
);
}
#[tokio::test]
async fn chromium_devtools_json_new_uses_put_and_decodes_first_query_component() {
// Ported from Chromium DevToolsHttpHandlerTest.MutatingActionsiRequireSafeVerb.
assert_eq!(
request_status("/json/new").await,
StatusCode::METHOD_NOT_ALLOWED
);
assert_eq!(
request_status_with_method(Method::POST, "/json/new").await,
StatusCode::METHOD_NOT_ALLOWED
);
assert_eq!(
request_json_with_method(Method::PUT, "/json/new").await["url"],
json!(DEFAULT_TARGET_URL)
);
// Ported from Chromium DevToolsHttpHandlerTest.TestJsonNew: the first
// query component is the target URL, and a trailing for_tab flag does
// not become part of that URL.
let encoded = "about%3Ablank%3Fq%3D1%26x%3D2";
let target =
request_json_with_method(Method::PUT, &format!("/json/new?{encoded}&for_tab")).await;
assert_eq!(target["url"], json!("about:blank?q=1&x=2"));
assert_eq!(target["title"], json!("about:blank?q=1&x=2"));
assert_eq!(target["type"], json!("tab"));
assert!(
target["webSocketDebuggerUrl"]
.as_str()
.is_some_and(|url| url.contains("/devtools/page/TAB-"))
);
let target = request_json_with_method(Method::PUT, "/json/new?url=about%3Ablank%23named").await;
assert_eq!(target["url"], json!("about:blank#named"));
let target = request_json_with_method(
Method::PUT,
"/json/new?session=abc&url=about%3Ablank%23session",
)
.await;
assert_eq!(target["url"], json!("about:blank#session"));
let target = request_json_with_method(Method::PUT, "/json/new?data:text/plain,direct").await;
assert_eq!(target["url"], json!("data:text/plain,direct"));
let target = request_json_with_method(Method::PUT, "/json/new?not%20a%20url").await;
assert_eq!(target["url"], json!(DEFAULT_TARGET_URL));
}
#[tokio::test]
async fn chromium_devtools_activate_and_close_return_text_payloads() {
// Ported from chrome/test/data/devtools/target_list/background.js.
let (status, body) =
request_status_and_text_with_method(Method::GET, "/json/activate/moli-default").await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body, "Target activated");
let (status, body) =
request_status_and_text_with_method(Method::GET, "/json/close/moli-default").await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body, "Target is closing");
let (status, body) =
request_status_and_text_with_method(Method::GET, "/json/activate/missing").await;
assert_eq!(status, StatusCode::NOT_FOUND);
assert_eq!(body, "No such target id: missing");
}
#[tokio::test]
async fn closed_default_target_is_not_readvertised_by_discovery() {
let app = build_router(test_state());
let first_list = app
.clone()
.oneshot(
Request::builder()
.uri("/json/list?for_tab")
.body(Body::empty())
.expect("list request"),
)
.await
.expect("first list response");
let first_list = serde_json::from_slice::<serde_json::Value>(
&to_bytes(first_list.into_body(), usize::MAX)
.await
.expect("first list body"),
)
.expect("first list JSON");
assert!(first_list.as_array().is_some_and(|targets| {
targets
.iter()
.any(|target| target["id"] == json!(DEFAULT_TARGET_ID))
&& targets
.iter()
.any(|target| target["id"] == json!(DEFAULT_TAB_TARGET_ID))
}));
let close = app
.clone()
.oneshot(
Request::builder()
.uri("/json/close/moli-default")
.body(Body::empty())
.expect("close request"),
)
.await
.expect("close response");
assert_eq!(close.status(), StatusCode::OK);
let second_list = app
.oneshot(
Request::builder()
.uri("/json/list?for_tab")
.body(Body::empty())
.expect("second list request"),
)
.await
.expect("second list response");
let second_list = serde_json::from_slice::<serde_json::Value>(
&to_bytes(second_list.into_body(), usize::MAX)
.await
.expect("second list body"),
)
.expect("second list JSON");
assert_eq!(second_list, json!([]));
}