Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
test(fetch): preserve explicitly empty author header values
ldm0f776d539bbce
diff --git a/moli-fetch/src/tests/mod.rs b/moli-fetch/src/tests/mod.rsindex ff93a6ef4..104654acc 100644--- a/moli-fetch/src/tests/mod.rs+++ b/moli-fetch/src/tests/mod.rs@@ -1554,6 +1554,88 @@ async fn fetch_redirects_recompute_bodyless_put_content_length() -> Result<()> {Ok(())}+#[tokio::test]+async fn request_headers_distinguish_empty_values_from_absent_upload_content_type() -> Result<()> {+ let mut cases = Vec::new();+ for buffered in [false, true] {+ for method in [+ "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "YO",+ ] {+ for body in [None, Some(Vec::new()), Some(b"payload".to_vec())] {+ if matches!(method, "GET" | "HEAD") && body.is_some() {+ continue;+ }+ for content_type in [None, Some(""), Some("application/example")] {+ cases.push((buffered, method, body.clone(), content_type));+ }+ }+ }+ }+ // Digest can probe with an empty upload before sending the body, even when+ // the fixture accepts the first request. Inspect both requests on the wire.+ let server = ScriptedHttps11Server::spawn(vec![ScriptedResponse::ok(""); cases.len() * 2]);+ let mut config = FetchConfig::default();+ config.set_tls_verify_host(false);+ config.set_default_request_headers(vec![("X-Default-Empty".to_owned(), String::new())]);+ let client = FetchClient::new(&config, new_shared_browser_cookie_store());++ for (index, (buffered, method, body, content_type)) in cases.iter().enumerate() {+ let mut headers = vec![("X-Empty".to_owned(), String::new())];+ if let Some(content_type) = content_type {+ headers.push(("Content-Type".to_owned(), (*content_type).to_owned()));+ }+ let mut request = Request::new_bytes(+ method,+ &server.url_path(&format!("/empty-headers/{index}")),+ body.clone(),+ headers,+ )?;+ if *buffered {+ request = request.with_auth(RequestAuth {+ target: RequestAuthTarget::Server,+ scheme: RequestAuthScheme::Digest,+ username: "user".to_owned(),+ password: "pass".to_owned(),+ });+ }+ assert_eq!(request.auth_requires_buffered_transport(), *buffered);+ assert_eq!(client.fetch_raw(request).await?.status, 200);+ }++ let requests = server.request_heads();+ server.shutdown();+ let mut seen = BTreeSet::new();+ for request in &requests {+ let index = request_path(request)+ .strip_prefix("/empty-headers/")+ .expect("fixture request path")+ .parse::<usize>()?;+ seen.insert(index);+ let case = &cases[index];+ let (_, method, _, content_type) = case;+ assert!(request.starts_with(&format!("{method} /empty-headers/{index} HTTP/1.1\r\n")));+ let values = |name: &str| {+ request+ .split("\r\n")+ .skip(1)+ .take_while(|line| !line.is_empty())+ .filter_map(|line| line.split_once(':'))+ .filter(|(key, _)| key.eq_ignore_ascii_case(name))+ .map(|(_, value)| value.trim())+ .collect::<Vec<_>>()+ };+ assert_eq!(values("x-empty"), [""], "{case:?}: {request}");+ assert_eq!(values("x-default-empty"), [""], "{case:?}: {request}");+ assert_eq!(+ values("content-type"),+ content_type.iter().copied().collect::<Vec<_>>(),+ "{case:?}: {request}"+ );+ }+ assert_eq!(seen, (0..cases.len()).collect());+ Ok(())+}+#[tokio::test]async fn fetch_redirect_303_rewrites_post_to_get_and_drops_body_headers() -> Result<()> {let server = ScriptedHttpServer::spawn(vec![diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/fetch.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/fetch.rsindex 4e94f9b85..9111fd328 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/fetch.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/fetch.rs@@ -494,6 +494,125 @@ async fn credentialless_child_xhr_uses_credentialless_network_partition_key() {.await;}+#[tokio::test]+async fn fetch_and_xhr_preserve_empty_headers_without_typing_binary_bodies() {+ run_page_vm_async_test(async move {+ for worker in [false, true] {+ for api in ["fetch", "fetch-clone", "xhr-async", "xhr-sync"] {+ for method in ["POST", "PUT"] {+ for empty_content_type in [false, true] {+ // Sync XHR blocks the VM's thread, so the fixture must+ // keep accepting and responding on a separate runtime.+ let (ready_tx, ready_rx) = tokio::sync::oneshot::channel();+ let server = std::thread::spawn(move || {+ tokio::runtime::Builder::new_current_thread()+ .enable_all()+ .build()+ .expect("request capture runtime")+ .block_on(async move {+ let (base_url, request_rx, server) =+ spawn_request_capture_http_server().await;+ ready_tx.send(base_url).expect("fixture ready receiver");+ let request = request_rx.await.expect("captured request");+ server.await.expect("request capture server should finish");+ request+ })+ });+ let base_url = ready_rx.await.expect("request capture fixture ready");+ let document_url = Url::parse(&format!("{base_url}/page.html"))+ .expect("document url");+ let mut page_vm = test_page_vm_with_document_url(document_url);+ let local_executor = page_vm.local_executor.clone();+ let send = format!(+ r#"(async () => {{+ const url = {base_url:?} + "/empty-headers";+ const body = new Uint8Array([1, 2]);+ const headers = [["X-Empty", " \t "]];+ if ({empty_content_type}) headers.push(["Content-Type", ""]);+ if ({api:?}.startsWith("fetch")) {{+ const init = {{method: {method:?}, body, headers}};+ const response = {api:?} === "fetch-clone"+ ? await fetch(new Request(url, init).clone())+ : await fetch(url, init);+ if (response.status !== 204) throw new Error("fetch status " + response.status);+ await response.text();+ }} else {{+ await new Promise((resolve, reject) => {{+ const xhr = new XMLHttpRequest();+ xhr.open({method:?}, url, {api:?} === "xhr-async");+ for (const [name, value] of headers) xhr.setRequestHeader(name, value);+ xhr.onload = () => xhr.status === 204 ? resolve() : reject(new Error("XHR status " + xhr.status));+ xhr.onerror = () => reject(new Error("XHR network error"));+ xhr.send(body);+ if ({api:?} === "xhr-sync") {{+ if (xhr.status !== 204) reject(new Error("sync XHR status " + xhr.status));+ else resolve();+ }}+ }});+ }}+ }})()"#+ );+ let script = if worker {+ let worker_source = serde_json::to_string(&format!(+ "{send}.then(() => postMessage('ok'), error => postMessage(String(error)))"+ ))+ .expect("serialize worker source");+ format!(+ r#"+ globalThis.__emptyHeaderResult = "pending";+ const source = URL.createObjectURL(new Blob([{worker_source}]));+ const worker = new Worker(source);+ worker.onmessage = event => {{+ globalThis.__emptyHeaderResult = event.data;+ worker.terminate();+ URL.revokeObjectURL(source);+ }};+ worker.onerror = event => {{ globalThis.__emptyHeaderResult = event.message; }};+ "#+ )+ } else {+ format!(+ "globalThis.__emptyHeaderResult = 'pending'; {send}.then(() => {{ globalThis.__emptyHeaderResult = 'ok'; }}, error => {{ globalThis.__emptyHeaderResult = String(error); }})"+ )+ };+ let result = local_executor+ .run(async move {+ page_vm.vm_mut().eval(&script)?;+ drive_websocket_until_done(+ &mut page_vm,+ "String(globalThis.__emptyHeaderResult !== 'pending')",+ "empty header request should complete",+ )+ .await?;+ page_vm.vm_mut().eval("globalThis.__emptyHeaderResult")+ })+ .await+ .expect("empty header test should run on owner lane");+ assert_eq!(+ result, "ok",+ "worker={worker}, {api}, {method}, empty_content_type={empty_content_type}"+ );+ let request = server.join().expect("request capture server should finish");+ let head = request.split("\r\n\r\n").next().expect("request head");+ let head = head.to_ascii_lowercase();+ assert!(head.lines().any(|line| line == "x-empty:"), "{request}");+ let content_types = head+ .lines()+ .filter(|line| line.starts_with("content-type:"))+ .collect::<Vec<_>>();+ if empty_content_type {+ assert_eq!(content_types, ["content-type:"], "{request}");+ } else {+ assert!(content_types.is_empty(), "{request}");+ }+ }+ }+ }+ }+ })+ .await;+}+#[tokio::test]async fn navigator_send_beacon_without_body_does_not_synthesize_content_type() {run_page_vm_async_test(async move {