Function raw_wire_protocol_bind_errors_are_synchronized

tests/client_compat.rs:179–258

()

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

    tokio::task::spawn_blocking(move || -> Result<()> {
        let mut stream = TcpStream::connect(addr).context("connect raw protocol socket")?;
        stream.set_read_timeout(Some(Duration::from_secs(120)))?;
        stream.set_write_timeout(Some(Duration::from_secs(10)))?;

        stream
            .write_all(&startup_message())
            .context("write startup message")?;
        let startup = read_until_ready(&mut stream).context("read startup response")?;
        assert!(
            startup.iter().any(|msg| msg.tag == b'R'),
            "startup should include AuthenticationOk"
        );
        assert_eq!(startup.last().map(|msg| msg.tag), Some(b'Z'));

        stream
            .write_all(
                &[
                    parse_statement("typed_int", "SELECT $1::int4 AS value"),
                    sync(),
                ]
                .concat(),
            )
            .context("write Parse + Sync")?;
        let parsed = read_until_ready(&mut stream).context("read Parse response")?;
        assert_message_tags_ignoring_parameter_status(&parsed, b"1Z");

        stream
            .write_all(
                &[
                    bind_statement("", "typed_int", &["not_an_int"]),
                    describe_portal(""),
                    execute_portal(""),
                    sync(),
                ]
                .concat(),
            )
            .context("write invalid Bind batch")?;
        let invalid_bind = read_until_ready(&mut stream).context("read invalid Bind response")?;
        assert_eq!(invalid_bind.last().map(|msg| msg.tag), Some(b'Z'));
        assert!(
            invalid_bind.iter().all(|msg| msg.tag != b'2'),
            "invalid Bind must not emit BindComplete"
        );
        assert_eq!(first_error_code(&invalid_bind).as_deref(), Some("22P02"));

        stream
            .write_all(&[bind_statement("", "typed_int", &[]), sync()].concat())
            .context("write wrong parameter count Bind batch")?;
        let wrong_count = read_until_ready(&mut stream).context("read wrong Bind response")?;
        assert_eq!(wrong_count.last().map(|msg| msg.tag), Some(b'Z'));
        assert!(
            wrong_count.iter().all(|msg| msg.tag != b'2'),
            "wrong parameter count must not emit BindComplete"