@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/crates/sdk-core/machine_coverage/TimerMachine_Coverage.puml

@@ -0,0 +1,13 @@
+@startuml
+Created -[#blue]-> StartCommandCreated: Schedule
+StartCommandCreated -[#blue]-> StartCommandCreated: CommandStartTimer
+StartCommandCreated -[#blue]-> StartCommandRecorded: TimerStarted
+StartCommandCreated -[#blue]-> Canceled: Cancel
+StartCommandRecorded -[#blue]-> Fired: TimerFired
+StartCommandRecorded -[#blue]-> CancelTimerCommandCreated: Cancel
+CancelTimerCommandCreated --> CancelTimerCommandCreated: Cancel
+CancelTimerCommandCreated -[#blue]-> CancelTimerCommandSent: CommandCancelTimer
+CancelTimerCommandSent --> Canceled: TimerCanceled
+Canceled -[#blue]-> Canceled: Cancel
+Fired -[#blue]-> Fired: Cancel
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/UpdateMachine_Coverage.puml

@@ -0,0 +1,19 @@
+@startuml
+RequestInitiated --> Accepted: Accept
+RequestInitiated --> Rejected: Reject
+Accepted --> CompletedImmediately: Complete
+Accepted --> CompletedImmediately: Reject
+Accepted -[#blue]-> AcceptCommandCreated: CommandProtocolMessage
+AcceptCommandCreated -[#blue]-> AcceptCommandRecorded: WorkflowExecutionUpdateAccepted
+AcceptCommandCreated --> CompletedImmediatelyAcceptCreated: Complete
+AcceptCommandCreated --> CompletedImmediatelyAcceptCreated: Reject
+AcceptCommandRecorded --> Completed: Complete
+AcceptCommandRecorded --> Completed: Reject
+Completed -[#blue]-> CompletedCommandCreated: CommandProtocolMessage
+CompletedCommandCreated -[#blue]-> CompletedCommandRecorded: WorkflowExecutionUpdateCompleted
+CompletedImmediately -[#blue]-> CompletedImmediatelyAcceptCreated: CommandProtocolMessage
+CompletedImmediatelyAcceptCreated -[#blue]-> CompletedImmediatelyCompleteCreated: CommandProtocolMessage
+CompletedImmediatelyCompleteCreated -[#blue]-> CompletedCommandCreated: WorkflowExecutionUpdateAccepted
+Rejected --> [*]
+CompletedCommandRecorded --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/UpsertSearchAttributesMachine_Coverage.puml

@@ -0,0 +1,5 @@
+@startuml
+Created -[#blue]-> CommandIssued: CommandScheduled
+CommandIssued -[#blue]-> Done: CommandRecorded
+Done --> [*]
+@enduml

package/sdk-core/crates/sdk-core/machine_coverage/WorkflowTaskMachine_Coverage.puml

@@ -0,0 +1,11 @@
+@startuml
+Created -[#blue]-> Scheduled: WorkflowTaskScheduled
+Scheduled -[#blue]-> Started: WorkflowTaskStarted
+Scheduled --> TimedOut: WorkflowTaskTimedOut
+Started -[#blue]-> Completed: WorkflowTaskCompleted
+Started -[#blue]-> Failed: WorkflowTaskFailed
+Started -[#blue]-> TimedOut: WorkflowTaskTimedOut
+TimedOut --> [*]
+Completed --> [*]
+Failed --> [*]
+@enduml

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

@@ -10,7 +10,7 @@ use std::{
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
 };
-use temporal_sdk_core_api::{
+use temporalio_common::{
     telemetry::metrics::TemporalMeter,
     worker::{
         SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
@@ -25,6 +25,7 @@ use tokio_util::sync::CancellationToken;
 #[derive(Clone)]
 pub(crate) struct MeteredPermitDealer<SK: SlotKind> {
     supplier: Arc<dyn SlotSupplier<SlotKind = SK> + Send + Sync>,
+    slot_supplier_kind: SlotSupplierKind,
     /// The number of permit owners who have acquired a permit, but are not yet meaningfully using
     /// that permit. This is useful for giving a more semantically accurate count of used task
     /// slots, since we typically wait for a permit first before polling, but that slot isn't used
@@ -54,6 +55,35 @@ pub(crate) struct PermitDealerContextData {
     pub(crate) worker_deployment_version: Option<WorkerDeploymentVersion>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum SlotSupplierKind {
+    Fixed,
+    ResourceBased,
+    Custom(String),
+}
+
+impl SlotSupplierKind {
+    fn from_label(label: &str) -> Self {
+        if label == "Fixed" {
+            SlotSupplierKind::Fixed
+        } else if label == "ResourceBased" {
+            SlotSupplierKind::ResourceBased
+        } else {
+            SlotSupplierKind::Custom(label.to_string())
+        }
+    }
+}
+
+impl std::fmt::Display for SlotSupplierKind {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SlotSupplierKind::Fixed => f.write_str("Fixed"),
+            SlotSupplierKind::ResourceBased => f.write_str("ResourceBased"),
+            SlotSupplierKind::Custom(name) => f.write_str(name.as_str()),
+        }
+    }
+}
+
 impl<SK> MeteredPermitDealer<SK>
 where
     SK: SlotKind + 'static,
@@ -65,8 +95,11 @@ where
         context_data: Arc<PermitDealerContextData>,
         meter: Option<TemporalMeter>,
     ) -> Self {
+        let supplier_kind_label = supplier.slot_supplier_kind();
+        let slot_supplier_kind = SlotSupplierKind::from_label(supplier_kind_label.as_ref());
         Self {
             supplier,
+            slot_supplier_kind,
             unused_claimants: Arc::new(AtomicUsize::new(0)),
             extant_permits: watch::channel(0),
             metrics_ctx,
@@ -81,6 +114,10 @@ where
         self.supplier.available_slots()
     }
 
+    pub(crate) fn slot_supplier_kind(&self) -> &SlotSupplierKind {
+        &self.slot_supplier_kind
+    }
+
     #[cfg(test)]
     pub(crate) fn unused_permits(&self) -> Option<usize> {
         self.available_permits()
@@ -386,10 +423,23 @@ impl<SK: SlotKind> OwnedMeteredSemPermit<SK> {
 pub(crate) struct UsedMeteredSemPermit<SK: SlotKind>(#[allow(dead_code)] OwnedMeteredSemPermit<SK>);
 
 macro_rules! dbg_panic {
-  ($($arg:tt)*) => {
-      error!($($arg)*);
-      debug_assert!(false, $($arg)*);
-  };
+    ($($arg:tt)*) => {{
+        let message = format!($($arg)*);
+        error!("{}", message);
+
+        #[cfg(feature = "antithesis_assertions")]
+        crate::antithesis::assert_always!(
+            false,
+            "dbg_panic invariant triggered",
+            ::serde_json::json!({
+                "message": message,
+                "file": file!(),
+                "line": line!(),
+                "module": module_path!(),
+            })
+        );
+        debug_assert!(false, "{}", message);
+    }};
 }
 pub(crate) use dbg_panic;
 
@@ -427,7 +477,7 @@ pub(crate) mod tests {
     use super::*;
     use crate::{advance_fut, worker::tuner::FixedSizeSlotSupplier};
     use futures_util::FutureExt;
-    use temporal_sdk_core_api::worker::WorkflowSlotKind;
+    use temporalio_common::worker::WorkflowSlotKind;
 
     pub(crate) fn fixed_size_permit_dealer<SK: SlotKind + Send + Sync + 'static>(
         size: usize,
@@ -492,4 +542,10 @@ pub(crate) mod tests {
         // Now it'll proceed
         acquire_fut.await;
     }
+
+    #[test]
+    fn captures_slot_supplier_kind() {
+        let dealer = fixed_size_permit_dealer::<WorkflowSlotKind>(1);
+        assert_eq!(*dealer.slot_supplier_kind(), SlotSupplierKind::Fixed);
+    }
 }

package/sdk-core/crates/sdk-core/src/antithesis.rs

@@ -0,0 +1,60 @@
+//! Antithesis SDK integration for invariant testing.
+//!
+//! This module provides assertion macros that integrate with the Antithesis
+//! testing platform to detect invariant violations during fuzz testing.
+
+use std::sync::OnceLock;
+
+/// Ensure Antithesis is initialized exactly once.
+pub(crate) fn ensure_init() {
+    static INIT: OnceLock<()> = OnceLock::new();
+    INIT.get_or_init(|| {
+        ::antithesis_sdk::antithesis_init();
+    });
+}
+
+/// Assert that a condition is always true during Antithesis fuzz testing.
+/// Use `false` as the condition to log an invariant violation.
+macro_rules! assert_always {
+    ($condition:expr, $message:literal, $details:expr) => {{
+        $crate::antithesis::ensure_init();
+        let details: ::serde_json::Value = $details;
+        ::antithesis_sdk::assert_always!($condition, $message, &details);
+    }};
+    ($condition:expr, $message:literal) => {{
+        $crate::antithesis::ensure_init();
+        ::antithesis_sdk::assert_always!($condition, $message);
+    }};
+}
+
+/// Assert that a condition is sometimes true during Antithesis fuzz testing.
+/// This checks that the condition occurs at least once across the entire test session.
+macro_rules! assert_sometimes {
+    ($condition:expr, $message:literal, $details:expr) => {{
+        $crate::antithesis::ensure_init();
+        let details: ::serde_json::Value = $details;
+        ::antithesis_sdk::assert_sometimes!($condition, $message, &details);
+    }};
+    ($condition:expr, $message:literal) => {{
+        $crate::antithesis::ensure_init();
+        ::antithesis_sdk::assert_sometimes!($condition, $message);
+    }};
+}
+
+/// Assert that a code location is unreachable during Antithesis fuzz testing.
+/// Use this for code paths that should never be reached (bugs, invariant violations).
+macro_rules! assert_unreachable {
+    ($message:literal, $details:expr) => {{
+        $crate::antithesis::ensure_init();
+        let details: ::serde_json::Value = $details;
+        ::antithesis_sdk::assert_unreachable!($message, &details);
+    }};
+    ($message:literal) => {{
+        $crate::antithesis::ensure_init();
+        ::antithesis_sdk::assert_unreachable!($message);
+    }};
+}
+
+pub(crate) use assert_always;
+pub(crate) use assert_sometimes;
+pub(crate) use assert_unreachable;

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

@@ -1,10 +1,10 @@
 use crate::{
     ActivityHeartbeat, Worker, advance_fut, job_assert, prost_dur,
     test_help::{
-        MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, ResponseType, TEST_Q, WorkerExt,
-        WorkflowCachingPolicy, build_fake_worker, build_mock_pollers, canned_histories,
-        gen_assert_and_reply, mock_manual_poller, mock_poller, mock_poller_from_resps,
-        mock_sdk_cfg, mock_worker, poll_and_reply, single_hist_mock_sg, test_worker_cfg,
+        MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, WorkerExt,
+        WorkflowCachingPolicy, build_fake_worker, build_mock_pollers, fanout_tasks,
+        gen_assert_and_reply, mock_manual_poller, mock_poller, mock_worker, poll_and_reply,
+        single_hist_mock_sg, test_worker_cfg,
     },
     worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
 };
@@ -19,47 +19,43 @@ use std::{
         Arc,
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
-    time::Duration,
+    time::{Duration, Instant},
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{ActivityOptions, WfContext};
-use temporal_sdk_core_api::{
+use temporalio_common::{
     Worker as WorkerTrait,
-    errors::{CompleteActivityError, PollError},
-    worker::PollerBehavior,
-};
-use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
-    coresdk::{
-        ActivityTaskCompletion,
-        activity_result::{
-            ActivityExecutionResult, ActivityResolution, Success, activity_execution_result,
-            activity_resolution,
-        },
-        activity_task::{ActivityCancelReason, ActivityTask, Cancel, activity_task},
-        workflow_activation::{ResolveActivity, WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{
-            ActivityCancellationType, CompleteWorkflowExecution, RequestCancelActivity,
-            ScheduleActivity,
-        },
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        command::v1::{ScheduleActivityTaskCommandAttributes, command::Attributes},
-        enums::v1::{CommandType, EventType},
-        history::v1::{
-            ActivityTaskScheduledEventAttributes, history_event::Attributes as EventAttributes,
+    errors::CompleteActivityError,
+    protos::{
+        TestHistoryBuilder, canned_histories,
+        coresdk::{
+            ActivityTaskCompletion,
+            activity_result::{
+                ActivityExecutionResult, ActivityResolution, Success, activity_execution_result,
+                activity_resolution,
+            },
+            activity_task::{ActivityCancelReason, ActivityTask, Cancel, activity_task},
+            workflow_activation::{
+                ResolveActivity, WorkflowActivationJob, workflow_activation_job,
+            },
+            workflow_commands::{
+                ActivityCancellationType, CompleteWorkflowExecution, RequestCancelActivity,
+                ScheduleActivity,
+            },
+            workflow_completion::WorkflowActivationCompletion,
         },
-        sdk::v1::UserMetadata,
-        workflowservice::v1::{
-            PollActivityTaskQueueResponse, RecordActivityTaskHeartbeatResponse,
-            RespondActivityTaskCanceledResponse, RespondActivityTaskCompletedResponse,
-            RespondActivityTaskFailedResponse, RespondWorkflowTaskCompletedResponse,
+        temporal::api::{
+            command::v1::{ScheduleActivityTaskCommandAttributes, command::Attributes},
+            enums::v1::EventType,
+            workflowservice::v1::{
+                PollActivityTaskQueueResponse, RecordActivityTaskHeartbeatResponse,
+                RespondActivityTaskCanceledResponse, RespondActivityTaskCompletedResponse,
+                RespondActivityTaskFailedResponse, RespondWorkflowTaskCompletedResponse,
+            },
         },
+        test_utils::start_timer_cmd,
     },
+    worker::{PollerBehavior, WorkerTaskTypes},
 };
-use temporal_sdk_core_test_utils::{TestWorker, fanout_tasks, start_timer_cmd};
-use tokio::{join, sync::Barrier, time::sleep};
+use tokio::{join, time::sleep};
 use tokio_util::sync::CancellationToken;
 
 fn three_tasks() -> VecDeque<PollActivityTaskQueueResponse> {
@@ -642,6 +638,47 @@ async fn max_tq_acts_set_passed_to_poll_properly() {
     worker.poll_activity_task().await.unwrap();
 }
 
+#[tokio::test]
+async fn max_worker_acts_per_second_respected() {
+    let mut mock_client = mock_worker_client();
+    mock_client
+        .expect_poll_activity_task()
+        .returning(move |_, _| {
+            Ok(PollActivityTaskQueueResponse {
+                task_token: vec![1],
+                activity_id: "some-id".to_string(),
+                ..Default::default()
+            })
+        });
+    mock_client
+        .expect_complete_activity_task()
+        .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
+
+    let cfg = test_worker_cfg()
+        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
+        .max_outstanding_activities(10_usize)
+        .max_worker_activities_per_second(1.0)
+        .build()
+        .unwrap();
+    let worker = Worker::new_test(cfg, mock_client);
+    let start = Instant::now();
+    let mut received = 0;
+    while start.elapsed().as_millis() < 900 {
+        let at = worker.poll_activity_task().await.unwrap();
+        received += 1;
+        worker
+            .complete_activity_task(ActivityTaskCompletion {
+                task_token: at.task_token,
+                result: Some(ActivityExecutionResult::ok("hi".into())),
+            })
+            .await
+            .unwrap();
+    }
+    // Two will be allowed because of the initial request. Without ratelimit in effect, this number
+    // would be comically high due to the mocks responding very fast.
+    assert_eq!(received, 2);
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn no_eager_activities_requested_when_worker_options_disable_it(
@@ -688,7 +725,7 @@ async fn no_eager_activities_requested_when_worker_options_disable_it(
     mock.worker_cfg(|wc| {
         wc.max_cached_workflows = 2;
         if reason == "no_remote" {
-            wc.no_remote_activities = true;
+            wc.task_types = WorkerTaskTypes::workflow_only();
         } else {
             wc.max_task_queue_activities_per_second = Some(1.0);
         }
@@ -701,7 +738,7 @@ async fn no_eager_activities_requested_when_worker_options_disable_it(
         ScheduleActivity {
             seq: 1,
             activity_id: "act_id".to_string(),
-            task_queue: TEST_Q.to_string(),
+            task_queue: core.get_config().task_queue.clone(),
             cancellation_type: ActivityCancellationType::TryCancel as i32,
             ..Default::default()
         }
@@ -781,11 +818,14 @@ async fn activity_tasks_from_completion_are_delivered() {
     mock.expect_complete_activity_task()
         .times(3)
         .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
-    let mut mock = single_hist_mock_sg(wfid, t, [1], mock, true);
     let act_tasks: Vec<QueueResponse<PollActivityTaskQueueResponse>> = vec![];
-    mock.set_act_poller(mock_poller_from_resps(act_tasks));
+    let mut mh = MockPollCfg::from_resp_batches(wfid, t, [1], mock);
+    mh.enforce_correct_number_of_polls = true;
+    mh.activity_responses = Some(act_tasks);
+    let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 2);
     let core = mock_worker(mock);
+    let task_queue = core.get_config().task_queue.clone();
 
     // Test start
     let wf_task = core.poll_workflow_activation().await.unwrap();
@@ -794,7 +834,7 @@ async fn activity_tasks_from_completion_are_delivered() {
             ScheduleActivity {
                 seq,
                 activity_id: format!("act_id_{seq}_same_queue"),
-                task_queue: TEST_Q.to_string(),
+                task_queue: task_queue.clone(),
                 cancellation_type: ActivityCancellationType::TryCancel as i32,
                 ..Default::default()
             }
@@ -805,7 +845,7 @@ async fn activity_tasks_from_completion_are_delivered() {
         ScheduleActivity {
             seq: 4,
             activity_id: "act_id_same_queue_not_eager".to_string(),
-            task_queue: TEST_Q.to_string(),
+            task_queue: task_queue.clone(),
             cancellation_type: ActivityCancellationType::TryCancel as i32,
             ..Default::default()
         }
@@ -848,160 +888,6 @@ async fn activity_tasks_from_completion_are_delivered() {
     assert_eq!(num_eager_requested.load(Ordering::Relaxed), 3);
 }
 
-#[tokio::test]
-async fn activity_tasks_from_completion_reserve_slots() {
-    let wf_id = "fake_wf_id";
-    let mut t = TestHistoryBuilder::default();
-    t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let schedid = t.add(EventAttributes::ActivityTaskScheduledEventAttributes(
-        ActivityTaskScheduledEventAttributes {
-            activity_id: "1".to_string(),
-            activity_type: Some("act1".into()),
-            ..Default::default()
-        },
-    ));
-    let startid = t.add_activity_task_started(schedid);
-    t.add_activity_task_completed(schedid, startid, b"hi".into());
-    t.add_full_wf_task();
-    let schedid = t.add(EventAttributes::ActivityTaskScheduledEventAttributes(
-        ActivityTaskScheduledEventAttributes {
-            activity_id: "2".to_string(),
-            activity_type: Some("act2".into()),
-            ..Default::default()
-        },
-    ));
-    let startid = t.add_activity_task_started(schedid);
-    t.add_activity_task_completed(schedid, startid, b"hi".into());
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
-
-    let mut mock = mock_worker_client();
-    // Set up two tasks to be returned via normal activity polling
-    let act_tasks = VecDeque::from(vec![
-        PollActivityTaskQueueResponse {
-            task_token: vec![1],
-            activity_id: "act1".to_string(),
-            ..Default::default()
-        }
-        .into(),
-        PollActivityTaskQueueResponse {
-            task_token: vec![2],
-            activity_id: "act2".to_string(),
-            ..Default::default()
-        }
-        .into(),
-    ]);
-    mock.expect_complete_activity_task()
-        .times(2)
-        .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
-    let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
-    let mut mh = MockPollCfg::from_resp_batches(
-        wf_id,
-        t,
-        [
-            ResponseType::ToTaskNum(1),
-            // We don't want the second task to be delivered until *after* the activity tasks
-            // have been completed, so that the second activity schedule will have slots available
-            ResponseType::UntilResolved(
-                async {
-                    barr.wait().await;
-                    barr.wait().await;
-                }
-                .boxed(),
-                2,
-            ),
-            ResponseType::AllHistory,
-        ],
-        mock,
-    );
-    mh.completion_mock_fn = Some(Box::new(|wftc| {
-        // Make sure when we see the completion with the schedule act command that it does
-        // not have the eager execution flag set the first time, and does the second.
-        if let Some(Attributes::ScheduleActivityTaskCommandAttributes(attrs)) = wftc
-            .commands
-            .first()
-            .and_then(|cmd| cmd.attributes.as_ref())
-        {
-            if attrs.activity_id == "1" {
-                assert!(!attrs.request_eager_execution);
-            } else {
-                assert!(attrs.request_eager_execution);
-            }
-        }
-        Ok(Default::default())
-    }));
-    let mut mock = build_mock_pollers(mh);
-    mock.worker_cfg(|cfg| {
-        cfg.max_cached_workflows = 2;
-        cfg.max_outstanding_activities = Some(2);
-    });
-    mock.set_act_poller(mock_poller_from_resps(act_tasks));
-    let core = Arc::new(mock_worker(mock));
-    let mut worker = TestWorker::new(core.clone(), TEST_Q.to_string());
-
-    // First poll for activities twice, occupying both slots
-    let at1 = core.poll_activity_task().await.unwrap();
-    let at2 = core.poll_activity_task().await.unwrap();
-    let workflow_complete_token = CancellationToken::new();
-    let workflow_complete_token_clone = workflow_complete_token.clone();
-
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| {
-        let complete_token = workflow_complete_token.clone();
-        async move {
-            ctx.activity(ActivityOptions {
-                activity_type: "act1".to_string(),
-                ..Default::default()
-            })
-            .await;
-            ctx.activity(ActivityOptions {
-                activity_type: "act2".to_string(),
-                ..Default::default()
-            })
-            .await;
-            complete_token.cancel();
-            Ok(().into())
-        }
-    });
-
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            DEFAULT_WORKFLOW_TYPE,
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    let act_completer = async {
-        barr.wait().await;
-        core.complete_activity_task(ActivityTaskCompletion {
-            task_token: at1.task_token,
-            result: Some(ActivityExecutionResult::ok("hi".into())),
-        })
-        .await
-        .unwrap();
-        core.complete_activity_task(ActivityTaskCompletion {
-            task_token: at2.task_token,
-            result: Some(ActivityExecutionResult::ok("hi".into())),
-        })
-        .await
-        .unwrap();
-        barr.wait().await;
-        // Wait for workflow to complete in order for all eager activities to be requested before shutting down.
-        // After shutdown, no eager activities slots can be allocated.
-        workflow_complete_token_clone.cancelled().await;
-        core.initiate_shutdown();
-        // Even though this test requests eager activity tasks, none are returned in poll responses.
-        let err = core.poll_activity_task().await.unwrap_err();
-        assert_matches!(err, PollError::ShutDown);
-    };
-    // This wf poll should *not* set the flag that it wants tasks back since both slots are
-    // occupied
-    let run_fut = async { worker.run_until_done().await.unwrap() };
-    join!(run_fut, act_completer);
-}
-
 #[tokio::test]
 async fn retryable_net_error_exhaustion_is_nonfatal() {
     let mut mock_client = mock_worker_client();
@@ -1198,57 +1084,6 @@ async fn activities_must_be_flushed_to_server_on_shutdown(#[values(true, false)]
     join!(shutdown_task, complete_task);
 }
 
-#[tokio::test]
-async fn pass_activity_summary_to_metadata() {
-    let t = canned_histories::single_activity("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"activity 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::ScheduleActivityTask
-                );
-                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.activity(ActivityOptions {
-            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-            summary: Some("activity summary".to_string()),
-            ..Default::default()
-        })
-        .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 heartbeat_response_can_be_paused() {
     let mut mock_client = mock_worker_client();