#![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 = "http2")]
#![allow(clippy::module_name_repetitions)]
mod test_server;
use std::time::Duration;
use eggfetch_core::error::Error;
use eggfetch_core::http_version::HttpVersionPolicy;
use eggfetch_core::Client;
use test_server::{TestServer, TestServerConfig};
#[tokio::test]
async fn forbidden_headers_are_stripped() {
let server = TestServer::start(&TestServerConfig {
consume_body: true,
..Default::default()
});
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http1Only)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let resp = client
.post(&server.url())
.unwrap()
.header("connection", "keep-alive")
.header("keep-alive", "timeout=5")
.header("transfer-encoding", "chunked")
.header("upgrade", "h2c")
.header("content-type", "text/plain")
.body("hello")
.send()
.await;
assert!(
resp.is_ok(),
"request with forbidden headers should succeed after stripping: {resp:?}"
);
let resp = resp.unwrap();
assert_eq!(resp.status().as_u16(), 200);
}
#[tokio::test]
async fn te_trailers_is_preserved() {
let server = TestServer::start(&TestServerConfig {
consume_body: true,
..Default::default()
});
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http1Only)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let resp = client
.get(&server.url())
.unwrap()
.header("te", "trailers")
.send()
.await
.unwrap();
assert_eq!(resp.status().as_u16(), 200);
}
#[tokio::test]
async fn te_non_trailers_is_stripped() {
let server = TestServer::start(&TestServerConfig {
consume_body: true,
..Default::default()
});
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http1Only)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let resp = client
.get(&server.url())
.unwrap()
.header("te", "gzip")
.send()
.await
.unwrap();
assert_eq!(resp.status().as_u16(), 200);
}
#[test]
fn http2_go_away_error_display() {
let err = Error::Http2GoAway {
last_stream_id: 5,
debug_data: "server shutting down".into(),
};
let msg = err.to_string();
assert!(msg.contains("GOAWAY"));
assert!(msg.contains("5"));
assert!(msg.contains("server shutting down"));
assert_eq!(err.kind(), "http2_go_away");
}
#[test]
fn http2_stream_reset_error_display() {
let err = Error::Http2StreamReset {
reason: "REFUSED_STREAM: stream refused before processing".into(),
};
let msg = err.to_string();
assert!(msg.contains("REFUSED_STREAM"));
assert_eq!(err.kind(), "http2_stream_reset");
}
#[test]
fn http2_flow_control_error_display() {
let err = Error::Http2FlowControl("flow-control window exhausted".into());
let msg = err.to_string();
assert!(msg.contains("flow control"));
assert_eq!(err.kind(), "http2_flow_control");
}
#[test]
fn http2_protocol_error_display() {
let err = Error::Http2Protocol("received data on half-closed stream".into());
let msg = err.to_string();
assert!(msg.contains("protocol error"));
assert_eq!(err.kind(), "http2_protocol");
}
#[test]
fn refused_stream_is_retryable() {
let err = Error::Http2StreamReset {
reason: "REFUSED_STREAM: stream refused before processing".into(),
};
assert!(eggfetch_core::RetryPolicy::is_error_retryable(&err));
}
#[test]
fn cancel_is_not_retryable() {
let err = Error::Http2StreamReset {
reason: "CANCEL: stream cancelled by peer".into(),
};
assert!(!eggfetch_core::RetryPolicy::is_error_retryable(&err));
}
#[test]
fn go_away_is_not_retryable() {
let err = Error::Http2GoAway {
last_stream_id: 0,
debug_data: "graceful shutdown".into(),
};
assert!(!eggfetch_core::RetryPolicy::is_error_retryable(&err));
}
#[test]
fn flow_control_is_not_retryable() {
let err = Error::Http2FlowControl("flow-control violated".into());
assert!(!eggfetch_core::RetryPolicy::is_error_retryable(&err));
}
#[test]
fn http2_protocol_is_not_retryable() {
let err = Error::Http2Protocol("stream closed after headers".into());
assert!(!eggfetch_core::RetryPolicy::is_error_retryable(&err));
}
#[test]
fn builder_accepts_http2_only_policy() {
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http2Only)
.build();
drop(client);
}
#[test]
fn builder_accepts_auto_policy() {
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Auto { allow_http3: false })
.build();
drop(client);
}
#[test]
fn builder_default_is_auto() {
let client = Client::builder().build();
drop(client);
}
#[tokio::test]
async fn concurrent_requests_share_pool() {
let server = TestServer::start(&TestServerConfig {
consume_body: true,
..Default::default()
});
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Auto { allow_http3: false })
.max_connections(5)
.max_connections_per_host(5)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(10)),
..Default::default()
})
.build();
let mut handles = Vec::new();
for _ in 0..5 {
let c = client.clone();
let url = server.url();
handles.push(tokio::spawn(async move {
let mut resp = c.get(&url).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let _ = resp.text().await;
}));
}
for h in handles {
h.await.unwrap();
}
}
#[tokio::test]
async fn pool_metrics_track_permits() {
let server = TestServer::start(&TestServerConfig {
consume_body: true,
..Default::default()
});
let client = Client::builder()
.max_connections(2)
.max_connections_per_host(2)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let mut r1 = client.get(&server.url()).unwrap().send().await.unwrap();
let _ = r1.text().await;
let mut r2 = client.get(&server.url()).unwrap().send().await.unwrap();
let _ = r2.text().await;
let metrics = client.pool_metrics();
let _ = metrics;
}
#[tokio::test]
async fn h2c_not_supported_no_panic() {
let server = TestServer::start(&TestServerConfig::default());
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http2Only)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(3)),
..Default::default()
})
.build();
let _ = client.get(&server.url()).unwrap().send().await;
}
#[tokio::test]
async fn response_version_reports_http1() {
let server = TestServer::start(&TestServerConfig::default());
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http1Only)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
let resp = client.get(&server.url()).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
assert_eq!(
resp.version(),
http::Version::HTTP_11,
"response version should be HTTP/1.1 for an HTTP/1.1 server"
);
}
#[tokio::test]
async fn dropping_stream_releases_permit() {
let server = TestServer::start(&TestServerConfig {
response_body: Some(b"hello world".to_vec()),
..Default::default()
});
let client = Client::builder()
.max_connections(1)
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(5)),
..Default::default()
})
.build();
{
let mut resp = client.get(&server.url()).unwrap().send().await.unwrap();
let mut stream = resp.bytes_stream().unwrap();
let _ = futures_util::StreamExt::next(&mut stream).await;
drop(stream);
}
let mut resp = client.get(&server.url()).unwrap().send().await.unwrap();
assert_eq!(resp.status().as_u16(), 200);
let _ = resp.text().await;
}
#[test]
fn http2_feature_is_enabled() {
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http2Only)
.build();
drop(client);
}
#[cfg(feature = "proxy")]
#[tokio::test]
async fn h2_only_rejects_http_forward_proxy() {
use eggfetch_core::Proxy;
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http2Only)
.proxy(Proxy::all("http://127.0.0.1:1").unwrap())
.timeout(eggfetch_core::Timeout {
total: Some(Duration::from_secs(3)),
..Default::default()
})
.build();
let err = client
.get("http://destination.example/path")
.unwrap()
.send()
.await
.expect_err("h2-only + http forward proxy must error");
assert!(
matches!(err, Error::Unsupported(_)),
"expected Error::Unsupported, got {err:?}"
);
assert!(
err.to_string().contains("HTTP/2-only"),
"error should mention HTTP/2-only policy: {err}"
);
}