@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/core/src/core_tests/workflow_tasks.rs

@@ -4,12 +4,11 @@ use crate::{
     job_assert,
     replay::TestHistoryBuilder,
     test_help::{
-        FakeWfResponses, MockPollCfg, MocksHolder, ResponseType, WorkerExt,
+        FakeWfResponses, MockPollCfg, MocksHolder, ResponseType, WorkerExt, WorkerTestHelpers,
         WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky},
-        build_fake_worker, build_mock_pollers, build_multihist_mock_sg, canned_histories,
-        gen_assert_and_fail, gen_assert_and_reply, hist_to_poll_resp, mock_sdk, mock_sdk_cfg,
-        mock_worker, poll_and_reply, poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg,
-        test_worker_cfg,
+        build_fake_worker, build_mock_pollers, build_multihist_mock_sg, fanout_tasks,
+        gen_assert_and_fail, gen_assert_and_reply, hist_to_poll_resp, mock_worker, poll_and_reply,
+        poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg, test_worker_cfg,
     },
     worker::{
         TunerBuilder,
@@ -28,18 +27,16 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{ActivityOptions, CancellableFuture, TimerOptions, WfContext};
 use temporal_sdk_core_api::{
     Worker as WorkerTrait,
     errors::PollError,
     worker::{
         PollerBehavior, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
-        SlotSupplier, SlotSupplierPermit, WorkerVersioningStrategy, WorkflowSlotKind,
+        SlotSupplier, SlotSupplierPermit, WorkflowSlotKind,
     },
 };
 use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE,
+    canned_histories,
     coresdk::{
         activity_result::{self as ar, ActivityResolution, activity_resolution},
         common::VersioningIntent,
@@ -58,20 +55,19 @@ use temporal_sdk_core_protos::{
     default_act_sched, default_wes_attribs,
     temporal::api::{
         command::v1::command::Attributes,
-        common::v1::{Payload, RetryPolicy, WorkerVersionStamp},
+        common::v1::{Payload, RetryPolicy},
         enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
         failure::v1::Failure,
         history::v1::{
             TimerFiredEventAttributes, WorkflowPropertiesModifiedExternallyEventAttributes,
             history_event,
         },
-        sdk::v1::UserMetadata,
         workflowservice::v1::{
             GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
         },
     },
+    test_utils::start_timer_cmd,
 };
-use temporal_sdk_core_test_utils::{WorkerTestHelpers, fanout_tasks, start_timer_cmd};
 use tokio::{
     join,
     sync::{Barrier, Semaphore},
@@ -474,54 +470,6 @@ async fn started_activity_cancellation_abandon(hist_batches: &'static [usize]) {
     verify_activity_cancellation(&core, activity_id, ActivityCancellationType::Abandon).await;
 }
 
-#[rstest(hist_batches, case::incremental(&[1, 2, 3, 4]), case::replay(&[4]))]
-#[tokio::test]
-async fn abandoned_activities_ignore_start_and_complete(hist_batches: &'static [usize]) {
-    let wfid = "fake_wf_id";
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let activity_id = "1";
-
-    let mut t = TestHistoryBuilder::default();
-    t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let act_scheduled_event_id = t.add_activity_task_scheduled(activity_id);
-    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
-    t.add_timer_fired(timer_started_event_id, "1".to_string());
-    t.add_full_wf_task();
-    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
-    let act_started_event_id = t.add_activity_task_started(act_scheduled_event_id);
-    t.add_activity_task_completed(
-        act_scheduled_event_id,
-        act_started_event_id,
-        Default::default(),
-    );
-    t.add_full_wf_task();
-    t.add_timer_fired(timer_started_event_id, "2".to_string());
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
-    let mock = mock_worker_client();
-    let mut worker = mock_sdk(MockPollCfg::from_resp_batches(wfid, t, hist_batches, mock));
-
-    worker.register_wf(wf_type.to_owned(), |ctx: WfContext| async move {
-        let act_fut = ctx.activity(ActivityOptions {
-            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-            start_to_close_timeout: Some(Duration::from_secs(5)),
-            cancellation_type: ActivityCancellationType::Abandon,
-            ..Default::default()
-        });
-        ctx.timer(Duration::from_secs(1)).await;
-        act_fut.cancel(&ctx);
-        ctx.timer(Duration::from_secs(3)).await;
-        act_fut.await;
-        Ok(().into())
-    });
-    worker
-        .submit_wf(wfid, wf_type, vec![], Default::default())
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
 #[rstest(hist_batches, case::incremental(&[1, 3]), case::replay(&[3]))]
 #[tokio::test]
 async fn scheduled_activity_cancellation_try_cancel_task_canceled(hist_batches: &'static [usize]) {
@@ -924,43 +872,6 @@ async fn workflow_failures_only_reported_once() {
     .await;
 }
 
-#[tokio::test]
-async fn max_wft_respected() {
-    let total_wfs = 100;
-    let wf_ids: Vec<_> = (0..total_wfs).map(|i| format!("fake-wf-{i}")).collect();
-    let hists = wf_ids.iter().map(|wf_id| {
-        let hist = canned_histories::single_timer("1");
-        FakeWfResponses {
-            wf_id: wf_id.to_string(),
-            hist,
-            response_batches: vec![1.into(), 2.into()],
-        }
-    });
-    let mh = MockPollCfg::new(hists.into_iter().collect(), true, 0);
-    let mut worker = mock_sdk_cfg(mh, |cfg| {
-        cfg.max_cached_workflows = total_wfs as usize;
-        cfg.max_outstanding_workflow_tasks = Some(1);
-    });
-    let active_count: &'static _ = Box::leak(Box::new(Semaphore::new(1)));
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| async move {
-        drop(
-            active_count
-                .try_acquire()
-                .expect("No multiple concurrent workflow tasks!"),
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        Ok(().into())
-    });
-
-    for wf_id in wf_ids {
-        worker
-            .submit_wf(wf_id, DEFAULT_WORKFLOW_TYPE, vec![], Default::default())
-            .await
-            .unwrap();
-    }
-    worker.run_until_done().await.unwrap();
-}
-
 #[rstest(hist_batches, case::incremental(&[1, 2]), case::replay(&[3]))]
 #[tokio::test]
 async fn activity_not_canceled_on_replay_repro(hist_batches: &'static [usize]) {
@@ -2058,6 +1969,7 @@ async fn no_race_acquiring_permits() {
     let task_barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
     mock_client
         .expect_poll_workflow_task()
+        .times(2)
         .returning(move |_, _| {
             let t = canned_histories::single_timer("1");
             let poll_resp = hist_to_poll_resp(&t, wfid.to_owned(), 2.into()).resp;
@@ -2067,6 +1979,9 @@ async fn no_race_acquiring_permits() {
             }
             .boxed()
         });
+    mock_client
+        .expect_poll_workflow_task()
+        .returning(move |_, _| async move { Ok(Default::default()) }.boxed());
     mock_client
         .expect_complete_workflow_task()
         .returning(|_| async move { Ok(Default::default()) }.boxed());
@@ -2075,6 +1990,7 @@ async fn no_race_acquiring_permits() {
         test_worker_cfg()
             .max_outstanding_workflow_tasks(2_usize)
             .max_cached_workflows(0_usize)
+            .ignore_evicts_on_shutdown(false)
             .build()
             .unwrap(),
         mock_client,
@@ -2111,6 +2027,21 @@ async fn no_race_acquiring_permits() {
         task_barr.wait().await;
     };
     join!(poll_1_f, poll_2_f, other_f);
+    // Deal with eviction due to cache being full
+    worker.handle_eviction().await;
+    // Complete workflow (otherwise, this test can encounter a rare shutdown-related race that is
+    // only possible with the `ignore_evicts_on_shutdown` flag set true, as it is to make tests
+    // more convenient).
+    let r = worker.poll_workflow_activation().await.unwrap();
+    worker
+        .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            r.run_id,
+            start_timer_cmd(1, Duration::from_secs(1)),
+        ))
+        .await
+        .unwrap();
+    let r = worker.poll_workflow_activation().await.unwrap();
+    worker.complete_execution(&r.run_id).await;
     worker.drain_pollers_and_shutdown().await;
 }
 
@@ -2679,89 +2610,6 @@ async fn jobs_are_in_appropriate_order() {
     );
 }
 
-#[rstest]
-#[tokio::test]
-async fn history_length_with_fail_and_timeout(
-    #[values(true, false)] use_cache: bool,
-    #[values(1, 2, 3)] history_responses_case: u8,
-) {
-    let wfid = "fake_wf_id";
-    let mut t = TestHistoryBuilder::default();
-    t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
-    t.add_timer_fired(timer_started_event_id, "1".to_string());
-    t.add_workflow_task_scheduled_and_started();
-    t.add_workflow_task_failed_with_failure(WorkflowTaskFailedCause::Unspecified, "ahh".into());
-    t.add_workflow_task_scheduled_and_started();
-    t.add_workflow_task_timed_out();
-    t.add_full_wf_task();
-    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
-    t.add_timer_fired(timer_started_event_id, "2".to_string());
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
-
-    let mut mock_client = mock_worker_client();
-    let history_responses = match history_responses_case {
-        1 => vec![ResponseType::AllHistory],
-        2 => vec![
-            ResponseType::ToTaskNum(1),
-            ResponseType::ToTaskNum(2),
-            ResponseType::AllHistory,
-        ],
-        3 => {
-            let mut needs_fetch = hist_to_poll_resp(&t, wfid, ResponseType::ToTaskNum(2)).resp;
-            needs_fetch.next_page_token = vec![1];
-            // Truncate the history a bit in order to force incomplete WFT
-            needs_fetch.history.as_mut().unwrap().events.truncate(6);
-            let needs_fetch_resp = ResponseType::Raw(needs_fetch);
-            let mut empty_fetch_resp: GetWorkflowExecutionHistoryResponse =
-                t.get_history_info(1).unwrap().into();
-            empty_fetch_resp.history.as_mut().unwrap().events = vec![];
-            mock_client
-                .expect_get_workflow_execution_history()
-                .returning(move |_, _, _| Ok(empty_fetch_resp.clone()))
-                .times(1);
-            vec![
-                ResponseType::ToTaskNum(1),
-                needs_fetch_resp,
-                ResponseType::ToTaskNum(2),
-                ResponseType::AllHistory,
-            ]
-        }
-        _ => unreachable!(),
-    };
-
-    let mut mh = MockPollCfg::from_resp_batches(wfid, t, history_responses, mock_client);
-    if history_responses_case == 3 {
-        // Expect the failed pagination fetch
-        mh.num_expected_fails = 1;
-    }
-    let mut worker = mock_sdk_cfg(mh, |wc| {
-        if use_cache {
-            wc.max_cached_workflows = 1;
-        }
-    });
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-        assert_eq!(ctx.history_length(), 3);
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(ctx.history_length(), 14);
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(ctx.history_length(), 19);
-        Ok(().into())
-    });
-    worker
-        .submit_wf(
-            wfid.to_owned(),
-            DEFAULT_WORKFLOW_TYPE.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
 #[tokio::test]
 async fn poller_wont_run_ahead_of_task_slots() {
     let popped_tasks = Arc::new(AtomicUsize::new(0));
@@ -2946,70 +2794,6 @@ async fn use_compatible_version_flag(
     worker.shutdown().await;
 }
 
-#[allow(deprecated)]
-#[tokio::test]
-async fn sets_build_id_from_wft_complete() {
-    let wfid = "fake_wf_id";
-
-    let mut t = TestHistoryBuilder::default();
-    t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
-    t.add_timer_fired(timer_started_event_id, "1".to_string());
-    t.add_full_wf_task();
-    t.modify_event(t.current_event_id(), |he| {
-        if let history_event::Attributes::WorkflowTaskCompletedEventAttributes(a) =
-            he.attributes.as_mut().unwrap()
-        {
-            a.worker_version = Some(WorkerVersionStamp {
-                build_id: "enchi-cat".to_string(),
-                ..Default::default()
-            });
-        }
-    });
-    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
-    t.add_timer_fired(timer_started_event_id, "2".to_string());
-    t.add_workflow_task_scheduled_and_started();
-
-    let mock = mock_worker_client();
-    let mut worker = mock_sdk_cfg(
-        MockPollCfg::from_resp_batches(wfid, t, [ResponseType::AllHistory], mock),
-        |cfg| {
-            cfg.versioning_strategy = WorkerVersioningStrategy::None {
-                build_id: "fierce-predator".to_string(),
-            };
-            cfg.max_cached_workflows = 1;
-        },
-    );
-
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-        // First task, it should be empty, since replaying and nothing in first WFT completed
-        assert_eq!(ctx.current_deployment_version(), None);
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(
-            ctx.current_deployment_version().unwrap().build_id,
-            "enchi-cat"
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        // Not replaying at this point, so we should see the worker's build id
-        assert_eq!(
-            ctx.current_deployment_version().unwrap().build_id,
-            "fierce-predator"
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(
-            ctx.current_deployment_version().unwrap().build_id,
-            "fierce-predator"
-        );
-        Ok(().into())
-    });
-    worker
-        .submit_wf(wfid, DEFAULT_WORKFLOW_TYPE, vec![], Default::default())
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
 #[tokio::test]
 async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
     let popped_tasks = Arc::new(AtomicUsize::new(0));
@@ -3101,53 +2885,6 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
     assert_eq!(popped_tasks.load(Ordering::Relaxed), 10);
 }
 
-#[tokio::test]
-async fn pass_timer_summary_to_metadata() {
-    let t = canned_histories::single_timer("1");
-    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-    let wf_id = mock_cfg.hists[0].wf_id.clone();
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let expected_user_metadata = Some(UserMetadata {
-        summary: Some(b"timer summary".into()),
-        details: None,
-    });
-    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-        asserts
-            .then(move |wft| {
-                assert_eq!(wft.commands.len(), 1);
-                assert_eq!(wft.commands[0].command_type(), CommandType::StartTimer);
-                assert_eq!(wft.commands[0].user_metadata, expected_user_metadata)
-            })
-            .then(move |wft| {
-                assert_eq!(wft.commands.len(), 1);
-                assert_eq!(
-                    wft.commands[0].command_type(),
-                    CommandType::CompleteWorkflowExecution
-                );
-            });
-    });
-
-    let mut worker = mock_sdk_cfg(mock_cfg, |_| {});
-    worker.register_wf(wf_type, |ctx: WfContext| async move {
-        ctx.timer(TimerOptions {
-            duration: Duration::from_secs(1),
-            summary: Some("timer summary".to_string()),
-        })
-        .await;
-        Ok(().into())
-    });
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
 #[tokio::test]
 async fn both_normal_and_sticky_pollers_poll_concurrently() {
     struct Counters {

package/sdk-core/core/src/ephemeral_server/mod.rs

@@ -241,8 +241,7 @@ impl EphemeralServer {
             }
         }
         Err(anyhow!(
-            "Failed connecting to test server after 5 seconds, last error: {:?}",
-            last_error
+            "Failed connecting to test server after 5 seconds, last error: {last_error:?}"
         ))
     }
 
@@ -282,6 +281,19 @@ pub enum EphemeralExe {
     },
 }
 
+/// Return the default cached download for test usage inside this repo
+pub fn default_cached_download() -> EphemeralExe {
+    EphemeralExe::CachedDownload {
+        version: EphemeralExeVersion::SDKDefault {
+            sdk_name: "sdk-rust".to_string(),
+            sdk_version: "0.1.0".to_string(),
+        },
+        dest_dir: None,
+        // 15 days
+        ttl: Some(Duration::from_secs(60 * 60 * 24 * 15)),
+    }
+}
+
 /// Which version of the exe to download.
 #[derive(Debug, Clone)]
 pub enum EphemeralExeVersion {
@@ -355,7 +367,7 @@ impl EphemeralExe {
                 let arch = match std::env::consts::ARCH {
                     "x86_64" => "amd64",
                     "arm" | "aarch64" => "arm64",
-                    other => return Err(anyhow!("Unsupported arch: {}", other)),
+                    other => return Err(anyhow!("Unsupported arch: {other}")),
                 };
                 let mut get_info_params = vec![("arch", arch), ("platform", platform)];
                 if let Some(format) = preferred_format {

package/sdk-core/core/src/internal_flags.rs

@@ -18,9 +18,10 @@ use temporal_sdk_core_protos::temporal::api::{
 /// may be removed from the enum. *Importantly*, all variants must be given explicit values, such
 /// that removing older variants does not create any change in existing values. Removed flag
 /// variants must be reserved forever (a-la protobuf), and should be called out in a comment.
+#[allow(unreachable_pub)] // re-exported in test_help::integ_helpers
 #[repr(u32)]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug, enum_iterator::Sequence)]
-pub(crate) enum CoreInternalFlags {
+pub enum CoreInternalFlags {
     /// In this flag additional checks were added to a number of state machines to ensure that
     /// the ID and type of activities, local activities, and child workflows match during replay.
     IdAndTypeDeterminismChecks = 1,
@@ -202,6 +203,15 @@ impl InternalFlags {
             Self::Disabled => Either::Right(iter::empty()),
         }
     }
+
+    pub(crate) fn last_sdk_version(&self) -> Option<&str> {
+        match self {
+            InternalFlags::Enabled {
+                last_sdk_version, ..
+            } if !last_sdk_version.is_empty() => Some(last_sdk_version),
+            InternalFlags::Enabled { .. } | InternalFlags::Disabled => None,
+        }
+    }
 }
 
 impl CoreInternalFlags {

package/sdk-core/core/src/lib.rs

@@ -26,9 +26,9 @@ mod worker;
 
 #[cfg(test)]
 mod core_tests;
-#[cfg(test)]
+#[cfg(any(feature = "test-utilities", test))]
 #[macro_use]
-mod test_help;
+pub mod test_help;
 
 pub(crate) use temporal_sdk_core_api::errors;
 
@@ -62,7 +62,7 @@ use crate::{
 use anyhow::bail;
 use futures_util::Stream;
 use std::sync::{Arc, OnceLock};
-use temporal_client::{ConfiguredClient, NamespacedClient, TemporalServiceClientWithMetrics};
+use temporal_client::{ConfiguredClient, NamespacedClient, SharedReplaceableClient};
 use temporal_sdk_core_api::{
     Worker as WorkerTrait,
     errors::{CompleteActivityError, PollError},
@@ -89,14 +89,15 @@ pub fn init_worker<CT>(
 where
     CT: Into<sealed::AnyClient>,
 {
-    let client = init_worker_client(&worker_config, *client.into().into_inner());
-    if client.namespace() != worker_config.namespace {
-        bail!("Passed in client is not bound to the same namespace as the worker");
-    }
-    if client.namespace() == "" {
-        bail!("Client namespace cannot be empty");
+    if worker_config.namespace.is_empty() {
+        bail!("Worker namespace cannot be empty");
     }
-    let client_ident = client.get_identity().to_owned();
+
+    let client = RetryClient::new(
+        SharedReplaceableClient::new(init_worker_client(&worker_config, client)),
+        RetryConfig::default(),
+    );
+    let client_ident = client.identity();
     let sticky_q = sticky_q_name_for_worker(&client_ident, &worker_config);
 
     if client_ident.is_empty() {
@@ -141,15 +142,15 @@ where
     rwi.into_core_worker()
 }
 
-pub(crate) fn init_worker_client(
-    config: &WorkerConfig,
-    client: ConfiguredClient<TemporalServiceClientWithMetrics>,
-) -> RetryClient<Client> {
-    let mut client = Client::new(client, config.namespace.clone());
+pub(crate) fn init_worker_client<CT>(config: &WorkerConfig, client: CT) -> Client
+where
+    CT: Into<sealed::AnyClient>,
+{
+    let mut client = Client::new(*client.into().into_inner(), config.namespace.clone());
     if let Some(ref id_override) = config.client_identity_override {
         client.options_mut().identity.clone_from(id_override);
     }
-    RetryClient::new(client, RetryConfig::default())
+    client
 }
 
 /// Creates a unique sticky queue name for a worker, iff the config allows for 1 or more cached
@@ -171,44 +172,57 @@ pub(crate) fn sticky_q_name_for_worker(
 
 mod sealed {
     use super::*;
+    use temporal_client::{SharedReplaceableClient, TemporalServiceClient};
 
     /// Allows passing different kinds of clients into things that want to be flexible. Motivating
     /// use-case was worker initialization.
     ///
     /// Needs to exist in this crate to avoid blanket impl conflicts.
     pub struct AnyClient {
-        pub(crate) inner: Box<ConfiguredClient<TemporalServiceClientWithMetrics>>,
+        pub(crate) inner: Box<ConfiguredClient<TemporalServiceClient>>,
     }
     impl AnyClient {
-        pub(crate) fn into_inner(self) -> Box<ConfiguredClient<TemporalServiceClientWithMetrics>> {
+        pub(crate) fn into_inner(self) -> Box<ConfiguredClient<TemporalServiceClient>> {
             self.inner
         }
     }
 
-    impl From<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>> for AnyClient {
-        fn from(c: RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>) -> Self {
-            Self {
-                inner: Box::new(c.into_inner()),
-            }
+    impl From<ConfiguredClient<TemporalServiceClient>> for AnyClient {
+        fn from(c: ConfiguredClient<TemporalServiceClient>) -> Self {
+            Self { inner: Box::new(c) }
+        }
+    }
+
+    impl From<Client> for AnyClient {
+        fn from(c: Client) -> Self {
+            c.into_inner().into()
         }
     }
-    impl From<RetryClient<Client>> for AnyClient {
-        fn from(c: RetryClient<Client>) -> Self {
-            Self {
-                inner: Box::new(c.into_inner().into_inner()),
-            }
+
+    impl<T> From<RetryClient<T>> for AnyClient
+    where
+        T: Into<AnyClient>,
+    {
+        fn from(c: RetryClient<T>) -> Self {
+            c.into_inner().into()
         }
     }
-    impl From<Arc<RetryClient<Client>>> for AnyClient {
-        fn from(c: Arc<RetryClient<Client>>) -> Self {
-            Self {
-                inner: Box::new(c.get_client().inner().clone()),
-            }
+
+    impl<T> From<SharedReplaceableClient<T>> for AnyClient
+    where
+        T: Into<AnyClient> + Clone + Send + Sync,
+    {
+        fn from(c: SharedReplaceableClient<T>) -> Self {
+            c.inner_clone().into()
         }
     }
-    impl From<ConfiguredClient<TemporalServiceClientWithMetrics>> for AnyClient {
-        fn from(c: ConfiguredClient<TemporalServiceClientWithMetrics>) -> Self {
-            Self { inner: Box::new(c) }
+
+    impl<T> From<Arc<T>> for AnyClient
+    where
+        T: Into<AnyClient> + Clone,
+    {
+        fn from(c: Arc<T>) -> Self {
+            Arc::unwrap_or_clone(c).into()
         }
     }
 }

package/sdk-core/core/src/pollers/mod.rs

@@ -22,16 +22,16 @@ use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
 use tokio::select;
 use tokio_util::sync::CancellationToken;
 
-#[cfg(test)]
+#[cfg(any(feature = "test-utilities", test))]
 use futures_util::Future;
-#[cfg(test)]
+#[cfg(any(feature = "test-utilities", test))]
 pub(crate) use poll_buffer::MockPermittedPollBuffer;
 
 pub(crate) type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
 /// A trait for things that long poll the server.
-#[cfg_attr(test, mockall::automock)]
-#[cfg_attr(test, allow(unused))]
+#[cfg_attr(any(feature = "test-utilities", test), mockall::automock)]
+#[cfg_attr(any(feature = "test-utilities", test), allow(unused))]
 #[async_trait::async_trait]
 pub(crate) trait Poller<PollResult>
 where
@@ -79,7 +79,7 @@ where
     }
 }
 
-#[cfg(test)]
+#[cfg(any(feature = "test-utilities", test))]
 mockall::mock! {
     pub ManualPoller<T: Send + Sync + 'static> {}
     #[allow(unused)]

package/sdk-core/core/src/pollers/poll_buffer.rs

@@ -666,14 +666,14 @@ impl TaskPollerResult for PollNexusTaskQueueResponse {
     }
 }
 
-#[cfg(test)]
+#[cfg(any(feature = "test-utilities", test))]
 #[derive(derive_more::Constructor)]
 pub(crate) struct MockPermittedPollBuffer<PT, SK: SlotKind> {
     sem: Arc<MeteredPermitDealer<SK>>,
     inner: PT,
 }
 
-#[cfg(test)]
+#[cfg(any(feature = "test-utilities", test))]
 #[async_trait::async_trait]
 impl<T, PT, SK> Poller<(T, OwnedMeteredSemPermit<SK>)> for MockPermittedPollBuffer<PT, SK>
 where