use custom builders everywhere

chris-olszewski · chris-olszewski · commit 1891c4b60cbf · 2026-04-20T09:07:00.000-04:00
diff --git a/crates/sdk-core/tests/heavy_tests.rs b/crates/sdk-core/tests/heavy_tests.rs
@@ -60,7 +60,7 @@ impl ActivityLoadWf {
             .start_activity(
                 StdActivities::echo,
                 input_str.clone(),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::Both {
+                ActivityOptions::with_close_timeouts(ActivityCloseTimeouts::Both {
                     start_to_close: Duration::from_secs(8),
                     schedule_to_close: Duration::from_secs(8),
                 })
@@ -129,11 +129,9 @@ impl ChunkyActivityWf {
             .start_activity(
                 ChunkyActivities::chunky_echo,
                 input_str.clone(),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(30),
-                ))
-                .activity_id("act-1".to_string())
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(30))
+                    .activity_id("act-1".to_string())
+                    .build(),
             )
             .await?;
         assert_eq!(res, input_str);
diff --git a/crates/sdk-core/tests/integ_tests/async_activity_client_tests.rs b/crates/sdk-core/tests/integ_tests/async_activity_client_tests.rs
@@ -11,8 +11,7 @@ use temporalio_common::protos::{
 };
 use temporalio_macros::{activities, workflow, workflow_methods};
 use temporalio_sdk::{
-    ActivityCloseTimeouts, ActivityExecutionError, ActivityOptions, CancellableFuture,
-    WorkflowContext, WorkflowResult,
+    ActivityExecutionError, ActivityOptions, CancellableFuture, WorkflowContext, WorkflowResult,
     activities::{ActivityContext, ActivityError},
 };
 use tokio::sync::mpsc;
@@ -111,15 +110,13 @@ async fn async_activity_completions(
             let activity_future = ctx.start_activity(
                 AsyncActivities::complete_async_activity,
                 expected_outcome,
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(30),
-                ))
-                .retry_policy(RetryPolicy {
-                    maximum_attempts: 1,
-                    ..Default::default()
-                })
-                .cancellation_type(ActivityCancellationType::WaitCancellationCompleted)
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(30))
+                    .retry_policy(RetryPolicy {
+                        maximum_attempts: 1,
+                        ..Default::default()
+                    })
+                    .cancellation_type(ActivityCancellationType::WaitCancellationCompleted)
+                    .build(),
             );
 
             // For cancellation, wait a bit to let the activity start, then request cancel
diff --git a/crates/sdk-core/tests/integ_tests/heartbeat_tests.rs b/crates/sdk-core/tests/integ_tests/heartbeat_tests.rs
@@ -26,9 +26,7 @@ use temporalio_common::{
     },
 };
 use temporalio_macros::{workflow, workflow_methods};
-use temporalio_sdk::{
-    ActivityCloseTimeouts, ActivityExecutionError, ActivityOptions, WorkflowContext, WorkflowResult,
-};
+use temporalio_sdk::{ActivityExecutionError, ActivityOptions, WorkflowContext, WorkflowResult};
 use temporalio_sdk_core::test_help::{WorkerTestHelpers, drain_pollers_and_shutdown};
 use tokio::time::sleep;
 
@@ -44,15 +42,13 @@ impl ActivityDoesntHeartbeatHitsTimeoutThenCompletesWf {
             .start_activity(
                 StdActivities::delay,
                 Duration::from_secs(4),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(10),
-                ))
-                .heartbeat_timeout(Duration::from_secs(2))
-                .retry_policy(RetryPolicy {
-                    maximum_attempts: 1,
-                    ..Default::default()
-                })
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(10))
+                    .heartbeat_timeout(Duration::from_secs(2))
+                    .retry_policy(RetryPolicy {
+                        maximum_attempts: 1,
+                        ..Default::default()
+                    })
+                    .build(),
             )
             .await;
         let err = res.unwrap_err();
diff --git a/crates/sdk-core/tests/integ_tests/metrics_tests.rs b/crates/sdk-core/tests/integ_tests/metrics_tests.rs
@@ -65,8 +65,8 @@ use temporalio_common::{
 };
 use temporalio_macros::{activities, workflow, workflow_methods};
 use temporalio_sdk::{
-    ActivityCloseTimeouts, ActivityOptions, CancellableFuture, LocalActivityOptions,
-    NexusOperationOptions, WorkflowContext, WorkflowResult,
+    ActivityOptions, CancellableFuture, LocalActivityOptions, NexusOperationOptions,
+    WorkflowContext, WorkflowResult,
     activities::{ActivityContext, ActivityError},
 };
 use temporalio_sdk_core::{
@@ -862,14 +862,12 @@ async fn activity_metrics() {
             let normal_act_fail = ctx.start_activity(
                 PassFailActivities::pass_fail_act,
                 "fail".to_string(),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(1),
-                ))
-                .retry_policy(RetryPolicy {
-                    maximum_attempts: 1,
-                    ..Default::default()
-                })
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(1))
+                    .retry_policy(RetryPolicy {
+                        maximum_attempts: 1,
+                        ..Default::default()
+                    })
+                    .build(),
             );
             let _ = join!(normal_act_pass, normal_act_fail);
             let local_act_pass = ctx.start_local_activity(
diff --git a/crates/sdk-core/tests/integ_tests/worker_heartbeat_tests.rs b/crates/sdk-core/tests/integ_tests/worker_heartbeat_tests.rs
@@ -35,7 +35,7 @@ use temporalio_common::{
 };
 use temporalio_macros::{activities, workflow, workflow_methods};
 use temporalio_sdk::{
-    ActivityCloseTimeouts, ActivityOptions, SyncWorkflowContext, WorkflowContext, WorkflowResult,
+    ActivityOptions, SyncWorkflowContext, WorkflowContext, WorkflowResult,
     activities::{ActivityContext, ActivityError},
 };
 use temporalio_sdk_core::{
@@ -896,16 +896,14 @@ async fn worker_heartbeat_failure_metrics() {
                 .start_activity(
                     FailingActivities::failing_act,
                     "boom".to_string(),
-                    ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                        Duration::from_secs(5),
-                    ))
-                    .retry_policy(RetryPolicy {
-                        initial_interval: Some(prost_dur!(from_millis(10))),
-                        backoff_coefficient: 1.0,
-                        maximum_attempts: 4,
-                        ..Default::default()
-                    })
-                    .build(),
+                    ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
+                        .retry_policy(RetryPolicy {
+                            initial_interval: Some(prost_dur!(from_millis(10))),
+                            backoff_coefficient: 1.0,
+                            maximum_attempts: 4,
+                            ..Default::default()
+                        })
+                        .build(),
                 )
                 .await;
 
diff --git a/crates/sdk-core/tests/integ_tests/workflow_tests/activities.rs b/crates/sdk-core/tests/integ_tests/workflow_tests/activities.rs
@@ -46,8 +46,7 @@ use temporalio_common::{
 };
 use temporalio_macros::{activities, workflow, workflow_methods};
 use temporalio_sdk::{
-    ActivityCloseTimeouts, ActivityOptions, CancellableFuture, WorkflowContext, WorkflowResult,
-    WorkflowTermination,
+    ActivityOptions, CancellableFuture, WorkflowContext, WorkflowResult, WorkflowTermination,
     activities::{ActivityContext, ActivityError},
 };
 use temporalio_sdk_core::{
@@ -958,11 +957,9 @@ impl OneActivityAbandonCancelledBeforeStarted {
         let act_fut = ctx.start_activity(
             StdActivities::delay,
             Duration::from_secs(2),
-            ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                Duration::from_secs(5),
-            ))
-            .cancellation_type(ActivityCancellationType::Abandon)
-            .build(),
+            ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
+                .cancellation_type(ActivityCancellationType::Abandon)
+                .build(),
         );
         act_fut.cancel();
         let _ = act_fut.await;
@@ -1004,11 +1001,9 @@ impl OneActivityAbandonCancelledAfterComplete {
         let act_fut = ctx.start_activity(
             StdActivities::delay,
             Duration::from_secs(2),
-            ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                Duration::from_secs(5),
-            ))
-            .cancellation_type(ActivityCancellationType::Abandon)
-            .build(),
+            ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
+                .cancellation_type(ActivityCancellationType::Abandon)
+                .build(),
         );
         ctx.timer(Duration::from_secs(1)).await;
         act_fut.cancel();
@@ -1089,15 +1084,13 @@ async fn graceful_shutdown() {
                 ctx.start_activity(
                     SleeperActivities::sleeper,
                     "hi".to_string(),
-                    ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                        Duration::from_secs(5),
-                    ))
-                    .retry_policy(RetryPolicy {
-                        maximum_attempts: 1,
-                        ..Default::default()
-                    })
-                    .cancellation_type(ActivityCancellationType::WaitCancellationCompleted)
-                    .build(),
+                    ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
+                        .retry_policy(RetryPolicy {
+                            maximum_attempts: 1,
+                            ..Default::default()
+                        })
+                        .cancellation_type(ActivityCancellationType::WaitCancellationCompleted)
+                        .build(),
                 )
             });
             temporalio_sdk::workflows::join_all(act_futs).await;
@@ -1183,14 +1176,12 @@ async fn activity_can_be_cancelled_by_local_timeout() {
                 .start_activity(
                     CancellableEchoActivities::cancellable_echo,
                     "hi!".to_string(),
-                    ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                        Duration::from_secs(1),
-                    ))
-                    .retry_policy(RetryPolicy {
-                        maximum_attempts: 1,
-                        ..Default::default()
-                    })
-                    .build(),
+                    ActivityOptions::with_start_to_close_timeout(Duration::from_secs(1))
+                        .retry_policy(RetryPolicy {
+                            maximum_attempts: 1,
+                            ..Default::default()
+                        })
+                        .build(),
                 )
                 .await;
             assert!(res.is_err_and(|e| e.is_timeout()));
@@ -1249,14 +1240,12 @@ async fn long_activity_timeout_repro() {
                     .start_activity(
                         StdActivities::echo,
                         "hi!".to_string(),
-                        ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                            Duration::from_secs(1),
-                        ))
-                        .retry_policy(RetryPolicy {
-                            maximum_attempts: 1,
-                            ..Default::default()
-                        })
-                        .build(),
+                        ActivityOptions::with_start_to_close_timeout(Duration::from_secs(1))
+                            .retry_policy(RetryPolicy {
+                                maximum_attempts: 1,
+                                ..Default::default()
+                            })
+                            .build(),
                     )
                     .await;
                 assert!(res.is_ok());
@@ -1317,11 +1306,9 @@ async fn pass_activity_summary_to_metadata() {
             ctx.start_activity(
                 StdActivities::default,
                 (),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(5),
-                ))
-                .summary("activity summary".to_string())
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
+                    .summary("activity summary".to_string())
+                    .build(),
             )
             .await
             .map_err(|e| anyhow!("{e}"))?;
@@ -1381,11 +1368,9 @@ async fn abandoned_activities_ignore_start_and_complete(hist_batches: &'static [
             let act_fut = ctx.start_activity(
                 StdActivities::default,
                 (),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(5),
-                ))
-                .cancellation_type(ActivityCancellationType::Abandon)
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
+                    .cancellation_type(ActivityCancellationType::Abandon)
+                    .build(),
             );
             ctx.timer(Duration::from_secs(1)).await;
             act_fut.cancel();
diff --git a/crates/sdk-core/tests/integ_tests/workflow_tests/determinism.rs b/crates/sdk-core/tests/integ_tests/workflow_tests/determinism.rs
@@ -26,8 +26,8 @@ use temporalio_common::{
 };
 use temporalio_macros::{workflow, workflow_methods};
 use temporalio_sdk::{
-    ActivityCloseTimeouts, ActivityOptions, ChildWorkflowOptions, LocalActivityOptions,
-    WorkflowContext, WorkflowResult, workflows,
+    ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WorkflowContext, WorkflowResult,
+    workflows,
 };
 use temporalio_sdk_core::{
     replay::DEFAULT_WORKFLOW_TYPE,
@@ -302,11 +302,9 @@ impl ActivityIdOrTypeChangeWf {
             ctx.start_activity(
                 StdActivities::default,
                 (),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(5),
-                ))
-                .activity_id("I'm bad and wrong!".to_string())
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
+                    .activity_id("I'm bad and wrong!".to_string())
+                    .build(),
             )
             .await
             .map_err(|e| anyhow::anyhow!("{e}"))?;
diff --git a/crates/sdk-core/tests/integ_tests/workflow_tests/local_activities.rs b/crates/sdk-core/tests/integ_tests/workflow_tests/local_activities.rs
@@ -48,9 +48,8 @@ use temporalio_common::{
 };
 use temporalio_macros::{activities, workflow, workflow_methods};
 use temporalio_sdk::{
-    ActivityCloseTimeouts, ActivityExecutionError, ActivityOptions, CancellableFuture,
-    LocalActivityOptions, WorkflowContext, WorkflowContextView, WorkflowResult,
-    WorkflowTermination,
+    ActivityExecutionError, ActivityOptions, CancellableFuture, LocalActivityOptions,
+    WorkflowContext, WorkflowContextView, WorkflowResult, WorkflowTermination,
     activities::{ActivityContext, ActivityError},
     interceptors::{FailOnNondeterminismInterceptor, WorkerInterceptor},
 };
@@ -1025,11 +1024,9 @@ async fn la_resolve_same_time_as_other_cancel() {
             let mut normal_act = ctx.start_activity(
                 DelayWithCancellation::delay,
                 Duration::from_secs(9),
-                ActivityOptions::with_close_timeout(ActivityCloseTimeouts::StartToClose(
-                    Duration::from_secs(9000),
-                ))
-                .cancellation_type(ActivityCancellationType::TryCancel)
-                .build(),
+                ActivityOptions::with_start_to_close_timeout(Duration::from_secs(9000))
+                    .cancellation_type(ActivityCancellationType::TryCancel)
+                    .build(),
             );
             // Make new task
             ctx.timer(Duration::from_millis(1)).await;
diff --git a/crates/sdk-core/tests/integ_tests/workflow_tests/patches.rs b/crates/sdk-core/tests/integ_tests/workflow_tests/patches.rs
diff --git a/crates/sdk-core/tests/shared_tests/priority.rs b/crates/sdk-core/tests/shared_tests/priority.rs
diff --git a/crates/sdk/src/workflow_context/options.rs b/crates/sdk/src/workflow_context/options.rs
