tez 0.0.3

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
//! Integration specifications for the blocking facade over Tez's shared core.

use std::{
    convert::Infallible,
    io::{Cursor, Read as _},
    time::Duration,
};

use serde::Deserialize;
use tez::{Event, StatusCode, Version, blocking::Client, redirect};

#[path = "harness/httpmock.rs"]
mod httpmock;
#[path = "harness/tlsmock.rs"]
mod tlsmock;

#[tokio::test(flavor = "multi_thread")]
async fn blocking_clients_reuse_http1_connections_after_bodies_are_consumed() {
    let server = httpmock::Server::start(|request| {
        httpmock::MockResponse::ok(request.path_and_query().to_owned())
    })
    .await;
    let base_url = server.base_url();

    tokio::task::spawn_blocking(move || {
        let client = Client::new().unwrap();
        assert_eq!(
            client
                .get(format!("{base_url}/one"))
                .send()
                .unwrap()
                .text()
                .unwrap(),
            "/one"
        );
        assert_eq!(
            client
                .get(format!("{base_url}/two"))
                .send()
                .unwrap()
                .text()
                .unwrap(),
            "/two"
        );
    })
    .await
    .unwrap();

    assert_eq!(server.accepted_connection_count(), 1);
    assert_eq!(server.recorded_requests().len(), 2);
    server.shutdown().await;
}

#[tokio::test(flavor = "multi_thread")]
async fn blocking_readers_stream_with_unknown_or_exact_request_lengths() {
    let server =
        httpmock::Server::start(|request| httpmock::MockResponse::ok(request.body.clone())).await;
    let base_url = server.base_url();

    tokio::task::spawn_blocking(move || {
        let client = Client::new().unwrap();
        let streamed = client
            .post(format!("{base_url}/streamed"))
            .reader(Cursor::new(b"streamed".to_vec()))
            .send()
            .unwrap()
            .bytes()
            .unwrap();
        assert_eq!(streamed, "streamed");

        let exact = client
            .post(format!("{base_url}/exact"))
            .reader_with_length(Cursor::new(b"exact-tail".to_vec()), 5)
            .send()
            .unwrap()
            .bytes()
            .unwrap();
        assert_eq!(exact, "exact");
    })
    .await
    .unwrap();

    let requests = server.recorded_requests();
    assert_eq!(requests.len(), 2);
    assert_eq!(requests[0].header("content-length"), None);
    assert_eq!(requests[0].header("transfer-encoding"), Some("chunked"));
    assert_eq!(requests[1].header("content-length"), Some("5"));
    server.shutdown().await;
}

#[tokio::test(flavor = "multi_thread")]
async fn blocking_response_reads_observe_the_total_request_deadline() {
    let server = httpmock::Server::start(|_| {
        httpmock::MockResponse::ok("late").with_body_delay(Duration::from_millis(200))
    })
    .await;
    let url = server.base_url();

    let (io_kind, collected_is_timeout) = tokio::task::spawn_blocking(move || {
        let client = Client::builder()
            .timeout(Duration::from_millis(40))
            .build()
            .unwrap();
        let mut response = client.get(url).send().unwrap();
        let mut body = String::new();
        let io_kind = response
            .body_mut()
            .read_to_string(&mut body)
            .unwrap_err()
            .kind();

        let retry = client
            .get(response.url().to_string())
            .send()
            .unwrap()
            .text()
            .unwrap_err();
        (io_kind, retry.is_timeout())
    })
    .await
    .unwrap();

    assert_eq!(io_kind, std::io::ErrorKind::TimedOut);
    assert!(collected_is_timeout);
    server.shutdown().await;
}

#[tokio::test(flavor = "multi_thread")]
async fn blocking_response_discard_preserves_timeout_errors() {
    let server = httpmock::Server::start(|_| {
        httpmock::MockResponse::ok("late").with_body_delay(Duration::from_millis(200))
    })
    .await;
    let url = server.base_url();

    let error = tokio::task::spawn_blocking(move || {
        Client::builder()
            .timeout(Duration::from_millis(40))
            .build()
            .unwrap()
            .get(url)
            .send()
            .unwrap()
            .discard()
            .unwrap_err()
    })
    .await
    .unwrap();

    assert!(error.is_timeout());
    server.shutdown().await;
}

#[tokio::test(flavor = "multi_thread")]
async fn blocking_response_copy_to_preserves_timeout_errors() {
    let server = httpmock::Server::start(|_| {
        httpmock::MockResponse::ok("late").with_body_delay(Duration::from_millis(200))
    })
    .await;
    let url = server.base_url();

    let error = tokio::task::spawn_blocking(move || {
        let mut output = Vec::new();
        Client::builder()
            .timeout(Duration::from_millis(40))
            .build()
            .unwrap()
            .get(url)
            .send()
            .unwrap()
            .copy_to(&mut output)
            .unwrap_err()
    })
    .await
    .unwrap();

    assert!(error.is_timeout());
    server.shutdown().await;
}

#[tokio::test(flavor = "multi_thread")]
async fn blocking_clients_share_tls_http2_redirect_and_body_policy() {
    let server = tlsmock::Server::start_http2().await;
    let url = server.base_url();

    let response = tokio::task::spawn_blocking(move || {
        Client::builder()
            .trust_pem(tlsmock::root_certificates_pem())
            .redirects(redirect::Policy::SameOrigin)
            .build()
            .unwrap()
            .get(url)
            .send()
            .unwrap()
    })
    .await
    .unwrap();

    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(response.version(), Version::HTTP_2);
    assert_eq!(response.text().unwrap(), "secure");
    assert_eq!(server.accepted_connection_count(), 1);
    server.shutdown().await;
}

#[derive(Debug, Deserialize, Eq, PartialEq)]
struct Message {
    text: String,
}

#[tokio::test(flavor = "multi_thread")]
async fn blocking_clients_stream_structured_requests_and_responses() {
    let server = httpmock::Server::start(|request| match request.path_and_query() {
        "/upload" => httpmock::MockResponse::ok(request.body.clone()),
        "/records" => httpmock::MockResponse::ok("{\"text\":\"first\"}\n{\"text\":\"second\"}\n"),
        "/events" => {
            httpmock::MockResponse::ok("event: update\nid: event-1\ndata: {\"text\":\"ready\"}\n\n")
        }
        _ => httpmock::MockResponse::ok("unexpected"),
    })
    .await;
    let base_url = server.base_url();

    tokio::task::spawn_blocking(move || {
        let client = Client::new().unwrap();
        let uploaded = client
            .post(format!("{base_url}/upload"))
            .ndjson([
                Ok::<_, Infallible>(serde_json::json!({ "id": 1 })),
                Ok(serde_json::json!({ "id": 2 })),
            ])
            .send()
            .unwrap()
            .text()
            .unwrap();
        assert_eq!(uploaded, "{\"id\":1}\n{\"id\":2}\n");

        let array = client
            .post(format!("{base_url}/upload"))
            .json_array([
                Ok::<_, Infallible>(serde_json::json!({ "id": 1 })),
                Ok(serde_json::json!({ "id": 2 })),
            ])
            .send()
            .unwrap()
            .text()
            .unwrap();
        assert_eq!(array, "[{\"id\":1},{\"id\":2}]");

        let records = client
            .get(format!("{base_url}/records"))
            .send()
            .unwrap()
            .ndjson::<Message>()
            .collect::<tez::Result<Vec<_>>>()
            .unwrap();
        assert_eq!(records[0].text, "first");
        assert_eq!(records[1].text, "second");

        let mut events = client
            .get(format!("{base_url}/events"))
            .send()
            .unwrap()
            .sse();
        let event = events.next().unwrap().unwrap();
        assert_eq!(event.event(), Some("update"));
        assert_eq!(event.id(), Some("event-1"));
        assert_eq!(
            event.json::<Message>().unwrap(),
            Message {
                text: "ready".to_owned(),
            }
        );

        let uploaded_event = Event::new("done").with_event("complete");
        let response = client
            .post(format!("{base_url}/upload"))
            .sse([Ok::<_, Infallible>(uploaded_event)])
            .send()
            .unwrap()
            .text()
            .unwrap();
        assert_eq!(response, "event: complete\ndata: done\n\n");
    })
    .await
    .unwrap();

    server.shutdown().await;
}