@temporalio/core-bridge 1.9.0 → 1.9.2

package/Cargo.lock

@@ -331,19 +331,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "crossbeam"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-epoch",
- "crossbeam-queue",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.11"
@@ -353,25 +340,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-queue"
 version = "0.3.11"
@@ -2382,7 +2350,8 @@ dependencies = [
  "arc-swap",
  "async-trait",
  "base64",
- "crossbeam",
+ "crossbeam-channel",
+ "crossbeam-queue",
  "dashmap",
  "derive_builder",
  "derive_more",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
@@ -22,7 +22,7 @@
   "author": "Temporal Technologies Inc. <sdk@temporal.io>",
   "license": "MIT",
   "dependencies": {
-    "@temporalio/common": "1.9.0",
+    "@temporalio/common": "^1.9.2",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.8",
     "which": "^4.0.0"
@@ -52,5 +52,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5096976287616207edcd3e4281a2a5e1f7393e33"
+  "gitHead": "5fd66f5787deece0b30f085808db7651187600b1"
 }

package/sdk-core/.github/workflows/per-pr.yml

@@ -65,7 +65,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: -- --include-ignored
+          args: -- --include-ignored --nocapture
       - uses: actions/upload-artifact@v3
         with:
           name: coverage-report

package/sdk-core/Cargo.toml

@@ -7,6 +7,7 @@ license = "MIT"
 license-file = "LICENSE.txt"
 
 [workspace.dependencies]
+derive_more = { version = "0.99", default-features = false, features = ["constructor", "display", "from", "into"] }
 tonic = "0.9"
 tonic-build = "0.9"
 opentelemetry = "0.21"

package/sdk-core/README.md

@@ -89,7 +89,7 @@ equivalent.
 This repo uses a subtree for upstream protobuf files. The path `sdk-core-protos/protos/api_upstream` is a
 subtree. To update it, use:
 
-`git pull --squash -s subtree ssh://git@github.com/temporalio/api.git master --allow-unrelated-histories`
+`git pull --squash --rebase=false -s subtree ssh://git@github.com/temporalio/api.git master --allow-unrelated-histories`
 
 Do not question why this git command is the way it is. It is not our place to interpret git's ways.
 

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

@@ -6,6 +6,7 @@
 
 #[macro_use]
 extern crate tracing;
+
 mod metrics;
 mod raw;
 mod retry;
@@ -49,7 +50,7 @@ use temporal_sdk_core_protos::{
     coresdk::{workflow_commands::QueryResult, IntoPayloadsExt},
     grpc::health::v1::health_client::HealthClient,
     temporal::api::{
-        common::v1::{Header, Payload, Payloads, WorkflowExecution, WorkflowType},
+        common::v1::{Header, Payload, Payloads, RetryPolicy, WorkflowExecution, WorkflowType},
         enums::v1::{TaskQueueKind, WorkflowIdReusePolicy},
         failure::v1::Failure,
         operatorservice::v1::operator_service_client::OperatorServiceClient,
@@ -151,9 +152,9 @@ pub struct TlsConfig {
 /// If using mTLS, both the client cert and private key must be specified, this contains them.
 #[derive(Clone)]
 pub struct ClientTlsConfig {
-    /// The certificate for this client
+    /// The certificate for this client, encoded as PEM
     pub client_cert: Vec<u8>,
-    /// The private key for this client
+    /// The private key for this client, encoded as PEM
     pub client_private_key: Vec<u8>,
 }
 
@@ -316,6 +317,7 @@ impl<C> Deref for ConfiguredClient<C> {
         &self.client
     }
 }
+
 impl<C> DerefMut for ConfiguredClient<C> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.client
@@ -493,6 +495,19 @@ pub struct TemporalServiceClient<T> {
     test_svc_client: OnceCell<TestServiceClient<T>>,
     health_svc_client: OnceCell<HealthClient<T>>,
 }
+
+/// We up the limit on incoming messages from server from the 4Mb default to 128Mb. If for
+/// whatever reason this needs to be changed by the user, we support overriding it via env var.
+fn get_decode_max_size() -> usize {
+    static _DECODE_MAX_SIZE: OnceCell<usize> = OnceCell::new();
+    *_DECODE_MAX_SIZE.get_or_init(|| {
+        std::env::var("TEMPORAL_MAX_INCOMING_GRPC_BYTES")
+            .ok()
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(128 * 1024 * 1024)
+    })
+}
+
 impl<T> TemporalServiceClient<T>
 where
     T: Clone,
@@ -512,23 +527,30 @@ where
     }
     /// Get the underlying workflow service client
     pub fn workflow_svc(&self) -> &WorkflowServiceClient<T> {
-        self.workflow_svc_client
-            .get_or_init(|| WorkflowServiceClient::new(self.svc.clone()))
+        self.workflow_svc_client.get_or_init(|| {
+            WorkflowServiceClient::new(self.svc.clone())
+                .max_decoding_message_size(get_decode_max_size())
+        })
     }
     /// Get the underlying operator service client
     pub fn operator_svc(&self) -> &OperatorServiceClient<T> {
-        self.operator_svc_client
-            .get_or_init(|| OperatorServiceClient::new(self.svc.clone()))
+        self.operator_svc_client.get_or_init(|| {
+            OperatorServiceClient::new(self.svc.clone())
+                .max_decoding_message_size(get_decode_max_size())
+        })
     }
     /// Get the underlying test service client
     pub fn test_svc(&self) -> &TestServiceClient<T> {
-        self.test_svc_client
-            .get_or_init(|| TestServiceClient::new(self.svc.clone()))
+        self.test_svc_client.get_or_init(|| {
+            TestServiceClient::new(self.svc.clone())
+                .max_decoding_message_size(get_decode_max_size())
+        })
     }
     /// Get the underlying health service client
     pub fn health_svc(&self) -> &HealthClient<T> {
-        self.health_svc_client
-            .get_or_init(|| HealthClient::new(self.svc.clone()))
+        self.health_svc_client.get_or_init(|| {
+            HealthClient::new(self.svc.clone()).max_decoding_message_size(get_decode_max_size())
+        })
     }
     /// Get the underlying workflow service client mutably
     pub fn workflow_svc_mut(&mut self) -> &mut WorkflowServiceClient<T> {
@@ -551,6 +573,7 @@ where
         self.health_svc_client.get_mut().unwrap()
     }
 }
+
 /// A [WorkflowServiceClient] with the default interceptors attached.
 pub type WorkflowServiceClientWithMetrics = WorkflowServiceClient<InterceptedMetricsSvc>;
 /// An [OperatorServiceClient] with the default interceptors attached.
@@ -986,6 +1009,9 @@ pub struct WorkflowOptions {
     /// Optionally enable Eager Workflow Start, a latency optimization using local workers
     /// NOTE: Experimental and incompatible with versioning with BuildIDs
     pub enable_eager_workflow_start: bool,
+
+    /// Optionally set a retry policy for the workflow
+    pub retry_policy: Option<RetryPolicy>,
 }
 
 #[async_trait::async_trait]
@@ -1023,6 +1049,7 @@ impl WorkflowClientTrait for Client {
                 search_attributes: options.search_attributes.map(|d| d.into()),
                 cron_schedule: options.cron_schedule.unwrap_or_default(),
                 request_eager_execution: options.enable_eager_workflow_start,
+                retry_policy: options.retry_policy,
                 ..Default::default()
             },
         )
@@ -1497,6 +1524,7 @@ mod sealed {
         WorkflowClientTrait + RawClientLike<SvcType = InterceptedMetricsSvc>
     {
     }
+
     impl<T> WfHandleClient for T where
         T: WorkflowClientTrait + RawClientLike<SvcType = InterceptedMetricsSvc>
     {
@@ -1523,6 +1551,7 @@ pub trait WfClientExt: WfHandleClient + Sized + Clone {
         )
     }
 }
+
 impl<T> WfClientExt for T where T: WfHandleClient + Clone + Sized {}
 
 #[cfg(test)]

package/sdk-core/client/src/workflow_handle/mod.rs

@@ -91,6 +91,10 @@ where
         }
     }
 
+    pub fn info(&self) -> &WorkflowExecutionInfo {
+        &self.info
+    }
+
     pub async fn get_workflow_result(
         &self,
         opts: GetWorkflowResultOpts,

package/sdk-core/core/Cargo.toml

@@ -27,10 +27,11 @@ arc-swap = "1.3"
 async-trait = "0.1"
 base64 = "0.21"
 console-subscriber = { version = "0.1", optional = true }
-crossbeam = "0.8"
+crossbeam-channel = "0.5"
+crossbeam-queue = "0.3"
 dashmap = "5.5"
 derive_builder = "0.12"
-derive_more = "0.99"
+derive_more = { workspace = true }
 enum_dispatch = "0.3"
 enum-iterator = "1.4"
 flate2 = { version = "1.0", optional = true }

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

@@ -17,7 +17,7 @@ use std::{
     future,
     rc::Rc,
     sync::{
-        atomic::{AtomicUsize, Ordering},
+        atomic::{AtomicBool, AtomicUsize, Ordering},
         Arc,
     },
     time::Duration,
@@ -1057,7 +1057,6 @@ async fn cant_complete_activity_with_unset_result_payload() {
 #[rstest::rstest]
 #[tokio::test]
 async fn graceful_shutdown(#[values(true, false)] at_max_outstanding: bool) {
-    let _task_q = "q";
     let grace_period = Duration::from_millis(200);
     let mut tasks = three_tasks();
     let mut mock_act_poller = mock_poller();
@@ -1122,3 +1121,71 @@ async fn graceful_shutdown(#[values(true, false)] at_max_outstanding: bool) {
     }
     worker.drain_pollers_and_shutdown().await;
 }
+
+#[rstest::rstest]
+#[tokio::test]
+async fn activities_must_be_flushed_to_server_on_shutdown(#[values(true, false)] use_grace: bool) {
+    let grace_period = if use_grace {
+        // Even though the grace period is shorter than the client call, the client call will still
+        // go through. This is reasonable since the client has a timeout anyway, and it's unlikely
+        // that a user *needs* an extremely short grace period (it'd be kind of pointless in that
+        // case). They can always force-kill their worker in this situation.
+        Duration::from_millis(50)
+    } else {
+        Duration::from_secs(10)
+    };
+    let shutdown_finished: &'static AtomicBool = Box::leak(Box::new(AtomicBool::new(false)));
+    let mut tasks = three_tasks();
+    let mut mock_act_poller = mock_poller();
+    mock_act_poller
+        .expect_poll()
+        .times(1)
+        .returning(move || Some(Ok(tasks.pop_front().unwrap())));
+    mock_act_poller
+        .expect_poll()
+        .times(1)
+        .returning(move || None);
+    let mut mock_client = mock_manual_workflow_client();
+    mock_client
+        .expect_complete_activity_task()
+        .times(1)
+        .returning(|_, _| {
+            async {
+                // We need some artificial delay here and there's nothing meaningful to sync with
+                tokio::time::sleep(Duration::from_millis(100)).await;
+                if shutdown_finished.load(Ordering::Acquire) {
+                    panic!("Shutdown must complete *after* server sees the activity completion");
+                }
+                Ok(Default::default())
+            }
+            .boxed()
+        });
+
+    let mw = MockWorkerInputs {
+        act_poller: Some(Box::from(mock_act_poller)),
+        config: test_worker_cfg()
+            .graceful_shutdown_period(grace_period)
+            .max_concurrent_at_polls(1_usize) // Makes test logic simple
+            .build()
+            .unwrap(),
+        ..Default::default()
+    };
+    let worker = mock_worker(MocksHolder::from_mock_worker(mock_client, mw));
+
+    let task = worker.poll_activity_task().await.unwrap();
+
+    let shutdown_task = async {
+        worker.drain_activity_poller_and_shutdown().await;
+        shutdown_finished.store(true, Ordering::Release);
+    };
+    let complete_task = async {
+        worker
+            .complete_activity_task(ActivityTaskCompletion {
+                task_token: task.task_token,
+                result: Some(ActivityExecutionResult::ok("hi".into())),
+            })
+            .await
+            .unwrap();
+    };
+    join!(shutdown_task, complete_task);
+}

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

@@ -2,13 +2,13 @@ use crate::{
     prost_dur,
     replay::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE},
     test_help::{
-        hist_to_poll_resp, mock_sdk, mock_sdk_cfg, mock_worker, single_hist_mock_sg, MockPollCfg,
-        ResponseType, WorkerExt,
+        build_mock_pollers, hist_to_poll_resp, mock_sdk, mock_sdk_cfg, mock_worker,
+        single_hist_mock_sg, MockPollCfg, ResponseType, WorkerExt,
     },
     worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID},
 };
 use anyhow::anyhow;
-use crossbeam::queue::SegQueue;
+use crossbeam_queue::SegQueue;
 use futures::{future::join_all, FutureExt};
 use std::{
     collections::HashMap,
@@ -38,7 +38,7 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{
         common::v1::RetryPolicy,
-        enums::v1::{EventType, TimeoutType, WorkflowTaskFailedCause},
+        enums::v1::{CommandType, EventType, TimeoutType, WorkflowTaskFailedCause},
         failure::v1::{failure::FailureInfo, Failure},
         query::v1::WorkflowQuery,
     },
@@ -1295,3 +1295,98 @@ async fn queries_can_be_received_while_heartbeating() {
 
     core.drain_pollers_and_shutdown().await;
 }
+
+#[tokio::test]
+async fn local_activity_after_wf_complete_is_discarded() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_wfe_started_with_wft_timeout(Duration::from_millis(200));
+    t.add_full_wf_task();
+    t.add_workflow_task_scheduled_and_started();
+
+    let mock = mock_workflow_client();
+    let mut mock_cfg = MockPollCfg::from_resp_batches(
+        wfid,
+        t,
+        [ResponseType::ToTaskNum(1), ResponseType::ToTaskNum(2)],
+        mock,
+    );
+    mock_cfg.make_poll_stream_interminable = true;
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 0);
+            })
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 2);
+                assert_eq!(wft.commands[0].command_type(), CommandType::RecordMarker);
+                assert_eq!(
+                    wft.commands[1].command_type(),
+                    CommandType::CompleteWorkflowExecution
+                );
+            });
+    });
+    let mut mock = build_mock_pollers(mock_cfg);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+
+    let barr = Barrier::new(2);
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        task.run_id,
+        vec![
+            ScheduleLocalActivity {
+                seq: 1,
+                activity_id: "1".to_string(),
+                activity_type: "test_act".to_string(),
+                start_to_close_timeout: Some(prost_dur!(from_secs(30))),
+                ..Default::default()
+            }
+            .into(),
+            ScheduleLocalActivity {
+                seq: 2,
+                activity_id: "2".to_string(),
+                activity_type: "test_act".to_string(),
+                start_to_close_timeout: Some(prost_dur!(from_secs(30))),
+                ..Default::default()
+            }
+            .into(),
+        ],
+    ))
+    .await
+    .unwrap();
+
+    let wf_poller = async {
+        let task = core.poll_workflow_activation().await.unwrap();
+        assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
+            }]
+        );
+        barr.wait().await;
+        core.complete_execution(&task.run_id).await;
+    };
+
+    let at_poller = async {
+        let act_task = core.poll_activity_task().await.unwrap();
+        core.complete_activity_task(ActivityTaskCompletion {
+            task_token: act_task.task_token,
+            result: Some(ActivityExecutionResult::ok(vec![1].into())),
+        })
+        .await
+        .unwrap();
+        let act_task = core.poll_activity_task().await.unwrap();
+        barr.wait().await;
+        core.complete_activity_task(ActivityTaskCompletion {
+            task_token: act_task.task_token,
+            result: Some(ActivityExecutionResult::ok(vec![2].into())),
+        })
+        .await
+        .unwrap();
+    };
+
+    join!(wf_poller, at_poller);
+    core.drain_pollers_and_shutdown().await;
+}

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

@@ -1,10 +1,11 @@
 use crate::{
     test_help::{
         build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, single_hist_mock_sg,
-        MockPollCfg, ResponseType, WorkerExt,
+        MockPollCfg, MocksHolder, ResponseType, WorkerExt,
     },
     worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID},
 };
+use futures_util::stream;
 use std::{
     collections::{HashMap, VecDeque},
     time::Duration,
@@ -891,3 +892,91 @@ async fn build_id_set_properly_on_query_on_first_task() {
         .unwrap();
     core.drain_pollers_and_shutdown().await;
 }
+
+#[tokio::test]
+async fn queries_arent_lost_in_buffer_void() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_we_signaled("sig", vec![]);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+    let tasks = [
+        hist_to_poll_resp(&t, wfid.to_owned(), 1.into()),
+        {
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into());
+            pr.query = Some(WorkflowQuery {
+                query_type: "1".to_string(),
+                ..Default::default()
+            });
+            pr.started_event_id = 0;
+            pr
+        },
+        {
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), 1.into());
+            pr.query = Some(WorkflowQuery {
+                query_type: "2".to_string(),
+                ..Default::default()
+            });
+            pr.started_event_id = 0;
+            pr
+        },
+        hist_to_poll_resp(&t, wfid.to_owned(), 2.into()),
+    ]
+    .map(|r| r.resp);
+
+    let mut mock = mock_workflow_client();
+    mock.expect_complete_workflow_task()
+        .returning(|_| Ok(Default::default()));
+    mock.expect_respond_legacy_query()
+        .times(2)
+        .returning(|_, _| Ok(Default::default()));
+    let mut mock = MocksHolder::from_wft_stream(mock, stream::iter(tasks));
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+        .await
+        .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+        }] => q.query_type == "1"
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        query_ok(LEGACY_QUERY_ID.to_string(), "hi"),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+        }] => q.query_type == "2"
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        query_ok(LEGACY_QUERY_ID.to_string(), "hi"),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
+        }]
+    );
+    core.complete_execution(&task.run_id).await;
+
+    core.shutdown().await;
+}

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

@@ -2112,15 +2112,12 @@ async fn continue_as_new_preserves_some_values() {
     wes_attrs.search_attributes = Some(search);
     wes_attrs.retry_policy = Some(retry_policy);
     let mut mock_client = mock_workflow_client();
-    let hist = {
+    let t = {
         let mut t = TestHistoryBuilder::default();
         t.add(wes_attrs.clone());
         t.add_full_wf_task();
         t
     };
-    mock_client.expect_poll_workflow_task().returning(move |_| {
-        Ok(hist_to_poll_resp(&hist, wfid.to_owned(), ResponseType::AllHistory).resp)
-    });
     mock_client
         .expect_complete_workflow_task()
         .returning(move |mut c| {
@@ -2135,8 +2132,8 @@ async fn continue_as_new_preserves_some_values() {
             }
             Ok(Default::default())
         });
-
-    let worker = Worker::new_test(test_worker_cfg().build().unwrap(), mock_client);
+    let mock = single_hist_mock_sg(wfid, t, vec![ResponseType::AllHistory], mock_client, true);
+    let worker = mock_worker(mock);
     let r = worker.poll_workflow_activation().await.unwrap();
     worker
         .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
@@ -2149,6 +2146,7 @@ async fn continue_as_new_preserves_some_values() {
         ))
         .await
         .unwrap();
+    worker.shutdown().await;
 }
 
 #[rstest]
@@ -2737,15 +2735,12 @@ async fn use_compatible_version_flag(
 ) {
     let wfid = "fake_wf_id";
     let mut mock_client = mock_workflow_client();
-    let hist = {
+    let t = {
         let mut t = TestHistoryBuilder::default();
         t.add_by_type(EventType::WorkflowExecutionStarted);
         t.add_full_wf_task();
         t
     };
-    mock_client.expect_poll_workflow_task().returning(move |_| {
-        Ok(hist_to_poll_resp(&hist, wfid.to_owned(), ResponseType::AllHistory).resp)
-    });
     let compat_flag_expected = match intent {
         VersioningIntent::Unspecified => !different_tq,
         VersioningIntent::Compatible => true,
@@ -2770,7 +2765,8 @@ async fn use_compatible_version_flag(
             Ok(Default::default())
         });
 
-    let worker = Worker::new_test(test_worker_cfg().build().unwrap(), mock_client);
+    let mock = single_hist_mock_sg(wfid, t, vec![ResponseType::AllHistory], mock_client, true);
+    let worker = mock_worker(mock);
     let r = worker.poll_workflow_activation().await.unwrap();
     let task_queue = if different_tq {
         "enchi cat!".to_string()
@@ -2806,6 +2802,7 @@ async fn use_compatible_version_flag(
         .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(r.run_id, cmd))
         .await
         .unwrap();
+    worker.shutdown().await;
 }
 
 #[tokio::test]