Skip to content

armgit / moli

Public Imported from GitHub
0

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

33.0 KB
Raw Blame
use std::{
    io::{Read, Write},
    net::{TcpListener, TcpStream},
    sync::{Arc, atomic::Ordering},
    thread,
    time::Instant,
};

use tokio::{sync::oneshot, time::timeout};
use tokio_tungstenite::tungstenite::{self, Message, handshake::derive_accept_key};

use super::*;
use crate::NetworkAddressPolicy;
use moli_dns_resolver::DnsTarget;

mod readiness;
mod shared;
mod storage;

const DEADLINE: Duration = Duration::from_secs(10);

#[test]
fn address_policy_leaves_proxy_resolved_websocket_target_to_proxy() {
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let connector = runtime
        .connector()
        .with_network_address_policy(NetworkAddressPolicy::new(true, Vec::new()));
    let mut request = CurlWebSocketRequest::new("wss://example.test/socket".to_owned());
    request.proxy = Some("http://127.0.0.1:1".to_owned());

    let connection = connector
        .connect(request)
        .expect("request-target policy must not reject a proxy-resolved hostname");
    drop(connection);
}

#[test]
fn address_policy_does_not_treat_an_empty_proxy_as_remote_dns() {
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let connector = runtime
        .connector()
        .with_network_address_policy(NetworkAddressPolicy::new(true, Vec::new()));
    let mut request = CurlWebSocketRequest::new("ws://127.0.0.1/socket".to_owned());
    request.proxy = Some(String::new());

    let error = connector
        .connect(request)
        .expect_err("an empty curl proxy setting is still a direct connection");
    assert!(
        error
            .to_string()
            .contains("blocked private network address")
    );
}

#[test]
fn address_policy_accepts_chromium_socks5_semantics() {
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let connector = runtime
        .connector()
        .with_network_address_policy(NetworkAddressPolicy::new(true, Vec::new()));
    let mut request = CurlWebSocketRequest::new("ws://example.test/socket".to_owned());
    request.proxy = Some("socks5://127.0.0.1:1".to_owned());

    let connection = connector
        .connect(request)
        .expect("socks5 must be normalized to remote-DNS socks5h before curl");
    drop(connection);
}

#[test]
fn strict_connector_checks_fixed_websocket_target_before_connecting() {
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let connector = runtime
        .connector()
        .with_network_address_policy(NetworkAddressPolicy::new(true, Vec::new()));
    let mut request = CurlWebSocketRequest::new("ws://example.test:65534/socket".to_owned());
    request.resolve_entries = vec!["example.test:65534:127.0.0.1".to_owned()];

    let error = connector
        .connect(request)
        .expect_err("a fixed private WebSocket target must be rejected before connecting");
    assert!(
        error
            .to_string()
            .contains("blocked private network address")
    );
}

#[tokio::test]
async fn strict_connector_checks_shared_websocket_dns_before_connecting() {
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let connector = runtime
        .connector()
        .with_network_address_policy(NetworkAddressPolicy::new(true, Vec::new()));
    let mut request = CurlWebSocketRequest::new("ws://localhost:65534/socket".to_owned());
    request.dns_resolution =
        CurlDnsResolution::resolve_endpoint(DnsTarget::new("localhost", 65534), Vec::new());

    let mut connection = connector.connect(request).unwrap();
    let event = timeout(DEADLINE, connection.recv())
        .await
        .expect("WebSocket DNS policy deadline")
        .expect("WebSocket DNS policy event");

    match event {
        CurlWebSocketEvent::Closed { result: Err(error) } => {
            assert!(error.contains("blocked private network address"))
        }
        unexpected => panic!("expected a DNS policy failure, got {unexpected:?}"),
    }
}

#[tokio::test]
async fn shared_proxy_dns_failure_never_starts_the_websocket_transfer() {
    let listener = TcpListener::bind(("127.0.0.1", 0))
        .expect("test proxy listener should bind to a local port");
    let proxy_address = listener
        .local_addr()
        .expect("test proxy listener should have an address");
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut request =
        CurlWebSocketRequest::new("ws://websocket-target.invalid/proxy-dns-failure".to_owned());
    request.proxy = Some(format!("http://{proxy_address}"));
    request.handshake_timeout = DEADLINE;
    request.dns_resolution = CurlDnsResolution::resolve_endpoint(
        DnsTarget::new("proxy.invalid", proxy_address.port()),
        Vec::new(),
    );

    let mut connection = runtime.connect(request).unwrap();
    let event = timeout(DEADLINE, connection.recv())
        .await
        .expect("WebSocket DNS failure deadline")
        .expect("WebSocket DNS failure event");
    match event {
        CurlWebSocketEvent::Closed { result: Err(error) } => {
            assert!(error.contains("reserved .invalid domain"), "{error}")
        }
        unexpected => panic!("expected a DNS failure, got {unexpected:?}"),
    }
    assert_listener_stays_idle(&listener);
}

fn server(handler: impl FnOnce(TcpStream) + Send + 'static) -> (String, thread::JoinHandle<()>) {
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let url = format!("ws://{}/native", listener.local_addr().unwrap());
    let task = thread::spawn(move || {
        let (stream, _) = listener.accept().unwrap();
        stream.set_read_timeout(Some(DEADLINE)).unwrap();
        stream.set_write_timeout(Some(DEADLINE)).unwrap();
        handler(stream);
    });
    (url, task)
}

fn read_request(stream: &mut TcpStream) -> String {
    String::from_utf8(read_request_bytes(stream)).unwrap()
}

fn read_request_bytes(stream: &mut TcpStream) -> Vec<u8> {
    let mut request = Vec::new();
    while !request.ends_with(b"\r\n\r\n") {
        let mut byte = [0];
        stream.read_exact(&mut byte).unwrap();
        request.push(byte[0]);
        assert!(request.len() < 65536);
    }
    request
}

fn assert_listener_stays_idle(listener: &TcpListener) {
    listener
        .set_nonblocking(true)
        .expect("test listener should become nonblocking");
    let deadline = Instant::now() + Duration::from_millis(200);
    loop {
        match listener.accept() {
            Ok(_) => panic!("curl connected after shared proxy DNS failed"),
            Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
                if Instant::now() >= deadline {
                    return;
                }
                thread::sleep(Duration::from_millis(5));
            }
            Err(error) => panic!("failed to inspect test listener: {error}"),
        }
    }
}

fn upgrade(stream: &mut TcpStream, tail: &[u8]) {
    let request = read_request(stream);
    let key = request
        .lines()
        .find_map(|line| {
            let (name, value) = line.split_once(':')?;
            name.eq_ignore_ascii_case("sec-websocket-key")
                .then_some(value.trim())
        })
        .unwrap();
    let mut response = format!("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {}\r\n\r\n", derive_accept_key(key.as_bytes())).into_bytes();
    response.extend_from_slice(tail);
    stream.write_all(&response).unwrap();
}

async fn event(connection: &mut CurlWebSocketConnection) -> CurlWebSocketEvent {
    timeout(DEADLINE, connection.recv())
        .await
        .expect("native event deadline")
        .expect("native event")
}

async fn opened(connection: &mut CurlWebSocketConnection) {
    match event(connection).await {
        CurlWebSocketEvent::Handshake {
            request,
            response,
            result,
        } => {
            result.unwrap();
            assert!(request.starts_with(b"GET /native HTTP/1.1\r\n"));
            assert!(response.starts_with(b"HTTP/1.1 101"));
        }
        unexpected => panic!("expected handshake, got {unexpected:?}"),
    }
}

#[tokio::test]
async fn native_handshake_preserves_non_utf8_duplicate_and_empty_headers() {
    let (finish_tx, finish_rx) = std::sync::mpsc::channel();
    let (url, task) = server(move |mut stream| {
        let request = read_request_bytes(&mut stream);
        let expected = b"X-Raw: \xe9\xff\r\nX-Raw: \xc3\xa9\r\nX-Empty:\r\n";
        assert!(
            request.windows(expected.len()).any(|part| part == expected),
            "request headers: {request:?}"
        );
        let key = request
            .split(|byte| *byte == b'\n')
            .find_map(|line| line.strip_prefix(b"Sec-WebSocket-Key: "))
            .unwrap()
            .trim_ascii();
        // Tungstenite serializes response headers through UTF-8; use raw bytes
        // so the fixture can exercise opaque response headers as well.
        let mut response = format!(
            "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {}\r\n",
            derive_accept_key(key)
        ).into_bytes();
        response.extend_from_slice(b"x-reply: \xff\x80\r\n\r\n");
        stream.write_all(&response).unwrap();
        finish_rx.recv_timeout(DEADLINE).unwrap();
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut request = CurlWebSocketRequest::new(url);
    request.headers = moli_header_field::HeaderFields::from_bytes(vec![
        ("X-Raw".to_owned(), vec![0xe9, 0xff]),
        ("X-Raw".to_owned(), vec![0xc3, 0xa9]),
        ("X-Empty".to_owned(), Vec::new()),
    ]);
    let mut connection = runtime.connect(request).unwrap();
    match event(&mut connection).await {
        CurlWebSocketEvent::Handshake {
            request,
            response,
            result,
        } => {
            result.unwrap();
            assert!(
                request
                    .windows(b"X-Raw: \xe9\xff\r\n".len())
                    .any(|part| part == b"X-Raw: \xe9\xff\r\n")
            );
            assert!(
                response
                    .windows(b"x-reply: \xff\x80\r\n".len())
                    .any(|part| part == b"x-reply: \xff\x80\r\n")
            );
        }
        unexpected => panic!("expected a handshake, got {unexpected:?}"),
    }
    finish_tx.send(()).unwrap();
    drop(connection);
    task.join().unwrap();
}

#[tokio::test]
async fn native_upgrade_retains_socket_and_same_packet_empty_frame() {
    let (url, task) = server(|mut stream| {
        // Empty text followed by a binary frame, coalesced with the handshake.
        upgrade(&mut stream, &[0x81, 0, 0x82, 3, 1, 2, 3]);
        assert_eq!(
            stream.read(&mut [0]).unwrap(),
            0,
            "receiver drop releases TCP"
        );
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
    opened(&mut connection).await;
    assert!(
        connection.events.is_empty(),
        "application reads start paused"
    );
    connection.sender().set_reading(true);
    match event(&mut connection).await {
        CurlWebSocketEvent::Chunk { data, frame } => {
            assert!(data.is_empty());
            assert_eq!(frame.flags(), WsFlags::TEXT);
            assert_eq!(frame.bytes_left(), 0);
        }
        unexpected => panic!("expected empty text, got {unexpected:?}"),
    }
    match event(&mut connection).await {
        CurlWebSocketEvent::Chunk { data, frame } => {
            assert_eq!(data, [1, 2, 3]);
            assert_eq!(frame.flags(), WsFlags::BINARY);
        }
        unexpected => panic!("expected binary, got {unexpected:?}"),
    }
    drop(connection);
    task.join().unwrap();
}

#[test]
fn native_proxy_headers_reject_cr_lf_and_nul_values() {
    let mut request = CurlWebSocketRequest::new("ws://example.test/socket".to_owned());
    request.proxy = Some("http://127.0.0.1:8080".to_owned());
    for name in ["User-Agent", "Proxy-Authorization"] {
        request.proxy_headers = vec![(name.to_owned(), "valid".to_owned())];
        assert!(super::request::configure(&request).is_ok());
        for value in ["good\rbad", "good\nbad", "good\0bad"] {
            request.proxy_headers[0].1 = value.to_owned();
            let error = super::request::configure(&request)
                .err()
                .expect("native proxy headers must reject control bytes");
            assert_eq!(error.to_string(), "invalid WebSocket request header");
        }
    }
}

#[tokio::test]
async fn native_decoder_rejects_invalid_framing_before_delivering_payload() {
    let mut cases = Vec::new();
    // Reserved opcodes/RSV, orphan continuations and fragmented control frames.
    for first in [
        0x83, 0x84, 0x85, 0x86, 0x87, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xc1, 0xa1, 0x91, 0x00, 0x80,
        0x08, 0x09, 0x0a,
    ] {
        cases.push((vec![first, 0], None));
    }
    cases.push((vec![0x81, 0x80, 0, 0, 0, 0], None)); // masked server frame
    cases.push((vec![0x82, 127, 128, 0, 0, 0, 0, 0, 0, 0], None)); // >63-bit size
    for first in [0x88, 0x89, 0x8a] {
        cases.push((vec![first, 126, 0, 126], None)); // control payload >125
    }
    // A new message cannot interrupt a fragmented one, even with the same type.
    for (first, kind) in [(0x01, WsFlags::TEXT), (0x02, WsFlags::BINARY)] {
        for next in [0x01, 0x02, 0x81, 0x82] {
            cases.push((vec![first, 1, b'x', next, 0], Some(kind | WsFlags::CONT)));
        }
    }
    let runtime = CurlWebSocketRuntime::new().unwrap();
    for (wire, prefix) in cases {
        let description = format!("{wire:02x?}");
        let (finish_tx, finish_rx) = std::sync::mpsc::channel();
        let (url, task) = server(move |mut stream| {
            upgrade(&mut stream, &wire);
            // Keep TCP open so failure must come from decoding, not peer EOF.
            finish_rx.recv_timeout(DEADLINE).unwrap();
        });
        let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
        opened(&mut connection).await;
        connection.sender().set_reading(true);
        if let Some(flags) = prefix {
            assert!(
                matches!(event(&mut connection).await,
                CurlWebSocketEvent::Chunk { data, frame }
                    if data == b"x" && frame.flags() == flags),
                "{description}"
            );
        }
        match event(&mut connection).await {
            CurlWebSocketEvent::Closed { result } => {
                let error = result.expect_err(&description);
                assert!(
                    error.starts_with("WebSocket receive failed:"),
                    "{description}: {error}"
                );
            }
            unexpected => {
                panic!("{description}: invalid frame escaped the decoder: {unexpected:?}")
            }
        }
        assert!(connection.recv().await.is_none());
        finish_tx.send(()).unwrap();
        task.join().unwrap();
    }
}

#[tokio::test]
async fn native_chunks_preserve_frame_boundaries_and_continuation_types() {
    let frames = [
        (
            0x01,
            WsFlags::TEXT | WsFlags::CONT,
            vec![b'a'; 40 * 1024 + 1],
        ),
        (0x89, WsFlags::PING, vec![b'p'; 125]),
        (0x00, WsFlags::TEXT | WsFlags::CONT, Vec::new()),
        (0x8a, WsFlags::PONG, vec![b'q'; 125]),
        (0x80, WsFlags::TEXT, vec![b'z'; 40 * 1024 + 3]),
        (0x81, WsFlags::TEXT, Vec::new()),
        (
            0x02,
            WsFlags::BINARY | WsFlags::CONT,
            vec![0; 20 * 1024 + 1],
        ),
        (0x80, WsFlags::BINARY, vec![255; 20 * 1024 + 3]),
        (0x82, WsFlags::BINARY, Vec::new()),
        (0x88, WsFlags::CLOSE, vec![0x03, 0xe8]),
    ];
    let mut wire = Vec::new();
    for (first, _, payload) in &frames {
        wire.push(*first);
        if payload.len() < 126 {
            wire.push(payload.len() as u8);
        } else {
            wire.push(126);
            wire.extend_from_slice(&(payload.len() as u16).to_be_bytes());
        }
        wire.extend_from_slice(payload);
    }
    let (url, task) = server(move |mut stream| {
        upgrade(&mut stream, &wire);
        assert_eq!(stream.read(&mut [0]).unwrap(), 0);
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
    opened(&mut connection).await;
    connection.sender().set_reading(true);
    for (_, flags, expected) in frames {
        let mut offset = 0;
        let mut chunks = 0;
        loop {
            let CurlWebSocketEvent::Chunk { data, frame } = event(&mut connection).await else {
                panic!("expected frame {flags:?} at offset {offset}");
            };
            assert_eq!(frame.flags(), flags);
            assert_eq!(frame.offset(), offset as u64);
            assert_eq!(frame.len(), data.len());
            assert!(!data.is_empty() || expected.is_empty());
            assert_eq!(data, expected[offset..offset + data.len()]);
            offset += data.len();
            chunks += 1;
            assert_eq!(frame.bytes_left(), (expected.len() - offset) as u64);
            if frame.bytes_left() == 0 {
                break;
            }
        }
        assert_eq!(offset, expected.len());
        if expected.len() > 16 * 1024 {
            assert!(chunks > 1, "exercise metadata across native reads");
        }
    }
    drop(connection);
    task.join().unwrap();
}

#[tokio::test]
async fn native_fragmented_send_completes_without_echo() {
    let payload: Vec<_> = (0..MAX_SEND_FRAME_BYTES * 2)
        .map(|i| (i % 251) as u8)
        .collect();
    let expected = payload.clone();
    let (url, task) = server(move |stream| {
        let mut socket = tungstenite::accept(stream).unwrap();
        assert_eq!(socket.read().unwrap(), Message::Binary(expected.into()));
        assert_eq!(socket.read().unwrap(), Message::Text("".into()));
        assert!(socket.read().unwrap().is_close());
        assert!(matches!(
            socket.flush(),
            Ok(()) | Err(tungstenite::Error::ConnectionClosed)
        ));
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
    opened(&mut connection).await;
    let sender = connection.sender();
    for (i, data) in payload.chunks(MAX_SEND_FRAME_BYTES).enumerate() {
        let send = sender.send_frame(CurlWebSocketSend {
            data: data.to_vec(),
            flags: if i == 0 {
                WsFlags::BINARY | WsFlags::CONT
            } else {
                WsFlags::BINARY
            },
        });
        assert_eq!(
            timeout(DEADLINE, send).await.unwrap().unwrap(),
            MAX_SEND_FRAME_BYTES
        );
    }
    let empty = sender.send_frame(CurlWebSocketSend {
        data: Vec::new(),
        flags: WsFlags::TEXT,
    });
    assert_eq!(timeout(DEADLINE, empty).await.unwrap().unwrap(), 0);
    let close = sender.send_frame(CurlWebSocketSend {
        data: 1000u16.to_be_bytes().to_vec(),
        flags: WsFlags::CLOSE,
    });
    assert_eq!(timeout(DEADLINE, close).await.unwrap().unwrap(), 2);
    sender.set_reading(true);
    assert!(
        matches!(event(&mut connection).await, CurlWebSocketEvent::Chunk { frame, .. } if frame.flags() == WsFlags::CLOSE)
    );
    task.join().unwrap();
}

#[tokio::test]
async fn native_full_delivery_queue_does_not_block_other_sessions_or_cancellation() {
    let (url, task) = server(|mut stream| {
        let tail: Vec<_> = (0..32).flat_map(|_| [0x82, 1, 7]).collect();
        upgrade(&mut stream, &tail);
        let result = stream.read(&mut [0]);
        assert!(
            matches!(result, Ok(0))
                || result.is_err_and(|e| e.kind() == std::io::ErrorKind::ConnectionReset)
        );
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut blocked = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
    opened(&mut blocked).await;
    blocked.sender().set_reading(true);
    timeout(DEADLINE, blocked.sender().control.read_blocked.notified())
        .await
        .unwrap();
    assert_eq!(blocked.events.len(), MAX_PENDING_EVENTS);

    let (other_url, other_task) = server(|mut stream| {
        upgrade(&mut stream, &[0x81, 2, b'o', b'k']);
        assert_eq!(stream.read(&mut [0]).unwrap(), 0);
    });
    let mut other = runtime
        .connect(CurlWebSocketRequest::new(other_url))
        .unwrap();
    assert_ne!(blocked.id(), other.id());
    opened(&mut other).await;
    other.sender().set_reading(true);
    assert!(
        matches!(event(&mut other).await, CurlWebSocketEvent::Chunk { data, .. } if data == b"ok")
    );
    drop(blocked);
    task.join().unwrap();
    drop(other);
    other_task.join().unwrap();
}

#[tokio::test]
async fn native_queue_capacity_restoration_wakes_owner() {
    let (url, task) = server(|mut stream| {
        let tail: Vec<_> = (0..32).flat_map(|i| [0x82, 1, i]).collect();
        upgrade(&mut stream, &tail);
        assert_eq!(stream.read(&mut [0]).unwrap(), 0);
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
    opened(&mut connection).await;
    connection.sender().set_reading(true);
    timeout(
        DEADLINE,
        connection.sender().control.read_blocked.notified(),
    )
    .await
    .unwrap();
    for expected in 0..32 {
        assert!(
            matches!(event(&mut connection).await, CurlWebSocketEvent::Chunk { data, .. } if data == [expected])
        );
    }
    drop(connection);
    task.join().unwrap();
}

#[tokio::test]
async fn native_pending_handshake_cancel_and_deadline_release_socket() {
    for cancel in [true, false] {
        let (accepted_tx, accepted_rx) = tokio::sync::oneshot::channel();
        let (url, task) = server(move |mut stream| {
            read_request(&mut stream);
            accepted_tx.send(()).unwrap();
            assert_eq!(stream.read(&mut [0]).unwrap(), 0);
        });
        let runtime = CurlWebSocketRuntime::new().unwrap();
        let mut request = CurlWebSocketRequest::new(url);
        if !cancel {
            request.handshake_timeout = Duration::from_millis(100);
        }
        let mut connection = runtime.connect(request).unwrap();
        timeout(DEADLINE, accepted_rx).await.unwrap().unwrap();
        if cancel {
            connection.sender().cancel();
        }
        loop {
            if let CurlWebSocketEvent::Closed { result } = event(&mut connection).await {
                if !cancel {
                    assert!(result.is_err());
                }
                break;
            }
        }
        assert!(connection.recv().await.is_none());
        task.join().unwrap();
    }
}

#[tokio::test]
async fn native_partial_write_retries_preserve_payload_and_control_boundaries() {
    const FRAMES: usize = 128;
    let (resume_tx, resume_rx) = std::sync::mpsc::channel();
    let (url, task) = server(move |stream| {
        let mut socket = tungstenite::accept(stream).unwrap();
        resume_rx.recv_timeout(DEADLINE).unwrap();
        let mut i = 0;
        let mut ping_seen = false;
        while i < FRAMES {
            let message = socket.read().unwrap();
            if let Message::Ping(payload) = &message {
                assert_eq!(&payload[..], b"between frames");
                assert!(!ping_seen);
                ping_seen = true;
                continue;
            }
            let expected = vec![(i % 251) as u8; MAX_SEND_FRAME_BYTES];
            assert_eq!(message, Message::Binary(expected.into()));
            i += 1;
        }
        assert!(ping_seen);
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
    opened(&mut connection).await;
    let sender = connection.sender();
    let sends = async {
        let mut ping_sent = false;
        for i in 0..FRAMES {
            let send = sender.send_frame(CurlWebSocketSend {
                flags: WsFlags::BINARY,
                data: vec![(i % 251) as u8; MAX_SEND_FRAME_BYTES],
            });
            tokio::pin!(send);
            let count = tokio::select! {
                biased;
                _ = sender.control.write_blocked.notified(), if !ping_sent => {
                    // The caller schedules control only after the partial frame
                    // finishes. The native layer must preserve its write cursor.
                    resume_tx.send(()).unwrap();
                    let count = send.await.unwrap();
                    assert_eq!(sender.send_frame(CurlWebSocketSend {
                        flags: WsFlags::PING,
                        data: b"between frames".to_vec(),
                    }).await.unwrap(), b"between frames".len());
                    ping_sent = true;
                    count
                },
                count = &mut send => count.unwrap(),
            };
            assert_eq!(count, MAX_SEND_FRAME_BYTES);
        }
        assert!(ping_sent, "server backpressure must reach native writer");
    };
    timeout(DEADLINE, sends).await.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();
    }
}

#[tokio::test]
async fn native_sends_progress_with_full_receive_queue() {
    let (url, task) = server(|mut stream| {
        let tail: Vec<_> = (0..MAX_PENDING_EVENTS).flat_map(|_| [0x82, 1, 7]).collect();
        upgrade(&mut stream, &tail);
        let mut socket = tungstenite::WebSocket::from_raw_socket(
            stream,
            tungstenite::protocol::Role::Server,
            None,
        );
        assert_eq!(
            socket.read().unwrap(),
            Message::Binary(vec![9; 2 * MAX_SEND_FRAME_BYTES].into())
        );
        assert!(matches!(
            socket.read(),
            Err(tungstenite::Error::Protocol(
                tungstenite::error::ProtocolError::ResetWithoutClosingHandshake
            ))
        ));
    });
    let runtime = CurlWebSocketRuntime::new().unwrap();
    let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
    opened(&mut connection).await;
    let sender = connection.sender();
    sender.set_reading(true);
    timeout(DEADLINE, sender.control.read_blocked.notified())
        .await
        .unwrap();
    assert_eq!(connection.events.len(), MAX_PENDING_EVENTS);
    for flags in [WsFlags::BINARY | WsFlags::CONT, WsFlags::BINARY] {
        let send = sender.send_frame(CurlWebSocketSend {
            flags,
            data: vec![9; MAX_SEND_FRAME_BYTES],
        });
        assert_eq!(
            timeout(DEADLINE, send).await.unwrap().unwrap(),
            MAX_SEND_FRAME_BYTES
        );
    }
    assert_eq!(connection.events.len(), MAX_PENDING_EVENTS);
    drop(connection);
    task.join().unwrap();
}

#[tokio::test]
async fn native_send_rejects_overlap_until_current_frame_completes() {
    for abandon in [false, true] {
        let (resume_tx, resume_rx) = std::sync::mpsc::channel();
        let (url, task) = server(move |stream| {
            resume_rx.recv_timeout(DEADLINE).unwrap();
            let mut socket = tungstenite::accept(stream).unwrap();
            assert_eq!(socket.read().unwrap(), Message::Text("x".into()));
            socket.send(Message::Text("ack".into())).unwrap();
            assert_eq!(
                socket.read().unwrap(),
                Message::Ping(b"control".to_vec().into())
            );
            assert_eq!(socket.read().unwrap(), Message::Text("next".into()));
            // Unpolled or rejected sends must not appear on the wire.
            assert!(socket.read().is_err());
        });
        let runtime = CurlWebSocketRuntime::new().unwrap();
        let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
        let sender = connection.sender();
        drop(sender.send_frame(CurlWebSocketSend {
            flags: WsFlags::TEXT,
            data: b"unpolled".to_vec(),
        }));
        let mut first = Box::pin(sender.send_frame(CurlWebSocketSend {
            flags: WsFlags::TEXT,
            data: b"x".to_vec(),
        }));
        assert!(
            std::future::poll_fn(|cx| std::task::Poll::Ready(
                std::future::Future::poll(first.as_mut(), cx).is_pending()
            ))
            .await
        );
        let first = if abandon {
            drop(first);
            None
        } else {
            Some(first)
        };
        let other = sender.clone();
        for flags in [WsFlags::TEXT, WsFlags::PING] {
            let error = other
                .send_frame(CurlWebSocketSend {
                    flags,
                    data: b"overlapping".to_vec(),
                })
                .await
                .unwrap_err();
            assert_eq!(error.to_string(), "WebSocket frame is already pending");
        }
        resume_tx.send(()).unwrap();
        opened(&mut connection).await;
        if let Some(first) = first {
            assert_eq!(timeout(DEADLINE, first).await.unwrap().unwrap(), 1);
        }
        sender.set_reading(true);
        // Native completion precedes reading the server's acknowledgment, even
        // when the send future was dropped. The slot can now be reused.
        assert!(matches!(event(&mut connection).await,
            CurlWebSocketEvent::Chunk { data, .. } if data == b"ack"));
        let control = sender.send_frame(CurlWebSocketSend {
            flags: WsFlags::PING,
            data: b"control".to_vec(),
        });
        assert_eq!(timeout(DEADLINE, control).await.unwrap().unwrap(), 7);
        let next = sender.send_frame(CurlWebSocketSend {
            flags: WsFlags::TEXT,
            data: b"next".to_vec(),
        });
        assert_eq!(timeout(DEADLINE, next).await.unwrap().unwrap(), 4);
        drop(connection);
        task.join().unwrap();
    }
}

#[tokio::test]
async fn native_cancel_or_failure_settles_send_during_handshake() {
    for cancel in [true, false] {
        let (accepted_tx, accepted_rx) = oneshot::channel();
        let (finish_tx, finish_rx) = std::sync::mpsc::channel();
        let (url, task) = server(move |mut stream| {
            read_request(&mut stream);
            accepted_tx.send(()).unwrap();
            if cancel {
                assert_eq!(stream.read(&mut [0]).unwrap(), 0);
            } else {
                finish_rx.recv_timeout(DEADLINE).unwrap();
            }
        });
        let runtime = CurlWebSocketRuntime::new().unwrap();
        let mut connection = runtime.connect(CurlWebSocketRequest::new(url)).unwrap();
        timeout(DEADLINE, accepted_rx).await.unwrap().unwrap();
        let sender = connection.sender();
        let mut send = Box::pin(sender.send_frame(CurlWebSocketSend {
            flags: WsFlags::TEXT,
            data: b"pending".to_vec(),
        }));
        assert!(
            std::future::poll_fn(|cx| std::task::Poll::Ready(
                std::future::Future::poll(send.as_mut(), cx).is_pending()
            ))
            .await
        );
        if cancel {
            sender.cancel();
        } else {
            finish_tx.send(()).unwrap();
        }
        assert!(timeout(DEADLINE, send).await.unwrap().is_err());
        loop {
            if let CurlWebSocketEvent::Closed { result } = event(&mut connection).await {
                if !cancel {
                    assert!(result.is_err());
                }
                break;
            }
        }
        assert!(
            sender
                .send_frame(CurlWebSocketSend {
                    flags: WsFlags::TEXT,
                    data: Vec::new(),
                })
                .await
                .is_err()
        );
        drop(connection);
        task.join().unwrap();
    }
}