test: Replace wall-clock with SimClock in activity tests

Author: tomasol

crates/wasm-workers/src/activity/activity_js_worker.rs

@@ -308,6 +308,7 @@ mod tests {
     use executor::worker::{WorkerContext, WorkerError, WorkerResultOk};
     use rstest::rstest;
     use serde_json::json;
+    use test_utils::sim_clock::SimClock;
     use tokio::sync::mpsc;
     use tracing::info_span;
     use val_json::wast_val::WastVal;
@@ -319,6 +320,7 @@ mod tests {
         user_return_type: ReturnTypeExtendable,
         allowed_hosts: Vec<crate::http_request_policy::AllowedHostConfig>,
         logs_storage_config: Option<crate::component_logger::LogStrageConfig>,
+        clock_fn: Box<dyn ClockFn>,
     }
 
     impl JsWorkerBuilder {
@@ -340,6 +342,7 @@ mod tests {
                 },
                 allowed_hosts: Vec::new(),
                 logs_storage_config: None,
+                clock_fn: Now.clone_box(),
             }
         }
 
@@ -371,12 +374,16 @@ mod tests {
             self
         }
 
+        fn with_clock_fn(mut self, clock_fn: Box<dyn ClockFn>) -> Self {
+            self.clock_fn = clock_fn;
+            self
+        }
+
         async fn build(self) -> Arc<dyn Worker> {
             let engine =
                 Engines::get_activity_engine_test(EngineConfig::on_demand_testing()).unwrap();
             let cancel_registry = CancelRegistry::new();
             let (db_forwarder_sender, _) = mpsc::channel(1);
-            let clock_fn: Box<dyn ClockFn> = Now.clone_box();
 
             let component_id = concepts::ComponentId::new(
                 ComponentType::Activity,
@@ -406,7 +413,7 @@ mod tests {
                 wasm_component,
                 config,
                 engine,
-                clock_fn,
+                self.clock_fn,
                 std::sync::Arc::new(TokioSleep),
             )
             .unwrap();
@@ -1207,6 +1214,7 @@ mod tests {
         js_source: &str,
         user_ffqn: FunctionFqn,
         listener: &std::net::TcpListener,
+        clock_fn: Box<dyn ClockFn>,
     ) -> Arc<dyn Worker> {
         let server_address = listener
             .local_addr()
@@ -1222,6 +1230,7 @@ mod tests {
         JsWorkerBuilder::new(js_source, user_ffqn)
             .with_params(user_params)
             .with_allowed_host(&allowed_host)
+            .with_clock_fn(clock_fn)
             .build()
             .await
     }
@@ -1255,12 +1264,19 @@ mod tests {
         "#;
 
         let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
-        let worker =
-            new_js_activity_worker_for_retry_test(js_source, ffqn.clone(), &listener).await;
+        let sim_clock = SimClock::epoch();
+        let worker = new_js_activity_worker_for_retry_test(
+            js_source,
+            ffqn.clone(),
+            &listener,
+            sim_clock.clone_box(),
+        )
+        .await;
 
         run_http_get_retry_test(
             listener,
             worker,
+            sim_clock,
             ffqn,
             |uri| Params::from_json_values_test(vec![json!(format!("{uri}/"))]),
             locking_strategy,

crates/wasm-workers/src/activity/activity_worker.rs

@@ -741,9 +741,11 @@ pub(crate) mod tests {
     /// 1. An activity that returns an error (from a 500 response) triggers a temporary failure with backoff
     /// 2. After the backoff expires, the activity is retried
     /// 3. On retry, either succeeds (if `succeed_eventually` is true) or fails permanently
+    #[expect(clippy::too_many_arguments)]
     pub(crate) async fn run_http_get_retry_test(
         listener: std::net::TcpListener,
         worker: Arc<dyn Worker>,
+        sim_clock: SimClock,
         ffqn: FunctionFqn,
         make_params: impl FnOnce(&str) -> Params,
         locking_strategy: LockingStrategy,
@@ -759,7 +761,6 @@ pub(crate) mod tests {
         const BODY: &str = "ok";
         const RETRY_EXP_BACKOFF: Duration = Duration::from_millis(10);
 
-        let sim_clock = SimClock::default();
         let (_guard, db_pool, db_close) = Database::Sqlite.set_up().await;
 
         let server_address = listener
@@ -935,25 +936,20 @@ pub(crate) mod tests {
     pub(crate) async fn create_activity_worker_with_allowed_host(
         wasm_path: &str,
         listener: &std::net::TcpListener,
+        clock_fn: Box<dyn ClockFn>,
     ) -> Arc<dyn Worker> {
         let engine = Engines::get_activity_engine_test(EngineConfig::on_demand_testing()).unwrap();
-        let sim_clock = SimClock::default();
         let server_address = listener
             .local_addr()
             .expect("Failed to get server address.");
         let uri = format!("http://127.0.0.1:{port}", port = server_address.port());
 
-        let (worker, _) = new_activity_worker_with_config(
-            wasm_path,
-            engine,
-            sim_clock.clone_box(),
-            TokioSleep,
-            {
+        let (worker, _) =
+            new_activity_worker_with_config(wasm_path, engine, clock_fn, TokioSleep, {
                 let uri = uri.clone();
                 move |component_id| activity_config_allowed_host(component_id, &uri)
-            },
-        )
-        .await;
+            })
+            .await;
         worker
     }
 
@@ -1611,15 +1607,18 @@ pub(crate) mod tests {
         test_utils::set_up();
 
         let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        let sim_clock = SimClock::epoch();
         let worker = create_activity_worker_with_allowed_host(
             test_programs_http_get_activity_builder::TEST_PROGRAMS_HTTP_GET_ACTIVITY,
             &listener,
+            sim_clock.clone_box(),
         )
         .await;
 
         run_http_get_retry_test(
             listener,
             worker,
+            sim_clock,
             HTTP_GET_SUCCESSFUL_ACTIVITY,
             |uri| Params::from_json_values_test(vec![json!(uri)]),
             locking_strategy,