From 038b465dde7351a0a05fb39a9e3ed7348344ff77 Mon Sep 17 00:00:00 2001 From: Daniel Boros Date: Tue, 10 Nov 2026 23:13:26 +0100 Subject: [PATCH 1/2] test: remove trivial and redundant tests --- tako-rs-core/src/conn_info.rs | 88 ----------- tako-rs-core/src/problem.rs | 27 ---- tako-rs-core/src/recycle.rs | 12 -- tako-rs-core/src/ws/message.rs | 28 ---- tako-rs-core/src/ws/receiver.rs | 7 - .../src/plugins/compression/tests.rs | 11 -- tako-rs-server-pt/src/config.rs | 10 -- tako-rs-server/tests/config_validation.rs | 17 -- tako-rs/tests/middleware/auth.rs | 36 ----- tako-rs/tests/middleware/chain.rs | 29 ---- tako-rs/tests/middleware/compression.rs | 35 ----- tako-rs/tests/middleware/response.rs | 16 -- tako-rs/tests/middleware/session.rs | 20 --- tako-rs/tests/mount_all.rs | 6 - tako-rs/tests/queue.rs | 31 ---- tako-rs/tests/queue_v2.rs | 15 -- tako-rs/tests/responder.rs | 8 - tako-rs/tests/router.rs | 15 -- tako-rs/tests/router/composition.rs | 19 --- tako-rs/tests/server_builder.rs | 7 - tako-rs/tests/sse_redirect_config.rs | 17 -- tako-rs/tests/udp_tcp_progress.rs | 148 ------------------ 22 files changed, 602 deletions(-) diff --git a/tako-rs-core/src/conn_info.rs b/tako-rs-core/src/conn_info.rs index 466f3b06..516510f4 100644 --- a/tako-rs-core/src/conn_info.rs +++ b/tako-rs-core/src/conn_info.rs @@ -137,91 +137,3 @@ pub struct UnixPeerAddr { /// Most client connections are unnamed (None). pub path: Option, } - -#[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))); - } -} diff --git a/tako-rs-core/src/problem.rs b/tako-rs-core/src/problem.rs index 19c5c813..796a7e54 100644 --- a/tako-rs-core/src/problem.rs +++ b/tako-rs-core/src/problem.rs @@ -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) diff --git a/tako-rs-core/src/recycle.rs b/tako-rs-core/src/recycle.rs index 12c56f73..e6b1c58d 100644 --- a/tako-rs-core/src/recycle.rs +++ b/tako-rs-core/src/recycle.rs @@ -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::().unwrap().as_str(), "/"); - } - #[test] fn recycling_drops_original_uri_and_preserves_reusable_entries() { let mut extensions = Extensions::new(); diff --git a/tako-rs-core/src/ws/message.rs b/tako-rs-core/src/ws/message.rs index e38bf5b7..fea712a4 100644 --- a/tako-rs-core/src/ws/message.rs +++ b/tako-rs-core/src/ws/message.rs @@ -227,8 +227,6 @@ mod tests { use bytes::Bytes; use super::CloseCode; - use super::CloseFrame; - use super::Message; use super::Utf8Bytes; #[test] @@ -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()); - } } diff --git a/tako-rs-core/src/ws/receiver.rs b/tako-rs-core/src/ws/receiver.rs index 3ac26033..4afe8447 100644 --- a/tako-rs-core/src/ws/receiver.rs +++ b/tako-rs-core/src/ws/receiver.rs @@ -268,13 +268,6 @@ mod tests { ); } - #[test] - fn sixteen_buffered_frames_decode_one_by_one() { - let bytes: Vec = (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 = (0..300u16).map(|i| i as u8).collect(); diff --git a/tako-rs-plugins/src/plugins/compression/tests.rs b/tako-rs-plugins/src/plugins/compression/tests.rs index 2d3e6db2..9d8d563d 100644 --- a/tako-rs-plugins/src/plugins/compression/tests.rs +++ b/tako-rs-plugins/src/plugins/compression/tests.rs @@ -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; @@ -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] { diff --git a/tako-rs-server-pt/src/config.rs b/tako-rs-server-pt/src/config.rs index 877df218..672834ce 100644 --- a/tako-rs-server-pt/src/config.rs +++ b/tako-rs-server-pt/src/config.rs @@ -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); - } -} diff --git a/tako-rs-server/tests/config_validation.rs b/tako-rs-server/tests/config_validation.rs index e52d7fad..7baee256 100644 --- a/tako-rs-server/tests/config_validation.rs +++ b/tako-rs-server/tests/config_validation.rs @@ -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}" - ); -} diff --git a/tako-rs/tests/middleware/auth.rs b/tako-rs/tests/middleware/auth.rs index 958590ff..b164a4ee 100644 --- a/tako-rs/tests/middleware/auth.rs +++ b/tako-rs/tests/middleware/auth.rs @@ -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; @@ -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; diff --git a/tako-rs/tests/middleware/chain.rs b/tako-rs/tests/middleware/chain.rs index 0925e7f2..b3140151 100644 --- a/tako-rs/tests/middleware/chain.rs +++ b/tako-rs/tests/middleware/chain.rs @@ -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; diff --git a/tako-rs/tests/middleware/compression.rs b/tako-rs/tests/middleware/compression.rs index 253e70e2..dbb2056e 100644 --- a/tako-rs/tests/middleware/compression.rs +++ b/tako-rs/tests/middleware/compression.rs @@ -2,41 +2,6 @@ use super::*; -#[cfg(feature = "plugins")] -#[tokio::test] -async fn compression_compresses_plain_response() { - use tako::plugins::TakoPlugin; - use tako::plugins::compression::CompressionBuilder; - - let mut router = Router::new(); - router.route(Method::GET, "/", |_req: Request| async move { - let payload = "x".repeat(2048); - http::Response::builder() - .header("content-type", "text/plain") - .body(TakoBody::from(payload)) - .unwrap() - }); - CompressionBuilder::new() - .enable_gzip(true) - .min_size(512) - .build() - .setup(&router) - .unwrap(); - - let mut req = make_req(Method::GET, "/"); - req - .headers_mut() - .insert("accept-encoding", "gzip".parse().unwrap()); - let resp = router.dispatch(req).await; - assert_eq!( - resp - .headers() - .get("content-encoding") - .map(|v| v.to_str().unwrap()), - Some("gzip") - ); -} - #[cfg(feature = "plugins")] #[tokio::test] async fn compression_skips_when_request_authenticated() { diff --git a/tako-rs/tests/middleware/response.rs b/tako-rs/tests/middleware/response.rs index d117cb33..5eabc22e 100644 --- a/tako-rs/tests/middleware/response.rs +++ b/tako-rs/tests/middleware/response.rs @@ -147,22 +147,6 @@ async fn request_id_preserved() { assert_eq!(resp.headers().get("x-request-id").unwrap(), "abc123"); } -#[tokio::test] -async fn request_id_custom_generator() { - use tako::middleware::request_id::RequestId; - - let mut router = Router::new(); - router.route(Method::GET, "/", |_req: Request| async { "ok" }); - router.middleware( - RequestId::new() - .generator(|| "fixed-id".to_string()) - .into_middleware(), - ); - - let resp = router.dispatch(make_req(Method::GET, "/")).await; - assert_eq!(resp.headers().get("x-request-id").unwrap(), "fixed-id"); -} - #[tokio::test] async fn request_id_custom_header() { use tako::middleware::request_id::RequestId; diff --git a/tako-rs/tests/middleware/session.rs b/tako-rs/tests/middleware/session.rs index f76a975f..645aae55 100644 --- a/tako-rs/tests/middleware/session.rs +++ b/tako-rs/tests/middleware/session.rs @@ -1,25 +1,5 @@ use super::*; -#[cfg_attr(not(feature = "compio"), tokio::test)] -#[cfg_attr(feature = "compio", compio::test)] -async fn session_new_request_sets_cookie() { - use tako::middleware::session::SessionMiddleware; - - let mut router = Router::new(); - router.route(Method::GET, "/", |_req: Request| async { "ok" }); - router.middleware(SessionMiddleware::new().into_middleware()); - - let resp = router.dispatch(make_req(Method::GET, "/")).await; - assert_eq!(resp.status(), StatusCode::OK); - - let set_cookie = resp - .headers() - .get_all("set-cookie") - .iter() - .find(|v| v.to_str().unwrap().starts_with("tako_session=")); - assert!(set_cookie.is_some(), "session cookie should be set"); -} - #[cfg_attr(not(feature = "compio"), tokio::test)] #[cfg_attr(feature = "compio", compio::test)] async fn session_get_set_data() { diff --git a/tako-rs/tests/mount_all.rs b/tako-rs/tests/mount_all.rs index de677a68..f4830d01 100644 --- a/tako-rs/tests/mount_all.rs +++ b/tako-rs/tests/mount_all.rs @@ -83,9 +83,3 @@ async fn mount_all_registers_every_attribute_route() { assert_eq!(resp.status(), StatusCode::OK); assert_eq!(body_str(resp).await, "deleted=7"); } - -#[tokio::test] -async fn mount_all_returns_self_for_chaining() { - let mut router = Router::new(); - let _: &mut Router = router.mount_all(); -} diff --git a/tako-rs/tests/queue.rs b/tako-rs/tests/queue.rs index 88d33543..ab71bb97 100644 --- a/tako-rs/tests/queue.rs +++ b/tako-rs/tests/queue.rs @@ -175,37 +175,6 @@ async fn retry_policy_exhausted_goes_to_dlq() { queue.shutdown(Duration::from_secs(1)).await; } -#[tokio::test] -async fn delayed_job() { - let executed_at = Arc::new(tokio::sync::Mutex::new(None)); - let e = executed_at.clone(); - let pushed_at = std::time::Instant::now(); - - let queue = Queue::builder().workers(1).build(); - queue.register("delayed", move |_: Job| { - let e = e.clone(); - async move { - *e.lock().await = Some(std::time::Instant::now()); - Ok(()) - } - }); - queue.start(); - - queue - .push_delayed("delayed", &(), Duration::from_millis(200)) - .await - .unwrap(); - - tokio::time::sleep(Duration::from_millis(50)).await; - assert!(executed_at.lock().await.is_none()); - - tokio::time::sleep(Duration::from_millis(300)).await; - let at = executed_at.lock().await.unwrap(); - assert!(at.duration_since(pushed_at) >= Duration::from_millis(200)); - - queue.shutdown(Duration::from_secs(1)).await; -} - #[tokio::test] async fn pending_and_inflight_count() { let barrier = Arc::new(tokio::sync::Barrier::new(2)); diff --git a/tako-rs/tests/queue_v2.rs b/tako-rs/tests/queue_v2.rs index 8c2c202d..91ce519e 100644 --- a/tako-rs/tests/queue_v2.rs +++ b/tako-rs/tests/queue_v2.rs @@ -66,18 +66,3 @@ async fn memory_backend_dead_letter_path() { assert_eq!(dlq.len(), 1); assert_eq!(dlq[0].0, id); } - -#[tokio::test] -async fn memory_backend_fail_requeues_with_attempt_increment() { - let backend = MemoryBackend::new(); - let id = backend - .push("retryq", b"y", PushOptions::default()) - .await - .unwrap(); - let job = backend.reserve("retryq").await.unwrap().unwrap(); - assert_eq!(job.attempt, 0); - backend.fail(id, None).await.unwrap(); - let again = backend.reserve("retryq").await.unwrap().unwrap(); - assert_eq!(again.id, id); - assert_eq!(again.attempt, 1); -} diff --git a/tako-rs/tests/responder.rs b/tako-rs/tests/responder.rs index de40ee4c..8e360603 100644 --- a/tako-rs/tests/responder.rs +++ b/tako-rs/tests/responder.rs @@ -1,7 +1,6 @@ use http::StatusCode; use http_body_util::BodyExt; use tako::body::TakoBody; -use tako::responder::NOT_FOUND; use tako::responder::Responder; use tako::responder::StaticHeaders; @@ -57,13 +56,6 @@ async fn anyhow_err_response() { assert_eq!(body_str(resp).await, "Internal Server Error"); } -#[tokio::test] -async fn not_found_constant() { - let resp = NOT_FOUND.into_response(); - assert_eq!(resp.status(), StatusCode::NOT_FOUND); - assert_eq!(body_str(resp).await, "Not Found"); -} - #[tokio::test] async fn static_headers_response() { let resp = ( diff --git a/tako-rs/tests/router.rs b/tako-rs/tests/router.rs index 8a1b4bbd..9b20ba45 100644 --- a/tako-rs/tests/router.rs +++ b/tako-rs/tests/router.rs @@ -47,21 +47,6 @@ async fn route_miss_returns_404() { assert_eq!(resp.status(), StatusCode::NOT_FOUND); } -#[tokio::test] -async fn different_method_returns_405_with_allow() { - let mut router = Router::new(); - router.route(Method::GET, "/hello", |_req: Request| async { "Hello" }); - - let resp = router.dispatch(make_req(Method::POST, "/hello")).await; - assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED); - let allow = resp - .headers() - .get(http::header::ALLOW) - .and_then(|v| v.to_str().ok()) - .unwrap_or(""); - assert!(allow.split(',').map(str::trim).any(|m| m == "GET")); -} - #[tokio::test] async fn custom_fallback() { let mut router = Router::new(); diff --git a/tako-rs/tests/router/composition.rs b/tako-rs/tests/router/composition.rs index f66c38c8..b1fd4486 100644 --- a/tako-rs/tests/router/composition.rs +++ b/tako-rs/tests/router/composition.rs @@ -130,12 +130,6 @@ async fn scope_groups_routes_under_prefix() { assert_eq!(body_str(resp).await, "dashboard"); } -#[test] -fn routes_is_empty_for_a_new_router() { - let router = Router::new(); - assert!(router.routes().is_empty()); -} - #[test] fn routes_returns_every_registered_route() { let mut router = Router::new(); @@ -160,19 +154,6 @@ fn routes_returns_every_registered_route() { ); } -#[test] -fn routes_preserves_the_tsr_flag() { - let mut router = Router::new(); - router.route(Method::GET, "/plain", |_req: Request| async { "ok" }); - router.route_with_tsr(Method::GET, "/tsr", |_req: Request| async { "ok" }); - - let routes = router.routes(); - let plain = routes.iter().find(|r| r.path.as_ref() == "/plain").unwrap(); - let tsr = routes.iter().find(|r| r.path.as_ref() == "/tsr").unwrap(); - assert!(!plain.tsr); - assert!(tsr.tsr); -} - #[test] fn routes_reflect_scope_prefixes() { let mut router = Router::new(); diff --git a/tako-rs/tests/server_builder.rs b/tako-rs/tests/server_builder.rs index 9fa6d5f3..cf677a4e 100644 --- a/tako-rs/tests/server_builder.rs +++ b/tako-rs/tests/server_builder.rs @@ -53,13 +53,6 @@ async fn server_builder_handles_http_request() { handle.shutdown(Duration::from_secs(2)).await; } -#[tokio::test] -async fn server_builder_default_config_is_default() { - let server = Server::builder().build(); - assert_eq!(server.config().drain_timeout, Duration::from_secs(30)); - assert_eq!(server.config().h2_max_concurrent_streams, 100); -} - #[tokio::test] async fn server_builder_handles_raw_tcp_echo() { use tokio::io::AsyncReadExt as _; diff --git a/tako-rs/tests/sse_redirect_config.rs b/tako-rs/tests/sse_redirect_config.rs index 8735e1b8..f9eb46ad 100644 --- a/tako-rs/tests/sse_redirect_config.rs +++ b/tako-rs/tests/sse_redirect_config.rs @@ -100,20 +100,3 @@ async fn redirect_struct_methods() { assert_eq!(resp2.status(), StatusCode::MOVED_PERMANENTLY); assert_eq!(resp2.headers().get("location").unwrap(), "/b"); } - -#[test] -fn config_new_and_inner() { - use tako::config::Config; - - let config = Config::new(42u32); - assert_eq!(*config.inner(), 42); - assert_eq!(config.into_inner(), 42); -} - -#[test] -fn config_error_display() { - use tako::config::ConfigError; - - let err = ConfigError("missing field".to_string()); - assert_eq!(format!("{err}"), "configuration error: missing field"); -} diff --git a/tako-rs/tests/udp_tcp_progress.rs b/tako-rs/tests/udp_tcp_progress.rs index bf0021b9..f73bff79 100644 --- a/tako-rs/tests/udp_tcp_progress.rs +++ b/tako-rs/tests/udp_tcp_progress.rs @@ -13,17 +13,6 @@ fn progress_state_percent_normal() { assert_eq!(state.percent(), Some(50)); } -#[test] -fn progress_state_percent_complete() { - use tako::middleware::upload_progress::ProgressState; - - let state = ProgressState { - bytes_read: 100, - total_bytes: Some(100), - }; - assert_eq!(state.percent(), Some(100)); -} - #[test] fn progress_state_percent_zero_total() { use tako::middleware::upload_progress::ProgressState; @@ -177,99 +166,6 @@ async fn upload_progress_percent_via_tracker() { assert_eq!(body_str, "100"); } -#[tokio::test] -async fn upload_progress_min_notify_interval() { - use tako::Method; - use tako::middleware::IntoMiddleware; - use tako::middleware::upload_progress::UploadProgress; - use tako::responder::Responder; - use tako::router::Router; - use tako::types::Request; - - async fn handler(_req: Request) -> impl Responder { - "ok" - } - - let call_count = Arc::new(AtomicU64::new(0)); - let cc = call_count.clone(); - - let progress = UploadProgress::new() - .on_progress(move |_state| { - cc.fetch_add(1, Ordering::Relaxed); - }) - .min_notify_interval_bytes(1_000_000); // 1MB — well above our payload - let mw = progress.into_middleware(); - - let mut router = Router::new(); - router - .route(Method::POST, "/upload", handler) - .middleware(mw); - - let payload = vec![0u8; 100]; // 100 bytes — well below 1MB interval - let req = http::Request::builder() - .method("POST") - .uri("/upload") - .header("content-length", payload.len().to_string()) - .body(tako::body::TakoBody::from(payload)) - .unwrap(); - - let _resp = router.dispatch(req).await; - - // Below the interval only the final notification may fire. - let count = call_count.load(Ordering::Relaxed); - assert!(count <= 1, "expected at most 1 callback, got {count}"); -} - -// Under compio these servers hand out `!Send` compio sockets, which `tokio::spawn` rejects. -#[cfg(not(feature = "compio"))] -#[tokio::test] -async fn tcp_echo_server() { - use tako::server_tcp::serve_tcp_with_shutdown; - use tokio::io::AsyncReadExt; - use tokio::io::AsyncWriteExt; - - let (tx, rx) = tokio::sync::oneshot::channel::<()>(); - - // Finds a free port, then frees it for the server, which binds by address. - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); - let port = listener.local_addr().unwrap().port(); - drop(listener); - - let addr = format!("127.0.0.1:{port}"); - let addr_clone = addr.clone(); - - let server = tokio::spawn(async move { - serve_tcp_with_shutdown( - &addr_clone, - |mut stream, _addr| { - Box::pin(async move { - let mut buf = vec![0u8; 1024]; - let n = stream.read(&mut buf).await?; - stream.write_all(&buf[..n]).await?; - Ok(()) - }) - }, - async { - rx.await.ok(); - }, - ) - .await - .unwrap(); - }); - - tokio::time::sleep(std::time::Duration::from_millis(50)).await; - - let mut client = tokio::net::TcpStream::connect(&addr).await.unwrap(); - client.write_all(b"hello tcp").await.unwrap(); - - let mut buf = vec![0u8; 1024]; - let n = client.read(&mut buf).await.unwrap(); - assert_eq!(&buf[..n], b"hello tcp"); - - tx.send(()).unwrap(); - server.await.unwrap(); -} - #[cfg(not(feature = "compio"))] #[tokio::test] async fn tcp_server_multiple_connections() { @@ -329,50 +225,6 @@ async fn tcp_server_multiple_connections() { server.await.unwrap(); } -#[cfg(not(feature = "compio"))] -#[cfg(feature = "udp")] -#[tokio::test] -async fn udp_echo_server() { - use tako::server_udp::serve_udp_with_shutdown; - - let (tx, rx) = tokio::sync::oneshot::channel::<()>(); - - let sock = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap(); - let port = sock.local_addr().unwrap().port(); - drop(sock); - - let addr = format!("127.0.0.1:{port}"); - let addr_clone = addr.clone(); - - let server = tokio::spawn(async move { - serve_udp_with_shutdown( - &addr_clone, - |data, peer, socket| { - Box::pin(async move { - let _ = socket.send_to(&data, peer).await; - }) - }, - async { - rx.await.ok(); - }, - ) - .await - .unwrap(); - }); - - tokio::time::sleep(std::time::Duration::from_millis(50)).await; - - let client = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap(); - client.send_to(b"hello udp", &addr).await.unwrap(); - - let mut buf = vec![0u8; 1024]; - let (n, _) = client.recv_from(&mut buf).await.unwrap(); - assert_eq!(&buf[..n], b"hello udp"); - - tx.send(()).unwrap(); - server.await.unwrap(); -} - #[cfg(not(feature = "compio"))] #[cfg(feature = "udp")] #[tokio::test] From 0a27ae9ebf07caf647b20cb4f2fd3a99f1aa3a4f Mon Sep 17 00:00:00 2001 From: Daniel Boros Date: Tue, 10 Nov 2026 23:26:18 +0100 Subject: [PATCH 2/2] fix: address beta clippy warnings --- tako-rs-core/src/server_support/driver.rs | 2 +- tako-rs-server/src/builder/tls_cert.rs | 9 +++------ 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/tako-rs-core/src/server_support/driver.rs b/tako-rs-core/src/server_support/driver.rs index a5153051..7e096160 100644 --- a/tako-rs-core/src/server_support/driver.rs +++ b/tako-rs-core/src/server_support/driver.rs @@ -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); } diff --git a/tako-rs-server/src/builder/tls_cert.rs b/tako-rs-server/src/builder/tls_cert.rs index 754a46d1..1cdb2c09 100644 --- a/tako-rs-server/src/builder/tls_cert.rs +++ b/tako-rs-server/src/builder/tls_cert.rs @@ -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(|| {