@temporalio/core-bridge 1.5.2 → 1.7.0

package/sdk-core/tests/integ_tests/visibility_tests.rs

@@ -1,15 +1,17 @@
 use assert_matches::assert_matches;
 use std::{sync::Arc, time::Duration};
 use temporal_client::{
-    ListClosedFilters, ListOpenFilters, Namespace, StartTimeFilter, WorkflowClientTrait,
-    WorkflowExecutionFilter, WorkflowOptions,
+    ListClosedFilters, ListOpenFilters, Namespace, RegisterNamespaceOptions, StartTimeFilter,
+    WorkflowClientTrait, WorkflowExecutionFilter,
 };
 use temporal_sdk_core_protos::coresdk::workflow_activation::{
     workflow_activation_job, WorkflowActivationJob,
 };
 use temporal_sdk_core_test_utils::{
-    get_integ_server_options, CoreWfStarter, WorkerTestHelpers, NAMESPACE,
+    drain_pollers_and_shutdown, get_integ_server_options, CoreWfStarter, WorkerTestHelpers,
+    NAMESPACE,
 };
+use tokio::time::sleep;
 
 #[tokio::test]
 async fn client_list_open_closed_workflow_executions() {
@@ -22,9 +24,7 @@ async fn client_list_open_closed_workflow_executions() {
     let latest = earliest + Duration::from_secs(60);
 
     // start workflow
-    let run_id = starter
-        .start_wf_with_id(wf_name.to_owned(), WorkflowOptions::default())
-        .await;
+    let run_id = starter.start_wf_with_id(wf_name.to_owned()).await;
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
@@ -52,28 +52,86 @@ async fn client_list_open_closed_workflow_executions() {
 
     // Complete workflow
     core.complete_execution(&task.run_id).await;
+    drain_pollers_and_shutdown(&core).await;
 
-    // List above CLOSED workflow
-    let start_time_filter = StartTimeFilter {
-        earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
-        latest_time: Some(latest).and_then(|t| t.try_into().ok()),
-    };
-    let filter = ListClosedFilters::ExecutionFilter(WorkflowExecutionFilter {
-        workflow_id: wf_name.clone(),
-        run_id,
-    });
-    let closed_workflows = client
-        .list_closed_workflow_executions(
-            1,
-            Default::default(),
-            Some(start_time_filter),
-            Some(filter),
-        )
+    // List above CLOSED workflow. Visibility doesn't always update immediately so we give this a
+    // few tries.
+    let mut passed = false;
+    for _ in 1..=5 {
+        let closed_workflows = client
+            .list_closed_workflow_executions(
+                1,
+                Default::default(),
+                Some(StartTimeFilter {
+                    earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
+                    latest_time: Some(latest).and_then(|t| t.try_into().ok()),
+                }),
+                Some(ListClosedFilters::ExecutionFilter(
+                    WorkflowExecutionFilter {
+                        workflow_id: wf_name.clone(),
+                        run_id: run_id.clone(),
+                    },
+                )),
+            )
+            .await
+            .unwrap();
+        if closed_workflows.executions.len() == 1 {
+            let workflow = &closed_workflows.executions[0];
+            if workflow.execution.as_ref().unwrap().workflow_id == wf_name {
+                passed = true;
+                break;
+            }
+        }
+        sleep(Duration::from_millis(100)).await;
+    }
+    assert!(passed);
+}
+
+#[tokio::test]
+async fn client_create_namespace() {
+    let client = Arc::new(
+        get_integ_server_options()
+            .connect(NAMESPACE.to_owned(), None, None)
+            .await
+            .expect("Must connect"),
+    );
+
+    let register_options = RegisterNamespaceOptions::builder()
+        .namespace("test-create-namespace")
+        .description("it's alive")
+        .build()
+        .unwrap();
+
+    client
+        .register_namespace(register_options.clone())
         .await
         .unwrap();
-    assert_eq!(closed_workflows.executions.len(), 1);
-    let workflow = closed_workflows.executions[0].clone();
-    assert_eq!(workflow.execution.as_ref().unwrap().workflow_id, wf_name);
+
+    //#Hack, not sure how else to wait for a proper response.  RegisterNamespace isn't safe to read
+    //after write
+    let mut attempts = 0;
+    let wait_time = Duration::from_secs(1);
+    loop {
+        attempts += 1;
+        let resp = client
+            .describe_namespace(Namespace::Name(register_options.namespace.clone()))
+            .await;
+
+        match resp {
+            Ok(n) => {
+                let namespace_info = n.namespace_info.unwrap();
+                assert_eq!(namespace_info.name, register_options.namespace);
+                assert_eq!(namespace_info.description, register_options.description);
+                return;
+            }
+            _ => {
+                if attempts == 12 {
+                    panic!("failed to query registered namespace");
+                }
+                sleep(wait_time).await
+            }
+        }
+    }
 }
 
 #[tokio::test]

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

@@ -1,8 +1,11 @@
+use anyhow::anyhow;
 use assert_matches::assert_matches;
+use futures_util::future::join_all;
 use std::time::Duration;
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
 use temporal_sdk::{
-    ActContext, ActExitValue, ActivityOptions, CancellableFuture, WfContext, WorkflowResult,
+    ActContext, ActExitValue, ActivityCancelledError, ActivityOptions, CancellableFuture,
+    WfContext, WorkflowResult,
 };
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -19,16 +22,17 @@ use temporal_sdk_core_protos::{
         IntoCompletion,
     },
     temporal::api::{
-        common::v1::{ActivityType, Payload, Payloads},
+        common::v1::{ActivityType, Payload, Payloads, RetryPolicy},
         enums::v1::RetryState,
         failure::v1::{failure::FailureInfo, ActivityFailureInfo, Failure},
     },
-    TaskToken,
+    TaskToken, DEFAULT_ACTIVITY_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter,
+    WorkerTestHelpers,
 };
-use tokio::time::sleep;
+use tokio::{join, sync::Semaphore, time::sleep};
 
 pub async fn one_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
     ctx.activity(ActivityOptions {
@@ -97,7 +101,7 @@ async fn activity_workflow() {
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+            assert_eq!(start_activity.activity_type, DEFAULT_ACTIVITY_TYPE.to_string())
         }
     );
     let response_payload = Payload {
@@ -154,16 +158,78 @@ async fn activity_non_retryable_failure() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters
+    // Poll activity and verify that it's been scheduled
     let task = core.poll_activity_task().await.unwrap();
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
+    // Fail activity with non-retryable error
+    let failure = Failure::application_failure("activity failed".to_string(), true);
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: task.task_token,
+        result: Some(ActivityExecutionResult::fail(failure.clone())),
+    })
+    .await
+    .unwrap();
+    // Poll workflow task and verify that activity has failed.
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
+        task.jobs.as_slice(),
+        [
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution{
+                    status: Some(act_res::Status::Failed(activity_result::Failure{
+                        failure: Some(f),
+                    }))})}
+                )),
+            },
+        ] => {
+            assert_eq!(*seq, 0);
+            assert_eq!(f, &Failure{
+                message: "Activity task failed".to_owned(),
+                cause: Some(Box::new(failure)),
+                failure_info: Some(FailureInfo::ActivityFailureInfo(ActivityFailureInfo{
+                    activity_id: "act-1".to_owned(),
+                    activity_type: Some(ActivityType {
+                        name: DEFAULT_ACTIVITY_TYPE.to_owned(),
+                    }),
+                    scheduled_event_id: 5,
+                    started_event_id: 6,
+                    identity: "integ_tester".to_owned(),
+                    retry_state: RetryState::NonRetryableFailure as i32,
+                })),
+                ..Default::default()
+            });
         }
     );
+    core.complete_execution(&task.run_id).await;
+}
+
+#[tokio::test]
+async fn activity_non_retryable_failure_with_error() {
+    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().await.unwrap();
+    // Complete workflow task and schedule activity
+    core.complete_workflow_activation(
+        schedule_activity_cmd(
+            0,
+            task_q,
+            activity_id,
+            ActivityCancellationType::TryCancel,
+            Duration::from_secs(60),
+            Duration::from_secs(60),
+        )
+        .into_completion(task.run_id),
+    )
+    .await
+    .unwrap();
+    // Poll activity and verify that it's been scheduled
+    let task = core.poll_activity_task().await.unwrap();
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Fail activity with non-retryable error
-    let failure = Failure::application_failure("activity failed".to_string(), true);
+    let failure = Failure::application_failure_from_error(anyhow!("activity failed"), true);
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
         result: Some(ActivityExecutionResult::fail(failure.clone())),
@@ -191,7 +257,7 @@ async fn activity_non_retryable_failure() {
                 failure_info: Some(FailureInfo::ActivityFailureInfo(ActivityFailureInfo{
                     activity_id: "act-1".to_owned(),
                     activity_type: Some(ActivityType {
-                        name: "test_activity".to_owned(),
+                        name: DEFAULT_ACTIVITY_TYPE.to_owned(),
                     }),
                     scheduled_event_id: 5,
                     started_event_id: 6,
@@ -228,12 +294,7 @@ async fn activity_retry() {
     .unwrap();
     // Poll activity 1st time
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Fail activity with retryable error
     let failure = Failure::application_failure("activity failed".to_string(), false);
     core.complete_activity_task(ActivityTaskCompletion {
@@ -244,12 +305,7 @@ async fn activity_retry() {
     .unwrap();
     // Poll 2nd time
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Complete activity successfully
     let response_payload = Payload {
         data: b"hello ".to_vec(),
@@ -308,15 +364,10 @@ async fn activity_cancellation_try_cancel() {
     )
     .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.
+    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
+    // test as activity is try-cancelled.
     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())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     // Poll workflow task and verify that activity has failed.
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
@@ -453,15 +504,10 @@ async fn started_activity_timeout() {
     )
     .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.
+    // Poll activity and verify that it's been scheduled, 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().await.unwrap();
-    assert_matches!(
-        activity_task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
@@ -517,15 +563,10 @@ async fn activity_cancellation_wait_cancellation_completed() {
     )
     .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.
+    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
+    // test as activity is wait-cancelled.
     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())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     // Poll workflow task and verify that activity has failed.
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
@@ -584,15 +625,10 @@ async fn activity_cancellation_abandon() {
     )
     .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.
+    // Poll activity and verify that it's been scheduled, we don't expect to complete it in this
+    // test as activity is abandoned.
     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())
-        }
-    );
+    assert_matches!(activity_task.variant, Some(act_task::Variant::Start(_)));
     // Poll workflow task and verify that activity has failed.
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
@@ -640,14 +676,9 @@ async fn async_activity_completion_workflow() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters
+    // Poll activity and verify that it's been scheduled
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     let response_payload = Payload {
         data: b"hello ".to_vec(),
         metadata: Default::default(),
@@ -712,14 +743,9 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     )
     .await
     .unwrap();
-    // Poll activity and verify that it's been scheduled with correct parameters
+    // Poll activity and verify that it's been scheduled
     let task = core.poll_activity_task().await.unwrap();
-    assert_matches!(
-        task.variant,
-        Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, "test_activity".to_string())
-        }
-    );
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
     // Delay the heartbeat
     sleep(Duration::from_secs(2)).await;
     core.record_activity_heartbeat(ActivityHeartbeat {
@@ -741,7 +767,7 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     .unwrap();
 
     // Verify shutdown completes
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
     // Cleanup just in case
     starter
         .get_client()
@@ -822,7 +848,7 @@ async fn it_can_complete_async() {
             Some(act_res::Status::Completed(activity_result::Success { result })) => result
                 .map(|p| String::from_json_payload(&p).unwrap())
                 .unwrap(),
-            _ => panic!("activity task failed {:?}", activity_resolution),
+            _ => panic!("activity task failed {activity_resolution:?}"),
         };
 
         assert_eq!(&res, async_response);
@@ -876,3 +902,66 @@ async fn it_can_complete_async() {
 
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn graceful_shutdown() {
+    let wf_name = "graceful_shutdown";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.worker_config.graceful_shutdown_period = Some(Duration::from_millis(500));
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let act_futs = (1..=10).map(|_| {
+            ctx.activity(ActivityOptions {
+                activity_type: "sleeper".to_string(),
+                start_to_close_timeout: Some(Duration::from_secs(5)),
+                retry_policy: Some(RetryPolicy {
+                    maximum_attempts: 1,
+                    ..Default::default()
+                }),
+                cancellation_type: ActivityCancellationType::WaitCancellationCompleted,
+                input: "hi".as_json_payload().unwrap(),
+                ..Default::default()
+            })
+        });
+        join_all(act_futs).await;
+        Ok(().into())
+    });
+    static ACTS_STARTED: Semaphore = Semaphore::const_new(0);
+    static ACTS_DONE: Semaphore = Semaphore::const_new(0);
+    worker.register_activity("sleeper", |ctx: ActContext, _: String| async move {
+        ACTS_STARTED.add_permits(1);
+        // just wait to be cancelled
+        ctx.cancelled().await;
+        ACTS_DONE.add_permits(1);
+        Result::<(), _>::Err(ActivityCancelledError::default().into())
+    });
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    let handle = worker.inner_mut().shutdown_handle();
+    let shutdowner = async {
+        // Wait for all acts to be started before initiating shutdown
+        let _ = ACTS_STARTED.acquire_many(10).await;
+        handle();
+        // Kill workflow once all acts are cancelled. This also ensures we actually see all the
+        // cancels, otherwise run_until_done will hang since the workflow won't complete.
+        let _ = ACTS_DONE.acquire_many(10).await;
+        client
+            .terminate_workflow_execution(wf_name.to_owned(), None)
+            .await
+            .unwrap();
+    };
+    let runner = async {
+        worker.run_until_done().await.unwrap();
+    };
+    join!(shutdowner, runner);
+}

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

@@ -33,6 +33,7 @@ async fn cancel_receiver(mut ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_cancel_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_cancel_to_other_wf");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("sender", cancel_sender);
     worker.register_wf("receiver", cancel_receiver);

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

@@ -1,5 +1,5 @@
 use std::time::Duration;
-use temporal_client::{WorkflowClientTrait, WorkflowOptions};
+use temporal_client::WorkflowClientTrait;
 use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -21,25 +21,18 @@ async fn cancelled_wf(mut ctx: WfContext) -> WorkflowResult<()> {
 async fn cancel_during_timer() {
     let wf_name = "cancel_during_timer";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
     worker.register_wf(wf_name.to_string(), cancelled_wf);
-
-    worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
+    starter.start_with_worker(wf_name, &mut worker).await;
+    let wf_id = starter.get_task_queue().to_string();
 
     let canceller = async {
         tokio::time::sleep(Duration::from_millis(500)).await;
         // Cancel the workflow externally
         client
-            .cancel_workflow_execution(wf_name.to_string(), None, "Dieee".to_string(), None)
+            .cancel_workflow_execution(wf_id.clone(), None, "Dieee".to_string(), None)
             .await
             .unwrap();
     };
@@ -47,7 +40,7 @@ async fn cancel_during_timer() {
     let (_, res) = tokio::join!(canceller, worker.run_until_done());
     res.unwrap();
     let desc = client
-        .describe_workflow_execution(wf_name.to_string(), None)
+        .describe_workflow_execution(wf_id, None)
         .await
         .unwrap();
 

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

@@ -1,8 +1,13 @@
 use anyhow::anyhow;
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::child_workflow::{child_workflow_result, Success};
+use std::time::Duration;
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
+use temporal_sdk::{ChildWorkflowOptions, WfContext, WfExitValue, WorkflowResult};
+use temporal_sdk_core_protos::{
+    coresdk::child_workflow::{child_workflow_result, ChildWorkflowCancellationType, Success},
+    temporal::api::enums::v1::ParentClosePolicy,
+};
 use temporal_sdk_core_test_utils::CoreWfStarter;
+use tokio::sync::Barrier;
 
 static PARENT_WF_TYPE: &str = "parent_wf";
 static CHILD_WF_TYPE: &str = "child_wf";
@@ -32,6 +37,7 @@ async fn parent_wf(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn child_workflow_happy_path() {
     let mut starter = CoreWfStarter::new("child-workflows");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
 
     worker.register_wf(PARENT_WF_TYPE.to_string(), parent_wf);
@@ -48,3 +54,74 @@ async fn child_workflow_happy_path() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn abandoned_child_bug_repro() {
+    let mut starter = CoreWfStarter::new("child-workflow-abandon-bug");
+    starter.no_remote_activities();
+    let mut worker = starter.worker().await;
+    let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
+
+    worker.register_wf(
+        PARENT_WF_TYPE.to_string(),
+        move |mut ctx: WfContext| async move {
+            let child = ctx.child_workflow(ChildWorkflowOptions {
+                workflow_id: "abandoned-child".to_owned(),
+                workflow_type: CHILD_WF_TYPE.to_owned(),
+                parent_close_policy: ParentClosePolicy::Abandon,
+                cancel_type: ChildWorkflowCancellationType::Abandon,
+                ..Default::default()
+            });
+
+            let started = child
+                .start(&ctx)
+                .await
+                .into_started()
+                .expect("Child chould start OK");
+            barr.wait().await;
+            // Wait for cancel signal
+            ctx.cancelled().await;
+            // Cancel the child immediately
+            started.cancel(&ctx);
+            // Need to do something else, so we'll see the ChildWorkflowExecutionCanceled event
+            ctx.timer(Duration::from_secs(1)).await;
+            started.result().await;
+            Ok(().into())
+        },
+    );
+    worker.register_wf(CHILD_WF_TYPE.to_string(), |mut ctx: WfContext| async move {
+        ctx.cancelled().await;
+        Ok(WfExitValue::Cancelled)
+    });
+
+    worker
+        .submit_wf(
+            "parent-abandoner".to_string(),
+            PARENT_WF_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    let client = starter.get_client().await;
+    let canceller = async {
+        barr.wait().await;
+        client
+            .cancel_workflow_execution(
+                "parent-abandoner".to_string(),
+                None,
+                "die".to_string(),
+                None,
+            )
+            .await
+            .unwrap();
+        client
+            .cancel_workflow_execution("abandoned-child".to_string(), None, "die".to_string(), None)
+            .await
+            .unwrap();
+    };
+    let runner = async move {
+        worker.run_until_done().await.unwrap();
+    };
+    tokio::join!(canceller, runner);
+}

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

@@ -21,6 +21,7 @@ async fn continue_as_new_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn continue_as_new_happy_path() {
     let wf_name = "continue_as_new_happy_path";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 
@@ -40,11 +41,14 @@ async fn continue_as_new_happy_path() {
 async fn continue_as_new_multiple_concurrent() {
     let wf_name = "continue_as_new_multiple_concurrent";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_cached_workflows(3).max_wft(3);
+    starter
+        .no_remote_activities()
+        .max_cached_workflows(3)
+        .max_wft(3);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 
-    let wf_names = (1..=20).map(|i| format!("{}-{}", wf_name, i));
+    let wf_names = (1..=20).map(|i| format!("{wf_name}-{i}"));
     for name in wf_names.clone() {
         worker
             .submit_wf(