Reduce duplication and improve readability across codebase

- Extract test_route() helper in lib.rs to replace repeated Route struct literals
- Extract create_client() helper in integration tests to replace 15 identical ClientBuilder chains
- Extract single_thread_rt() helper in benchmarks to deduplicate tokio runtime creation
- Simplify catch-all route warning from two-pass collect+iterate to single-pass O(n)
- Replace magic `/ 2` jitter divisor with named JITTER_FRACTION_DENOM constant
- Use consistent let-chain style for host matching, matching the method check pattern

Author: Haut

benches/throughput.rs

@@ -4,6 +4,13 @@ use route_ratelimit::{RateLimitMiddleware, ThrottleBehavior};
 use std::sync::Arc;
 use std::time::Duration;
 
+fn single_thread_rt() -> tokio::runtime::Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap()
+}
+
 /// Benchmark the full check_and_apply_limits path with varying route counts.
 fn bench_check_and_apply_limits(c: &mut Criterion) {
     let mut group = c.benchmark_group("check_and_apply_limits");
@@ -30,10 +37,7 @@ fn bench_check_and_apply_limits(c: &mut Criterion) {
             BenchmarkId::new("routes", route_count),
             &route_count,
             |b, _| {
-                let rt = tokio::runtime::Builder::new_current_thread()
-                    .enable_time()
-                    .build()
-                    .unwrap();
+                let rt = single_thread_rt();
                 b.iter(|| {
                     rt.block_on(async { black_box(middleware.check_and_apply_limits(&req).await) })
                 })
@@ -120,10 +124,7 @@ fn bench_stacked_limits(c: &mut Criterion) {
             BenchmarkId::new("limits", limit_count),
             &limit_count,
             |b, _| {
-                let rt = tokio::runtime::Builder::new_current_thread()
-                    .enable_time()
-                    .build()
-                    .unwrap();
+                let rt = single_thread_rt();
                 b.iter(|| {
                     rt.block_on(async { black_box(middleware.check_and_apply_limits(&req).await) })
                 })

src/builder.rs

@@ -142,35 +142,22 @@ impl RateLimitBuilder {
     /// Emit a warning if catch-all routes precede more specific routes.
     #[cfg(feature = "tracing")]
     fn warn_catch_all_route_order(&self) {
-        // Collect indices of all catch-all routes
-        let catch_all_indices: Vec<usize> = self
-            .routes
-            .iter()
-            .enumerate()
-            .filter(|(_, route)| route.is_catch_all())
-            .map(|(i, _)| i)
-            .collect();
-
-        // For each catch-all, warn about specific routes that follow it
-        for &catch_all_index in &catch_all_indices {
-            // Find the first specific route after this catch-all
-            if let Some((specific_index, _)) = self
-                .routes
-                .iter()
-                .enumerate()
-                .skip(catch_all_index + 1)
-                .find(|(_, route)| !route.is_catch_all())
-            {
+        let mut last_catch_all = None;
+        for (i, route) in self.routes.iter().enumerate() {
+            if route.is_catch_all() {
+                last_catch_all = Some(i);
+            } else if let Some(catch_all_index) = last_catch_all {
                 tracing::warn!(
                     catch_all_route_index = catch_all_index,
-                    specific_route_index = specific_index,
+                    specific_route_index = i,
                     "Catch-all route (index {}) precedes more specific route (index {}). \
                      All matching routes' limits are applied, so the catch-all will affect \
                      requests intended for the specific route. Consider reordering routes \
                      or using host-scoped builders.",
                     catch_all_index,
-                    specific_index
+                    i
                 );
+                last_catch_all = None;
             }
         }
     }

src/lib.rs

@@ -93,15 +93,19 @@ mod tests {
     use http::Method;
     use std::time::Duration;
 
-    #[test]
-    fn test_route_matching_all() {
-        let route = Route {
-            host: None,
-            method: None,
-            path_prefix: String::new(),
+    fn test_route(host: Option<&str>, method: Option<Method>, path: &str) -> Route {
+        Route {
+            host: host.map(String::from),
+            method,
+            path_prefix: path.to_string(),
             limits: vec![],
             on_limit: ThrottleBehavior::Delay,
-        };
+        }
+    }
+
+    #[test]
+    fn test_route_matching_all() {
+        let route = test_route(None, None, "");
 
         let req = reqwest::Client::new()
             .get("https://example.com/test")
@@ -113,13 +117,7 @@ mod tests {
 
     #[test]
     fn test_route_matching_host() {
-        let route = Route {
-            host: Some("api.example.com".to_string()),
-            method: None,
-            path_prefix: String::new(),
-            limits: vec![],
-            on_limit: ThrottleBehavior::Delay,
-        };
+        let route = test_route(Some("api.example.com"), None, "");
 
         let req_match = reqwest::Client::new()
             .get("https://api.example.com/test")
@@ -136,13 +134,7 @@ mod tests {
 
     #[test]
     fn test_route_matching_method() {
-        let route = Route {
-            host: None,
-            method: Some(Method::POST),
-            path_prefix: String::new(),
-            limits: vec![],
-            on_limit: ThrottleBehavior::Delay,
-        };
+        let route = test_route(None, Some(Method::POST), "");
 
         let req_match = reqwest::Client::new()
             .post("https://example.com/test")
@@ -159,13 +151,7 @@ mod tests {
 
     #[test]
     fn test_route_matching_path_prefix() {
-        let route = Route {
-            host: None,
-            method: None,
-            path_prefix: "/api/v1".to_string(),
-            limits: vec![],
-            on_limit: ThrottleBehavior::Delay,
-        };
+        let route = test_route(None, None, "/api/v1");
 
         let req_match = reqwest::Client::new()
             .get("https://example.com/api/v1/users")
@@ -182,13 +168,7 @@ mod tests {
 
     #[test]
     fn test_route_matching_path_segment_boundary() {
-        let route = Route {
-            host: None,
-            method: None,
-            path_prefix: "/order".to_string(),
-            limits: vec![],
-            on_limit: ThrottleBehavior::Delay,
-        };
+        let route = test_route(None, None, "/order");
 
         // Should match: exact, with trailing slash, with sub-path
         let req_exact = reqwest::Client::new()

src/middleware.rs

@@ -14,6 +14,9 @@ use crate::error::RateLimitError;
 use crate::gcra::GcraState;
 use crate::types::{Route, ThrottleBehavior};
 
+/// Jitter adds up to 50% of the wait duration (denominator of the fraction).
+const JITTER_FRACTION_DENOM: u128 = 2;
+
 /// The rate limiting middleware.
 ///
 /// This middleware tracks rate limits and either delays or rejects requests
@@ -112,9 +115,10 @@ impl RateLimitMiddleware {
     ) -> Result<(), RateLimitError> {
         match route.on_limit {
             ThrottleBehavior::Delay => {
-                // Add jitter (0-50% of wait duration) to prevent thundering herd
+                // Add jitter to prevent thundering herd
                 let jitter_max_nanos =
-                    u64::try_from(wait_duration.as_nanos() / 2).unwrap_or(u64::MAX);
+                    u64::try_from(wait_duration.as_nanos() / JITTER_FRACTION_DENOM)
+                        .unwrap_or(u64::MAX);
                 let jitter_nanos = if jitter_max_nanos > 0 {
                     rand::rng().random_range(0..=jitter_max_nanos)
                 } else {

src/types.rs

@@ -158,11 +158,10 @@ impl Route {
         req_path: &str,
     ) -> bool {
         // Check host
-        if let Some(ref host) = self.host {
-            match req_host {
-                Some(h) if h == host => {}
-                _ => return false,
-            }
+        if let Some(ref host) = self.host
+            && req_host != Some(host.as_str())
+        {
+            return false;
         }
 
         // Check method