Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

test(fetch): preserve explicitly empty author header values

ldm0f776d539bbce
diff --git a/moli-fetch/src/tests/mod.rs b/moli-fetch/src/tests/mod.rs
index 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.rs
index 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 {