@temporalio/core-bridge 1.1.0 → 1.3.1

package/sdk-core/sdk/src/workflow_context/options.rs

@@ -1,4 +1,6 @@
 use std::{collections::HashMap, time::Duration};
+
+use temporal_client::WorkflowOptions;
 use temporal_sdk_core_protos::{
     coresdk::{
         child_workflow::ChildWorkflowCancellationType,
@@ -59,6 +61,8 @@ pub struct ActivityOptions {
     pub heartbeat_timeout: Option<Duration>,
     /// Determines what the SDK does when the Activity is cancelled.
     pub cancellation_type: ActivityCancellationType,
+    /// Activity retry policy
+    pub retry_policy: Option<RetryPolicy>,
 }
 
 impl IntoWorkflowCommand for ActivityOptions {
@@ -72,12 +76,17 @@ impl IntoWorkflowCommand for ActivityOptions {
             },
             activity_type: self.activity_type,
             task_queue: self.task_queue,
-            schedule_to_close_timeout: self.schedule_to_close_timeout.map(Into::into),
-            schedule_to_start_timeout: self.schedule_to_start_timeout.map(Into::into),
-            start_to_close_timeout: self.start_to_close_timeout.map(Into::into),
-            heartbeat_timeout: self.heartbeat_timeout.map(Into::into),
+            schedule_to_close_timeout: self
+                .schedule_to_close_timeout
+                .and_then(|d| d.try_into().ok()),
+            schedule_to_start_timeout: self
+                .schedule_to_start_timeout
+                .and_then(|d| d.try_into().ok()),
+            start_to_close_timeout: self.start_to_close_timeout.and_then(|d| d.try_into().ok()),
+            heartbeat_timeout: self.heartbeat_timeout.and_then(|d| d.try_into().ok()),
             cancellation_type: self.cancellation_type as i32,
             arguments: vec![self.input],
+            retry_policy: self.retry_policy,
             ..Default::default()
         }
     }
@@ -144,11 +153,15 @@ impl IntoWorkflowCommand for LocalActivityOptions {
             activity_type: self.activity_type,
             arguments: vec![self.input],
             retry_policy: Some(self.retry_policy),
-            local_retry_threshold: self.timer_backoff_threshold.map(Into::into),
+            local_retry_threshold: self.timer_backoff_threshold.and_then(|d| d.try_into().ok()),
             cancellation_type: self.cancel_type.into(),
-            schedule_to_close_timeout: self.schedule_to_close_timeout.map(Into::into),
-            schedule_to_start_timeout: self.schedule_to_start_timeout.map(Into::into),
-            start_to_close_timeout: self.start_to_close_timeout.map(Into::into),
+            schedule_to_close_timeout: self
+                .schedule_to_close_timeout
+                .and_then(|d| d.try_into().ok()),
+            schedule_to_start_timeout: self
+                .schedule_to_start_timeout
+                .and_then(|d| d.try_into().ok()),
+            start_to_close_timeout: self.start_to_close_timeout.and_then(|d| d.try_into().ok()),
             ..Default::default()
         }
     }
@@ -165,6 +178,8 @@ pub struct ChildWorkflowOptions {
     pub input: Vec<Payload>,
     /// Cancellation strategy for the child workflow
     pub cancel_type: ChildWorkflowCancellationType,
+    /// Common options
+    pub options: WorkflowOptions,
 }
 
 impl IntoWorkflowCommand for ChildWorkflowOptions {
@@ -176,6 +191,18 @@ impl IntoWorkflowCommand for ChildWorkflowOptions {
             workflow_type: self.workflow_type,
             input: self.input,
             cancellation_type: self.cancel_type as i32,
+            workflow_id_reuse_policy: self.options.id_reuse_policy as i32,
+            workflow_execution_timeout: self
+                .options
+                .execution_timeout
+                .and_then(|d| d.try_into().ok()),
+            workflow_run_timeout: self
+                .options
+                .execution_timeout
+                .and_then(|d| d.try_into().ok()),
+            workflow_task_timeout: self.options.task_timeout.and_then(|d| d.try_into().ok()),
+            search_attributes: self.options.search_attributes.unwrap_or_default(),
+            cron_schedule: self.options.cron_schedule.unwrap_or_default(),
             ..Default::default()
         }
     }
@@ -239,6 +266,7 @@ impl Signal {
 }
 
 /// Data contained within a signal
+#[derive(Default)]
 pub struct SignalData {
     /// The arguments the signal will receive
     pub input: Vec<Payload>,

package/sdk-core/sdk/src/workflow_context.rs

@@ -171,7 +171,11 @@ impl WfContext {
             CommandCreateRequest {
                 cmd: StartTimer {
                     seq,
-                    start_to_fire_timeout: Some(duration.into()),
+                    start_to_fire_timeout: Some(
+                        duration
+                            .try_into()
+                            .expect("Durations must fit into 64 bits"),
+                    ),
                 }
                 .into(),
                 unblocker,
@@ -294,13 +298,10 @@ impl WfContext {
     }
 
     /// Return a stream that produces values when the named signal is sent to this workflow
-    pub fn make_signal_channel(
-        &self,
-        signal_name: impl Into<String>,
-    ) -> impl Stream<Item = SignalData> {
+    pub fn make_signal_channel(&self, signal_name: impl Into<String>) -> DrainableSignalStream {
         let (tx, rx) = mpsc::unbounded_channel();
         self.send(RustWfCmd::SubscribeSignal(signal_name.into(), tx));
-        UnboundedReceiverStream::new(rx)
+        DrainableSignalStream(UnboundedReceiverStream::new(rx))
     }
 
     /// Force a workflow task failure (EX: in order to retry on non-sticky queue)
@@ -366,6 +367,29 @@ impl WfContext {
     }
 }
 
+/// Helper Wrapper that can drain the channel into a Vec<SignalData> in a blocking way.  Useful
+/// for making sure channels are empty before ContinueAsNew-ing a workflow
+pub struct DrainableSignalStream(UnboundedReceiverStream<SignalData>);
+
+impl DrainableSignalStream {
+    pub fn drain_all(self) -> Vec<SignalData> {
+        let mut receiver = self.0.into_inner();
+        let mut signals = vec![];
+        while let Ok(s) = receiver.try_recv() {
+            signals.push(s);
+        }
+        signals
+    }
+}
+
+impl Stream for DrainableSignalStream {
+    type Item = SignalData;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Pin::new(&mut self.0).poll_next(cx)
+    }
+}
+
 /// A Future that can be cancelled.
 /// Used in the prototype SDK for cancelling operations like timers and activities.
 pub trait CancellableFuture<T>: Future<Output = T> {

package/sdk-core/sdk/src/workflow_future.rs

@@ -24,7 +24,7 @@ use temporal_sdk_core_protos::{
         },
         workflow_commands::{
             request_cancel_external_workflow_execution as cancel_we, workflow_command,
-            CancelSignalWorkflow, CancelTimer, CancelUnstartedChildWorkflowExecution,
+            CancelChildWorkflowExecution, CancelSignalWorkflow, CancelTimer,
             CancelWorkflowExecution, CompleteWorkflowExecution, FailWorkflowExecution,
             RequestCancelActivity, RequestCancelExternalWorkflowExecution,
             RequestCancelLocalActivity, ScheduleActivity, ScheduleLocalActivity,
@@ -334,9 +334,9 @@ impl Future for WorkflowFuture {
                             }
                             CancellableID::ChildWorkflow(seq) => {
                                 activation_cmds.push(
-                                    workflow_command::Variant::CancelUnstartedChildWorkflowExecution(
-                                        CancelUnstartedChildWorkflowExecution {
-                                            child_workflow_seq: seq
+                                    workflow_command::Variant::CancelChildWorkflowExecution(
+                                        CancelChildWorkflowExecution {
+                                            child_workflow_seq: seq,
                                         },
                                     ),
                                 );

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -17,14 +17,14 @@ history_builders = ["uuid", "rand"]
 anyhow = "1.0"
 base64 = "0.13"
 derive_more = "0.99"
-prost = "0.9"
-prost-types = "0.9"
+prost = "0.11"
+prost-types = "0.11"
 rand = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 thiserror = "1.0"
-tonic = "0.6"
-uuid = { version = "0.8.2", features = ["v4"], optional = true }
+tonic = "0.8"
+uuid = { version = "1.1", features = ["v4"], optional = true }
 
 [build-dependencies]
-tonic-build = "0.6"
+tonic-build = "0.8"

package/sdk-core/sdk-core-protos/build.rs

@@ -93,8 +93,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 "../protos/local/temporal/sdk/core/core_interface.proto",
                 "../protos/local/temporal/sdk/core/bridge/bridge.proto",
                 "../protos/api_upstream/temporal/api/workflowservice/v1/service.proto",
+                "../protos/api_upstream/temporal/api/operatorservice/v1/service.proto",
+                "../protos/testsrv_upstream/temporal/api/testservice/v1/service.proto",
+                "../protos/grpc/health/v1/health.proto",
+            ],
+            &[
+                "../protos/api_upstream",
+                "../protos/local",
+                "../protos/testsrv_upstream",
+                "../protos/grpc",
             ],
-            &["../protos/api_upstream", "../protos/local"],
         )?;
     Ok(())
 }

package/sdk-core/sdk-core-protos/src/history_builder.rs

@@ -334,6 +334,7 @@ impl TestHistoryBuilder {
                 failure_info: Some(failure::FailureInfo::CanceledFailureInfo(
                     CanceledFailureInfo { details: None },
                 )),
+                encoded_attributes: Default::default(),
             }),
             None,
         );
@@ -486,7 +487,11 @@ pub fn default_wes_attribs() -> WorkflowExecutionStartedEventAttributes {
         workflow_type: Some(WorkflowType {
             name: DEFAULT_WORKFLOW_TYPE.to_owned(),
         }),
-        workflow_task_timeout: Some(Duration::from_secs(5).into()),
+        workflow_task_timeout: Some(
+            Duration::from_secs(5)
+                .try_into()
+                .expect("5 secs is a valid duration"),
+        ),
         ..Default::default()
     }
 }

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -17,7 +17,7 @@ pub use history_builder::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKF
 pub use history_info::HistoryInfo;
 pub use task_token::TaskToken;
 
-#[allow(clippy::large_enum_variant)]
+#[allow(clippy::large_enum_variant, clippy::derive_partial_eq_without_eq)]
 // I'd prefer not to do this, but there are some generated things that just don't need it.
 #[allow(missing_docs)]
 pub mod coresdk {
@@ -201,7 +201,8 @@ pub mod coresdk {
             pub fn timed_out(&self) -> bool {
                 matches!(self.status, Some(activity_resolution::Status::Failed(Failure {
                     failure: Some(ref f)
-                })) if f.is_timeout())
+                })) if f.is_timeout()
+                    || f.cause.as_ref().map(|c| c.is_timeout()).unwrap_or_default())
             }
 
             pub fn cancelled(&self) -> bool {
@@ -270,8 +271,9 @@ pub mod coresdk {
         pub fn decode_change_marker_details(
             details: &HashMap<String, Payloads>,
         ) -> Option<(String, bool)> {
-            let name = std::str::from_utf8(&details.get("patch_id")?.payloads.get(0)?.data).ok()?;
-            let deprecated = *details.get("deprecated")?.payloads.get(0)?.data.get(0)? != 0;
+            let name =
+                std::str::from_utf8(&details.get("patch_id")?.payloads.first()?.data).ok()?;
+            let deprecated = *details.get("deprecated")?.payloads.first()?.data.first()? != 0;
             Some((name.to_string(), deprecated))
         }
 
@@ -788,11 +790,11 @@ pub mod coresdk {
             }
         }
 
-        impl Display for CancelUnstartedChildWorkflowExecution {
+        impl Display for CancelChildWorkflowExecution {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(
                     f,
-                    "CancelUnstartedChildWorkflowExecution({})",
+                    "CancelChildWorkflowExecution({})",
                     self.child_workflow_seq
                 )
             }
@@ -1318,6 +1320,16 @@ pub mod coresdk {
 // This is disgusting, but unclear to me how to avoid it. TODO: Discuss w/ prost maintainer
 pub mod temporal {
     pub mod api {
+        pub mod cluster {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.cluster.v1");
+            }
+        }
+        pub mod batch {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.batch.v1");
+            }
+        }
         pub mod command {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.command.v1");
@@ -1488,9 +1500,22 @@ pub mod temporal {
                                 input: c.arguments.into_payloads(),
                                 workflow_run_timeout: c.workflow_run_timeout,
                                 workflow_task_timeout: c.workflow_task_timeout,
-                                memo: Some(c.memo.into()),
-                                header: Some(c.headers.into()),
-                                search_attributes: Some(c.search_attributes.into()),
+                                memo: if c.memo.is_empty() {
+                                    None
+                                } else {
+                                    Some(c.memo.into())
+                                },
+                                header: if c.headers.is_empty() {
+                                    None
+                                } else {
+                                    Some(c.headers.into())
+                                },
+                                retry_policy: c.retry_policy,
+                                search_attributes: if c.search_attributes.is_empty() {
+                                    None
+                                } else {
+                                    Some(c.search_attributes.into())
+                                },
                                 ..Default::default()
                             },
                         )
@@ -1506,21 +1531,6 @@ pub mod temporal {
                 }
             }
         }
-        pub mod enums {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.enums.v1");
-            }
-        }
-        pub mod failure {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.failure.v1");
-            }
-        }
-        pub mod filter {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.filter.v1");
-            }
-        }
         pub mod common {
             pub mod v1 {
                 use std::{
@@ -1585,6 +1595,21 @@ pub mod temporal {
                     }
                 }
 
+                impl From<Memo> for HashMap<String, Payload> {
+                    fn from(h: Memo) -> Self {
+                        h.fields.into_iter().map(|(k, v)| (k, v.into())).collect()
+                    }
+                }
+
+                impl From<SearchAttributes> for HashMap<String, Payload> {
+                    fn from(h: SearchAttributes) -> Self {
+                        h.indexed_fields
+                            .into_iter()
+                            .map(|(k, v)| (k, v.into()))
+                            .collect()
+                    }
+                }
+
                 impl From<HashMap<String, Payload>> for SearchAttributes {
                     fn from(h: HashMap<String, Payload>) -> Self {
                         Self {
@@ -1594,6 +1619,21 @@ pub mod temporal {
                 }
             }
         }
+        pub mod enums {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.enums.v1");
+            }
+        }
+        pub mod failure {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.failure.v1");
+            }
+        }
+        pub mod filter {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.filter.v1");
+            }
+        }
         pub mod history {
             pub mod v1 {
                 use crate::temporal::api::{
@@ -1709,31 +1749,31 @@ pub mod temporal {
                 }
             }
         }
-
         pub mod namespace {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.namespace.v1");
             }
         }
-
+        pub mod operatorservice {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.operatorservice.v1");
+            }
+        }
         pub mod query {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.query.v1");
             }
         }
-
         pub mod replication {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.replication.v1");
             }
         }
-
         pub mod schedule {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.schedule.v1");
             }
         }
-
         pub mod taskqueue {
             pub mod v1 {
                 use crate::temporal::api::enums::v1::TaskQueueKind;
@@ -1749,19 +1789,26 @@ pub mod temporal {
                 }
             }
         }
-
+        pub mod testservice {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.testservice.v1");
+            }
+        }
+        pub mod update {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.update.v1");
+            }
+        }
         pub mod version {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.version.v1");
             }
         }
-
         pub mod workflow {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.workflow.v1");
             }
         }
-
         pub mod workflowservice {
             pub mod v1 {
                 use std::{
@@ -1847,3 +1894,17 @@ pub mod temporal {
         }
     }
 }
+
+#[allow(
+    clippy::all,
+    missing_docs,
+    rustdoc::broken_intra_doc_links,
+    rustdoc::bare_urls
+)]
+pub mod grpc {
+    pub mod health {
+        pub mod v1 {
+            tonic::include_proto!("grpc.health.v1");
+        }
+    }
+}

package/sdk-core/test-utils/Cargo.toml

@@ -15,8 +15,8 @@ base64 = "0.13"
 futures = "0.3"
 log = "0.4"
 parking_lot = "0.12"
-prost = "0.9"
-prost-types = "0.9"
+prost = "0.11"
+prost-types = "0.11"
 rand = "0.8"
 serde_json = "1.0"
 temporal-client = { path = "../client" }
@@ -28,7 +28,7 @@ tokio = "1.1"
 tokio-util = { version = "0.7" }
 tracing = "0.1"
 url = "2.2"
-uuid = "0.8"
+uuid = "1.1"
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"

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

@@ -1,4 +1,6 @@
+use prost::Message;
 use rand::RngCore;
+use std::{fs::File, io::Write, path::PathBuf};
 use temporal_sdk_core::replay::TestHistoryBuilder;
 use temporal_sdk_core_protos::{
     coresdk::common::NamespacedWorkflowExecution,
@@ -1430,6 +1432,49 @@ pub fn single_child_workflow_cancelled(child_wf_id: &str) -> TestHistoryBuilder
     t
 }
 
+///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
+///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
+///  4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+///  5: EVENT_TYPE_START_CHILD_WORKFLOW_EXECUTION_INITIATED
+///  6: EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_STARTED
+///  7: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+///  8: EVENT_TYPE_WORKFLOW_TASK_STARTED
+///  9: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+/// 10: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
+pub fn single_child_workflow_abandon_cancelled(child_wf_id: &str) -> TestHistoryBuilder {
+    let (mut t, _, _) = start_child_wf_preamble(child_wf_id);
+    t.add_workflow_execution_completed();
+    t
+}
+
+///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
+///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
+///  4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+///  5: EVENT_TYPE_START_CHILD_WORKFLOW_EXECUTION_INITIATED
+///  6: EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_STARTED
+///  7: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+///  8: EVENT_TYPE_WORKFLOW_TASK_STARTED
+///  9: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+/// 10: EVENT_TYPE_REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED
+/// 11: EVENT_TYPE_EXTERNAL_WORKFLOW_EXECUTION_CANCEL_REQUESTED
+/// 12: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+/// 13: EVENT_TYPE_WORKFLOW_TASK_STARTED
+/// 14: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+/// 15: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
+pub fn single_child_workflow_try_cancelled(child_wf_id: &str) -> TestHistoryBuilder {
+    let (mut t, _, _) = start_child_wf_preamble(child_wf_id);
+    let id = t.add_cancel_external_wf(NamespacedWorkflowExecution {
+        workflow_id: child_wf_id.to_string(),
+        ..Default::default()
+    });
+    t.add_cancel_external_wf_completed(id);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+    t
+}
+
 ///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
 ///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
 ///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
@@ -1519,3 +1564,16 @@ pub fn two_local_activities_separated_by_timer() -> TestHistoryBuilder {
     t.add_workflow_execution_completed();
     t
 }
+
+/// Useful for one-of needs to write a crafted history to a file. Writes it as serialized proto
+/// binary to the provided path.
+pub fn write_hist_to_binfile(
+    thb: &TestHistoryBuilder,
+    file_path: PathBuf,
+) -> Result<(), anyhow::Error> {
+    let as_complete_hist: History = thb.get_full_history_info()?.into();
+    let serialized = as_complete_hist.encode_to_vec();
+    let mut file = File::create(file_path)?;
+    file.write_all(&serialized)?;
+    Ok(())
+}

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

@@ -160,6 +160,7 @@ impl CoreWfStarter {
                 self.worker_config.task_queue.clone(),
                 workflow_id,
                 self.task_queue_name.clone(),
+                None,
                 opts,
             )
             .await
@@ -319,6 +320,7 @@ impl TestWorker {
                     self.inner.task_queue().to_string(),
                     wfid.clone(),
                     workflow_type.into(),
+                    None,
                     options,
                 )
                 .await?;
@@ -362,6 +364,8 @@ impl TestWorker {
     }
 }
 
+pub type BoxDynActivationHook = Box<dyn Fn(&WorkflowActivationCompletion)>;
+
 pub enum TestWorkerShutdownCond {
     GetResults(Vec<WorkflowExecutionInfo>, Arc<RetryClient<Client>>),
     NoAutoShutdown,
@@ -370,7 +374,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 {
@@ -483,10 +487,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 +507,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 +519,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 +569,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()],
         ))