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;
}