@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/core/src/worker/slot_provider.rs

@@ -58,6 +58,7 @@ pub(super) struct SlotProvider {
     task_queue: String,
     wft_semaphore: MeteredPermitDealer<WorkflowSlotKind>,
     external_wft_tx: WFTStreamSender,
+    deployment_options: Option<temporal_sdk_core_api::worker::WorkerDeploymentOptions>,
 }
 
 impl SlotProvider {
@@ -66,12 +67,14 @@ impl SlotProvider {
         task_queue: String,
         wft_semaphore: MeteredPermitDealer<WorkflowSlotKind>,
         external_wft_tx: WFTStreamSender,
+        deployment_options: Option<temporal_sdk_core_api::worker::WorkerDeploymentOptions>,
     ) -> Self {
         Self {
             namespace,
             task_queue,
             wft_semaphore,
             external_wft_tx,
+            deployment_options,
         }
     }
 }
@@ -89,6 +92,9 @@ impl SlotProviderTrait for SlotProvider {
             None => None,
         }
     }
+    fn deployment_options(&self) -> Option<temporal_sdk_core_api::worker::WorkerDeploymentOptions> {
+        self.deployment_options.clone()
+    }
 }
 
 #[cfg(test)]
@@ -125,6 +131,7 @@ mod tests {
             "my_queue".to_string(),
             wft_semaphore,
             external_wft_tx,
+            None,
         );
 
         let slot = provider
@@ -146,6 +153,7 @@ mod tests {
                 "my_queue".to_string(),
                 wft_semaphore,
                 external_wft_tx,
+                None,
             );
             assert!(provider.try_reserve_wft_slot().is_some());
         }
@@ -163,6 +171,7 @@ mod tests {
                 "my_queue".to_string(),
                 wft_semaphore.clone(),
                 external_wft_tx,
+                None,
             );
             let slot = provider.try_reserve_wft_slot();
             assert!(slot.is_some());

package/sdk-core/core/src/worker/tuner.rs

@@ -108,6 +108,24 @@ impl TunerHolderOptions {
             }
             None => {}
         }
+        match self.nexus_slot_options {
+            Some(SlotSupplierOptions::FixedSize { slots }) => {
+                builder.nexus_slot_supplier(Arc::new(FixedSizeSlotSupplier::new(slots)));
+            }
+            Some(SlotSupplierOptions::ResourceBased(rso)) => {
+                builder.nexus_slot_supplier(
+                    rb_tuner
+                        .as_mut()
+                        .unwrap()
+                        .with_nexus_slots_options(rso)
+                        .nexus_task_slot_supplier(),
+                );
+            }
+            Some(SlotSupplierOptions::Custom(ss)) => {
+                builder.nexus_slot_supplier(ss);
+            }
+            None => {}
+        }
         Ok(builder.build())
     }
 }
@@ -144,6 +162,9 @@ impl TunerHolderOptionsBuilder {
         ) || matches!(
             self.local_activity_slot_options,
             Some(Some(SlotSupplierOptions::ResourceBased(_)))
+        ) || matches!(
+            self.nexus_slot_options,
+            Some(Some(SlotSupplierOptions::ResourceBased(_)))
         );
         if any_is_resource_based && matches!(self.resource_based_options, None | Some(None)) {
             return Err(
@@ -270,3 +291,141 @@ impl WorkerTuner for TunerHolder {
         self.nexus_supplier.clone()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+    use temporal_sdk_core_api::worker::{
+        SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplierPermit,
+    };
+
+    struct TestSlotSupplier;
+    #[async_trait::async_trait]
+    impl SlotSupplier for TestSlotSupplier {
+        type SlotKind = NexusSlotKind;
+        async fn reserve_slot(&self, _: &dyn SlotReservationContext) -> SlotSupplierPermit {
+            SlotSupplierPermit::default()
+        }
+        fn try_reserve_slot(&self, _: &dyn SlotReservationContext) -> Option<SlotSupplierPermit> {
+            Some(SlotSupplierPermit::default())
+        }
+        fn mark_slot_used(&self, _: &dyn SlotMarkUsedContext<SlotKind = Self::SlotKind>) {}
+        fn release_slot(&self, _: &dyn SlotReleaseContext<SlotKind = Self::SlotKind>) {}
+    }
+
+    #[test]
+    fn tuner_holder_options_nexus_fixed_size() {
+        let options = TunerHolderOptions {
+            workflow_slot_options: None,
+            activity_slot_options: None,
+            local_activity_slot_options: None,
+            nexus_slot_options: Some(SlotSupplierOptions::FixedSize { slots: 50 }),
+            resource_based_options: None,
+        };
+
+        let tuner = options.build_tuner_holder().unwrap();
+        // The tuner is built successfully with fixed size nexus slots
+        let _ = tuner.nexus_task_slot_supplier();
+    }
+
+    #[test]
+    fn tuner_holder_options_nexus_resource_based() {
+        let resource_opts = ResourceBasedSlotsOptionsBuilder::default()
+            .target_mem_usage(0.8)
+            .target_cpu_usage(0.9)
+            .build()
+            .unwrap();
+
+        let options = TunerHolderOptions {
+            workflow_slot_options: None,
+            activity_slot_options: None,
+            local_activity_slot_options: None,
+            nexus_slot_options: Some(SlotSupplierOptions::ResourceBased(
+                ResourceSlotOptions::new(5, 100, Duration::from_millis(100)),
+            )),
+            resource_based_options: Some(resource_opts),
+        };
+
+        let tuner = options.build_tuner_holder().unwrap();
+        // The tuner is built successfully with resource-based nexus slots
+        let _ = tuner.nexus_task_slot_supplier();
+    }
+
+    #[test]
+    fn tuner_holder_options_nexus_custom() {
+        let custom_supplier: Arc<dyn SlotSupplier<SlotKind = NexusSlotKind> + Send + Sync> =
+            Arc::new(TestSlotSupplier);
+
+        let options = TunerHolderOptions {
+            workflow_slot_options: None,
+            activity_slot_options: None,
+            local_activity_slot_options: None,
+            nexus_slot_options: Some(SlotSupplierOptions::Custom(custom_supplier.clone())),
+            resource_based_options: None,
+        };
+
+        let tuner = options.build_tuner_holder().unwrap();
+        // The tuner is built successfully with custom nexus slots
+        let _ = tuner.nexus_task_slot_supplier();
+    }
+
+    #[test]
+    fn tuner_builder_with_nexus_slot_supplier() {
+        let mut builder = TunerBuilder::default();
+        let custom_supplier: Arc<dyn SlotSupplier<SlotKind = NexusSlotKind> + Send + Sync> =
+            Arc::new(FixedSizeSlotSupplier::new(25));
+
+        builder.nexus_slot_supplier(custom_supplier.clone());
+        let tuner = builder.build();
+
+        // The tuner is built successfully with the custom nexus slot supplier
+        let _ = tuner.nexus_task_slot_supplier();
+    }
+
+    #[test]
+    fn tuner_holder_options_builder_validates_resource_based_requirements() {
+        // Should fail when nexus uses ResourceBased but resource_based_options is not set
+        let result = TunerHolderOptionsBuilder::default()
+            .nexus_slot_options(SlotSupplierOptions::ResourceBased(
+                ResourceSlotOptions::new(5, 100, Duration::from_millis(100)),
+            ))
+            .build();
+
+        assert!(result.is_err());
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("resource_based_options")
+        );
+    }
+
+    #[test]
+    fn tuner_holder_options_all_slot_types() {
+        let resource_opts = ResourceBasedSlotsOptionsBuilder::default()
+            .target_mem_usage(0.8)
+            .target_cpu_usage(0.9)
+            .build()
+            .unwrap();
+
+        let options = TunerHolderOptions {
+            workflow_slot_options: Some(SlotSupplierOptions::FixedSize { slots: 10 }),
+            activity_slot_options: Some(SlotSupplierOptions::FixedSize { slots: 20 }),
+            local_activity_slot_options: Some(SlotSupplierOptions::ResourceBased(
+                ResourceSlotOptions::new(2, 50, Duration::from_millis(100)),
+            )),
+            nexus_slot_options: Some(SlotSupplierOptions::ResourceBased(
+                ResourceSlotOptions::new(5, 100, Duration::from_millis(100)),
+            )),
+            resource_based_options: Some(resource_opts),
+        };
+
+        let tuner = options.build_tuner_holder().unwrap();
+        // All suppliers should be successfully configured
+        let _ = tuner.workflow_task_slot_supplier();
+        let _ = tuner.activity_task_slot_supplier();
+        let _ = tuner.local_activity_slot_supplier();
+        let _ = tuner.nexus_task_slot_supplier();
+    }
+}

package/sdk-core/core/src/worker/workflow/history_update.rs

@@ -806,15 +806,12 @@ mod tests {
     use super::*;
     use crate::{
         replay::{HistoryInfo, TestHistoryBuilder},
-        test_help::{MockPollCfg, ResponseType, canned_histories, hist_to_poll_resp, mock_sdk_cfg},
+        test_help::{ResponseType, hist_to_poll_resp},
         worker::client::mocks::mock_worker_client,
     };
-    use futures_util::{StreamExt, TryStreamExt};
-    use std::sync::atomic::{AtomicUsize, Ordering};
-    use temporal_client::WorkflowOptions;
-    use temporal_sdk::WfContext;
+    use futures_util::TryStreamExt;
     use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
+        canned_histories,
         temporal::api::{
             common::v1::WorkflowExecution, enums::v1::WorkflowTaskFailedCause,
             workflowservice::v1::GetWorkflowExecutionHistoryResponse,
@@ -1334,124 +1331,6 @@ mod tests {
         assert_matches!(update.take_next_wft_sequence(8), NextWFT::ReplayOver);
     }
 
-    #[tokio::test]
-    async fn weird_pagination_doesnt_drop_wft_events() {
-        let wf_id = "fakeid";
-        // 1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
-        // 2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-        // 3: EVENT_TYPE_WORKFLOW_TASK_STARTED
-        // 4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
-        // empty page
-        // 5: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 6: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-        // 7: EVENT_TYPE_WORKFLOW_TASK_STARTED
-        // 8: EVENT_TYPE_WORKFLOW_TASK_FAILED
-        // empty page
-        // 9: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 10: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-        // 11: EVENT_TYPE_WORKFLOW_TASK_STARTED
-        // empty page
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-
-        t.add_we_signaled("hi", vec![]);
-        t.add_workflow_task_scheduled_and_started();
-        t.add_workflow_task_failed_with_failure(
-            WorkflowTaskFailedCause::UnhandledCommand,
-            Default::default(),
-        );
-
-        t.add_we_signaled("hi", vec![]);
-        t.add_workflow_task_scheduled_and_started();
-
-        let workflow_task = t.get_full_history_info().unwrap();
-        let mut wft_resp = workflow_task.as_poll_wft_response();
-        wft_resp.workflow_execution = Some(WorkflowExecution {
-            workflow_id: wf_id.to_string(),
-            run_id: t.get_orig_run_id().to_string(),
-        });
-        // Just 9/10/11 in WFT
-        wft_resp.history.as_mut().unwrap().events.drain(0..8);
-
-        let mut resp_1: GetWorkflowExecutionHistoryResponse =
-            t.get_full_history_info().unwrap().into();
-        resp_1.next_page_token = vec![1];
-        resp_1.history.as_mut().unwrap().events.truncate(4);
-
-        let mut mock_client = mock_worker_client();
-        mock_client
-            .expect_get_workflow_execution_history()
-            .returning(move |_, _, _| Ok(resp_1.clone()))
-            .times(1);
-        mock_client
-            .expect_get_workflow_execution_history()
-            .returning(move |_, _, _| {
-                Ok(GetWorkflowExecutionHistoryResponse {
-                    history: Some(History { events: vec![] }),
-                    raw_history: vec![],
-                    next_page_token: vec![2],
-                    archived: false,
-                })
-            })
-            .times(1);
-        let mut resp_2: GetWorkflowExecutionHistoryResponse =
-            t.get_full_history_info().unwrap().into();
-        resp_2.next_page_token = vec![3];
-        resp_2.history.as_mut().unwrap().events.drain(0..4);
-        resp_2.history.as_mut().unwrap().events.truncate(4);
-        mock_client
-            .expect_get_workflow_execution_history()
-            .returning(move |_, _, _| Ok(resp_2.clone()))
-            .times(1);
-        mock_client
-            .expect_get_workflow_execution_history()
-            .returning(move |_, _, _| {
-                Ok(GetWorkflowExecutionHistoryResponse {
-                    history: Some(History { events: vec![] }),
-                    raw_history: vec![],
-                    next_page_token: vec![],
-                    archived: false,
-                })
-            })
-            .times(1);
-
-        let wf_type = DEFAULT_WORKFLOW_TYPE;
-        let mh =
-            MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::Raw(wft_resp)], mock_client);
-        let mut worker = mock_sdk_cfg(mh, |cfg| {
-            cfg.max_cached_workflows = 2;
-            cfg.ignore_evicts_on_shutdown = false;
-        });
-
-        let sig_ctr = Arc::new(AtomicUsize::new(0));
-        let sig_ctr_clone = sig_ctr.clone();
-        worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| {
-            let sig_ctr_clone = sig_ctr_clone.clone();
-            async move {
-                let mut sigchan = ctx.make_signal_channel("hi");
-                while sigchan.next().await.is_some() {
-                    if sig_ctr_clone.fetch_add(1, Ordering::AcqRel) == 1 {
-                        break;
-                    }
-                }
-                Ok(().into())
-            }
-        });
-
-        worker
-            .submit_wf(
-                wf_id.to_owned(),
-                wf_type.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
-            )
-            .await
-            .unwrap();
-        worker.run_until_done().await.unwrap();
-        assert_eq!(sig_ctr.load(Ordering::Acquire), 2);
-    }
-
     #[tokio::test]
     async fn extreme_pagination_doesnt_drop_wft_events_paginator() {
         // 1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
@@ -1559,147 +1438,6 @@ mod tests {
         assert_eq!(seq.last().unwrap().event_id, 15);
     }
 
-    #[tokio::test]
-    async fn extreme_pagination_doesnt_drop_wft_events_worker() {
-        let wf_id = "fakeid";
-
-        // In this test, we add empty pages between each event
-
-        // 1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
-        // 2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-        // 3: EVENT_TYPE_WORKFLOW_TASK_STARTED // <- previous_started_event_id
-        // 4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
-
-        // 5: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 6: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-        // 7: EVENT_TYPE_WORKFLOW_TASK_STARTED
-        // 8: EVENT_TYPE_WORKFLOW_TASK_FAILED
-
-        // 9: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 10: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 11: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 12: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 13: EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED
-        // 14: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
-        // 15: EVENT_TYPE_WORKFLOW_TASK_STARTED // <- started_event_id
-
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-
-        t.add_we_signaled("hi", vec![]);
-        t.add_workflow_task_scheduled_and_started();
-        t.add_workflow_task_failed_with_failure(
-            WorkflowTaskFailedCause::UnhandledCommand,
-            Default::default(),
-        );
-
-        t.add_we_signaled("hi", vec![]);
-        t.add_we_signaled("hi", vec![]);
-        t.add_we_signaled("hi", vec![]);
-        t.add_we_signaled("hi", vec![]);
-        t.add_we_signaled("hi", vec![]);
-        t.add_workflow_task_scheduled_and_started();
-
-        /////
-
-        let events: Vec<HistoryEvent> = t.get_full_history_info().unwrap().into_events();
-        let first_event = events[0].clone();
-
-        let mut mock_client = mock_worker_client();
-
-        for (i, event) in events.into_iter().enumerate() {
-            // Add an empty page
-            mock_client
-                .expect_get_workflow_execution_history()
-                .returning(move |_, _, _| {
-                    Ok(GetWorkflowExecutionHistoryResponse {
-                        history: Some(History { events: vec![] }),
-                        raw_history: vec![],
-                        next_page_token: vec![(i * 10 + 1) as u8],
-                        archived: false,
-                    })
-                })
-                .times(1);
-
-            // Add a page with just event i
-            mock_client
-                .expect_get_workflow_execution_history()
-                .returning(move |_, _, _| {
-                    Ok(GetWorkflowExecutionHistoryResponse {
-                        history: Some(History {
-                            events: vec![event.clone()],
-                        }),
-                        raw_history: vec![],
-                        next_page_token: vec![(i * 10) as u8],
-                        archived: false,
-                    })
-                })
-                .times(1);
-        }
-
-        // Add an extra empty page at the end, with no NPT
-        mock_client
-            .expect_get_workflow_execution_history()
-            .returning(move |_, _, _| {
-                Ok(GetWorkflowExecutionHistoryResponse {
-                    history: Some(History { events: vec![] }),
-                    raw_history: vec![],
-                    next_page_token: vec![],
-                    archived: false,
-                })
-            })
-            .times(1);
-
-        let workflow_task = t.get_full_history_info().unwrap();
-        let mut wft_resp = workflow_task.as_poll_wft_response();
-        wft_resp.workflow_execution = Some(WorkflowExecution {
-            workflow_id: wf_id.to_string(),
-            run_id: t.get_orig_run_id().to_string(),
-        });
-        wft_resp.history = Some(History {
-            events: vec![first_event],
-        });
-        wft_resp.next_page_token = vec![1];
-        wft_resp.previous_started_event_id = 3;
-        wft_resp.started_event_id = 15;
-
-        let wf_type = DEFAULT_WORKFLOW_TYPE;
-        let mh =
-            MockPollCfg::from_resp_batches(wf_id, t, [ResponseType::Raw(wft_resp)], mock_client);
-        let mut worker = mock_sdk_cfg(mh, |cfg| {
-            cfg.max_cached_workflows = 2;
-            cfg.ignore_evicts_on_shutdown = false;
-        });
-
-        let sig_ctr = Arc::new(AtomicUsize::new(0));
-        let sig_ctr_clone = sig_ctr.clone();
-        worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| {
-            let sig_ctr_clone = sig_ctr_clone.clone();
-            async move {
-                let mut sigchan = ctx.make_signal_channel("hi");
-                while sigchan.next().await.is_some() {
-                    if sig_ctr_clone.fetch_add(1, Ordering::AcqRel) == 5 {
-                        break;
-                    }
-                }
-                Ok(().into())
-            }
-        });
-
-        worker
-            .submit_wf(
-                wf_id.to_owned(),
-                wf_type.to_owned(),
-                vec![],
-                WorkflowOptions::default(),
-            )
-            .await
-            .unwrap();
-        worker.run_until_done().await.unwrap();
-        assert_eq!(sig_ctr.load(Ordering::Acquire), 6);
-    }
-
     #[tokio::test]
     async fn finding_end_index_with_started_as_last_event() {
         let wf_id = "fakeid";

package/sdk-core/core/src/worker/workflow/machines/activity_state_machine.rs

@@ -803,63 +803,10 @@ mod test {
     use super::*;
     use crate::{
         internal_flags::InternalFlags,
-        replay::TestHistoryBuilder,
-        test_help::{MockPollCfg, ResponseType, build_fake_sdk},
         worker::workflow::{OutgoingJob, machines::Machines},
     };
     use std::{cell::RefCell, mem::discriminant, rc::Rc};
-    use temporal_sdk::{ActivityOptions, CancellableFuture, WfContext, WorkflowFunction};
-    use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
-        coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-    };
-    use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor;
-
-    #[tokio::test]
-    async fn immediate_activity_cancelation() {
-        let func = WorkflowFunction::new(|ctx: WfContext| async move {
-            let cancel_activity_future = ctx.activity(ActivityOptions::default());
-            // Immediately cancel the activity
-            cancel_activity_future.cancel(&ctx);
-            cancel_activity_future.await;
-            Ok(().into())
-        });
-
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-        let mut worker = build_fake_sdk(MockPollCfg::from_resps(t, [ResponseType::AllHistory]));
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
-
-        let mut aai = ActivationAssertionsInterceptor::default();
-        aai.then(|a| {
-            assert_matches!(
-                a.jobs.as_slice(),
-                [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                }]
-            )
-        });
-        aai.then(|a| {
-            assert_matches!(
-                a.jobs.as_slice(),
-                [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::ResolveActivity(
-                        ResolveActivity {
-                            result: Some(ActivityResolution {
-                                status: Some(activity_resolution::Status::Cancelled(_))
-                            }),
-                            ..
-                        }
-                    )),
-                },]
-            )
-        });
-
-        worker.set_worker_interceptor(aai);
-        worker.run().await.unwrap();
-    }
+    use temporal_sdk_core_protos::coresdk::workflow_activation::workflow_activation_job;
 
     #[test]
     fn cancels_ignored_terminal() {

package/sdk-core/core/src/worker/workflow/machines/cancel_external_state_machine.rs

@@ -210,85 +210,3 @@ impl WFMachinesAdapter for CancelExternalMachine {
         })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{
-        replay::TestHistoryBuilder,
-        test_help::{MockPollCfg, build_fake_sdk},
-    };
-    use temporal_sdk::{WfContext, WorkflowResult};
-    use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE;
-
-    async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
-        let res = ctx
-            .cancel_external(
-                NamespacedWorkflowExecution {
-                    namespace: "some_namespace".to_string(),
-                    workflow_id: "fake_wid".to_string(),
-                    run_id: "fake_rid".to_string(),
-                },
-                "cancel reason".to_string(),
-            )
-            .await;
-        if res.is_err() {
-            Err(anyhow::anyhow!("Cancel fail!"))
-        } else {
-            Ok(().into())
-        }
-    }
-
-    #[rstest::rstest]
-    #[case::succeeds(false)]
-    #[case::fails(true)]
-    #[tokio::test]
-    async fn sends_cancel(#[case] fails: bool) {
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        let id = t.add_cancel_external_wf(NamespacedWorkflowExecution {
-            namespace: "some_namespace".to_string(),
-            workflow_id: "fake_wid".to_string(),
-            run_id: "fake_rid".to_string(),
-        });
-        if fails {
-            t.add_cancel_external_wf_failed(id);
-        } else {
-            t.add_cancel_external_wf_completed(id);
-        }
-        t.add_full_wf_task();
-        if fails {
-            t.add_workflow_execution_failed();
-        } else {
-            t.add_workflow_execution_completed();
-        }
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts
-                .then(|wft| {
-                    assert_matches!(
-                        wft.commands[0].command_type(),
-                        CommandType::RequestCancelExternalWorkflowExecution
-                    );
-                })
-                .then(move |wft| {
-                    if fails {
-                        assert_eq!(
-                            wft.commands[0].command_type(),
-                            CommandType::FailWorkflowExecution
-                        );
-                    } else {
-                        assert_eq!(
-                            wft.commands[0].command_type(),
-                            CommandType::CompleteWorkflowExecution
-                        );
-                    }
-                });
-        });
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, cancel_sender);
-        worker.run().await.unwrap();
-    }
-}