Function postgres_control_packets_are_handled_safely

tests/client_compat.rs:993–1033

()

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn postgres_control_packets_are_handled_safely() -> Result<()> {
    let server = PgliteServer::temporary_tcp()?;
    let addr = server.tcp_addr().context("server should use TCP")?;

    let ssl_response = tokio::task::spawn_blocking(move || -> Result<u8> {
        let mut stream = TcpStream::connect(addr).context("connect raw SSLRequest socket")?;
        stream
            .write_all(&startup_control_packet(SSL_REQUEST_CODE, &[]))
            .context("write SSLRequest")?;
        let mut response = [0u8; 1];
        stream
            .read_exact(&mut response)
            .context("read SSLRequest response")?;
        Ok(response[0])
    })
    .await??;
    assert_eq!(ssl_response, b'N');

    let cancel_closed = tokio::task::spawn_blocking(move || -> Result<bool> {
        let mut stream = TcpStream::connect(addr).context("connect raw CancelRequest socket")?;
        stream
            .write_all(&startup_control_packet(
                CANCEL_REQUEST_CODE,
                &[0, 0, 0, 1, 0, 0, 0, 2],
            ))
            .context("write CancelRequest")?;
        let mut response = [0u8; 1];
        let read = stream
            .read(&mut response)
            .context("read CancelRequest close")?;
        Ok(read == 0)
    })
    .await??;
    assert!(
        cancel_closed,
        "CancelRequest should close without backend panic"
    );

    server.shutdown()?;
    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn postgres_startup_identity_is_delegated_to_postgres() -> Result<()> {