@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/{core → crates/sdk-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,50 +27,48 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{ActivityOptions, CancellableFuture, TimerOptions, WfContext};
-use temporal_sdk_core_api::{
+use temporalio_client::MESSAGE_TOO_LARGE_KEY;
+use temporalio_common::{
     Worker as WorkerTrait,
     errors::PollError,
-    worker::{
-        PollerBehavior, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
-        SlotSupplier, SlotSupplierPermit, WorkerVersioningStrategy, WorkflowSlotKind,
-    },
-};
-use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE,
-    coresdk::{
-        activity_result::{self as ar, ActivityResolution, activity_resolution},
-        common::VersioningIntent,
-        workflow_activation::{
-            FireTimer, InitializeWorkflow, ResolveActivity, UpdateRandomSeed,
-            WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
+    protos::{
+        canned_histories,
+        coresdk::{
+            activity_result::{self as ar, ActivityResolution, activity_resolution},
+            common::VersioningIntent,
+            workflow_activation::{
+                FireTimer, InitializeWorkflow, ResolveActivity, UpdateRandomSeed,
+                WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
+            },
+            workflow_commands::{
+                ActivityCancellationType, CancelTimer, CompleteWorkflowExecution,
+                ContinueAsNewWorkflowExecution, FailWorkflowExecution, RequestCancelActivity,
+                ScheduleActivity, SetPatchMarker, StartChildWorkflowExecution, UpdateResponse,
+                update_response::Response, workflow_command,
+            },
+            workflow_completion::WorkflowActivationCompletion,
         },
-        workflow_commands::{
-            ActivityCancellationType, CancelTimer, CompleteWorkflowExecution,
-            ContinueAsNewWorkflowExecution, FailWorkflowExecution, RequestCancelActivity,
-            ScheduleActivity, SetPatchMarker, StartChildWorkflowExecution, UpdateResponse,
-            update_response::Response, workflow_command,
+        default_act_sched, default_wes_attribs,
+        temporal::api::{
+            command::v1::command::Attributes,
+            common::v1::{Payload, RetryPolicy},
+            enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
+            failure::v1::Failure,
+            history::v1::{
+                TimerFiredEventAttributes, WorkflowPropertiesModifiedExternallyEventAttributes,
+                history_event,
+            },
+            workflowservice::v1::{
+                GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
+            },
         },
-        workflow_completion::WorkflowActivationCompletion,
+        test_utils::start_timer_cmd,
     },
-    default_act_sched, default_wes_attribs,
-    temporal::api::{
-        command::v1::command::Attributes,
-        common::v1::{Payload, RetryPolicy, WorkerVersionStamp},
-        enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
-        failure::v1::Failure,
-        history::v1::{
-            TimerFiredEventAttributes, WorkflowPropertiesModifiedExternallyEventAttributes,
-            history_event,
-        },
-        sdk::v1::UserMetadata,
-        workflowservice::v1::{
-            GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
-        },
+    worker::{
+        PollerBehavior, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
+        SlotSupplier, SlotSupplierPermit, WorkerTaskTypes, WorkflowSlotKind,
     },
 };
-use temporal_sdk_core_test_utils::{WorkerTestHelpers, fanout_tasks, start_timer_cmd};
 use tokio::{
     join,
     sync::{Barrier, Semaphore},
@@ -474,54 +471,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 +873,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]) {
@@ -1375,6 +1287,40 @@ async fn fail_wft_then_recover() {
     core.shutdown().await;
 }
 
+#[tokio::test]
+async fn default_wft_fail_cause_is_worker_unhandled() {
+    let t = canned_histories::single_timer("1");
+    let mut mh = MockPollCfg::from_resp_batches(
+        "fake_wf_id",
+        t,
+        [ResponseType::AllHistory],
+        mock_worker_client(),
+    );
+    mh.num_expected_fails = 1;
+    mh.expect_fail_wft_matcher = Box::new(|_, cause, _| {
+        matches!(
+            cause,
+            WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure
+        )
+    });
+    let mock = build_mock_pollers(mh);
+    let core = mock_worker(mock);
+
+    let act = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::fail(
+        act.run_id,
+        Failure {
+            message: "Simulated workflow failure".to_string(),
+            ..Default::default()
+        },
+        None,
+    ))
+    .await
+    .unwrap();
+
+    core.shutdown().await;
+}
+
 #[tokio::test]
 async fn poll_response_triggers_wf_error() {
     let mut t = TestHistoryBuilder::default();
@@ -2058,6 +2004,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 +2014,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 +2025,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 +2062,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 +2645,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));
@@ -2788,7 +2671,7 @@ async fn poller_wont_run_ahead_of_task_slots() {
             .max_cached_workflows(10_usize)
             .max_outstanding_workflow_tasks(10_usize)
             .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::workflow_only())
             .build()
             .unwrap(),
         mock_client,
@@ -2848,7 +2731,7 @@ async fn poller_wont_poll_until_lang_polls() {
 
     let worker = Worker::new_test(
         test_worker_cfg()
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::workflow_only())
             .build()
             .unwrap(),
         mock_client,
@@ -2946,70 +2829,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));
@@ -3057,7 +2876,7 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
                     .build(),
             ))
             .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::workflow_only())
             .build()
             .unwrap(),
         mock_client,
@@ -3101,53 +2920,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 {
@@ -3252,14 +3024,15 @@ async fn both_normal_and_sticky_pollers_poll_concurrently() {
             .max_outstanding_workflow_tasks(2_usize)
             .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2_usize))
             .nonsticky_to_sticky_poll_ratio(0.2)
-            .no_remote_activities(true)
+            .task_types(WorkerTaskTypes::workflow_only())
             .build()
             .unwrap(),
         Some("stickytq".to_string()),
         Arc::new(mock_client),
         None,
         None,
-    );
+    )
+    .unwrap();
 
     for _ in 1..50 {
         let activation = worker.poll_workflow_activation().await.unwrap();
@@ -3298,3 +3071,54 @@ async fn both_normal_and_sticky_pollers_poll_concurrently() {
         "At peak, there should be exactly 2 pollers active at the same time"
     );
 }
+
+#[tokio::test]
+async fn grpc_message_too_large_doesnt_spam_task_fails() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_workflow_task_scheduled_and_started();
+
+    let mut mh = MockPollCfg::from_resp_batches(
+        "fake_wf_id",
+        t,
+        [
+            ResponseType::AllHistory,
+            ResponseType::AllHistory,
+            ResponseType::AllHistory,
+            ResponseType::AllHistory,
+            ResponseType::AllHistory,
+            ResponseType::AllHistory,
+        ],
+        mock_worker_client(),
+    );
+    mh.num_expected_fails = 1;
+    let mut times = 1;
+    mh.completion_mock_fn = Some(Box::new(move |_| {
+        if times <= 5 {
+            let mut err = tonic::Status::new(tonic::Code::ResourceExhausted, "message too large");
+            // This key is what we look for
+            err.metadata_mut().insert(MESSAGE_TOO_LARGE_KEY, 1.into());
+            times += 1;
+            Err(err)
+        } else {
+            Ok(Default::default())
+        }
+    }));
+
+    let mut mock = build_mock_pollers(mh);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+
+    // Since the mock makes us fail 5 times, we should succeed on the sixth
+    for _ in 1..=5 {
+        let act = core.poll_workflow_activation().await.unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(&act.run_id))
+            .await
+            .unwrap();
+        core.handle_eviction().await;
+    }
+    let act = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&act.run_id).await;
+    core.drain_pollers_and_shutdown().await;
+    // Mock only expects 1 task failure, and would fail here if we spammed
+}

package/sdk-core/{core → crates/sdk-core}/src/debug_client.rs

@@ -6,7 +6,7 @@ use hyper::http::HeaderValue;
 use prost::Message;
 use reqwest::{self, header::HeaderMap};
 use std::time::Duration;
-use temporal_sdk_core_protos::temporal::api::history::v1::History;
+use temporalio_common::protos::temporal::api::history::v1::History;
 use url::Url;
 
 /// A client for interacting with the VSCode debug plugin

package/sdk-core/{core → crates/sdk-core}/src/ephemeral_server/mod.rs

@@ -10,7 +10,7 @@ use std::{
     io,
     path::{Path, PathBuf},
 };
-use temporal_client::ClientOptionsBuilder;
+use temporalio_client::ClientOptions;
 use tokio::{
     task::spawn_blocking,
     time::{Duration, sleep},
@@ -224,12 +224,12 @@ impl EphemeralServer {
         // Try to connect every 100ms for 5s
         // TODO(cretz): Some other way, e.g. via stdout, to know whether the
         // server is up?
-        let client_options = ClientOptionsBuilder::default()
+        let client_options = ClientOptions::builder()
             .identity("online_checker".to_owned())
             .target_url(Url::parse(&target_url)?)
             .client_name("online-checker".to_owned())
             .client_version("0.1.0".to_owned())
-            .build()?;
+            .build();
         let mut last_error = None;
         for _ in 0..50 {
             sleep(Duration::from_millis(100)).await;
@@ -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/{test-utils → crates/sdk-core}/src/histfetch.rs

@@ -5,13 +5,18 @@
 //! We can use `clap` if this needs more arguments / other stuff later on.
 
 use prost::Message;
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk_core_test_utils::get_integ_server_options;
+use temporalio_client::{ClientOptions, WorkflowClientTrait};
+use url::Url;
 
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
-    let gw_opts = get_integ_server_options();
-    let client = gw_opts.connect("default", None).await?;
+    let url = Url::try_from("http://localhost:7233").unwrap();
+    let copts = ClientOptions::builder()
+        .client_name("histfetch")
+        .client_version("0.0")
+        .target_url(url)
+        .build();
+    let client = copts.connect("default", None).await?;
     let wf_id = std::env::args()
         .nth(1)
         .expect("must provide workflow id as only argument");