use std::{
future::Future,
io::{Read as _, Write as _},
net::{SocketAddr, TcpListener},
pin::Pin,
sync::{
Arc, Mutex,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
};
use tez::{Client, HeaderValue, Limits, Timeouts, auth::Authentication};
#[path = "harness/httpmock.rs"]
mod httpmock;
#[test]
fn public_types_and_send_futures_are_send() {
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
fn assert_send_value<T: Send>(_: T) {}
assert_send::<Client>();
assert_sync::<Client>();
assert_send::<tez::Body>();
assert_send::<tez::EventStream>();
assert_send::<tez::JsonStream<serde_json::Value>>();
assert_send::<tez::Request>();
assert_send::<tez::Response>();
assert_send::<tez::ResponseStream>();
assert_send::<tez::Upgrade>();
assert_send::<tez::Upgraded>();
#[cfg(feature = "cookies")]
{
assert_send::<tez::CookieJar>();
assert_sync::<tez::CookieJar>();
}
let client = Client::new().unwrap();
assert_send_value(client.get("http://127.0.0.1:1").send());
}
#[test]
fn client_builds_without_a_runtime() {
assert!(Client::new().is_ok());
}
#[test]
fn requests_run_on_the_futures_executor_without_tokio_or_smol() {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let address = listener.local_addr().unwrap();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut request = [0; 1024];
let _ = stream.read(&mut request).unwrap();
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
.unwrap();
});
let client = Client::new().unwrap();
let text = futures_executor::block_on(async {
client
.get(format!("http://{address}"))
.send()
.await
.unwrap()
.text()
.await
.unwrap()
});
assert_eq!(text, "ok");
server.join().unwrap();
}
#[cfg(feature = "runtime-tokio")]
#[tokio::test]
async fn a_tokio_runtime_drives_the_complete_client_io_path() {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let address = listener.local_addr().unwrap();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut request = [0; 1024];
let _ = stream.read(&mut request).unwrap();
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\ntokio")
.unwrap();
});
let runtime = tez::runtime::Tokio::current().unwrap().runtime();
let text = Client::builder()
.runtime(runtime)
.build()
.unwrap()
.get(format!("http://{address}"))
.send()
.await
.unwrap()
.text()
.await
.unwrap();
assert_eq!(text, "tokio");
server.join().unwrap();
}
#[cfg(feature = "runtime-tokio")]
#[test]
fn an_explicit_tokio_handle_does_not_depend_on_the_callers_executor() {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let port = listener.local_addr().unwrap().port();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut request = [0; 1024];
let _ = stream.read(&mut request).unwrap();
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 8\r\n\r\nportable")
.unwrap();
});
let tokio = tokio::runtime::Runtime::new().unwrap();
let client = Client::builder()
.runtime(tez::runtime::Tokio::new(tokio.handle().clone()).runtime())
.build()
.unwrap();
let text = futures_executor::block_on(async {
client
.get(format!("http://localhost:{port}"))
.send()
.await
.unwrap()
.text()
.await
.unwrap()
});
assert_eq!(text, "portable");
server.join().unwrap();
}
#[cfg(feature = "runtime-smol")]
#[test]
fn a_smol_runtime_drives_the_complete_client_io_path() {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let address = listener.local_addr().unwrap();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut request = [0; 1024];
let _ = stream.read(&mut request).unwrap();
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\nsmol")
.unwrap();
});
let text = smol::block_on(async {
Client::builder()
.runtime(tez::runtime::Smol::runtime())
.build()
.unwrap()
.get(format!("http://{address}"))
.send()
.await
.unwrap()
.text()
.await
.unwrap()
});
assert_eq!(text, "smol");
server.join().unwrap();
}
#[tokio::test]
async fn low_level_connection_client_preserves_standard_http_types() {
use tez::BodyExt as _;
let server = httpmock::Server::start(|_| httpmock::MockResponse::ok("wire")).await;
let request = tez::HttpRequest::get(format!("{}/wire", server.base_url()))
.body(tez::Body::empty())
.unwrap();
let mut response = tez::connection::Client::builder()
.build()
.unwrap()
.send(request)
.await
.unwrap();
assert_eq!(response.status(), tez::StatusCode::OK);
assert_eq!(
response
.extensions()
.get::<tez::connection::Info>()
.copied()
.unwrap()
.remote_addr(),
server.address()
);
assert_eq!(
response
.body_mut()
.frame()
.await
.unwrap()
.unwrap()
.into_data()
.unwrap(),
"wire"
);
}
#[derive(Clone)]
struct CountingConnector {
calls: Arc<AtomicUsize>,
}
impl tez::runtime::Connector for CountingConnector {
fn connect(
&self,
address: SocketAddr,
options: tez::runtime::SocketOptions,
) -> tez::runtime::Connect<'_> {
self.calls.fetch_add(1, Ordering::Relaxed);
tez::runtime::Connector::connect(&tez::runtime::AsyncIoConnector, address, options)
}
}
#[derive(Clone)]
struct DelayedConnector {
active: Arc<AtomicUsize>,
maximum: Arc<AtomicUsize>,
}
impl tez::runtime::Connector for DelayedConnector {
fn connect(
&self,
address: SocketAddr,
options: tez::runtime::SocketOptions,
) -> tez::runtime::Connect<'_> {
let active = Arc::clone(&self.active);
let maximum = Arc::clone(&self.maximum);
Box::pin(async move {
struct Release(Arc<AtomicUsize>);
impl Drop for Release {
fn drop(&mut self) {
self.0.fetch_sub(1, Ordering::SeqCst);
}
}
let connected = active.fetch_add(1, Ordering::SeqCst) + 1;
maximum.fetch_max(connected, Ordering::SeqCst);
let _release = Release(active);
tokio::time::sleep(Duration::from_millis(100)).await;
tez::runtime::Connector::connect(&tez::runtime::AsyncIoConnector, address, options)
.await
})
}
}
#[tokio::test]
async fn cold_http1_connections_open_concurrently_after_protocol_discovery() {
let server = httpmock::Server::start(|_| httpmock::MockResponse::ok("ok")).await;
let maximum = Arc::new(AtomicUsize::new(0));
let runtime = tez::Runtime::builder()
.connector(DelayedConnector {
active: Arc::new(AtomicUsize::new(0)),
maximum: Arc::clone(&maximum),
})
.build();
let client = Client::builder()
.runtime(runtime)
.timeout(Duration::from_secs(2))
.build()
.unwrap();
let url = server.base_url();
let (first, second, third) = tokio::join!(
client.get(&url).send(),
client.get(&url).send(),
client.get(&url).send(),
);
let (first, second, third) = (first.unwrap(), second.unwrap(), third.unwrap());
assert_eq!(server.accepted_connection_count(), 3);
assert_eq!(maximum.load(Ordering::SeqCst), 2);
first.discard().await.unwrap();
second.discard().await.unwrap();
third.discard().await.unwrap();
server.shutdown().await;
}
#[test]
fn a_custom_runtime_supplies_every_async_capability() {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let address = listener.local_addr().unwrap();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut request = [0; 1024];
let _ = stream.read(&mut request).unwrap();
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\ncustom")
.unwrap();
});
let executions = Arc::new(AtomicUsize::new(0));
let timers = Arc::new(AtomicUsize::new(0));
let resolutions = Arc::new(AtomicUsize::new(0));
let connections = Arc::new(AtomicUsize::new(0));
let runtime = tez::Runtime::builder()
.executor(tez::Executor::new({
let executions = Arc::clone(&executions);
move |future| {
executions.fetch_add(1, Ordering::Relaxed);
std::thread::spawn(move || futures_executor::block_on(future));
}
}))
.timer(tez::Timer::new({
let timers = Arc::clone(&timers);
move |deadline| {
timers.fetch_add(1, Ordering::Relaxed);
async move {
let _ = async_io::Timer::at(deadline).await;
}
}
}))
.resolver({
#[derive(Clone)]
struct Resolver {
address: SocketAddr,
calls: Arc<AtomicUsize>,
}
impl tez::dns::Resolver for Resolver {
fn resolve<'a>(&'a self, _host: &'a str, _port: u16) -> tez::dns::Resolve<'a> {
self.calls.fetch_add(1, Ordering::Relaxed);
Box::pin(async move { Ok(vec![self.address]) })
}
}
Resolver {
address,
calls: Arc::clone(&resolutions),
}
})
.connector(CountingConnector {
calls: Arc::clone(&connections),
})
.build();
let body = futures_executor::block_on(async {
Client::builder()
.runtime(runtime)
.build()
.unwrap()
.get(format!("http://tez.invalid:{}/", address.port()))
.send()
.await
.unwrap()
.text()
.await
.unwrap()
});
assert_eq!(body, "custom");
assert!(executions.load(Ordering::Relaxed) > 0);
assert!(timers.load(Ordering::Relaxed) > 0);
assert_eq!(resolutions.load(Ordering::Relaxed), 1);
assert_eq!(connections.load(Ordering::Relaxed), 1);
server.join().unwrap();
}
#[test]
fn a_silently_closed_idle_connection_is_replaced_before_sending() {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let address = listener.local_addr().unwrap();
let server = std::thread::spawn(move || {
for _ in 0..2 {
let (mut stream, _) = listener.accept().unwrap();
let mut request = Vec::new();
let mut byte = [0; 1];
while !request.ends_with(b"\r\n\r\n") {
stream.read_exact(&mut byte).unwrap();
request.push(byte[0]);
}
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
.unwrap();
}
});
let client = Client::new().unwrap();
futures_executor::block_on(async {
for _ in 0..2 {
assert_eq!(
client
.get(format!("http://{address}"))
.send()
.await
.unwrap()
.text()
.await
.unwrap(),
"ok"
);
async_io::Timer::after(Duration::from_millis(10)).await;
}
});
server.join().unwrap();
}
#[tokio::test]
async fn cloned_clients_share_one_pool_after_body_consumption() {
let server = httpmock::Server::start(|_| httpmock::MockResponse::ok("ok")).await;
let client = Client::builder()
.timeout(Duration::from_secs(1))
.build()
.unwrap();
let clone = client.clone();
client
.get(format!("{}/one", server.base_url()))
.send()
.await
.unwrap()
.discard()
.await
.unwrap();
clone
.get(format!("{}/two", server.base_url()))
.send()
.await
.unwrap()
.discard()
.await
.unwrap();
let requests = server.recorded_requests();
assert_eq!(server.accepted_connection_count(), 1);
assert_eq!(requests[0].connection_id(), requests[1].connection_id());
server.shutdown().await;
}
#[tokio::test]
async fn idle_http1_connections_expire_before_the_next_request() {
let server = httpmock::Server::start(|_| httpmock::MockResponse::ok("ok")).await;
let client = Client::builder()
.timeouts(Timeouts::default().idle_connection(Duration::from_millis(20)))
.build()
.unwrap();
client
.get(server.base_url())
.send()
.await
.unwrap()
.discard()
.await
.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
client
.get(server.base_url())
.send()
.await
.unwrap()
.discard()
.await
.unwrap();
assert_eq!(server.accepted_connection_count(), 2);
server.shutdown().await;
}
#[derive(Clone)]
struct FixedResolver(SocketAddr);
impl tez::dns::Resolver for FixedResolver {
fn resolve<'a>(&'a self, _host: &'a str, _port: u16) -> tez::dns::Resolve<'a> {
Box::pin(async move { Ok(vec![self.0]) })
}
}
#[derive(Clone)]
struct RecordingResolver {
address: SocketAddr,
host: Arc<Mutex<Option<String>>>,
}
impl tez::dns::Resolver for RecordingResolver {
fn resolve<'a>(&'a self, host: &'a str, _port: u16) -> tez::dns::Resolve<'a> {
*self.host.lock().unwrap() = Some(host.to_owned());
Box::pin(async move { Ok(vec![self.address]) })
}
}
#[tokio::test]
async fn custom_resolver_controls_origin_address_lookup() {
let server = httpmock::Server::start(|_| httpmock::MockResponse::ok("resolved")).await;
let client = Client::builder()
.resolver(FixedResolver(server.address()))
.build()
.unwrap();
let url = format!("http://tez.invalid:{}/resource", server.address().port());
assert_eq!(
client.get(url).send().await.unwrap().text().await.unwrap(),
"resolved"
);
server.shutdown().await;
}
#[tokio::test]
async fn numeric_ipv6_origins_use_unbracketed_dns_and_bracketed_host_headers() {
let server = httpmock::Server::start(|_| httpmock::MockResponse::ok("resolved")).await;
let host = Arc::new(Mutex::new(None));
let client = Client::builder()
.resolver(RecordingResolver {
address: server.address(),
host: Arc::clone(&host),
})
.build()
.unwrap();
let url = format!("http://[::1]:{}/resource", server.address().port());
assert_eq!(
client.get(url).send().await.unwrap().text().await.unwrap(),
"resolved"
);
assert_eq!(host.lock().unwrap().as_deref(), Some("::1"));
let host_header = format!("[::1]:{}", server.address().port());
assert_eq!(
server.recorded_requests()[0].header("host"),
Some(host_header.as_str())
);
server.shutdown().await;
}
#[tokio::test]
async fn connection_limits_apply_backpressure_until_an_http1_body_is_released() {
let server = httpmock::Server::start(|_| {
httpmock::MockResponse::ok("ok").with_body_delay(Duration::from_millis(100))
})
.await;
let client = Client::builder()
.limits(
Limits::default()
.connections_per_origin(1)
.idle_connections_per_origin(1),
)
.timeout(Duration::from_secs(2))
.build()
.unwrap();
let first = client
.get(format!("{}/first", server.base_url()))
.send()
.await
.unwrap();
let second_client = client.clone();
let second_url = format!("{}/second", server.base_url());
let second = tokio::spawn(async move { second_client.get(second_url).send().await });
tokio::time::sleep(Duration::from_millis(25)).await;
assert_eq!(server.accepted_connection_count(), 1);
assert_eq!(server.recorded_requests().len(), 1);
first.discard().await.unwrap();
second.await.unwrap().unwrap().discard().await.unwrap();
assert_eq!(server.accepted_connection_count(), 1);
assert_eq!(server.recorded_requests().len(), 2);
server.shutdown().await;
}
#[tokio::test]
async fn ambiguous_transport_failure_is_not_retried() {
let server =
httpmock::Server::start(|_| httpmock::MockResponse::disconnect_before_response()).await;
let client = Client::builder()
.timeout(Duration::from_secs(1))
.build()
.unwrap();
let error = client
.get(format!("{}/one-shot", server.base_url()))
.send()
.await
.unwrap_err();
assert!(error.is_body() || error.is_connect());
assert_eq!(server.recorded_requests().len(), 1);
assert_eq!(server.accepted_connection_count(), 1);
server.shutdown().await;
}
#[derive(Clone)]
struct RotatingAuthentication(Arc<AtomicUsize>);
impl Authentication for RotatingAuthentication {
fn authenticate<'request>(
&'request self,
request: &'request mut tez::Request,
) -> Pin<Box<dyn Future<Output = tez::Result<()>> + Send + 'request>> {
Box::pin(async move {
let value = self.0.fetch_add(1, Ordering::SeqCst) + 1;
request.headers_mut().insert(
"x-credential-version",
HeaderValue::from_str(&value.to_string()).unwrap(),
);
Ok(())
})
}
}
#[tokio::test]
async fn custom_authentication_refreshes_and_owns_the_headers_it_applies() {
let server = httpmock::Server::start(|_| httpmock::MockResponse::ok("ok")).await;
let client = Client::builder()
.default_header("x-credential-version", "static")
.auth(RotatingAuthentication(Arc::new(AtomicUsize::new(0))))
.build()
.unwrap();
client
.get(format!("{}/first", server.base_url()))
.send()
.await
.unwrap()
.discard()
.await
.unwrap();
client
.get(format!("{}/second", server.base_url()))
.header("x-credential-version", "request")
.send()
.await
.unwrap()
.discard()
.await
.unwrap();
let requests = server.recorded_requests();
assert_eq!(requests[0].header("x-credential-version"), Some("1"));
assert_eq!(requests[1].header("x-credential-version"), Some("2"));
server.shutdown().await;
}
struct FailingAuthentication;
impl Authentication for FailingAuthentication {
fn authenticate<'request>(
&'request self,
_request: &'request mut tez::Request,
) -> Pin<Box<dyn Future<Output = tez::Result<()>> + Send + 'request>> {
Box::pin(async { Err(tez::Error::authentication()) })
}
}
#[tokio::test]
async fn custom_authentication_failures_use_the_redacted_error_contract() {
let error = Client::builder()
.auth(FailingAuthentication)
.build()
.unwrap()
.get("http://127.0.0.1:1")
.send()
.await
.unwrap_err();
assert!(error.is_authentication());
assert_eq!(
error.to_string(),
"request authentication could not be obtained"
);
}
#[test]
fn debug_output_does_not_print_request_or_transport_secrets() {
let client = Client::builder()
.base_url("https://example.com/api?token=secret")
.build();
let error = client.unwrap_err();
assert!(!error.to_string().contains("secret"));
assert!(!format!("{error:?}").contains("secret"));
}