@temporalio/core-bridge 1.1.0 → 1.3.1

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

@@ -0,0 +1,141 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+use temporal_client::{TestService, WorkflowService};
+use temporal_sdk_core::{
+    ephemeral_server::{
+        EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporaliteConfigBuilder,
+        TestServerConfigBuilder,
+    },
+    ClientOptions, ClientOptionsBuilder,
+};
+use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
+use temporal_sdk_core_test_utils::NAMESPACE;
+use url::Url;
+
+#[tokio::test]
+async fn temporalite_default() {
+    let config = TemporaliteConfigBuilder::default()
+        .exe(default_cached_download())
+        .build()
+        .unwrap();
+    let server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+}
+
+#[tokio::test]
+async fn temporalite_fixed() {
+    let config = TemporaliteConfigBuilder::default()
+        .exe(fixed_cached_download("v0.1.1"))
+        .build()
+        .unwrap();
+    let server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+}
+
+#[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 server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+}
+
+#[tokio::test]
+async fn test_server_fixed() {
+    let config = TestServerConfigBuilder::default()
+        .exe(fixed_cached_download("v1.16.0"))
+        .build()
+        .unwrap();
+    let server = config.start_server().await.unwrap();
+    assert_ephemeral_server(&server).await;
+}
+
+#[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();
+}
+
+async fn assert_ephemeral_server(server: &EphemeralServer) {
+    // Connect and describe namespace
+    let mut client = client_options(&server.target)
+        .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);
+    }
+}
+
+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,
+    }
+}
+
+fn fixed_cached_download(version: &str) -> EphemeralExe {
+    EphemeralExe::CachedDownload {
+        version: EphemeralExeVersion::Fixed(version.to_string()),
+        dest_dir: None,
+    }
+}
+
+fn client_options(target: &str) -> ClientOptions {
+    return ClientOptionsBuilder::default()
+        .identity("integ_tester".to_string())
+        .target_url(Url::try_from(&*format!("http://{}", target)).unwrap())
+        .client_name("temporal-core".to_string())
+        .client_version("0.1.0".to_string())
+        .build()
+        .unwrap();
+}

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(),
         ]

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(),
         ],
@@ -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();
     };

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

@@ -189,10 +189,10 @@ async fn local_act_retry_timer_backoff() {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_micros(15).into()),
+                    initial_interval: Some(prost_dur!(from_micros(15))),
                     // We want two local backoffs that are short. Third backoff will use timer
                     backoff_coefficient: 1_000.,
-                    maximum_interval: Some(Duration::from_millis(1500).into()),
+                    maximum_interval: Some(prost_dur!(from_millis(1500))),
                     maximum_attempts: 4,
                     non_retryable_error_types: vec![],
                 },
@@ -318,9 +318,9 @@ async fn cancel_after_act_starts(
             activity_type: "echo".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(bo_dur.into()),
+                initial_interval: Some(bo_dur.try_into().unwrap()),
                 backoff_coefficient: 1.,
-                maximum_interval: Some(bo_dur.into()),
+                maximum_interval: Some(bo_dur.try_into().unwrap()),
                 // Retry forever until cancelled
                 ..Default::default()
             },
@@ -410,9 +410,9 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_micros(15).into()),
+                    initial_interval: Some(prost_dur!(from_micros(15))),
                     backoff_coefficient: 1_000.,
-                    maximum_interval: Some(Duration::from_millis(1500).into()),
+                    maximum_interval: Some(prost_dur!(from_millis(1500))),
                     maximum_attempts: 4,
                     non_retryable_error_types: vec![],
                 },
@@ -467,9 +467,9 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_micros(15).into()),
+                    initial_interval: Some(prost_dur!(from_micros(15))),
                     backoff_coefficient: 1_000.,
-                    maximum_interval: Some(Duration::from_millis(1500).into()),
+                    maximum_interval: Some(prost_dur!(from_millis(1500))),
                     maximum_attempts: 40,
                     non_retryable_error_types: vec![],
                 },
@@ -538,9 +538,9 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
             activity_type: "echo".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(Duration::from_micros(15).into()),
+                initial_interval: Some(prost_dur!(from_micros(15))),
                 backoff_coefficient: 1_000.,
-                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_interval: Some(prost_dur!(from_millis(1500))),
                 maximum_attempts: 4,
                 non_retryable_error_types: vec![],
             },
@@ -551,9 +551,9 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
             activity_type: "echo".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(Duration::from_millis(15).into()),
+                initial_interval: Some(prost_dur!(from_millis(15))),
                 backoff_coefficient: 10.,
-                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_interval: Some(prost_dur!(from_millis(1500))),
                 maximum_attempts: 4,
                 non_retryable_error_types: vec![],
             },
@@ -593,9 +593,9 @@ async fn repro_nondeterminism_with_timer_bug() {
             activity_type: "delay".to_string(),
             input: "hi".as_json_payload().expect("serializes fine"),
             retry_policy: RetryPolicy {
-                initial_interval: Some(Duration::from_micros(15).into()),
+                initial_interval: Some(prost_dur!(from_micros(15))),
                 backoff_coefficient: 1_000.,
-                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_interval: Some(prost_dur!(from_millis(1500))),
                 maximum_attempts: 4,
                 non_retryable_error_types: vec![],
             },

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

@@ -30,7 +30,7 @@ async fn timer_workflow_replay() {
         task.run_id,
         vec![StartTimer {
             seq: 0,
-            start_to_fire_timeout: Some(Duration::from_secs(1).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
         }
         .into()],
     ))

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

@@ -46,13 +46,12 @@ async fn reset_workflow() {
         .await
         .unwrap();
 
-    let client = starter.get_client().await;
+    let mut client = starter.get_client().await;
+    let client = Arc::make_mut(&mut client);
     let resetter_fut = async {
         notify.notified().await;
         // Do the reset
         client
-            .get_client()
-            .raw_retry_client()
             .reset_workflow_execution(ResetWorkflowExecutionRequest {
                 namespace: NAMESPACE.to_owned(),
                 workflow_execution: Some(WorkflowExecution {
@@ -69,15 +68,16 @@ async fn reset_workflow() {
 
         // Unblock the workflow by sending the signal. Run ID will have changed after reset so
         // we use empty run id
-        client
-            .signal_workflow_execution(
-                wf_name.to_owned(),
-                "".to_owned(),
-                POST_RESET_SIG.to_owned(),
-                None,
-            )
-            .await
-            .unwrap();
+        WorkflowClientTrait::signal_workflow_execution(
+            client,
+            wf_name.to_owned(),
+            "".to_owned(),
+            POST_RESET_SIG.to_owned(),
+            None,
+            None,
+        )
+        .await
+        .unwrap();
 
         // Wait for the now-reset workflow to finish
         client