use std::net::SocketAddr;
use std::time::Duration;
use tokio::io::AsyncWriteExt;
use tokio::time::{sleep, timeout};
use url::Url;
use crate::error::Aria2Error;
use super::super::manager::HttpConnectionManager;
use super::super::types::HttpConfig;
async fn start_test_server(
handler: impl Fn(tokio::net::TcpStream) + Send + 'static,
) -> (SocketAddr, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let handle = tokio::spawn(async move {
while let Ok((stream, _)) = listener.accept().await {
handler(stream);
}
});
(addr, handle)
}
#[tokio::test]
async fn test_connection_pool_reuse() {
let config = HttpConfig {
max_connections: 4,
connect_timeout: Duration::from_millis(500),
read_timeout: Duration::from_millis(1000),
write_timeout: Duration::from_millis(1000),
idle_timeout: Duration::from_millis(2000),
max_idle_per_host: 4,
};
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|mut stream| {
tokio::spawn(async move {
let response = "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK";
stream.write_all(response.as_bytes()).await.unwrap();
});
})
.await;
sleep(Duration::from_millis(100)).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn1 = manager
.acquire(&url, None)
.await
.expect("First acquisition should succeed");
assert_eq!(manager.active_count(), 1);
manager.put_back(conn1).await;
let conn2 = manager
.acquire(&url, None)
.await
.expect("Second acquisition should succeed");
assert!(manager.active_count() >= 1);
manager.put_back(conn2).await;
manager.cleanup().await;
server_handle.abort();
}
#[tokio::test]
async fn test_discard_decrements_active_count() {
let config = HttpConfig::default();
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|_stream| {}).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn = manager.acquire(&url, None).await.unwrap();
assert_eq!(manager.active_count(), 1);
manager.discard(conn).await;
assert_eq!(manager.active_count(), 0);
server_handle.abort();
}
#[tokio::test]
async fn test_evict_peer_removes_matching_idle_direct_connection() {
let config = HttpConfig::default();
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|_stream| {}).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn = manager.acquire(&url, None).await.unwrap();
let context = conn.connection_context().clone();
manager.put_back(conn).await;
assert_eq!(manager.pool_size(), 1);
let evicted = manager.evict_peer(&context).await;
assert_eq!(evicted, 1);
assert_eq!(manager.pool_size(), 0);
assert_eq!(manager.active_count(), 0);
server_handle.abort();
}
#[tokio::test]
async fn test_timeout_on_slow_server() {
use std::time::Instant;
let config = HttpConfig {
max_connections: 2,
connect_timeout: Duration::from_millis(100),
read_timeout: Duration::from_millis(200),
write_timeout: Duration::from_millis(200),
idle_timeout: Duration::from_secs(60),
max_idle_per_host: 2,
};
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|_stream| {
tokio::spawn(async move {
sleep(Duration::from_secs(10)).await;
});
})
.await;
sleep(Duration::from_millis(50)).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let start = Instant::now();
let _result = timeout(
config.connect_timeout + Duration::from_millis(50),
manager.acquire(&url, None),
)
.await;
let elapsed = start.elapsed();
assert!(
elapsed < config.connect_timeout + Duration::from_millis(300),
"Elapsed time too long: {:.2}ms",
elapsed.as_millis()
);
manager.cleanup().await;
server_handle.abort();
}
#[tokio::test]
async fn test_max_connections_limit() {
let config = HttpConfig {
max_connections: 2,
connect_timeout: Duration::from_millis(500),
read_timeout: Duration::from_millis(1000),
write_timeout: Duration::from_millis(1000),
idle_timeout: Duration::from_secs(60),
max_idle_per_host: 2,
};
let mut manager = HttpConnectionManager::new(&config);
let (addr, _server_handle) = start_test_server(|mut stream| {
tokio::spawn(async move {
let response = "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK";
stream.write_all(response.as_bytes()).await.unwrap();
sleep(Duration::from_secs(10)).await;
});
})
.await;
sleep(Duration::from_millis(100)).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn1 = manager.acquire(&url, None).await.unwrap();
assert!(manager.active_count() >= 1);
let conn2 = manager.acquire(&url, None).await.unwrap();
assert!(manager.active_count() >= 2);
let result = manager.acquire(&url, None).await;
assert!(
result.is_err(),
"Should return error when max connection limit exceeded"
);
if let Err(e) = result {
match &e {
Aria2Error::Recoverable(_) => {}
other => panic!("Expected Recoverable error, got: {:?}", other),
}
}
manager.put_back(conn1).await;
match manager.acquire(&url, None).await {
Ok(conn3) => {
println!(
"Successfully acquired new connection after release: id={}",
conn3.id
);
manager.put_back(conn3).await;
}
Err(e) => {
println!(
"Acquisition failed after release (may be connection reuse limit): {}",
e
);
}
}
manager.put_back(conn2).await;
manager.cleanup().await;
}
#[tokio::test]
async fn test_release_all_closes_idle() {
let config = HttpConfig {
max_connections: 4,
connect_timeout: Duration::from_millis(500),
read_timeout: Duration::from_millis(1000),
write_timeout: Duration::from_millis(1000),
idle_timeout: Duration::from_secs(60),
max_idle_per_host: 4,
};
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|mut stream| {
tokio::spawn(async move {
let resp = "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK";
let _ = stream.write_all(resp.as_bytes()).await;
});
})
.await;
sleep(Duration::from_millis(100)).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn1 = manager.acquire(&url, None).await.unwrap();
let conn2 = manager.acquire(&url, None).await.unwrap();
manager.put_back(conn1).await;
manager.put_back(conn2).await;
assert_eq!(manager.pool_size(), 2);
manager.release_all().await;
assert_eq!(manager.pool_size(), 0);
manager.cleanup().await;
server_handle.abort();
}
#[tokio::test]
async fn test_put_back_enforces_idle_limit() {
let config = HttpConfig {
max_connections: 8,
connect_timeout: Duration::from_millis(500),
read_timeout: Duration::from_millis(1000),
write_timeout: Duration::from_millis(1000),
idle_timeout: Duration::from_secs(60),
max_idle_per_host: 2, };
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|mut stream| {
tokio::spawn(async move {
let resp = "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK";
let _ = stream.write_all(resp.as_bytes()).await;
});
})
.await;
sleep(Duration::from_millis(100)).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn1 = manager.acquire(&url, None).await.unwrap();
let conn2 = manager.acquire(&url, None).await.unwrap();
let conn3 = manager.acquire(&url, None).await.unwrap();
manager.put_back(conn1).await;
assert_eq!(manager.pool_size(), 1);
manager.put_back(conn2).await;
assert_eq!(manager.pool_size(), 2);
manager.put_back(conn3).await;
assert_eq!(manager.pool_size(), 2);
manager.cleanup().await;
server_handle.abort();
}
#[tokio::test]
async fn test_check_timeout_evicts_expired() {
let config = HttpConfig {
max_connections: 4,
connect_timeout: Duration::from_millis(500),
read_timeout: Duration::from_millis(1000),
write_timeout: Duration::from_millis(1000),
idle_timeout: Duration::from_millis(200), max_idle_per_host: 4,
};
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|mut stream| {
tokio::spawn(async move {
let resp = "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK";
let _ = stream.write_all(resp.as_bytes()).await;
});
})
.await;
sleep(Duration::from_millis(100)).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn = manager.acquire(&url, None).await.unwrap();
manager.put_back(conn).await;
assert_eq!(manager.pool_size(), 1);
sleep(Duration::from_millis(300)).await;
let evicted = manager.check_timeout();
assert_eq!(evicted, 1);
assert_eq!(manager.pool_size(), 0);
manager.cleanup().await;
server_handle.abort();
}
#[tokio::test]
async fn test_put_back_returns_connection_to_pool() {
let config = HttpConfig {
max_connections: 4,
connect_timeout: Duration::from_millis(500),
read_timeout: Duration::from_millis(1000),
write_timeout: Duration::from_millis(1000),
idle_timeout: Duration::from_secs(60),
max_idle_per_host: 4,
};
let mut manager = HttpConnectionManager::new(&config);
let (addr, server_handle) = start_test_server(|mut stream| {
tokio::spawn(async move {
let resp = "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK";
let _ = stream.write_all(resp.as_bytes()).await;
});
})
.await;
sleep(Duration::from_millis(100)).await;
let url = Url::parse(&format!("http://{}", addr)).unwrap();
let conn = manager.acquire(&url, None).await.unwrap();
let conn_id = conn.id;
manager.put_back(conn).await;
assert_eq!(manager.pool_size(), 1);
let conn2 = manager.acquire(&url, None).await.unwrap();
assert_eq!(conn2.id, conn_id);
manager.put_back(conn2).await;
assert_eq!(manager.pool_size(), 1);
manager.cleanup().await;
server_handle.abort();
}