refactor(tick): align API with Rust guidelines

crates/fetch/src/fake.rs

@@ -172,7 +172,10 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[test]
     fn fake_builder_custom_clock() {
-        let clock = tick::ClockControl::new().auto_advance(Duration::from_secs(2)).to_clock();
+        let clock = tick::ClockControl::builder()
+            .auto_advance(Duration::from_secs(2))
+            .build()
+            .to_clock();
 
         let _client = HttpClient::builder_fake(FakeHandler::never_completes(), &clock)
             .custom_pipeline(|root, ctx| {

crates/fetch/tests/resilience.rs

@@ -65,7 +65,7 @@ async fn retry_defaults_restore_requests() {
         let index = req.extensions().get::<Attempt>().copied().unwrap().index();
         HttpError::unavailable(format!("unavailable-{index}")).with_request(req)
     });
-    let clock = ClockControl::default().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     let client = HttpClient::builder_fake(handler, FakeDeps { clock })
         .custom_pipeline(move |dispatch, context| {
             let layer = HttpRetry::layer("dummy", context.resilience_context())
@@ -101,7 +101,7 @@ async fn retry_defaults_non_cloneable_body() {
 }
 
 fn create_retry_client(status: StatusCode) -> HttpClient {
-    let clock = ClockControl::default().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     HttpClient::builder_fake(status, FakeDeps { clock })
         .custom_pipeline(move |dispatch, context| {
             let layer = HttpRetry::layer("dummy", context.resilience_context())
@@ -166,7 +166,7 @@ async fn breaker_rejected_request_error_attaches_request() {
 
 fn create_breaker_client(status: StatusCode) -> HttpClient {
     let handler = FakeHandler::from(HttpResponseBuilder::new_fake().status(status).build().unwrap());
-    let clock = ClockControl::default().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     HttpClient::builder_fake(handler, FakeDeps { clock })
         .custom_pipeline(move |dispatch, context| {
             let layer = HttpBreaker::layer("test", context.resilience_context())

crates/fetch/tests/standard_pipeline.rs

@@ -72,7 +72,7 @@ fn create_per_host_client(calls: Calls) -> HttpClient {
         HttpResponseBuilder::new_fake().status(status).build()
     });
 
-    let clock = ClockControl::default().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     HttpClient::builder_fake(handler, FakeDeps { clock })
         .standard_pipeline(|pipeline, _| {
             pipeline
@@ -98,7 +98,7 @@ fn create_uniform_client(status: StatusCode, calls: Calls) -> HttpClient {
         HttpResponseBuilder::new_fake().status(status).build()
     });
 
-    let clock = ClockControl::default().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     HttpClient::builder_fake(handler, FakeDeps { clock })
         .standard_pipeline(|pipeline, _| {
             pipeline
@@ -284,7 +284,7 @@ const HEDGING_DELAY: Duration = Duration::from_millis(100);
 /// Creates a hedging client whose handler returns status codes from the
 /// given iterator in order.
 fn create_hedging_client(calls: Calls, responses: Vec<StatusCode>) -> HttpClient {
-    let clock = ClockControl::default().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     let responses = Arc::new(std::sync::Mutex::new(responses.into_iter()));
 
     let handler = FakeHandler::from_fn(move |_req| {
@@ -368,7 +368,7 @@ async fn fallback_router_recovers_when_primary_is_unavailable() {
         other => panic!("unexpected host: {other:?}"),
     });
 
-    let clock = ClockControl::default().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     let client = HttpClient::builder_fake(handler, FakeDeps { clock })
         .router(Router::fallback(
             BaseUri::from_static("https://primary.example.com/"),

crates/fetch/tests/timeout.rs

@@ -15,7 +15,7 @@ use tick::ClockControl;
 #[tokio::test]
 async fn response_timeout() {
     let handler = FakeHandler::never_completes();
-    let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+    let clock = ClockControl::new_auto_advancing().to_clock();
     let client = HttpClient::builder_fake(handler, FakeDeps { clock }).minimal_pipeline().build();
 
     let err = client

crates/fetch_hyper/src/builder.rs

@@ -100,9 +100,7 @@ where
 /// let transport: HyperTransport = HyperTransportBuilder::new(
 ///     Execute::new(connect),
 ///     Spawner::new_tokio(),
-///     tick::ClockControl::new()
-///         .auto_advance_timers(true)
-///         .to_clock(),
+///     tick::ClockControl::new_auto_advancing().to_clock(),
 ///     TransportOptions::default(),
 /// )
 /// .build(tls);
@@ -299,9 +297,9 @@ mod tests {
 
     fn make_builder_with(options: TransportOptions) -> HyperTransportBuilder<FakeConnector, crate::testing::FakeStream> {
         HyperTransportBuilder::new(
-            FakeConnector::new_success(Bytes::new(), tick::ClockControl::new().auto_advance_timers(true).to_clock()),
+            FakeConnector::new_success(Bytes::new(), tick::ClockControl::new_auto_advancing().to_clock()),
             Spawner::new_tokio(),
-            tick::ClockControl::new().auto_advance_timers(true).to_clock(),
+            tick::ClockControl::new_auto_advancing().to_clock(),
             options,
         )
     }
@@ -392,7 +390,7 @@ mod tests {
     async fn build_with_explicit_meter_yields_working_transport() {
         let provider = SdkMeterProvider::builder().build();
         let response_bytes = Bytes::from_static(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let handler = HyperTransportBuilder::new(
             FakeConnector::new_success(response_bytes, clock.clone()),
             Spawner::new_tokio(),
@@ -412,7 +410,7 @@ mod tests {
         // We can't easily inspect hyper's internal flag, but we can at least
         // exercise the build path with HTTP/2-only configuration to confirm
         // it succeeds without panicking.
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let mut options = TransportOptions::default();
         options.supported_http_versions = vec![Version::HTTP_2];
         let _handler = HyperTransportBuilder::new(
@@ -428,7 +426,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn hyper_transport_clones_share_underlying_service() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let response_bytes = Bytes::from_static(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
         let handler = HyperTransportBuilder::new(
             FakeConnector::new_success(response_bytes, clock.clone()),
@@ -447,7 +445,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn hyper_transport_into_dynamic_service_executes_request() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let response_bytes = Bytes::from_static(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
         let handler = HyperTransportBuilder::new(
             FakeConnector::new_success(response_bytes, clock.clone()),
@@ -470,7 +468,7 @@ mod tests {
         // is provided, `build` synthesizes one and still produces a working
         // transport.
         let response_bytes = Bytes::from_static(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let handler = HyperTransportBuilder::new(
             FakeConnector::new_success(response_bytes, clock.clone()),
             Spawner::new_tokio(),

crates/fetch_hyper/src/connection/client_connector.rs

@@ -334,7 +334,7 @@ mod tests {
             .f64_histogram("http.client.connection.setup.duration")
             .build();
 
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_success(Bytes::new(), clock.clone());
         let base = BaseUri::from_static("http://example.com");
         let result = connect_with_timeout(
@@ -361,7 +361,7 @@ mod tests {
             .f64_histogram("http.client.connection.setup.duration")
             .build();
 
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_connect_failure(TestError::new("boom"), clock.clone());
         let base = BaseUri::from_static("http://example.com");
         let err = connect_with_timeout(
@@ -389,7 +389,7 @@ mod tests {
             .f64_histogram("http.client.connection.setup.duration")
             .build();
 
-        let control = tick::ClockControl::new().auto_advance_timers(true);
+        let control = tick::ClockControl::new_auto_advancing();
         let clock = control.to_clock();
         let base = BaseUri::from_static("http://example.com");
         // pending() never resolves, so the timeout always wins.
@@ -411,7 +411,7 @@ mod tests {
 
         use crate::testing::FakeConnector;
 
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_success(Bytes::new(), clock.clone());
         let provider = SdkMeterProvider::builder().build();
         let meter = provider.meter("test");
@@ -436,7 +436,7 @@ mod tests {
 
         use crate::testing::FakeConnector;
 
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_success(Bytes::new(), clock.clone());
         let provider = SdkMeterProvider::builder().build();
         let meter = provider.meter("test");

crates/fetch_hyper/src/connection/hyper_connector_adapter.rs

@@ -81,7 +81,7 @@ mod tests {
     async fn call_translates_uri_into_base_uri_and_invokes_connector() {
         let mut adapter = HyperConnectorAdapter::new(FakeConnector::new_success(
             Bytes::from_static(b""),
-            tick::ClockControl::new().auto_advance_timers(true).to_clock(),
+            tick::ClockControl::new_auto_advancing().to_clock(),
         ));
         adapter.call(Uri::from_static("https://example.com/")).await.unwrap();
     }
@@ -91,7 +91,7 @@ mod tests {
     async fn call_propagates_invalid_uri_error() {
         let mut adapter = HyperConnectorAdapter::new(FakeConnector::new_success(
             Bytes::from_static(b""),
-            tick::ClockControl::new().auto_advance_timers(true).to_clock(),
+            tick::ClockControl::new_auto_advancing().to_clock(),
         ));
         // A relative URI (no scheme/authority) is not a valid BaseUri.
         adapter

crates/fetch_hyper/src/connection/hyper_handler.rs

@@ -209,7 +209,7 @@ mod tests {
     }
 
     fn make_handler(connector: FakeConnector, lifetime: ConnectionLifetime) -> HyperTransport {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let mut options = fetch_options::TransportOptions::default();
         options.request_filter = RequestFilter::HttpAndHttps;
         options.connection_pool.connection_lifetime = lifetime;
@@ -228,7 +228,7 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn debug_renders_handler_type() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_success(http_response_bytes(), clock.clone());
         let mut options = fetch_options::TransportOptions::default();
         options.request_filter = RequestFilter::HttpAndHttps;
@@ -248,7 +248,7 @@ mod tests {
         // The byte stream is not a valid HTTP/1 response, so hyper's client
         // request future fails with a `legacy::Error`, exercising
         // `create_http_error_from_hyper_util`.
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_success(Bytes::from_static(b"NOT A VALID HTTP RESPONSE"), clock.clone());
         let handler = make_handler(connector, ConnectionLifetime::unlimited());
         let err = handler.execute(test_request()).await.expect_err("expected error");
@@ -261,7 +261,7 @@ mod tests {
         // Builder with HTTP/2-only flips `http2_only(true)` on hyper's builder.
         // Using FakeStream over HTTP/1.1-style data will fail, but we want to
         // simply exercise the build path and request execution.
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_success(http_response_bytes(), clock.clone());
         let mut options = fetch_options::TransportOptions::default();
         options.request_filter = RequestFilter::HttpAndHttps;
@@ -320,7 +320,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn end_to_end_response_is_returned_with_body() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_success(http_response_bytes(), clock.clone());
         let handler = make_handler(connector, ConnectionLifetime::unlimited());
         let resp = handler.execute(test_request()).await.unwrap();

crates/fetch_hyper/src/testing.rs

@@ -374,7 +374,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn fake_connector_serves_canned_response() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let mut options = fetch_options::TransportOptions::default();
         options.request_filter = RequestFilter::HttpAndHttps;
         let handler = HyperTransportBuilder::new(
@@ -396,7 +396,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn fake_connector_propagates_connect_failure() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let mut options = fetch_options::TransportOptions::default();
         options.request_filter = RequestFilter::HttpAndHttps;
         options.connect_timeout = Duration::from_secs(5);
@@ -427,7 +427,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn https_only_filter_rejects_http_request() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let handler = HyperTransportBuilder::new(
             FakeConnector::new_success(http_1_response(), clock.clone()),
             Spawner::new_tokio(),

crates/fetch_hyper/src/timer.rs

@@ -56,7 +56,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn sleep_advances_by_duration() {
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let timer = ClockTimer::new(clock.clone());
 
         let watch = clock.stopwatch();
@@ -67,7 +67,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn sleep_until_advances_to_deadline() {
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let timer = ClockTimer::new(clock.clone());
         let now = clock.instant();
 
@@ -79,7 +79,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn sleep_until_past_deadline_returns_immediately() {
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let timer = ClockTimer::new(clock.clone());
 
         let watch = clock.stopwatch();

crates/fetch_hyper/src/tls/connector.rs

@@ -331,7 +331,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn execute_native_tls_propagates_connector_error() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_connect_failure(TestError::new("fail"), clock);
         let c: TlsConnector<FakeConnector, FakeStream> =
             TlsConnector::new(native_tls_backend(), connector, RequestFilter::HttpAndHttps, &[Version::HTTP_11]);
@@ -345,7 +345,7 @@ mod tests {
     #[cfg_attr(miri, ignore)]
     #[tokio::test]
     async fn execute_rustls_propagates_connector_error() {
-        let clock = tick::ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = tick::ClockControl::new_auto_advancing().to_clock();
         let connector = FakeConnector::new_connect_failure(TestError::new("fail-rustls"), clock);
         let c: TlsConnector<FakeConnector, FakeStream> = TlsConnector::new(
             rustls_backend(),

crates/fetch_hyper/tests/smoke.rs

@@ -41,7 +41,7 @@ fn build_tls() -> TlsBackend {
 }
 
 fn test_clock() -> Clock {
-    ClockControl::new().auto_advance_timers(true).to_clock()
+    ClockControl::new_auto_advancing().to_clock()
 }
 
 /// Builds [`TransportOptions`] with `HttpAndHttps`, a 5s connect timeout, and

crates/http_extensions/src/body/timeout_body.rs

@@ -120,7 +120,7 @@ mod tests {
 
     #[test]
     fn stream_body_times_out_when_pending() {
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let builder = HttpBodyBuilder::new(GlobalPool::new(), &clock);
 
         // A body that never yields data.
@@ -135,7 +135,7 @@ mod tests {
 
     #[test]
     fn body_timeout_chains_with_buffer_limit() {
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let builder = HttpBodyBuilder::new(GlobalPool::new(), &clock).with_options(HttpBodyOptions::default().buffer_limit(1024));
 
         assert_eq!(builder.options, HttpBodyOptions::default().buffer_limit(1024));
@@ -209,7 +209,7 @@ mod tests {
 
     #[test]
     fn poll_frame_times_out_when_pending_with_short_timeout() {
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let builder = HttpBodyBuilder::new(GlobalPool::new(), &clock);
 
         // A body that never yields data with a very short timeout.
@@ -273,7 +273,7 @@ mod tests {
 
     #[test]
     fn poll_frame_returns_error_after_timeout() {
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let timeout = Duration::from_millis(50);
 
         let mut timeout_body = super::TimeoutBody::new(PendingBody, timeout, &clock);

crates/http_extensions/src/fake_handler.rs

@@ -481,7 +481,7 @@ mod tests {
     #[test]
     fn never_completes_handler() {
         let handler = FakeHandler::never_completes();
-        let clock = ClockControl::new().auto_advance_timers(true).to_clock();
+        let clock = ClockControl::new_auto_advancing().to_clock();
         let error = block_on(
             handler
                 .request_builder()