@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/tests/integ_tests/workflow_tests/activities.rs

@@ -1,5 +1,6 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -23,7 +24,7 @@ use temporal_sdk_core_protos::{
     },
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers, CoreWfStarter,
+    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 
@@ -50,7 +51,12 @@ async fn one_activity() {
     );
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -58,25 +64,27 @@ async fn one_activity() {
 
 #[tokio::test]
 async fn activity_workflow() {
-    let (core, task_q) = init_core_and_create_wf("activity_workflow").await;
+    let mut starter = init_core_and_create_wf("activity_workflow").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity
     core.complete_workflow_activation(
         schedule_activity_cmd(
             0,
-            &task_q,
+            task_q,
             activity_id,
             ActivityCancellationType::TryCancel,
             Duration::from_secs(60),
             Duration::from_secs(60),
         )
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters
-    let task = core.poll_activity_task(&task_q).await.unwrap();
+    let task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -90,13 +98,12 @@ async fn activity_workflow() {
     // Complete activity successfully.
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::ok(response_payload.clone())),
     })
     .await
     .unwrap();
     // Poll workflow task and verify that activity has succeeded.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -114,30 +121,32 @@ async fn activity_workflow() {
             assert_eq!(r, &response_payload);
         }
     );
-    core.complete_execution(&task_q, &task.run_id).await;
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn activity_non_retryable_failure() {
-    let (core, task_q) = init_core_and_create_wf("activity_non_retryable_failure").await;
+    let mut starter = init_core_and_create_wf("activity_non_retryable_failure").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity
     core.complete_workflow_activation(
         schedule_activity_cmd(
             0,
-            &task_q,
+            task_q,
             activity_id,
             ActivityCancellationType::TryCancel,
             Duration::from_secs(60),
             Duration::from_secs(60),
         )
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters
-    let task = core.poll_activity_task(&task_q).await.unwrap();
+    let task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -148,13 +157,12 @@ async fn activity_non_retryable_failure() {
     let failure = Failure::application_failure("activity failed".to_string(), true);
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::fail(failure.clone())),
     })
     .await
     .unwrap();
     // Poll workflow task and verify that activity has failed.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -185,30 +193,32 @@ async fn activity_non_retryable_failure() {
             });
         }
     );
-    core.complete_execution(&task_q, &task.run_id).await;
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn activity_retry() {
-    let (core, task_q) = init_core_and_create_wf("activity_retry").await;
+    let mut starter = init_core_and_create_wf("activity_retry").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity
     core.complete_workflow_activation(
         schedule_activity_cmd(
             0,
-            &task_q,
+            task_q,
             activity_id,
             ActivityCancellationType::TryCancel,
             Duration::from_secs(60),
             Duration::from_secs(60),
         )
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity 1st time
-    let task = core.poll_activity_task(&task_q).await.unwrap();
+    let task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -219,13 +229,12 @@ async fn activity_retry() {
     let failure = Failure::application_failure("activity failed".to_string(), false);
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::fail(failure)),
     })
     .await
     .unwrap();
     // Poll 2nd time
-    let task = core.poll_activity_task(&task_q).await.unwrap();
+    let task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -239,13 +248,12 @@ async fn activity_retry() {
     };
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::ok(response_payload.clone())),
     })
     .await
     .unwrap();
     // Poll workflow task and verify activity has succeeded.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -260,20 +268,22 @@ async fn activity_retry() {
             assert_eq!(r, &response_payload);
         }
     );
-    core.complete_execution(&task_q, &task.run_id).await;
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn activity_cancellation_try_cancel() {
-    let (core, task_q) = init_core_and_create_wf("activity_cancellation_try_cancel").await;
+    let mut starter = init_core_and_create_wf("activity_cancellation_try_cancel").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity and a timer that fires immediately
     core.complete_workflow_activation(
         vec![
             schedule_activity_cmd(
                 0,
-                &task_q,
+                task_q,
                 activity_id,
                 ActivityCancellationType::TryCancel,
                 Duration::from_secs(60),
@@ -285,13 +295,13 @@ async fn activity_cancellation_try_cancel() {
             }
             .into(),
         ]
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
     // complete it in this test as activity is try-cancelled.
-    let activity_task = core.poll_activity_task(&task_q).await.unwrap();
+    let activity_task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         activity_task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -299,7 +309,7 @@ async fn activity_cancellation_try_cancel() {
         }
     );
     // Poll workflow task and verify that activity has failed.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -313,28 +323,29 @@ async fn activity_cancellation_try_cancel() {
         }
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_execution(&task_q, &task.run_id).await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
-    let (core, task_q) =
+    let mut starter =
         init_core_and_create_wf("activity_cancellation_plus_complete_doesnt_double_resolve").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity and a timer that fires immediately
     core.complete_workflow_activation(
         vec![
             schedule_activity_cmd(
                 0,
-                &task_q,
+                task_q,
                 activity_id,
                 ActivityCancellationType::TryCancel,
                 Duration::from_secs(60),
@@ -346,13 +357,13 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
             }
             .into(),
         ]
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
-    let activity_task = core.poll_activity_task(&task_q).await.unwrap();
+    let activity_task = core.poll_activity_task().await.unwrap();
     assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [WorkflowActivationJob {
@@ -360,13 +371,12 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
         }]
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Should get cancel task
     assert_matches!(
         task.jobs.as_slice(),
@@ -384,7 +394,6 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     // We need to complete the wf task to send the activity cancel command to the server, so start
     // another short timer
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![StartTimer {
             seq: 2,
@@ -397,7 +406,6 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     // Now say the activity completes anyways
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: activity_task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::ok([1].into())),
     })
     .await
@@ -405,45 +413,47 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     // Ensure we do not get a wakeup with the activity being resolved completed, and instead get
     // the timer fired event (also wait for timer to fire)
     sleep(Duration::from_secs(1)).await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [WorkflowActivationJob {
             variant: Some(workflow_activation_job::Variant::FireTimer(_)),
         }]
     );
-    core.complete_execution(&task_q, &task.run_id).await;
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn started_activity_timeout() {
-    let (core, task_q) = init_core_and_create_wf("started_activity_timeout").await;
+    let mut starter = init_core_and_create_wf("started_activity_timeout").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity that times out in 1 second.
     core.complete_workflow_activation(
         schedule_activity_cmd(
             0,
-            &task_q,
+            task_q,
             activity_id,
             ActivityCancellationType::TryCancel,
             Duration::from_secs(1),
             Duration::from_secs(60),
         )
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
     // complete it in this test as activity is timed out after 1 second.
-    let activity_task = core.poll_activity_task(&task_q).await.unwrap();
+    let activity_task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         activity_task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
             assert_eq!(start_activity.activity_type, "test_activity".to_string())
         }
     );
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -466,21 +476,23 @@ async fn started_activity_timeout() {
             assert_eq!(*seq, 0);
         }
     );
-    core.complete_execution(&task_q, &task.run_id).await;
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn activity_cancellation_wait_cancellation_completed() {
-    let (core, task_q) =
+    let mut starter =
         init_core_and_create_wf("activity_cancellation_wait_cancellation_completed").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity and a timer that fires immediately
     core.complete_workflow_activation(
         vec![
             schedule_activity_cmd(
                 0,
-                &task_q,
+                task_q,
                 activity_id,
                 ActivityCancellationType::WaitCancellationCompleted,
                 Duration::from_secs(60),
@@ -492,13 +504,13 @@ async fn activity_cancellation_wait_cancellation_completed() {
             }
             .into(),
         ]
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
     // complete it in this test as activity is wait-cancelled.
-    let activity_task = core.poll_activity_task(&task_q).await.unwrap();
+    let activity_task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         activity_task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -506,7 +518,7 @@ async fn activity_cancellation_wait_cancellation_completed() {
         }
     );
     // Poll workflow task and verify that activity has failed.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -520,7 +532,6 @@ async fn activity_cancellation_wait_cancellation_completed() {
         }
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
     ))
@@ -528,26 +539,27 @@ async fn activity_cancellation_wait_cancellation_completed() {
     .unwrap();
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: activity_task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::cancel_from_details(None)),
     })
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_execution(&task_q, &task.run_id).await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn activity_cancellation_abandon() {
-    let (core, task_q) = init_core_and_create_wf("activity_cancellation_abandon").await;
+    let mut starter = init_core_and_create_wf("activity_cancellation_abandon").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity and a timer that fires immediately
     core.complete_workflow_activation(
         vec![
             schedule_activity_cmd(
                 0,
-                &task_q,
+                task_q,
                 activity_id,
                 ActivityCancellationType::Abandon,
                 Duration::from_secs(60),
@@ -559,13 +571,13 @@ async fn activity_cancellation_abandon() {
             }
             .into(),
         ]
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
     // complete it in this test as activity is abandoned.
-    let activity_task = core.poll_activity_task(&task_q).await.unwrap();
+    let activity_task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         activity_task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -573,7 +585,7 @@ async fn activity_cancellation_abandon() {
         }
     );
     // Poll workflow task and verify that activity has failed.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -587,7 +599,6 @@ async fn activity_cancellation_abandon() {
         }
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
     ))
@@ -595,31 +606,33 @@ async fn activity_cancellation_abandon() {
     .unwrap();
     // Poll workflow task expecting that activation has been created by the state machine
     // immediately after the cancellation request.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_execution(&task_q, &task.run_id).await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn async_activity_completion_workflow() {
-    let (core, task_q) = init_core_and_create_wf("async_activity_workflow").await;
+    let mut starter = init_core_and_create_wf("async_activity_workflow").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity
     core.complete_workflow_activation(
         schedule_activity_cmd(
             0,
-            &task_q,
+            task_q,
             activity_id,
             ActivityCancellationType::TryCancel,
             Duration::from_secs(60),
             Duration::from_secs(60),
         )
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters
-    let task = core.poll_activity_task(&task_q).await.unwrap();
+    let task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -633,23 +646,24 @@ async fn async_activity_completion_workflow() {
     // Complete activity asynchronously.
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token.clone(),
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::will_complete_async()),
     })
     .await
     .unwrap();
-    let gw = core.server_gateway();
-    gw.complete_activity_task(
-        task.task_token.into(),
-        Some(Payloads {
-            payloads: vec![response_payload.clone().into()],
-        }),
-    )
-    .await
-    .unwrap();
+    starter
+        .get_client()
+        .await
+        .complete_activity_task(
+            task.task_token.into(),
+            Some(Payloads {
+                payloads: vec![response_payload.clone().into()],
+            }),
+        )
+        .await
+        .unwrap();
 
     // Poll workflow task and verify that activity has succeeded.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -665,15 +679,16 @@ async fn async_activity_completion_workflow() {
             assert_eq!(r, &response_payload);
         }
     );
-    core.complete_execution(&task_q, &task.run_id).await;
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn activity_cancelled_after_heartbeat_times_out() {
-    let (core, task_q) =
-        init_core_and_create_wf("activity_cancelled_after_heartbeat_times_out").await;
+    let mut starter = init_core_and_create_wf("activity_cancelled_after_heartbeat_times_out").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue().to_string();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity
     core.complete_workflow_activation(
         schedule_activity_cmd(
@@ -684,12 +699,12 @@ async fn activity_cancelled_after_heartbeat_times_out() {
             Duration::from_secs(60),
             Duration::from_secs(1),
         )
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters
-    let task = core.poll_activity_task(&task_q).await.unwrap();
+    let task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -700,30 +715,29 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     sleep(Duration::from_secs(2)).await;
     core.record_activity_heartbeat(ActivityHeartbeat {
         task_token: task.task_token.clone(),
-        task_queue: task_q.to_string(),
         details: vec![],
     });
 
     // Verify activity got cancelled
-    let cancel_task = core.poll_activity_task(&task_q).await.unwrap();
+    let cancel_task = core.poll_activity_task().await.unwrap();
     assert_eq!(cancel_task.task_token, task.task_token.clone());
     assert_matches!(cancel_task.variant, Some(act_task::Variant::Cancel(_)));
 
     // Complete activity with cancelled result
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token.clone(),
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::cancel_from_details(None)),
     })
     .await
     .unwrap();
 
     // Verify shutdown completes
-    core.shutdown_worker(task_q.as_str()).await;
     core.shutdown().await;
     // Cleanup just in case
-    core.server_gateway()
-        .terminate_workflow_execution(task_q, None)
+    starter
+        .get_client()
+        .await
+        .terminate_workflow_execution(task_q.clone(), None)
         .await
         .unwrap();
 }

package/sdk-core/tests/integ_tests/workflow_tests/cancel_external.rs

@@ -1,3 +1,4 @@
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::common::NamespacedWorkflowExecution;
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -37,7 +38,12 @@ async fn sends_cancel_to_other_wf() {
     worker.register_wf("receiver", cancel_receiver);
 
     let receiver_run_id = worker
-        .submit_wf(RECEIVER_WFID, "receiver", vec![])
+        .submit_wf(
+            RECEIVER_WFID,
+            "receiver",
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker
@@ -45,6 +51,7 @@ async fn sends_cancel_to_other_wf() {
             "sends-cancel-sender",
             "sender",
             vec![receiver_run_id.into()],
+            WorkflowOptions::default(),
         )
         .await
         .unwrap();