Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
88 changes: 0 additions & 88 deletions tako-rs-core/src/conn_info.rs
Original file line number Diff line number Diff line change
Expand Up @@ -137,91 +137,3 @@ pub struct UnixPeerAddr {
/// Most client connections are unnamed (None).
pub path: Option<PathBuf>,
}

#[cfg(test)]
mod tests {
use super::*;

#[test]
fn peer_addr_as_socket_returns_socket_for_ip_variant() {
let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
let peer = PeerAddr::Ip(addr);
assert_eq!(peer.as_socket(), Some(&addr));
}

#[test]
fn peer_addr_as_socket_returns_none_for_unix_variant() {
let peer = PeerAddr::Unix(Some(PathBuf::from("/tmp/sock")));
assert!(peer.as_socket().is_none());
}

#[test]
fn peer_addr_as_socket_returns_none_for_other_variant() {
let peer = PeerAddr::Other("vsock:42:9999".to_string());
assert!(peer.as_socket().is_none());
}

#[test]
fn peer_addr_from_socket_addr() {
let addr: SocketAddr = "[::1]:443".parse().unwrap();
let peer: PeerAddr = addr.into();
assert!(matches!(peer, PeerAddr::Ip(_)));
assert_eq!(peer.as_socket(), Some(&addr));
}

#[test]
fn conn_info_tcp_helper() {
let addr: SocketAddr = "10.0.0.1:80".parse().unwrap();
let info = ConnInfo::tcp(addr);
assert_eq!(info.transport, Transport::Http1);
assert!(info.tls.is_none());
assert_eq!(info.peer.as_socket(), Some(&addr));
}

#[test]
fn conn_info_h2_tls_helper() {
let addr: SocketAddr = "10.0.0.2:443".parse().unwrap();
let tls = TlsInfo {
alpn: Some(bytes::Bytes::from_static(b"h2")),
sni: Some("example.com".into()),
version: Some("TLSv1.3"),
};
let info = ConnInfo::h2_tls(addr, tls.clone());
assert_eq!(info.transport, Transport::Http2);
let info_tls = info.tls.expect("tls present");
assert_eq!(info_tls.alpn.as_deref(), Some(b"h2".as_slice()));
assert_eq!(info_tls.sni.as_deref(), Some("example.com"));
assert_eq!(info_tls.version, Some("TLSv1.3"));
}

#[test]
fn conn_info_h1_tls_helper_keeps_http1_label() {
let addr: SocketAddr = "10.0.0.3:443".parse().unwrap();
let info = ConnInfo::h1_tls(addr, TlsInfo::default());
assert_eq!(info.transport, Transport::Http1);
assert!(info.tls.is_some());
}

#[test]
fn conn_info_h3_helper() {
let addr: SocketAddr = "10.0.0.4:443".parse().unwrap();
let info = ConnInfo::h3(addr, TlsInfo::default());
assert_eq!(info.transport, Transport::Http3);
assert!(info.tls.is_some());
}

#[test]
fn conn_info_unix_helper() {
let info = ConnInfo::unix(Some(PathBuf::from("/var/run/x.sock")));
assert_eq!(info.transport, Transport::Unix);
assert!(info.tls.is_none());
assert!(matches!(info.peer, PeerAddr::Unix(Some(_))));
}

#[test]
fn conn_info_unix_helper_without_path() {
let info = ConnInfo::unix(None);
assert_eq!(info.transport, Transport::Unix);
assert!(matches!(info.peer, PeerAddr::Unix(None)));
}
}
27 changes: 0 additions & 27 deletions tako-rs-core/src/problem.rs
Original file line number Diff line number Diff line change
Expand Up @@ -175,33 +175,6 @@ mod tests {
})
}

#[test]
fn problem_from_status_uses_canonical_reason() {
let p = Problem::from_status(StatusCode::NOT_FOUND);
assert_eq!(p.status, 404);
assert_eq!(p.title.as_deref(), Some("Not Found"));
assert!(p.detail.is_none());
assert!(p.r#type.is_none());
}

#[test]
fn problem_with_detail_setter() {
let p = Problem::from_status(StatusCode::BAD_REQUEST).with_detail("missing field 'name'");
assert_eq!(p.detail.as_deref(), Some("missing field 'name'"));
}

#[test]
fn problem_with_type_and_instance() {
let p = Problem::from_status(StatusCode::CONFLICT)
.with_type("https://example.com/probs/conflict")
.with_instance("/orders/42");
assert_eq!(
p.r#type.as_deref(),
Some("https://example.com/probs/conflict")
);
assert_eq!(p.instance.as_deref(), Some("/orders/42"));
}

#[test]
fn problem_with_extension_round_trips_through_serde() {
let p = Problem::from_status(StatusCode::UNPROCESSABLE_ENTITY)
Expand Down
12 changes: 0 additions & 12 deletions tako-rs-core/src/recycle.rs
Original file line number Diff line number Diff line change
Expand Up @@ -166,18 +166,6 @@ mod tests {
assert_eq!(take_headers().capacity(), 0);
}

#[test]
fn extensions_with_only_framework_entries_keep_them_for_reuse() {
let mut extensions = Extensions::new();
extensions.insert(ConnInfo::tcp(peer()));
extensions.insert(peer());
extensions.insert(MatchedPath("/".into()));
recycle_extensions(extensions);
let reused = take_extensions();
assert_eq!(reused.len(), 3);
assert_eq!(reused.get::<MatchedPath>().unwrap().as_str(), "/");
}

#[test]
fn recycling_drops_original_uri_and_preserves_reusable_entries() {
let mut extensions = Extensions::new();
Expand Down
2 changes: 1 addition & 1 deletion tako-rs-core/src/server_support/driver.rs
Original file line number Diff line number Diff line change
Expand Up @@ -285,7 +285,7 @@ mod tests {
let mut first = Box::pin(driver(&signal, &ctx, None));
assert!(futures_util::poll!(first.as_mut()).is_pending());
drop(first);
let mut second = Box::pin(driver(&signal, &ctx, None));
let mut second = std::pin::pin!(driver(&signal, &ctx, None));
assert!(futures_util::poll!(second.as_mut()).is_pending());
assert_eq!(signal.registered(), 1);
}
Expand Down
28 changes: 0 additions & 28 deletions tako-rs-core/src/ws/message.rs
Original file line number Diff line number Diff line change
Expand Up @@ -227,8 +227,6 @@ mod tests {
use bytes::Bytes;

use super::CloseCode;
use super::CloseFrame;
use super::Message;
use super::Utf8Bytes;

#[test]
Expand Down Expand Up @@ -256,30 +254,4 @@ mod tests {
assert!(!CloseCode::new(code).is_allowed(), "{code}");
}
}

#[test]
fn into_data_returns_each_payload() {
assert_eq!(Message::text("hi").into_data(), "hi");
assert_eq!(
Message::binary(vec![1, 2]).into_data(),
Bytes::from_static(&[1, 2])
);
assert_eq!(Message::Ping(Bytes::from_static(b"p")).into_data(), "p");
assert_eq!(Message::Pong(Bytes::from_static(b"q")).into_data(), "q");
let close = CloseFrame {
code: CloseCode::NORMAL,
reason: Utf8Bytes::from_static("bye"),
};
assert_eq!(Message::Close(Some(close)).into_data(), "bye");
assert!(Message::Close(None).into_data().is_empty());
}

#[test]
fn kind_predicates_match_the_variant() {
assert!(Message::from("x").is_text());
assert!(Message::from(vec![0u8]).is_binary());
assert!(Message::Ping(Bytes::new()).is_ping());
assert!(Message::Pong(Bytes::new()).is_pong());
assert!(Message::Close(None).is_close());
}
}
7 changes: 0 additions & 7 deletions tako-rs-core/src/ws/receiver.rs
Original file line number Diff line number Diff line change
Expand Up @@ -268,13 +268,6 @@ mod tests {
);
}

#[test]
fn sixteen_buffered_frames_decode_one_by_one() {
let bytes: Vec<u8> = (0..16).flat_map(|_| client_frame(TEXT, b"hello")).collect();
let frames = decode_all(&mut Receiver::new(LIMITS), &bytes).unwrap();
assert_eq!(frames.len(), 16);
}

#[test]
fn a_frame_decodes_once_its_last_byte_arrives() {
let payload: Vec<u8> = (0..300u16).map(|i| i as u8).collect();
Expand Down
11 changes: 0 additions & 11 deletions tako-rs-plugins/src/plugins/compression/tests.rs
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,6 @@ use tako_rs_core::body::TakoBody;
use super::brotli_stream::stream_brotli;
use super::deflate_stream::stream_deflate;
use super::encoder::compress_brotli;
use super::encoder::compress_deflate;
use super::gzip_stream::stream_gzip;
#[cfg(feature = "zstd")]
use super::zstd_stream::stream_zstd;
Expand Down Expand Up @@ -62,16 +61,6 @@ async fn compression_streams_round_trip_multiple_chunks_and_finish() {
}
}

#[test]
fn buffered_http_deflate_uses_a_zlib_wrapper() {
let input = b"a deflate-encoded HTTP response";
let encoded = compress_deflate(input, 5).unwrap();
assert_eq!(
decode(flate2::read::ZlibDecoder::new(encoded.as_slice())),
input
);
}

#[test]
fn buffered_brotli_round_trips_bodies_around_the_buffer_size() {
for len in [0, 1, 4095, 4096, 4097, 100_000] {
Expand Down
10 changes: 0 additions & 10 deletions tako-rs-server-pt/src/config.rs
Original file line number Diff line number Diff line change
Expand Up @@ -78,13 +78,3 @@ impl Default for PerThreadConfig {
fn num_cpus() -> usize {
std::thread::available_parallelism().map_or(1, std::num::NonZero::get)
}

#[cfg(test)]
mod tests {
use super::PerThreadConfig;

#[test]
fn workers_are_not_pinned_by_default() {
assert!(!PerThreadConfig::default().pin_to_core);
}
}
9 changes: 3 additions & 6 deletions tako-rs-server/src/builder/tls_cert.rs
Original file line number Diff line number Diff line change
Expand Up @@ -218,13 +218,10 @@ fn build_certified_key(

// Installs aws-lc-rs only when no provider exists yet; otherwise the earlier one, e.g. ring,
// loads and signs with the key, which the one-time warning below reports.
let we_installed = if rustls::crypto::CryptoProvider::get_default().is_none() {
rustls::crypto::aws_lc_rs::default_provider()
let we_installed = rustls::crypto::CryptoProvider::get_default().is_none()
&& rustls::crypto::aws_lc_rs::default_provider()
.install_default()
.is_ok()
} else {
false
};
.is_ok();
if !we_installed {
static WARNED: std::sync::Once = std::sync::Once::new();
WARNED.call_once(|| {
Expand Down
17 changes: 0 additions & 17 deletions tako-rs-server/tests/config_validation.rs
Original file line number Diff line number Diff line change
Expand Up @@ -52,20 +52,3 @@ async fn invalid_connection_limit_is_rejected_before_http_startup() {
);
}
}

#[test]
fn invalid_configuration_is_rejected_before_raw_tcp_binding() {
let result = Server::builder()
.config(ServerConfig {
max_connections: Some(0),
..ServerConfig::default()
})
.build()
.try_spawn_tcp_raw("invalid socket address", |_, _| Box::pin(async { Ok(()) }));
let error = result.expect_err("invalid configuration must fail");

assert!(
error.to_string().contains("max_connections"),
"configuration must be checked before attempting to bind: {error}"
);
}
36 changes: 0 additions & 36 deletions tako-rs/tests/middleware/auth.rs
Original file line number Diff line number Diff line change
Expand Up @@ -92,25 +92,6 @@ async fn api_key_with_verify() {
assert_eq!(resp2.status(), StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn basic_auth_valid() {
use tako::middleware::basic_auth::BasicAuth;

let mut router = Router::new();
router.route(Method::GET, "/secure", |_req: Request| async { "ok" });
router.middleware(BasicAuth::single("admin", "password").into_middleware());

let encoded =
base64::Engine::encode(&base64::engine::general_purpose::STANDARD, "admin:password");
let mut req = make_req(Method::GET, "/secure");
req
.headers_mut()
.insert("authorization", format!("Basic {encoded}").parse().unwrap());

let resp = router.dispatch(req).await;
assert_eq!(resp.status(), StatusCode::OK);
}

#[tokio::test]
async fn basic_auth_missing() {
use tako::middleware::basic_auth::BasicAuth;
Expand Down Expand Up @@ -175,23 +156,6 @@ async fn basic_auth_custom_realm() {
assert!(www_auth.contains("Admin Area"));
}

#[tokio::test]
async fn bearer_auth_valid() {
use tako::middleware::bearer_auth::BearerAuth;

let mut router = Router::new();
router.route(Method::GET, "/api", |_req: Request| async { "ok" });
router.middleware(BearerAuth::static_token("my-token").into_middleware());

let mut req = make_req(Method::GET, "/api");
req
.headers_mut()
.insert("authorization", "Bearer my-token".parse().unwrap());

let resp = router.dispatch(req).await;
assert_eq!(resp.status(), StatusCode::OK);
}

#[tokio::test]
async fn bearer_auth_missing() {
use tako::middleware::bearer_auth::BearerAuth;
Expand Down
29 changes: 0 additions & 29 deletions tako-rs/tests/middleware/chain.rs
Original file line number Diff line number Diff line change
Expand Up @@ -123,35 +123,6 @@ async fn problem_json_rewrites_text_404() {
assert!(body.contains("\"status\":404"));
}

#[tokio::test]
async fn etag_304_on_match() {
use tako::middleware::etag::ETag;

let mut router = Router::new();
router.route(Method::GET, "/", |_req: Request| async { "hello" });
router.middleware(ETag::new().into_middleware());

let resp = router.dispatch(make_req(Method::GET, "/")).await;
let etag = resp
.headers()
.get("etag")
.unwrap()
.to_str()
.unwrap()
.to_string();

let mut req = make_req(Method::GET, "/");
req
.headers_mut()
.insert("if-none-match", etag.parse().unwrap());
let resp = router.dispatch(req).await;
assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
assert!(
etag.starts_with("W/\""),
"expected weak validator prefix, got: {etag}"
);
}

#[tokio::test]
async fn etag_if_modified_since_rfc850() {
use tako::middleware::etag::ETag;
Expand Down
Loading
Loading