@temporalio/core-bridge 1.1.0 → 1.4.0

package/sdk-core/test-utils/src/lib.rs

@@ -20,6 +20,7 @@ use temporal_client::{
 };
 use temporal_sdk::{interceptors::WorkerInterceptor, IntoActivityFunc, Worker, WorkflowFunction};
 use temporal_sdk_core::{
+    ephemeral_server::{EphemeralExe, EphemeralExeVersion},
     init_replay_worker, init_worker, telemetry_init, ClientOptions, ClientOptionsBuilder, Logger,
     MetricsExporter, OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder,
     TraceExporter, WorkerConfig, WorkerConfigBuilder,
@@ -40,11 +41,17 @@ use url::Url;
 
 pub const NAMESPACE: &str = "default";
 pub const TEST_Q: &str = "q";
+/// The env var used to specify where the integ tests should point
+pub const INTEG_SERVER_TARGET_ENV_VAR: &str = "TEMPORAL_SERVICE_ADDRESS";
+/// This env var is set (to any value) if temporalite is in use
+pub const INTEG_TEMPORALITE_USED_ENV_VAR: &str = "INTEG_TEMPORALITE_ON";
+/// This env var is set (to any value) if the test server is in use
+pub const INTEG_TEST_SERVER_USED_ENV_VAR: &str = "INTEG_TEST_SERVER_ON";
+
 /// If set, turn export traces and metrics to the OTel collector at the given URL
 const OTEL_URL_ENV_VAR: &str = "TEMPORAL_INTEG_OTEL_URL";
 /// If set, enable direct scraping of prom metrics on the specified port
 const PROM_ENABLE_ENV_VAR: &str = "TEMPORAL_INTEG_PROM_PORT";
-
 /// Create a worker instance which will use the provided test name to base the task queue and wf id
 /// upon. Returns the instance and the task queue name (which is also the workflow id).
 pub async fn init_core_and_create_wf(test_name: &str) -> CoreWfStarter {
@@ -160,6 +167,7 @@ impl CoreWfStarter {
                 self.worker_config.task_queue.clone(),
                 workflow_id,
                 self.task_queue_name.clone(),
+                None,
                 opts,
             )
             .await
@@ -319,6 +327,7 @@ impl TestWorker {
                     self.inner.task_queue().to_string(),
                     wfid.clone(),
                     workflow_type.into(),
+                    None,
                     options,
                 )
                 .await?;
@@ -362,6 +371,8 @@ impl TestWorker {
     }
 }
 
+pub type BoxDynActivationHook = Box<dyn Fn(&WorkflowActivationCompletion)>;
+
 pub enum TestWorkerShutdownCond {
     GetResults(Vec<WorkflowExecutionInfo>, Arc<RetryClient<Client>>),
     NoAutoShutdown,
@@ -370,7 +381,7 @@ pub enum TestWorkerShutdownCond {
 pub struct TestWorkerCompletionIceptor {
     condition: TestWorkerShutdownCond,
     shutdown_handle: Arc<dyn Fn()>,
-    every_activation: Option<Box<dyn Fn(&WorkflowActivationCompletion)>>,
+    every_activation: Option<BoxDynActivationHook>,
     next: Option<Box<dyn WorkerInterceptor>>,
 }
 impl TestWorkerCompletionIceptor {
@@ -429,8 +440,10 @@ impl WorkerInterceptor for TestWorkerCompletionIceptor {
     }
 }
 
+/// Returns the client options used to connect to the server used for integration tests.
 pub fn get_integ_server_options() -> ClientOptions {
-    let temporal_server_address = match env::var("TEMPORAL_SERVICE_ADDRESS") {
+    telemetry_init(&get_integ_telem_options()).expect("Telemetry inits cleanly");
+    let temporal_server_address = match env::var(INTEG_SERVER_TARGET_ENV_VAR) {
         Ok(addr) => addr,
         Err(_) => "http://localhost:7233".to_owned(),
     };
@@ -469,6 +482,16 @@ pub fn get_integ_telem_options() -> TelemetryOptions {
         .unwrap()
 }
 
+pub fn default_cached_download() -> EphemeralExe {
+    EphemeralExe::CachedDownload {
+        version: EphemeralExeVersion::Default {
+            sdk_name: "sdk-rust".to_string(),
+            sdk_version: "0.1.0".to_string(),
+        },
+        dest_dir: None,
+    }
+}
+
 pub fn schedule_activity_cmd(
     seq: u32,
     task_q: &str,
@@ -483,10 +506,10 @@ pub fn schedule_activity_cmd(
         activity_type: "test_activity".to_string(),
         namespace: NAMESPACE.to_owned(),
         task_queue: task_q.to_owned(),
-        schedule_to_start_timeout: Some(activity_timeout.into()),
-        start_to_close_timeout: Some(activity_timeout.into()),
-        schedule_to_close_timeout: Some(activity_timeout.into()),
-        heartbeat_timeout: Some(heartbeat_timeout.into()),
+        schedule_to_start_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        start_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        schedule_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        heartbeat_timeout: Some(heartbeat_timeout.try_into().expect("duration fits")),
         cancellation_type: cancellation_type as i32,
         ..Default::default()
     }
@@ -503,9 +526,9 @@ pub fn schedule_local_activity_cmd(
         seq,
         activity_id: activity_id.to_string(),
         activity_type: "test_activity".to_string(),
-        schedule_to_start_timeout: Some(activity_timeout.into()),
-        start_to_close_timeout: Some(activity_timeout.into()),
-        schedule_to_close_timeout: Some(activity_timeout.into()),
+        schedule_to_start_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        start_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
+        schedule_to_close_timeout: Some(activity_timeout.try_into().expect("duration fits")),
         cancellation_type: cancellation_type as i32,
         ..Default::default()
     }
@@ -515,7 +538,7 @@ pub fn schedule_local_activity_cmd(
 pub fn start_timer_cmd(seq: u32, duration: Duration) -> workflow_command::Variant {
     StartTimer {
         seq,
-        start_to_fire_timeout: Some(duration.into()),
+        start_to_fire_timeout: Some(duration.try_into().expect("duration fits")),
     }
     .into()
 }
@@ -565,7 +588,7 @@ where
             run_id.to_string(),
             vec![StartTimer {
                 seq,
-                start_to_fire_timeout: Some(duration.into()),
+                start_to_fire_timeout: Some(duration.try_into().expect("duration fits")),
             }
             .into()],
         ))

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

@@ -0,0 +1,128 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
+use temporal_sdk_core::ephemeral_server::{
+    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporaliteConfigBuilder,
+    TestServerConfigBuilder,
+};
+use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
+use temporal_sdk_core_test_utils::{default_cached_download, NAMESPACE};
+use url::Url;
+
+#[tokio::test]
+async fn temporalite_default() {
+    let config = TemporaliteConfigBuilder::default()
+        .exe(default_cached_download())
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn temporalite_fixed() {
+    let config = TemporaliteConfigBuilder::default()
+        .exe(fixed_cached_download("v0.1.1"))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn temporalite_shutdown_port_reuse() {
+    // Start, test shutdown, do again immediately on same port to ensure we can
+    // reuse after shutdown
+    let config = TemporaliteConfigBuilder::default()
+        .exe(default_cached_download())
+        .port(Some(10123))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn test_server_default() {
+    let config = TestServerConfigBuilder::default()
+        .exe(default_cached_download())
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn test_server_fixed() {
+    let config = TestServerConfigBuilder::default()
+        .exe(fixed_cached_download("v1.16.0"))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+#[tokio::test]
+async fn test_server_shutdown_port_reuse() {
+    // Start, test shutdown, do again immediately on same port to ensure we can
+    // reuse after shutdown
+    let config = TestServerConfigBuilder::default()
+        .exe(default_cached_download())
+        .port(Some(10124))
+        .build()
+        .unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
+}
+
+fn fixed_cached_download(version: &str) -> EphemeralExe {
+    EphemeralExe::CachedDownload {
+        version: EphemeralExeVersion::Fixed(version.to_string()),
+        dest_dir: None,
+    }
+}
+
+async fn assert_ephemeral_server(server: &EphemeralServer) {
+    // Connect and describe namespace
+    let mut client = ClientOptionsBuilder::default()
+        .identity("integ_tester".to_string())
+        .target_url(Url::try_from(&*format!("http://{}", server.target)).unwrap())
+        .client_name("temporal-core".to_string())
+        .client_version("0.1.0".to_string())
+        .build()
+        .unwrap()
+        .connect_no_namespace(None, None)
+        .await
+        .unwrap();
+    let resp = client
+        .describe_namespace(DescribeNamespaceRequest {
+            namespace: NAMESPACE.to_string(),
+            ..Default::default()
+        })
+        .await
+        .unwrap();
+    assert!(resp.into_inner().namespace_info.unwrap().name == "default");
+
+    // If it has test service, make sure we can use it too
+    if server.has_test_service {
+        let resp = client.get_current_time(()).await.unwrap();
+        // Make sure it's within 5 mins of now
+        let resp_seconds = resp.get_ref().time.as_ref().unwrap().seconds as u64;
+        let curr_seconds = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        assert!(curr_seconds - 300 < resp_seconds && curr_seconds + 300 > resp_seconds);
+    }
+}

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

@@ -1,5 +1,7 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
+use temporal_client::{WfClientExt, WorkflowOptions};
+use temporal_sdk::{ActContext, ActivityOptions, WfContext};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{
@@ -9,12 +11,12 @@ use temporal_sdk_core_protos::{
         workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob},
         workflow_commands::{ActivityCancellationType, ScheduleActivity},
         workflow_completion::WorkflowActivationCompletion,
-        ActivityHeartbeat, ActivityTaskCompletion, IntoCompletion,
+        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
     temporal::api::common::v1::{Payload, RetryPolicy},
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, WorkerTestHelpers,
+    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 
@@ -103,14 +105,14 @@ async fn many_act_fails_with_heartbeats() {
             activity_id: activity_id.to_string(),
             activity_type: "test_act".to_string(),
             task_queue: starter.get_task_queue().to_string(),
-            start_to_close_timeout: Some(Duration::from_secs(30).into()),
+            start_to_close_timeout: Some(prost_dur!(from_secs(30))),
             retry_policy: Some(RetryPolicy {
-                initial_interval: Some(Duration::from_millis(10).into()),
+                initial_interval: Some(prost_dur!(from_millis(10))),
                 backoff_coefficient: 1.0,
                 maximum_attempts: 4,
                 ..Default::default()
             }),
-            heartbeat_timeout: Some(Duration::from_secs(1).into()),
+            heartbeat_timeout: Some(prost_dur!(from_secs(1))),
             ..Default::default()
         }
         .into(),
@@ -166,3 +168,51 @@ async fn many_act_fails_with_heartbeats() {
     core.complete_execution(&task.run_id).await;
     core.shutdown().await;
 }
+
+#[tokio::test]
+async fn activity_doesnt_heartbeat_hits_timeout_then_completes() {
+    let wf_name = "activity_doesnt_heartbeat_hits_timeout_then_completes";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    worker.register_activity(
+        "echo_activity",
+        |_ctx: ActContext, echo_me: String| async move {
+            sleep(Duration::from_secs(4)).await;
+            Ok(echo_me)
+        },
+    );
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let res = ctx
+            .activity(ActivityOptions {
+                activity_type: "echo_activity".to_string(),
+                input: "hi!".as_json_payload().expect("serializes fine"),
+                start_to_close_timeout: Some(Duration::from_secs(10)),
+                heartbeat_timeout: Some(Duration::from_secs(2)),
+                retry_policy: Some(RetryPolicy {
+                    maximum_attempts: 1,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            })
+            .await;
+        assert!(res.timed_out());
+        Ok(().into())
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    let handle = client.get_untyped_workflow_handle(wf_name, run_id);
+    handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+}

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

@@ -36,7 +36,7 @@ async fn out_of_order_completion_doesnt_hang() {
             ),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_millis(50).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
             }
             .into(),
         ]
@@ -133,6 +133,7 @@ async fn can_paginate_long_history() {
     worker.run_until_done().await.unwrap();
 }
 
+// TODO: Takes ages now, fix somehow
 #[tokio::test]
 async fn poll_of_nonexistent_namespace_is_fatal() {
     let mut starter = CoreWfStarter::new("whatever_yo");

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

@@ -24,12 +24,12 @@ async fn simple_query_legacy() {
         vec![
             StartTimer {
                 seq: 0,
-                start_to_fire_timeout: Some(Duration::from_millis(500).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(500))),
             }
             .into(),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_secs(3).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_secs(3))),
             }
             .into(),
         ],
@@ -105,7 +105,7 @@ async fn simple_query_legacy() {
     assert_eq!(&q_resp.unwrap()[0].data, query_resp);
 }
 
-#[rstest::rstest]
+#[rstest]
 #[case::no_eviction(false)]
 #[case::with_eviction(true)]
 #[tokio::test]
@@ -343,12 +343,12 @@ async fn fail_legacy_query() {
     let t1_resp = vec![
         StartTimer {
             seq: 1,
-            start_to_fire_timeout: Some(Duration::from_millis(500).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_millis(500))),
         }
         .into(),
         StartTimer {
             seq: 2,
-            start_to_fire_timeout: Some(Duration::from_secs(3).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_secs(3))),
         }
         .into(),
     ];

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

@@ -0,0 +1,93 @@
+use assert_matches::assert_matches;
+use std::{sync::Arc, time::Duration};
+use temporal_client::{
+    ListClosedFilters, ListOpenFilters, Namespace, StartTimeFilter, WorkflowClientTrait,
+    WorkflowExecutionFilter, WorkflowOptions,
+};
+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,
+};
+
+#[tokio::test]
+async fn client_list_open_closed_workflow_executions() {
+    let wf_name = "client_list_open_closed_workflow_executions".to_owned();
+    let mut starter = CoreWfStarter::new(&wf_name);
+    let core = starter.get_worker().await;
+    let client = starter.get_client().await;
+
+    let earliest = std::time::SystemTime::now();
+    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 task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+        }]
+    );
+
+    // List above OPEN 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 = ListOpenFilters::ExecutionFilter(WorkflowExecutionFilter {
+        workflow_id: wf_name.clone(),
+        run_id: "".to_owned(),
+    });
+    let open_workflows = client
+        .list_open_workflow_executions(1, Default::default(), Some(start_time_filter), Some(filter))
+        .await
+        .unwrap();
+    assert_eq!(open_workflows.executions.len(), 1);
+    let workflow = open_workflows.executions[0].clone();
+    assert_eq!(workflow.execution.as_ref().unwrap().workflow_id, wf_name);
+
+    // Complete workflow
+    core.complete_execution(&task.run_id).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),
+        )
+        .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);
+}
+
+#[tokio::test]
+async fn client_describe_namespace() {
+    let client = Arc::new(
+        get_integ_server_options()
+            .connect(NAMESPACE.to_owned(), None, None)
+            .await
+            .expect("Must connect"),
+    );
+
+    let namespace_result = client
+        .describe_namespace(Namespace::Name(NAMESPACE.to_owned()))
+        .await
+        .unwrap();
+    assert_eq!(namespace_result.namespace_info.unwrap().name, NAMESPACE);
+}

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

@@ -1,12 +1,13 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, CancellableFuture, WfContext, WorkflowResult};
+use temporal_sdk::{
+    ActContext, ActExitValue, ActivityOptions, CancellableFuture, WfContext, WorkflowResult,
+};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{
-            self, activity_resolution, activity_resolution as act_res, ActivityExecutionResult,
-            ActivityResolution,
+            self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution,
         },
         activity_task::activity_task as act_task,
         workflow_activation::{
@@ -14,13 +15,15 @@ use temporal_sdk_core_protos::{
         },
         workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
         workflow_completion::WorkflowActivationCompletion,
-        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
+        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
+        IntoCompletion,
     },
     temporal::api::{
         common::v1::{ActivityType, Payload, Payloads},
         enums::v1::RetryState,
         failure::v1::{failure::FailureInfo, ActivityFailureInfo, Failure},
     },
+    TaskToken,
 };
 use temporal_sdk_core_test_utils::{
     init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
@@ -297,7 +300,7 @@ async fn activity_cancellation_try_cancel() {
             ),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_millis(50).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
             }
             .into(),
         ]
@@ -359,7 +362,7 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
             ),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_millis(50).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
             }
             .into(),
         ]
@@ -390,7 +393,7 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
             variant: Some(workflow_activation_job::Variant::ResolveActivity(
                 ResolveActivity {
                     result: Some(ActivityResolution {
-                        status: Some(activity_resolution::Status::Cancelled(_))
+                        status: Some(act_res::Status::Cancelled(_))
                     }),
                     ..
                 }
@@ -403,7 +406,7 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
         task.run_id,
         vec![StartTimer {
             seq: 2,
-            start_to_fire_timeout: Some(Duration::from_millis(100).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_millis(100))),
         }
         .into()],
     ))
@@ -506,7 +509,7 @@ async fn activity_cancellation_wait_cancellation_completed() {
             ),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_millis(50).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
             }
             .into(),
         ]
@@ -573,7 +576,7 @@ async fn activity_cancellation_abandon() {
             ),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_millis(50).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
             }
             .into(),
         ]
@@ -793,3 +796,83 @@ async fn one_activity_abandon_cancelled_after_complete() {
         .unwrap();
     assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
 }
+
+#[tokio::test]
+async fn it_can_complete_async() {
+    use std::sync::Arc;
+    use tokio::sync::Mutex;
+
+    let wf_name = "it_can_complete_async".to_owned();
+    let mut starter = CoreWfStarter::new(&wf_name);
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    let async_response = "agence";
+    let shared_token: Arc<Mutex<Option<Vec<u8>>>> = Arc::new(Mutex::new(None));
+    worker.register_wf(wf_name.clone(), move |ctx: WfContext| async move {
+        let activity_resolution = ctx
+            .activity(ActivityOptions {
+                activity_type: "complete_async_activity".to_string(),
+                input: "hi".as_json_payload().expect("serializes fine"),
+                start_to_close_timeout: Some(Duration::from_secs(30)),
+                ..Default::default()
+            })
+            .await;
+
+        let res = match activity_resolution.status {
+            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),
+        };
+
+        assert_eq!(&res, async_response);
+        Ok(().into())
+    });
+
+    let shared_token_ref = shared_token.clone();
+    worker.register_activity(
+        "complete_async_activity",
+        move |ctx: ActContext, _: String| {
+            let shared_token_ref = shared_token_ref.clone();
+            async move {
+                // set the `activity_task_token`
+                let activity_info = ctx.get_info();
+                let task_token = &activity_info.task_token;
+                let mut shared = shared_token_ref.lock().await;
+                *shared = Some(task_token.clone());
+                Ok::<ActExitValue<()>, _>(ActExitValue::WillCompleteAsync)
+            }
+        },
+    );
+
+    let shared_token_ref2 = shared_token.clone();
+    tokio::spawn(async move {
+        loop {
+            let mut shared = shared_token_ref2.lock().await;
+            let maybe_token = shared.take();
+
+            if let Some(task_token) = maybe_token {
+                client
+                    .complete_activity_task(
+                        TaskToken(task_token),
+                        Some(async_response.as_json_payload().unwrap().into()),
+                    )
+                    .await
+                    .unwrap();
+                return;
+            }
+        }
+    });
+
+    let _run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    worker.run_until_done().await.unwrap();
+}

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

@@ -39,7 +39,7 @@ async fn cancel_during_timer() {
         tokio::time::sleep(Duration::from_millis(500)).await;
         // Cancel the workflow externally
         client
-            .cancel_workflow_execution(wf_name.to_string(), None, "Dieee".to_string())
+            .cancel_workflow_execution(wf_name.to_string(), None, "Dieee".to_string(), None)
             .await
             .unwrap();
     };