Skip to content

armgit / moli

Public Imported from GitHub
0

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

test(websocket): cover browser lifecycle and transport backpressure

ldm049848795c4c5
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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)
+}