nbreq 0.3.1

Runtime-independent cancellable HTTP client
Documentation
use super::super::*;
use std::net::TcpListener;

fn failure(kind: NativeFailureKind) -> NativeFailure {
    NativeFailure {
        kind,
        message: "controlled socket failure".into(),
        io_kind: Some(std::io::ErrorKind::ConnectionRefused),
    }
}

fn connecting(tls: bool) -> (NativeHttpBackend, RequestId, TcpListener, TcpListener) {
    let first = TcpListener::bind("127.0.0.1:0").expect("first listener");
    let second = TcpListener::bind("127.0.0.1:0").expect("second listener");
    let config = EngineConfig::manual();
    let configs = tls.then(|| {
        NativeTlsConfigs::with_test_root({
            let key = rcgen::KeyPair::generate().expect("key");
            rcgen::CertificateParams::new(vec!["fallback.test".into()])
                .expect("parameters")
                .self_signed(&key)
                .expect("certificate")
                .der()
                .clone()
        })
        .expect("TLS configs")
    });
    let mut backend = NativeHttpBackend::new(
        HttpLimits::from_config(&config),
        None,
        configs,
        ConnectionLimits::from_config(&config),
    )
    .expect("backend");
    let id = RequestId {
        engine: 1,
        sequence: 1,
    };
    let request = Request::post(format!(
        "{}://fallback.test/",
        if tls { "https" } else { "http" }
    ))
    .body(vec![17; 50 * 1024])
    .build()
    .expect("request");
    let deadline = Instant::now() + Duration::from_secs(5);
    let pending = match backend.make_pending(
        id,
        request,
        PendingDeadlines {
            connect: Some(deadline),
            total: Some(deadline),
            inactivity: None,
        },
        0,
        ErrorKind::InvalidRequest,
        PendingResponse::Buffered,
    ) {
        Ok(pending) => pending,
        Err((error, _)) => panic!("pending: {error}"),
    };
    assert!(backend.reserve_connection(&pending.key));
    assert!(
        backend
            .begin_connection(
                VecDeque::from([
                    first.local_addr().expect("first address"),
                    second.local_addr().expect("second address")
                ]),
                pending
            )
            .is_none()
    );
    (backend, id, first, second)
}

#[test]
fn fallback_preserves_body_deadlines_and_one_reservation_then_cancel_releases_it() {
    for tls in [false, true] {
        let (mut backend, id, _first, _second) = connecting(tls);
        let original = backend.request_to_slot[&id];
        let transfer = &backend.transfers[&original];
        let body = transfer.request.body().as_ptr();
        let wire = transfer
            .connecting
            .as_ref()
            .expect("connecting")
            .cleartext_request
            .as_ref()
            .map(|bytes| bytes.as_ptr());
        let deadlines = (transfer.connect_deadline, transfer.total_deadline);
        let mut completions = Vec::new();
        backend.fail_native(
            original,
            failure(NativeFailureKind::Connect),
            &mut completions,
        );
        let replacement = backend.request_to_slot[&id];
        assert_ne!(replacement, original);
        let transfer = &backend.transfers[&replacement];
        assert_eq!(
            transfer.request.body().as_ptr(),
            body,
            "address fallback copied the request body"
        );
        assert_eq!(
            transfer
                .connecting
                .as_ref()
                .expect("connecting")
                .cleartext_request
                .as_ref()
                .map(|bytes| bytes.as_ptr()),
            wire
        );
        assert_eq!(
            (transfer.connect_deadline, transfer.total_deadline),
            deadlines
        );
        assert_eq!(backend.connection_count, 1);
        assert_eq!(backend.reactor.active_count(), 1);
        assert!(
            backend
                .reactor
                .outbound_is_empty(replacement)
                .expect("outbound"),
            "request bytes sent before TCP connected"
        );
        backend.cancel(id);
        backend.fail_native(
            original,
            failure(NativeFailureKind::Connect),
            &mut completions,
        );
        backend.fail_native(
            replacement,
            failure(NativeFailureKind::Connect),
            &mut completions,
        );
        assert!(
            completions.is_empty(),
            "stale failures resurrected cancellation"
        );
        assert!(backend.transfers.is_empty());
        assert_eq!(backend.connection_count, 0);
        assert_eq!(backend.reactor.active_count(), 0);
        backend.shutdown().expect("shutdown");
    }
}

#[test]
fn fallback_exhaustion_and_expiry_complete_once_without_resetting_deadlines() {
    for expire in [false, true] {
        let (mut backend, id, _first, second) = connecting(false);
        let original = backend.request_to_slot[&id];
        let mut completions = Vec::new();
        if expire {
            backend
                .transfers
                .get_mut(&original)
                .expect("transfer")
                .connect_deadline = Some(Instant::now());
        }
        backend.fail_native(
            original,
            failure(NativeFailureKind::Connect),
            &mut completions,
        );
        if !expire {
            let next = backend.request_to_slot[&id];
            backend.fail_native(next, failure(NativeFailureKind::Connect), &mut completions);
            backend.fail_native(next, failure(NativeFailureKind::Connect), &mut completions);
        } else {
            second.set_nonblocking(true).expect("bounded accept");
            assert!(
                matches!(second.accept(), Err(error) if error.kind() == std::io::ErrorKind::WouldBlock)
            );
        }
        assert_eq!(completions.len(), 1);
        match &completions[0].completion {
            Completion::Failed(error) if expire => {
                assert_eq!(error.timeout_kind(), Some(TimeoutKind::Connect))
            }
            Completion::Failed(error) => {
                assert_eq!(error.transport_stage(), Some(TransportStage::Connect))
            }
            other => panic!("unexpected completion: {other:?}"),
        }
        assert_eq!(backend.connection_count, 0);
        assert_eq!(backend.reactor.active_count(), 0);
        backend.shutdown().expect("shutdown");
    }
}

#[test]
fn fallback_never_replays_a_request_after_tcp_connects() {
    for tls in [false, true] {
        let (mut backend, id, _first, second) = connecting(tls);
        let slot = backend.request_to_slot[&id];
        let mut completions = Vec::new();
        backend
            .handle_connected(slot, true, &mut completions)
            .expect("connected");
        assert!(backend.transfers[&slot].connecting.is_none());
        backend.fail_native(slot, failure(NativeFailureKind::Read), &mut completions);
        assert_eq!(completions.len(), 1);
        assert_eq!(backend.connection_count, 0);
        second.set_nonblocking(true).expect("bounded accept");
        assert!(
            matches!(second.accept(), Err(error) if error.kind() == std::io::ErrorKind::WouldBlock)
        );
        backend.shutdown().expect("shutdown");
    }
}