temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/tests/integ_tests/workflow_tests/replay.rs

@@ -1,6 +1,8 @@
 use assert_matches::assert_matches;
-use std::time::Duration;
-use temporal_sdk::{WfContext, Worker, WorkflowFunction};
+use parking_lot::Mutex;
+use std::{collections::HashSet, sync::Arc, time::Duration};
+use temporal_sdk::{interceptors::WorkerInterceptor, WfContext, Worker, WorkflowFunction};
+use temporal_sdk_core::replay::{HistoryFeeder, HistoryForReplay};
 use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -8,20 +10,29 @@ use temporal_sdk_core_protos::{
         workflow_commands::{ScheduleActivity, StartTimer},
         workflow_completion::WorkflowActivationCompletion,
     },
-    DEFAULT_WORKFLOW_TYPE,
+    TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    canned_histories, history_from_proto_binary, init_core_replay_preloaded, WorkerTestHelpers,
+    canned_histories, history_from_proto_binary, init_core_replay_preloaded, replay_sdk_worker,
+    replay_sdk_worker_stream, WorkerTestHelpers,
 };
 use tokio::join;
 
+fn test_hist_to_replay(t: TestHistoryBuilder) -> HistoryForReplay {
+    let hi = t.get_full_history_info().unwrap().into();
+    HistoryForReplay::new(hi, "fake".to_string())
+}
+
 #[tokio::test]
 async fn timer_workflow_replay() {
-    let (core, _) = init_core_replay_preloaded(
+    let core = init_core_replay_preloaded(
         "timer_workflow_replay",
-        &history_from_proto_binary("histories/timer_workflow_history.bin")
-            .await
-            .unwrap(),
+        [HistoryForReplay::new(
+            history_from_proto_binary("histories/timer_workflow_history.bin")
+                .await
+                .unwrap(),
+            "fake".to_owned(),
+        )],
     );
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
@@ -43,6 +54,14 @@ async fn timer_workflow_replay() {
         );
     };
     let poll_fut = async {
+        let evict_task = core
+            .poll_workflow_activation()
+            .await
+            .expect("Should be an eviction activation");
+        assert!(evict_task.eviction_reason().is_some());
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(evict_task.run_id))
+            .await
+            .unwrap();
         assert_matches!(
             core.poll_workflow_activation().await,
             Err(PollWfError::ShutDown)
@@ -64,11 +83,14 @@ async fn timer_workflow_replay() {
 
 #[tokio::test]
 async fn workflow_nondeterministic_replay() {
-    let (core, _) = init_core_replay_preloaded(
+    let core = init_core_replay_preloaded(
         "timer_workflow_replay",
-        &history_from_proto_binary("histories/timer_workflow_history.bin")
-            .await
-            .unwrap(),
+        [HistoryForReplay::new(
+            history_from_proto_binary("histories/timer_workflow_history.bin")
+                .await
+                .unwrap(),
+            "fake".to_owned(),
+        )],
     );
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
@@ -102,29 +124,85 @@ async fn replay_using_wf_function() {
     let num_timers = 10;
     let t = canned_histories::long_sequential_timers(num_timers as usize);
     let func = timers_wf(num_timers);
-    let (worker, _) =
-        init_core_replay_preloaded("replay_bench", &t.get_full_history_info().unwrap().into());
-    let mut worker = Worker::new_from_core(worker, "replay_bench".to_string());
+    let mut worker = replay_sdk_worker([test_hist_to_replay(t)]);
     worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
     worker.run().await.unwrap();
 }
 
+async fn replay_abrupt_ending(t: TestHistoryBuilder) {
+    let func = timers_wf(1);
+    let mut worker = replay_sdk_worker([test_hist_to_replay(t)]);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    worker.run().await.unwrap();
+}
 #[tokio::test]
-async fn replay_ok_ending_with_terminated_or_timed_out() {
+async fn replay_ok_ending_with_terminated() {
     let mut t1 = canned_histories::single_timer("1");
     t1.add_workflow_execution_terminated();
+    replay_abrupt_ending(t1).await;
+}
+#[tokio::test]
+async fn replay_ok_ending_with_timed_out() {
     let mut t2 = canned_histories::single_timer("1");
     t2.add_workflow_execution_timed_out();
-    for t in [t1, t2] {
-        let func = timers_wf(1);
-        let (worker, _) = init_core_replay_preloaded(
-            "replay_ok_terminate",
-            &t.get_full_history_info().unwrap().into(),
-        );
-        let mut worker = Worker::new_from_core(worker, "replay_ok_terminate".to_string());
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    replay_abrupt_ending(t2).await;
+}
+
+#[rstest::rstest]
+#[tokio::test]
+async fn multiple_histories_replay(#[values(false, true)] use_feeder: bool) {
+    let num_timers = 10;
+    let seq_timer_wf = timers_wf(num_timers);
+    let one_timer_wf = timers_wf(1);
+    let mut one_timer_hist = canned_histories::single_timer("1");
+    one_timer_hist.set_wf_type("onetimer");
+    let mut seq_timer_hist = canned_histories::long_sequential_timers(num_timers as usize);
+    seq_timer_hist.set_wf_type("seqtimer");
+    let (feeder, stream) = HistoryFeeder::new(1);
+    let mut worker = if use_feeder {
+        replay_sdk_worker_stream(stream)
+    } else {
+        replay_sdk_worker([
+            test_hist_to_replay(one_timer_hist.clone()),
+            test_hist_to_replay(seq_timer_hist.clone()),
+        ])
+    };
+    let runs_ctr_i = UniqueRunsCounter::default();
+    let runs_ctr = runs_ctr_i.runs.clone();
+    worker.set_worker_interceptor(Box::new(runs_ctr_i));
+    worker.register_wf("onetimer", one_timer_wf);
+    worker.register_wf("seqtimer", seq_timer_wf);
+
+    if use_feeder {
+        let feed_fut = async move {
+            feeder
+                .feed(test_hist_to_replay(one_timer_hist))
+                .await
+                .unwrap();
+            feeder
+                .feed(test_hist_to_replay(seq_timer_hist))
+                .await
+                .unwrap();
+        };
+        let (_, runr) = join!(feed_fut, worker.run());
+        runr.unwrap();
+    } else {
         worker.run().await.unwrap();
     }
+    assert_eq!(runs_ctr.lock().len(), 2);
+}
+
+#[tokio::test]
+async fn multiple_histories_can_handle_dupe_run_ids() {
+    let mut hist1 = canned_histories::single_timer("1");
+    hist1.set_wf_type("onetimer");
+    let mut worker = replay_sdk_worker([
+        test_hist_to_replay(hist1.clone()),
+        test_hist_to_replay(hist1.clone()),
+        test_hist_to_replay(hist1),
+    ]);
+    worker.register_wf("onetimer", timers_wf(1));
+    worker.run().await.unwrap();
 }
 
 fn timers_wf(num_timers: u32) -> WorkflowFunction {
@@ -135,3 +213,16 @@ fn timers_wf(num_timers: u32) -> WorkflowFunction {
         Ok(().into())
     })
 }
+
+#[derive(Default)]
+struct UniqueRunsCounter {
+    runs: Arc<Mutex<HashSet<String>>>,
+}
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for UniqueRunsCounter {
+    async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion) {
+        self.runs.lock().insert(completion.run_id.clone());
+    }
+
+    fn on_shutdown(&self, _: &Worker) {}
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/resets.rs

@@ -14,6 +14,7 @@ const POST_RESET_SIG: &str = "post-reset";
 async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.fetch_results = false;
     let notify = Arc::new(Notify::new());

data/bridge/sdk-core/tests/integ_tests/workflow_tests/signals.rs

@@ -1,7 +1,9 @@
 use std::collections::HashMap;
 
 use futures::StreamExt;
-use temporal_client::{WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions};
+use temporal_client::{
+    SignalWithStartOptions, WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions,
+};
 use temporal_sdk::{
     ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
 };
@@ -32,6 +34,7 @@ async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
 async fn sends_signal_to_missing_wf() {
     let wf_name = "sends_signal_to_missing_wf";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), signal_sender);
 
@@ -59,7 +62,6 @@ async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
 
 async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
     let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
-    println!("HEADER: {:?}", res.headers);
     assert_eq!(&res.input, &[b"tada".into()]);
     assert_eq!(
         *res.headers.get("tupac").expect("tupac header exists"),
@@ -71,6 +73,7 @@ async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("sender", signal_sender);
     worker.register_wf("receiver", signal_receiver);
@@ -99,24 +102,24 @@ async fn sends_signal_to_other_wf() {
 #[tokio::test]
 async fn sends_signal_with_create_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
-    worker.register_wf("receiversignal", signal_with_create_wf_receiver);
+    worker.register_wf("receiver_signal", signal_with_create_wf_receiver);
 
     let client = starter.get_client().await;
     let mut header: HashMap<String, Payload> = HashMap::new();
     header.insert("tupac".into(), "shakur".into());
+    let options = SignalWithStartOptions::builder()
+        .task_queue(worker.inner_mut().task_queue())
+        .workflow_id("sends_signal_with_create_wf")
+        .workflow_type("receiver_signal")
+        .signal_name(SIGNAME)
+        .signal_input(vec![b"tada".into()].into_payloads())
+        .signal_header(header.into())
+        .build()
+        .unwrap();
     let res = client
-        .signal_with_start_workflow_execution(
-            None,
-            worker.inner_mut().task_queue().to_owned(),
-            "sends_signal_with_create_wf".to_owned(),
-            "receiversignal".to_owned(),
-            None,
-            WorkflowOptions::default(),
-            SIGNAME.to_owned(),
-            vec![b"tada".into()].into_payloads(),
-            Some(header.into()),
-        )
+        .signal_with_start_workflow_execution(options, WorkflowOptions::default())
         .await
         .expect("request succeeds.qed");
 
@@ -150,6 +153,7 @@ async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_child() {
     let mut starter = CoreWfStarter::new("sends_signal_to_child");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("child_signaler", signals_child);
     worker.register_wf("child_receiver", signal_receiver);

data/bridge/sdk-core/tests/integ_tests/workflow_tests/stickyness.rs

@@ -12,19 +12,12 @@ use tokio::sync::Barrier;
 async fn timer_workflow_not_sticky() {
     let wf_name = "timer_wf_not_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     starter.max_cached_workflows(0);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -47,19 +40,12 @@ async fn timer_workflow_timeout_on_sticky() {
     // on a not-sticky queue
     let wf_name = "timer_workflow_timeout_on_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.wft_timeout(Duration::from_secs(2));
+    starter.no_remote_activities();
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(2));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
     // If it didn't run twice it didn't time out
     assert_eq!(RUN_CT.load(Ordering::SeqCst), 2);
@@ -69,7 +55,7 @@ async fn timer_workflow_timeout_on_sticky() {
 async fn cache_miss_ok() {
     let wf_name = "cache_miss_ok";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_wft(1);
+    starter.no_remote_activities().max_wft(1);
     let mut worker = starter.worker().await;
 
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));

data/bridge/sdk-core/tests/integ_tests/workflow_tests/timers.rs

@@ -1,12 +1,13 @@
 use std::time::Duration;
-use temporal_client::WorkflowOptions;
+
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
     workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
     workflow_completion::WorkflowActivationCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, start_timer_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, start_timer_cmd, CoreWfStarter,
+    WorkerTestHelpers,
 };
 
 pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -18,18 +19,11 @@ pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn timer_workflow_workflow_driver() {
     let wf_name = "timer_wf_new";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
@@ -37,6 +31,7 @@ async fn timer_workflow_workflow_driver() {
 async fn timer_workflow_manual() {
     let mut starter = init_core_and_create_wf("timer_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -50,13 +45,14 @@ async fn timer_workflow_manual() {
     .unwrap();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_execution(&task.run_id).await;
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 #[tokio::test]
 async fn timer_cancel_workflow() {
     let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -115,17 +111,10 @@ async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn parallel_timers() {
     let wf_name = "parallel_timers";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);
 
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }

data/bridge/sdk-core/tests/integ_tests/workflow_tests/upsert_search_attrs.rs

@@ -1,9 +1,9 @@
-use log::warn;
 use std::{collections::HashMap, env};
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORALITE_USED_ENV_VAR};
+use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR};
+use tracing::warn;
 use uuid::Uuid;
 
 // These are initialized on the server as part of the autosetup container which we
@@ -24,9 +24,11 @@ async fn sends_upsert() {
     let wf_name = "sends_upsert_search_attrs";
     let wf_id = Uuid::new_v4();
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
-    if env::var(INTEG_TEMPORALITE_USED_ENV_VAR).is_ok() {
-        warn!("skipping sends_upsert -- does not work on temporalite");
+    // TODO: this should be supported in server 1.20, remove this condition when CLI is upgraded.
+    if env::var(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR).is_ok() {
+        warn!("skipping sends_upsert -- does not work on temporal dev server");
         return;
     }
 

data/bridge/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -6,6 +6,7 @@ mod child_workflows;
 mod continue_as_new;
 mod determinism;
 mod local_activities;
+mod modify_wf_properties;
 mod patches;
 mod replay;
 mod resets;
@@ -28,6 +29,7 @@ use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{
     interceptors::WorkerInterceptor, ActContext, ActivityOptions, WfContext, WorkflowResult,
 };
+use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core_api::{errors::PollWfError, Worker};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -37,11 +39,11 @@ use temporal_sdk_core_protos::{
         workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
-    temporal::api::failure::v1::Failure,
+    temporal::api::{failure::v1::Failure, history::v1::history_event},
 };
 use temporal_sdk_core_test_utils::{
-    history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
-    schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf,
+    init_core_replay_preloaded, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 use uuid::Uuid;
@@ -56,8 +58,7 @@ async fn parallel_workflows_same_queue() {
     let num_workflows = 25usize;
 
     let run_ids: Vec<_> = future::join_all(
-        (0..num_workflows)
-            .map(|i| starter.start_wf_with_id(format!("wf-id-{}", i), WorkflowOptions::default())),
+        (0..num_workflows).map(|i| starter.start_wf_with_id(format!("wf-id-{i}"))),
     )
     .await;
 
@@ -102,6 +103,7 @@ async fn parallel_workflows_same_queue() {
     for handle in handles {
         handle.await.unwrap()
     }
+    drain_pollers_and_shutdown(&core).await;
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
@@ -115,7 +117,7 @@ pub async fn cache_evictions_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn workflow_lru_cache_evictions() {
     let wf_type = "workflow_lru_cache_evictions";
     let mut starter = CoreWfStarter::new(wf_type);
-    starter.max_cached_workflows(1);
+    starter.no_remote_activities().max_cached_workflows(1);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_type.to_string(), cache_evictions_wf);
 
@@ -160,7 +162,7 @@ async fn shutdown_aborts_actively_blocked_poll() {
     let tcore = core.clone();
     let handle = tokio::spawn(async move {
         std::thread::sleep(Duration::from_millis(100));
-        tcore.shutdown().await;
+        drain_pollers_and_shutdown(&tcore).await;
     });
     assert_matches!(
         core.poll_workflow_activation().await.unwrap_err(),
@@ -179,13 +181,20 @@ async fn shutdown_aborts_actively_blocked_poll() {
 #[tokio::test]
 async fn fail_wf_task(#[values(true, false)] replay: bool) {
     let core = if replay {
-        let (core, _) = init_core_replay_preloaded(
-            "fail_wf_task",
-            &history_from_proto_binary("histories/fail_wf_task.bin")
-                .await
-                .unwrap(),
-        );
-        core
+        // We need to send the history twice, since we fail it the first time.
+        let mut hist_proto = history_from_proto_binary("histories/fail_wf_task.bin")
+            .await
+            .unwrap();
+        let hist = HistoryForReplay::new(hist_proto.clone(), "fake".to_string());
+        if let Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(
+            ref mut attrs,
+        )) = hist_proto.events[0].attributes
+        {
+            attrs.original_execution_run_id = "run2".to_string();
+            attrs.first_execution_run_id = "run2".to_string();
+        }
+        let hist2 = HistoryForReplay::new(hist_proto, "fake".to_string());
+        init_core_replay_preloaded("fail_wf_task", [hist, hist2])
     } else {
         let mut starter = init_core_and_create_wf("fail_wf_task").await;
         starter.get_worker().await
@@ -425,8 +434,8 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     wf_starter
         // Test needs eviction on and a short timeout
         .max_cached_workflows(0)
-        .max_wft(1)
-        .wft_timeout(Duration::from_secs(1));
+        .max_wft(1);
+    wf_starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let core = wf_starter.get_worker().await;
     let client = wf_starter.get_client().await;
     let task_q = wf_starter.get_task_queue();
@@ -450,7 +459,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .unwrap();
         wf_task
     };
-    wf_starter.start_wf().await;
+    wf_starter.start_wf_with_id(wf_id.to_string()).await;
 
     // Poll and schedule the activity
     let wf_task = poll_sched_act().await;
@@ -562,7 +571,7 @@ async fn slow_completes_with_small_cache() {
     for i in 0..20 {
         worker
             .submit_wf(
-                format!("{}_{}", wf_name, i),
+                format!("{wf_name}_{i}"),
                 wf_name.to_owned(),
                 vec![],
                 WorkflowOptions::default(),

data/bridge/sdk-core/tests/main.rs

@@ -1,25 +1,16 @@
 //! Integration tests
-//!
-//! Note that integ tests which want to use the server (nearly all of them) *need* to use the
-//! `#[rstest]` macro and accept the TODO fixture to support auto setup & teardown of ephemeral
-//! local servers.
 
 #[macro_use]
 extern crate rstest;
+#[macro_use]
+extern crate temporal_sdk_core_test_utils;
 
 #[cfg(test)]
 mod integ_tests {
-    #[macro_export]
-    macro_rules! prost_dur {
-        ($dur_call:ident $args:tt) => {
-            std::time::Duration::$dur_call$args
-                .try_into()
-                .expect("test duration fits")
-        };
-    }
     mod client_tests;
     mod ephemeral_server_tests;
     mod heartbeat_tests;
+    mod metrics_tests;
     mod polling_tests;
     mod queries_tests;
     mod visibility_tests;
@@ -28,10 +19,10 @@ mod integ_tests {
     use std::str::FromStr;
     use temporal_client::WorkflowService;
     use temporal_sdk_core::{
-        init_worker, telemetry_init, ClientOptionsBuilder, ClientTlsConfig, TlsConfig,
+        init_worker, ClientOptionsBuilder, ClientTlsConfig, CoreRuntime, TlsConfig,
         WorkflowClientTrait,
     };
-    use temporal_sdk_core_api::{worker::WorkerConfigBuilder, CoreTelemetry};
+    use temporal_sdk_core_api::worker::WorkerConfigBuilder;
     use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
     use temporal_sdk_core_test_utils::{
         get_integ_server_options, get_integ_telem_options, NAMESPACE,
@@ -43,13 +34,14 @@ mod integ_tests {
     #[ignore] // Really a compile time check more than anything
     async fn lang_bridge_example() {
         let opts = get_integ_server_options();
-        let telem_d = telemetry_init(&get_integ_telem_options()).unwrap();
+        let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
         let mut retrying_client = opts
-            .connect_no_namespace(telem_d.get_metric_meter(), None)
+            .connect_no_namespace(runtime.metric_meter().as_deref(), None)
             .await
             .unwrap();
 
         let _worker = init_worker(
+            &runtime,
             WorkerConfigBuilder::default()
                 .namespace("default")
                 .task_queue("Wheee!")