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(websocket): cover browser lifecycle and transport backpressure
ldm049848795c4c5
diff --git a/Cargo.lock b/Cargo.lockindex b1770f53c..4c476f609 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2470,6 +2470,8 @@ dependencies = ["moli-dns-resolver","openssl-sys","parking_lot",+ "rcgen",+ "rustls","tokio","tokio-tungstenite","tracing",diff --git a/moli-curl/Cargo.toml b/moli-curl/Cargo.tomlindex 911aa93ef..594742f27 100644--- a/moli-curl/Cargo.toml+++ b/moli-curl/Cargo.toml@@ -16,6 +16,8 @@ tokio = { version = "1.51.0", features = ["sync"] }url = "2.5.7"[dev-dependencies]+rcgen = { version = "0.13", default-features = false, features = ["aws_lc_rs", "pem"] }+rustls = { version = "0.23", default-features = false, features = ["aws_lc_rs", "std", "tls12"] }tokio = { version = "1.51.0", features = ["macros", "rt", "time"] }tokio-tungstenite = { version = "0.28.0", default-features = false, features = ["handshake"] }diff --git a/moli-curl/src/websocket/tests.rs b/moli-curl/src/websocket/tests.rsindex 1836a4fc1..b23c05197 100644--- a/moli-curl/src/websocket/tests.rs+++ b/moli-curl/src/websocket/tests.rs@@ -362,3 +362,52 @@ async fn native_partial_write_retries_preserve_payload_and_control_boundaries().unwrap();task.join().unwrap();}++#[test]+fn native_wss_configuration_validates_chain_and_hostname() {+ use rustls::{+ ServerConfig, ServerConnection, StreamOwned,+ pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer},+ };+ let certificate = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();+ let config = Arc::new(+ ServerConfig::builder()+ .with_no_client_auth()+ .with_single_cert(+ vec![CertificateDer::from(certificate.cert.der().to_vec())],+ PrivateKeyDer::from(PrivatePkcs8KeyDer::from(+ certificate.key_pair.serialize_der(),+ )),+ )+ .unwrap(),+ );+ for (host, trusted, succeeds) in [+ ("localhost", true, true),+ ("127.0.0.1", true, false),+ ("localhost", false, false),+ ] {+ let config = config.clone();+ let (url, task) = server(move |stream| {+ let tls = StreamOwned::new(ServerConnection::new(config).unwrap(), stream);+ assert_eq!(tungstenite::accept(tls).is_ok(), succeeds);+ });+ let url = url.replacen("ws://127.0.0.1", &format!("wss://{host}"), 1);+ let request = CurlWebSocketRequest::new(url);+ let mut easy = super::request::configure(&request).unwrap();+ if trusted {+ easy.ssl_cainfo_blob(certificate.cert.pem().as_bytes())+ .unwrap();+ }+ let result = easy.perform();+ if succeeds {+ result.unwrap();+ } else {+ assert!(+ result.unwrap_err().is_peer_failed_verification(),+ "certificate policy must reject the connection"+ );+ }+ drop(easy);+ task.join().unwrap();+ }+}diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rsindex 5cbf84f93..409b9846a 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/websocket/basic.rs@@ -1012,3 +1012,56 @@ async fn websocket_open_and_frames_record_network_trace_entries() {}).await;}++#[tokio::test]+async fn dropping_page_releases_native_websocket_and_websocket_stream_transports() {+ run_page_vm_async_test(async move {+ for constructor in ["WebSocket", "WebSocketStream"] {+ let (url, server) =+ moli_websocket::test_support::spawn_transport_retirement_websocket_server().await;+ let page_vm = test_page_vm();+ let local_executor = page_vm.local_executor.clone();+ local_executor+ .run(async move {+ let mut page_vm = page_vm;+ page_vm.vm_mut().eval(&format!(+ r#"+ globalThis.__nativeTransportOpened = false;+ globalThis.__nativeTransport = new {constructor}({url:?});+ if ({constructor:?} === 'WebSocket') {{+ __nativeTransport.onopen = () => {{ __nativeTransportOpened = true; }};+ }} else {{+ __nativeTransport.opened.then(() => {{ __nativeTransportOpened = true; }});+ }}+ "#+ ))?;+ tokio::time::timeout(Duration::from_secs(3), async {+ loop {+ while page_vm+ .run_exact_page_websocket_selected_task_for_test()+ .await?+ .is_some()+ {}+ if page_vm.vm_mut().eval("String(__nativeTransportOpened)")? == "true" {+ break;+ }+ page_vm+ .wait_for_page_work_arrival_without_timeout(false)+ .await;+ }+ Ok::<(), anyhow::Error>(())+ })+ .await+ .expect("native transport should open")?;+ drop(page_vm);+ Ok::<(), anyhow::Error>(())+ })+ .await+ .expect("page retirement should run on owner lane");+ server+ .await+ .expect("dropping Page releases its native socket");+ }+ })+ .await;+}diff --git a/moli-renderer-v8/src/worker/thread/tests/network.rs b/moli-renderer-v8/src/worker/thread/tests/network.rsindex bca868347..8db9427e0 100644--- a/moli-renderer-v8/src/worker/thread/tests/network.rs+++ b/moli-renderer-v8/src/worker/thread/tests/network.rs@@ -6969,3 +6969,28 @@ async fn worker_xmlhttprequest_cross_origin_redirect_final_url_obeys_connect_src));}++#[tokio::test]+async fn worker_termination_releases_native_websocket_transport() {+ ensure_v8();+ let (url, server) =+ moli_websocket::test_support::spawn_transport_retirement_websocket_server().await;+ let loader =+ ResourceRequestClient::new(&FetchConfig::default()).expect("worker network client");+ let mut handle = spawn_worker_with_request_client(+ format!(+ r#"+ globalThis.socket = new WebSocket({url:?});+ socket.onopen = () => postMessage('opened');+ socket.onerror = () => postMessage('error');+ "#+ ),+ "http://127.0.0.1/worker/main.js".into(),+ loader,+ );+ assert_eq!(recv_post_json(&mut handle).await, r#""opened""#);+ handle.terminate_and_join();+ server+ .await+ .expect("terminating Worker releases its native socket");+}diff --git a/moli-websocket/src/native_tests.rs b/moli-websocket/src/native_tests.rsindex 05a4f31d3..179affa21 100644--- a/moli-websocket/src/native_tests.rs+++ b/moli-websocket/src/native_tests.rs@@ -194,3 +194,63 @@ async fn native_large_incoming_frame_keeps_chunk_offsets_and_utf8() {assert_close(&mut rx, 74, 1000, "", true).await;server.await.unwrap();}++#[tokio::test]+async fn native_close_handshake_finishes_while_message_sink_is_blocked() {+ use std::sync::Arc;+ use tokio::{+ io::AsyncReadExt,+ sync::{Notify, Semaphore},+ };+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let url = format!("ws://{}/blocked-delivery", listener.local_addr().unwrap());+ let (released_tx, released_rx) = oneshot::channel();+ let server = tokio::spawn(async move {+ let (stream, _) = listener.accept().await.unwrap();+ let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();+ socket.send(Message::Text("blocked".into())).await.unwrap();+ assert!(matches!(socket.next().await, Some(Ok(Message::Close(_)))));+ let _ = socket.flush().await;+ assert_eq!(socket.get_mut().read(&mut [0]).await.unwrap(), 0);+ released_tx.send(()).unwrap();+ });+ let blocked = Arc::new(Notify::new());+ let resume = Arc::new(Semaphore::new(0));+ let (events, mut rx) = mpsc::channel(8);+ let sink = crate::EventSender::with_async_sink({+ let blocked = blocked.clone();+ let resume = resume.clone();+ move |event| {+ let blocked = blocked.clone();+ let resume = resume.clone();+ let events = events.clone();+ async move {+ if matches!(event, Event::TextMessage { .. }) {+ blocked.notify_one();+ resume.acquire().await.unwrap().forget();+ }+ events.send(event).await.is_ok()+ }+ }+ });+ let handle = spawn_connection(75, url, Vec::new(), test_websocket_context(), sink);+ recv_open_event(&mut rx).await;+ timeout(Duration::from_secs(3), blocked.notified())+ .await+ .unwrap();+ handle+ .send(Command::Close {+ code: Some(1000),+ reason: String::new(),+ })+ .unwrap();+ timeout(Duration::from_secs(3), released_rx)+ .await+ .expect("physical close must not wait for the event sink or closing timeout")+ .unwrap();+ resume.add_permits(1);+ assert_text_message(&mut rx, 75, "blocked").await;+ assert_closing(&mut rx, 75).await;+ assert_close(&mut rx, 75, 1000, "", true).await;+ server.await.unwrap();+}diff --git a/moli-websocket/src/test_support.rs b/moli-websocket/src/test_support.rsindex c2101777f..4226264d4 100644--- a/moli-websocket/src/test_support.rs+++ b/moli-websocket/src/test_support.rs@@ -1068,3 +1068,24 @@ pub fn header_value(headers: &[(String, String)], name: &str) -> Option<String>.iter().find_map(|(header_name, value)| (header_name == name).then(|| value.clone()))}++/// Observes physical transport retirement without cooperating in a Close handshake.+pub async fn spawn_transport_retirement_websocket_server() -> (String, tokio::task::JoinHandle<()>)+{+ let listener = TcpListener::bind("127.0.0.1:0")+ .await+ .expect("bind retirement server");+ let addr = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ let (stream, _) = listener.accept().await.unwrap();+ let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap();+ let terminal = timeout(Duration::from_secs(3), socket.next())+ .await+ .expect("retirement must physically release TCP");+ assert!(+ terminal.is_none() || terminal.is_some_and(|event| event.is_err()),+ "retirement cancels without a graceful Close"+ );+ });+ (format!("ws://{addr}/retirement"), server)+}