#![allow(
missing_docs,
dead_code,
unused_mut,
clippy::large_futures,
clippy::missing_panics_doc,
clippy::redundant_closure_for_method_calls,
clippy::inefficient_to_string,
clippy::manual_let_else,
clippy::single_char_pattern,
clippy::match_same_arms,
clippy::needless_borrow,
clippy::trim_split_whitespace,
clippy::too_many_lines,
clippy::unused_self,
clippy::items_after_statements,
clippy::expect_fun_call,
clippy::len_zero,
clippy::unnecessary_debug_formatting,
clippy::format_push_string,
clippy::new_without_default,
clippy::map_unwrap_or
)]
#![cfg(feature = "high-level-url")]
mod test_server;
use std::sync::atomic::Ordering;
use std::time::Duration;
use eggfetch_core::Client;
use test_server::{TestServer, TestServerConfig};
#[tokio::test]
async fn test_reuse_connections() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder().build();
for _ in 0..5 {
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
let accepted = server.connections_accepted();
assert!(
accepted <= 3,
"expected at most 3 TCP connections for sequential reuse, got {accepted}"
);
server.shutdown();
}
#[tokio::test]
async fn test_connection_close_not_reused() {
let mut server = TestServer::start(&TestServerConfig {
close_connection: true,
..Default::default()
});
let url = server.url();
let client = Client::builder().max_connections(8).build();
for _ in 0..5 {
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
tokio::task::yield_now().await;
}
let accepted = server.connections_accepted();
assert!(
accepted >= 5,
"expected at least 5 TCP connections with Connection: close, got {accepted}"
);
server.shutdown();
}
#[tokio::test]
async fn test_max_connections_limits() {
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 200,
..Default::default()
});
let url = server.url();
let max_conn: usize = 2;
let client = Client::builder().max_connections(max_conn).build();
let start = std::time::Instant::now();
let mut handles = Vec::new();
for _ in 0..6 {
let client = client.clone();
let url = url.clone();
handles.push(tokio::spawn(async move {
client.get(&url).unwrap().send().await.unwrap();
}));
}
for h in handles {
h.await.unwrap();
}
let elapsed = start.elapsed();
let min_expected = Duration::from_millis(350);
assert!(
elapsed >= min_expected,
"expected at least {min_expected:?} with max_connections={max_conn}, elapsed {elapsed:?}"
);
server.shutdown();
}
#[tokio::test]
async fn test_max_connections_per_host() {
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 200,
..Default::default()
});
let url = server.url();
let max_per_host: usize = 2;
let client = Client::builder()
.max_connections(8)
.max_connections_per_host(max_per_host)
.build();
let start = std::time::Instant::now();
let mut handles = Vec::new();
for _ in 0..6 {
let client = client.clone();
let url = url.clone();
handles.push(tokio::spawn(async move {
client.get(&url).unwrap().send().await.unwrap();
}));
}
for h in handles {
h.await.unwrap();
}
let elapsed = start.elapsed();
let min_expected = Duration::from_millis(350);
assert!(
elapsed >= min_expected,
"expected at least {min_expected:?} with max_connections_per_host={max_per_host}, elapsed {elapsed:?}"
);
server.shutdown();
}
#[tokio::test]
async fn test_pool_metrics_tracking() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder().build();
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
let metrics = client.pool_metrics();
assert_eq!(
metrics.acquisition_waits.load(Ordering::Relaxed),
0,
"no waits expected without limits"
);
assert_eq!(
metrics.acquisition_cancellations.load(Ordering::Relaxed),
0,
"no cancellations expected"
);
server.shutdown();
}
#[tokio::test]
async fn test_clone_shares_pool() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder().max_connections(4).build();
let client2 = client.clone();
let r1 = client.get(&url).unwrap().send().await.unwrap();
let r2 = client2.get(&url).unwrap().send().await.unwrap();
assert!(r1.is_success());
assert!(r2.is_success());
tokio::task::yield_now().await;
let accepted = server.connections_accepted();
assert!(
accepted <= 3,
"cloned clients should share pool, expected <= 3 connections, got {accepted}"
);
server.shutdown();
}
#[test]
fn test_client_builder_pool_config() {
let _client = Client::builder()
.max_connections(10)
.max_connections_per_host(5)
.max_idle_connections(20)
.max_idle_connections_per_host(10)
.idle_timeout(Duration::from_secs(30))
.user_agent("test-agent")
.build();
}
#[test]
fn test_idle_timeout_config() {
let _client = Client::builder()
.idle_timeout(Duration::from_secs(60))
.build();
}
#[tokio::test]
async fn test_idle_timeout_allows_reuse_within_timeout() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder()
.idle_timeout(Duration::from_secs(30))
.build();
for _ in 0..3 {
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
}
assert!(
server.connections_accepted() <= 2,
"expected connection reuse within the idle timeout, got {} accepted",
server.connections_accepted()
);
server.shutdown();
}
#[tokio::test]
async fn test_idle_timer_evicts_connection_in_background() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder()
.idle_timeout(Duration::from_millis(100))
.build();
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
drop(resp);
assert_eq!(server.connections_accepted(), 1);
assert_eq!(server.open_connections(), 1);
let deadline = std::time::Instant::now() + Duration::from_secs(5);
loop {
if server.open_connections() == 0 {
break;
}
assert!(
std::time::Instant::now() < deadline,
"idle connection was not evicted in the background; still open"
);
tokio::time::sleep(Duration::from_millis(50)).await;
}
server.shutdown();
}
#[tokio::test]
async fn test_connection_reuse_same_host() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder().build();
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
tokio::task::yield_now().await;
let after_first = server.connections_accepted();
assert!(
after_first >= 1,
"at least 1 connection after first request"
);
for _ in 0..5 {
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
tokio::task::yield_now().await;
}
let after_all = server.connections_accepted();
assert!(
after_all <= after_first + 6,
"expected reuse: {after_first} -> {after_all}"
);
server.shutdown();
}
#[tokio::test]
async fn test_acquisition_wait() {
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 150,
..Default::default()
});
let url = server.url();
let client = Client::builder().max_connections(1).build();
let start = std::time::Instant::now();
let h1 = {
let client = client.clone();
let url = url.clone();
tokio::spawn(async move { client.get(&url).unwrap().send().await })
};
let h2 = {
let client = client.clone();
let url = url.clone();
tokio::spawn(async move { client.get(&url).unwrap().send().await })
};
let mut r1 = h1.await.unwrap().unwrap();
assert!(r1.is_success());
let _ = r1.bytes().await;
drop(r1);
let mut r2 = h2.await.unwrap().unwrap();
assert!(r2.is_success());
let _ = r2.bytes().await;
drop(r2);
let elapsed = start.elapsed();
assert!(
elapsed >= Duration::from_millis(250),
"expected serialization delay, elapsed {elapsed:?}"
);
let metrics = client.pool_metrics();
assert!(
metrics.acquisition_waits.load(Ordering::SeqCst) >= 1,
"expected at least 1 acquisition wait"
);
server.shutdown();
}
#[tokio::test]
async fn test_max_connections_bounds_three() {
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 300,
..Default::default()
});
let url = server.url();
let max_conn: usize = 2;
let client = Client::builder().max_connections(max_conn).build();
let start = std::time::Instant::now();
let mut handles = Vec::new();
for _ in 0..3 {
let client = client.clone();
let url = url.clone();
handles.push(tokio::spawn(async move {
client.get(&url).unwrap().send().await.unwrap();
}));
}
for h in handles {
h.await.unwrap();
}
let elapsed = start.elapsed();
let min_expected = Duration::from_millis(450);
assert!(
elapsed >= min_expected,
"expected at least {min_expected:?} with max_connections={max_conn}, elapsed {elapsed:?}"
);
server.shutdown();
}
#[tokio::test]
async fn test_connection_refused() {
let client = Client::builder().build();
let result = client.get("http://127.0.0.1:1").unwrap().send().await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_post_with_body() {
let mut server = TestServer::start(&TestServerConfig {
consume_body: true,
..Default::default()
});
let url = server.url();
let client = Client::builder().build();
let resp = client
.post(&url)
.unwrap()
.header("Content-Type", "text/plain")
.body("hello")
.send()
.await
.unwrap();
assert!(resp.is_success());
server.shutdown();
}
#[tokio::test]
async fn test_pool_metrics_waits() {
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 100,
..Default::default()
});
let url = server.url();
let client = Client::builder().max_connections(1).build();
let start = std::time::Instant::now();
let h1 = {
let client = client.clone();
let url = url.clone();
tokio::spawn(async move { client.get(&url).unwrap().send().await })
};
let h2 = {
let client = client.clone();
let url = url.clone();
tokio::spawn(async move { client.get(&url).unwrap().send().await })
};
let mut r1 = h1.await.unwrap().unwrap();
assert!(r1.is_success());
let _ = r1.bytes().await;
drop(r1);
let mut r2 = h2.await.unwrap().unwrap();
assert!(r2.is_success());
let _ = r2.bytes().await;
drop(r2);
let elapsed = start.elapsed();
assert!(
elapsed >= Duration::from_millis(150),
"expected serialization, elapsed {elapsed:?}"
);
let metrics = client.pool_metrics();
assert!(
metrics.acquisition_waits.load(Ordering::SeqCst) >= 1,
"expected at least 1 acquisition wait"
);
server.shutdown();
}
#[tokio::test]
async fn test_idle_timeout_closes_stale_connection() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder()
.idle_timeout(Duration::from_millis(100))
.build();
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
assert_eq!(server.connections_accepted(), 1);
tokio::time::sleep(Duration::from_millis(200)).await;
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
assert!(
server.connections_accepted() >= 2,
"expected at least 2 connections after idle timeout, got {}",
server.connections_accepted()
);
server.shutdown();
}
#[tokio::test]
async fn test_sni_cached_client_obeys_idle_policy() {
use eggfetch_core::TransportHints;
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder()
.idle_timeout(Duration::from_millis(100))
.build();
let sni_hints = || TransportHints {
sni_hostname: Some("sni-idle.test".to_owned()),
..Default::default()
};
let resp = client
.get(&url)
.unwrap()
.transport_hints(sni_hints())
.send()
.await
.unwrap();
assert!(resp.is_success());
drop(resp);
assert_eq!(server.connections_accepted(), 1);
tokio::time::sleep(Duration::from_millis(300)).await;
let resp = client
.get(&url)
.unwrap()
.transport_hints(sni_hints())
.send()
.await
.unwrap();
assert!(resp.is_success());
assert!(
server.connections_accepted() >= 2,
"expected the SNI route to reconnect after idle timeout, got {}",
server.connections_accepted()
);
server.shutdown();
}
#[tokio::test]
async fn test_idle_per_host_cap_zero_disables_reuse() {
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder().max_idle_connections_per_host(0).build();
for _ in 0..3 {
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
}
assert_eq!(
server.connections_accepted(),
3,
"zero per-host idle cap must prevent reuse, got {}",
server.connections_accepted()
);
server.shutdown();
let mut server = TestServer::start(&TestServerConfig::default());
let url = server.url();
let client = Client::builder().max_idle_connections(0).build();
for _ in 0..2 {
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
}
assert_eq!(
server.connections_accepted(),
2,
"zero fallback idle cap must prevent reuse, got {}",
server.connections_accepted()
);
server.shutdown();
}
#[tokio::test]
async fn test_cancelled_waiter_releases_cleanly() {
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 50,
..Default::default()
});
let url = server.url();
let client = Client::builder().max_connections(1).build();
let h1 = {
let client = client.clone();
let url = url.clone();
tokio::spawn(async move { client.get(&url).unwrap().send().await })
};
tokio::time::sleep(Duration::from_millis(20)).await;
let h2 = {
let client = client.clone();
let url = url.clone();
tokio::spawn(async move { client.get(&url).unwrap().send().await })
};
tokio::time::sleep(Duration::from_millis(20)).await;
h2.abort();
tokio::time::sleep(Duration::from_millis(10)).await;
let mut r1 = h1.await.unwrap().unwrap();
assert!(r1.is_success());
let _ = r1.bytes().await;
drop(r1);
let resp = client.get(&url).unwrap().send().await.unwrap();
assert!(resp.is_success());
server.shutdown();
}
#[tokio::test]
async fn test_streaming_response_holds_permit_until_consumed() {
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 100,
..Default::default()
});
let url = server.url();
let client = Client::builder().max_connections(1).build();
let mut resp1 = client.get(&url).unwrap().send().await.unwrap();
let body_stream = resp1.bytes_stream().unwrap();
let start = std::time::Instant::now();
let h2 = {
let client = client.clone();
let url = url.clone();
tokio::spawn(async move { client.get(&url).unwrap().send().await })
};
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
assert!(
!h2.is_finished(),
"second request should be waiting for the permit"
);
drop(body_stream);
drop(resp1);
let resp2 = h2.await.unwrap().unwrap();
let elapsed = start.elapsed();
assert!(
elapsed >= std::time::Duration::from_millis(40),
"second request should have waited, only {elapsed:?}"
);
assert!(resp2.is_success());
server.shutdown();
}
#[tokio::test]
async fn per_origin_eviction_skips_entries_with_active_waiter() {
use eggfetch_core::{Client, Limits};
let client = Client::builder()
.limits(Limits {
max_connections_per_host: Some(1),
..Default::default()
})
.build();
let mut server = TestServer::start(&TestServerConfig {
response_delay_ms: 100,
..Default::default()
});
let url = server.url();
let req1 = client.get(&url).unwrap().send();
tokio::time::sleep(Duration::from_millis(20)).await;
let req2 = client.get(&url).unwrap().send();
let resp1 = req1.await.unwrap();
drop(resp1);
let resp2 = req2.await.unwrap();
assert!(resp2.is_success());
server.shutdown();
}