@temporalio/core-bridge 0.23.0 → 1.0.0

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

@@ -7,20 +7,12 @@ extern crate tracing;
 pub mod canned_histories;
 
 use crate::stream::TryStreamExt;
-use futures::{stream, stream::FuturesUnordered, StreamExt};
+use futures::{future, stream, stream::FuturesUnordered, StreamExt};
 use parking_lot::Mutex;
 use prost::Message;
 use rand::{distributions::Standard, Rng};
 use std::{
-    convert::TryFrom,
-    env,
-    future::Future,
-    net::SocketAddr,
-    path::PathBuf,
-    sync::{
-        atomic::{AtomicUsize, Ordering},
-        Arc,
-    },
+    convert::TryFrom, env, future::Future, net::SocketAddr, path::PathBuf, sync::Arc,
     time::Duration,
 };
 use temporal_client::{
@@ -35,14 +27,13 @@ use temporal_sdk_core::{
 use temporal_sdk_core_api::Worker as CoreWorker;
 use temporal_sdk_core_protos::{
     coresdk::{
-        common::Payload,
         workflow_commands::{
             workflow_command, ActivityCancellationType, CompleteWorkflowExecution,
             ScheduleActivity, StartTimer,
         },
         workflow_completion::WorkflowActivationCompletion,
     },
-    temporal::api::history::v1::History,
+    temporal::api::{common::v1::Payload, history::v1::History},
 };
 use tokio::sync::OnceCell;
 use url::Url;
@@ -69,9 +60,11 @@ pub fn init_core_replay_preloaded(
     test_name: &str,
     history: &History,
 ) -> (Arc<dyn CoreWorker>, String) {
+    telemetry_init(&get_integ_telem_options()).expect("Telemetry inits cleanly");
     let worker_cfg = WorkerConfigBuilder::default()
         .namespace(NAMESPACE)
         .task_queue(test_name)
+        .worker_build_id("test_bin_id")
         .build()
         .expect("Configuration options construct properly");
     let worker = init_replay_worker(worker_cfg, history).expect("Replay worker must init properly");
@@ -92,7 +85,7 @@ pub struct CoreWfStarter {
     /// Used for both the task queue and workflow id
     task_queue_name: String,
     telemetry_options: TelemetryOptions,
-    worker_config: WorkerConfig,
+    pub worker_config: WorkerConfig,
     wft_timeout: Option<Duration>,
     initted_worker: OnceCell<InitializedWorker>,
 }
@@ -116,6 +109,7 @@ impl CoreWfStarter {
             worker_config: WorkerConfigBuilder::default()
                 .namespace(NAMESPACE)
                 .task_queue(task_queue)
+                .worker_build_id("test_build_id")
                 .max_cached_workflows(1000_usize)
                 .build()
                 .unwrap(),
@@ -257,28 +251,29 @@ impl CoreWfStarter {
 /// Provides conveniences for running integ tests with the SDK (against real server or mocks)
 pub struct TestWorker {
     inner: Worker,
-    pub orig_core_worker: Arc<dyn CoreWorker>,
+    pub core_worker: Arc<dyn CoreWorker>,
     client: Option<Arc<RetryClient<Client>>>,
-    /// Defaults true, and if set, auto-shutdown the worker once all workflows started via
-    /// `submit_wf` have completed (as determined by fetching their result with following runs).
-    pub auto_shutdown: bool,
-    started_workflows: Mutex<Vec<WorkflowExecutionInfo>>,
-    /// Used only for mocked testing, where fetching results to determine if a WF is finished is too
-    /// annoying to make work.
-    incomplete_workflows: Arc<AtomicUsize>,
+    pub started_workflows: Mutex<Vec<WorkflowExecutionInfo>>,
+    /// If set true (default), and a client is available, we will fetch workflow results to
+    /// determine when they have all completed.
+    pub fetch_results: bool,
+    iceptor: Option<TestWorkerCompletionIceptor>,
 }
 impl TestWorker {
     /// Create a new test worker
     pub fn new(core_worker: Arc<dyn CoreWorker>, task_queue: impl Into<String>) -> Self {
-        let ct = Arc::new(AtomicUsize::new(0));
         let inner = Worker::new_from_core(core_worker.clone(), task_queue);
+        let iceptor = TestWorkerCompletionIceptor::new(
+            TestWorkerShutdownCond::NoAutoShutdown,
+            Arc::new(inner.shutdown_handle()),
+        );
         Self {
             inner,
-            orig_core_worker: core_worker,
+            core_worker,
             client: None,
-            auto_shutdown: true,
             started_workflows: Mutex::new(vec![]),
-            incomplete_workflows: ct,
+            fetch_results: true,
+            iceptor: Some(iceptor),
         }
     }
 
@@ -340,70 +335,87 @@ impl TestWorker {
 
     /// Runs until all expected workflows have completed
     pub async fn run_until_done(&mut self) -> Result<(), anyhow::Error> {
-        self.run_until_done_intercepted(Option::<TestWorkerInterceptor>::None)
+        self.run_until_done_intercepted(Option::<TestWorkerCompletionIceptor>::None)
             .await
     }
 
-    /// See [Self::run_until_done], except calls the provided callback just before performing core
-    /// shutdown.
+    /// See [Self::run_until_done], but allows configuration of some low-level interception.
     pub async fn run_until_done_intercepted(
         &mut self,
         interceptor: Option<impl WorkerInterceptor + 'static>,
     ) -> Result<(), anyhow::Error> {
-        let iceptor = TestWorkerInterceptor {
-            incomplete_workflows: self.incomplete_workflows.clone(),
-            // Only use counting-based shutdown in the interceptor in mocked tests
-            shutdown_handle: if self.auto_shutdown && self.client.is_none() {
-                Some(Box::new(self.inner.shutdown_handle()))
-            } else {
-                None
-            },
-            next: interceptor.map(|i| Box::new(i) as Box<dyn WorkerInterceptor>),
-        };
-        self.inner.set_worker_interceptor(Box::new(iceptor));
-        let workflows_complete_fut = async {
-            if self.auto_shutdown && self.client.is_some() {
-                let wfs = std::mem::take(self.started_workflows.get_mut());
-                let client = self.client.clone().expect("Client must exist when running");
-                stream::iter(
-                    wfs.into_iter()
-                        .map(|info| info.bind_untyped((*client).clone())),
-                )
-                .map(Ok)
-                .try_for_each_concurrent(None, |wh| async move {
-                    wh.get_workflow_result(Default::default()).await?;
-                    Ok::<_, anyhow::Error>(())
-                })
-                .await?;
-                self.orig_core_worker.initiate_shutdown();
+        let mut iceptor = self.iceptor.take().unwrap();
+        // Automatically use results-based complete detection if we have a client
+        if self.fetch_results {
+            if let Some(c) = self.client.clone() {
+                iceptor.condition = TestWorkerShutdownCond::GetResults(
+                    std::mem::take(&mut self.started_workflows.lock()),
+                    c,
+                );
             }
-            Ok::<_, anyhow::Error>(())
-        };
-        tokio::try_join!(self.inner.run(), workflows_complete_fut)?;
+        }
+        iceptor.next = interceptor.map(|i| Box::new(i) as Box<dyn WorkerInterceptor>);
+        let get_results_waiter = iceptor.wait_all_wfs();
+        self.inner.set_worker_interceptor(Box::new(iceptor));
+        tokio::try_join!(self.inner.run(), get_results_waiter)?;
         Ok(())
     }
 }
 
+pub enum TestWorkerShutdownCond {
+    GetResults(Vec<WorkflowExecutionInfo>, Arc<RetryClient<Client>>),
+    NoAutoShutdown,
+}
 /// Implements calling the shutdown handle when the expected number of test workflows has completed
-struct TestWorkerInterceptor {
-    incomplete_workflows: Arc<AtomicUsize>,
-    shutdown_handle: Option<Box<dyn Fn()>>,
+pub struct TestWorkerCompletionIceptor {
+    condition: TestWorkerShutdownCond,
+    shutdown_handle: Arc<dyn Fn()>,
+    every_activation: Option<Box<dyn Fn(&WorkflowActivationCompletion)>>,
     next: Option<Box<dyn WorkerInterceptor>>,
 }
+impl TestWorkerCompletionIceptor {
+    pub fn new(condition: TestWorkerShutdownCond, shutdown_handle: Arc<dyn Fn()>) -> Self {
+        Self {
+            condition,
+            shutdown_handle,
+            every_activation: None,
+            next: None,
+        }
+    }
 
+    fn wait_all_wfs(&mut self) -> impl Future<Output = Result<(), anyhow::Error>> + 'static {
+        if let TestWorkerShutdownCond::GetResults(ref mut wfs, ref client) = self.condition {
+            let wfs = std::mem::take(wfs);
+            let shutdown_h = self.shutdown_handle.clone();
+            let client = (**client).clone();
+            let stream = stream::iter(
+                wfs.into_iter()
+                    .map(move |info| info.bind_untyped(client.clone())),
+            )
+            .map(Ok);
+            future::Either::Left(async move {
+                stream
+                    .try_for_each_concurrent(None, |wh| async move {
+                        wh.get_workflow_result(Default::default()).await?;
+                        Ok::<_, anyhow::Error>(())
+                    })
+                    .await?;
+                shutdown_h();
+                Ok(())
+            })
+        } else {
+            future::Either::Right(future::ready(Ok(())))
+        }
+    }
+}
 #[async_trait::async_trait(?Send)]
-impl WorkerInterceptor for TestWorkerInterceptor {
+impl WorkerInterceptor for TestWorkerCompletionIceptor {
     async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion) {
+        if let Some(func) = self.every_activation.as_ref() {
+            func(completion);
+        }
         if completion.has_execution_ending() {
             info!("Workflow {} says it's finishing", &completion.run_id);
-            let prev = self.incomplete_workflows.fetch_sub(1, Ordering::SeqCst);
-            if prev <= 1 {
-                if let Some(sh) = self.shutdown_handle.as_ref() {
-                    info!("Test worker calling shutdown");
-                    // There are now zero, we just subtracted one
-                    sh()
-                }
-            }
         }
         if let Some(n) = self.next.as_ref() {
             n.on_workflow_activation_completion(completion).await;
@@ -425,7 +437,6 @@ pub fn get_integ_server_options() -> ClientOptions {
     let url = Url::try_from(&*temporal_server_address).unwrap();
     ClientOptionsBuilder::default()
         .identity("integ_tester".to_string())
-        .worker_binary_id("fakebinaryid".to_string())
         .target_url(url)
         .client_name("temporal-core".to_string())
         .client_version("0.1.0".to_string())
@@ -439,10 +450,12 @@ pub fn get_integ_telem_options() -> TelemetryOptions {
         .ok()
         .map(|x| x.parse::<Url>().unwrap())
     {
-        ob.tracing(TraceExporter::Otel(OtelCollectorOptions {
+        let opts = OtelCollectorOptions {
             url,
             headers: Default::default(),
-        }));
+        };
+        ob.tracing(TraceExporter::Otel(opts.clone()));
+        ob.metrics(MetricsExporter::Otel(opts));
     }
     if let Some(addr) = env::var(PROM_ENABLE_ENV_VAR)
         .ok()

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

@@ -1,15 +1,17 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
-use temporal_sdk_core_protos::coresdk::{
-    activity_result::{
-        self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution,
+use temporal_sdk_core_protos::{
+    coresdk::{
+        activity_result::{
+            self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution,
+        },
+        activity_task::activity_task,
+        workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob},
+        workflow_commands::{ActivityCancellationType, ScheduleActivity},
+        workflow_completion::WorkflowActivationCompletion,
+        ActivityHeartbeat, ActivityTaskCompletion, IntoCompletion,
     },
-    activity_task::activity_task,
-    common::{Payload, RetryPolicy},
-    workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob},
-    workflow_commands::{ActivityCancellationType, ScheduleActivity},
-    workflow_completion::WorkflowActivationCompletion,
-    ActivityHeartbeat, ActivityTaskCompletion, IntoCompletion,
+    temporal::api::common::v1::{Payload, RetryPolicy},
 };
 use temporal_sdk_core_test_utils::{
     init_core_and_create_wf, schedule_activity_cmd, WorkerTestHelpers,

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

@@ -3,6 +3,7 @@ use futures::future::join_all;
 use std::time::Duration;
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_api::errors::PollWfError;
 use temporal_sdk_core_protos::coresdk::{
     activity_task::activity_task as act_task,
     workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob},
@@ -131,3 +132,14 @@ async fn can_paginate_long_history() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn poll_of_nonexistent_namespace_is_fatal() {
+    let mut starter = CoreWfStarter::new("whatever_yo");
+    starter.worker_config.namespace = "I do not exist".to_string();
+    let worker = starter.get_worker().await;
+    assert_matches!(
+        worker.poll_workflow_activation().await,
+        Err(PollWfError::TonicError(_))
+    );
+}

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

@@ -112,7 +112,7 @@ async fn simple_query_legacy() {
 async fn query_after_execution_complete(#[case] do_evict: bool) {
     let query_resp = b"response";
     let mut starter =
-        init_core_and_create_wf(&format!("after_done_query_evict-{}", do_evict)).await;
+        init_core_and_create_wf(&format!("query_after_execution_complete-{}", do_evict)).await;
     let core = &starter.get_worker().await;
     let workflow_id = &starter.get_task_queue().to_string();
 
@@ -156,19 +156,19 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
                     .unwrap();
                 continue;
             }
-            assert_matches!(
+            if matches!(
                 task.jobs.as_slice(),
                 [WorkflowActivationJob {
                     variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
                 }]
-            );
-            let run_id = task.run_id.clone();
-            core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
-                .await;
-            let task = core.poll_workflow_activation().await.unwrap();
-            core.complete_execution(&task.run_id).await;
+            ) {
+                core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
+                    .await;
+            } else {
+                core.complete_execution(&task.run_id).await;
+            }
             if !go_until_query {
-                break run_id;
+                break task.run_id;
             }
         }
     };
@@ -205,6 +205,7 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
         query_futs.push(do_workflow(true).map(|_| ()).boxed());
     }
     while query_futs.next().await.is_some() {}
+    core.shutdown().await;
 }
 
 #[ignore]
@@ -339,20 +340,21 @@ async fn fail_legacy_query() {
     let core = starter.get_worker().await;
     let workflow_id = starter.get_task_queue().to_string();
     let task = core.poll_workflow_activation().await.unwrap();
+    let t1_resp = vec![
+        StartTimer {
+            seq: 1,
+            start_to_fire_timeout: Some(Duration::from_millis(500).into()),
+        }
+        .into(),
+        StartTimer {
+            seq: 2,
+            start_to_fire_timeout: Some(Duration::from_secs(3).into()),
+        }
+        .into(),
+    ];
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id.clone(),
-        vec![
-            StartTimer {
-                seq: 1,
-                start_to_fire_timeout: Some(Duration::from_millis(500).into()),
-            }
-            .into(),
-            StartTimer {
-                seq: 2,
-                start_to_fire_timeout: Some(Duration::from_secs(3).into()),
-            }
-            .into(),
-        ],
+        t1_resp.clone(),
     ))
     .await
     .unwrap();
@@ -410,7 +412,22 @@ async fn fail_legacy_query() {
         ))
         .await
         .unwrap();
-        // Finish the workflow
+        // Finish the workflow (handling cache removal)
+        let task = core.poll_workflow_activation().await.unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+            .await
+            .unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+            task.run_id,
+            t1_resp.clone(),
+        ))
+        .await
+        .unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
+        core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+            .await
+            .unwrap();
         let task = core.poll_workflow_activation().await.unwrap();
         core.complete_execution(&task.run_id).await;
     };

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

@@ -1,7 +1,7 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
+use temporal_sdk::{ActContext, ActivityOptions, CancellableFuture, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{
@@ -9,7 +9,6 @@ use temporal_sdk_core_protos::{
             ActivityResolution,
         },
         activity_task::activity_task as act_task,
-        common::Payload,
         workflow_activation::{
             workflow_activation_job, FireTimer, ResolveActivity, WorkflowActivationJob,
         },
@@ -18,7 +17,7 @@ use temporal_sdk_core_protos::{
         ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
     temporal::api::{
-        common::v1::{ActivityType, Payloads},
+        common::v1::{ActivityType, Payload, Payloads},
         enums::v1::RetryState,
         failure::v1::{failure::FailureInfo, ActivityFailureInfo, Failure},
     },
@@ -663,7 +662,7 @@ async fn async_activity_completion_workflow() {
         .complete_activity_task(
             task.task_token.into(),
             Some(Payloads {
-                payloads: vec![response_payload.clone().into()],
+                payloads: vec![response_payload.clone()],
             }),
         )
         .await
@@ -748,3 +747,49 @@ async fn activity_cancelled_after_heartbeat_times_out() {
         .await
         .unwrap();
 }
+
+#[tokio::test]
+async fn one_activity_abandon_cancelled_after_complete() {
+    let wf_name = "one_activity_abandon_cancelled_after_complete";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let act_fut = ctx.activity(ActivityOptions {
+            activity_type: "echo_activity".to_string(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            input: "hi!".as_json_payload().expect("serializes fine"),
+            cancellation_type: ActivityCancellationType::Abandon,
+            ..Default::default()
+        });
+        ctx.timer(Duration::from_secs(1)).await;
+        act_fut.cancel(&ctx);
+        ctx.timer(Duration::from_secs(3)).await;
+        act_fut.await;
+        Ok(().into())
+    });
+    worker.register_activity(
+        "echo_activity",
+        |_ctx: ActContext, echo_me: String| async move {
+            sleep(Duration::from_secs(2)).await;
+            Ok(echo_me)
+        },
+    );
+
+    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);
+    let res = handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+    assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
+}

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

@@ -0,0 +1,61 @@
+use assert_matches::assert_matches;
+use std::time::Duration;
+use temporal_client::{WfClientExt, WorkflowExecutionResult, WorkflowOptions};
+use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+const TEST_APPDATA_MESSAGE: &str = "custom app data, yay";
+
+struct Data {
+    message: String,
+}
+
+pub async fn appdata_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.activity(ActivityOptions {
+        activity_type: "echo_activity".to_string(),
+        start_to_close_timeout: Some(Duration::from_secs(5)),
+        input: "hi!".as_json_payload().expect("serializes fine"),
+        ..Default::default()
+    })
+    .await;
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn appdata_access_in_activities_and_workflows() {
+    let wf_name = "appdata_activity";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.inner_mut().insert_app_data(Data {
+        message: TEST_APPDATA_MESSAGE.to_owned(),
+    });
+
+    let client = starter.get_client().await;
+    worker.register_wf(wf_name.to_owned(), appdata_activity_wf);
+    worker.register_activity(
+        "echo_activity",
+        |ctx: ActContext, echo_me: String| async move {
+            let data = ctx.app_data::<Data>().expect("appdata exists. qed");
+            assert_eq!(data.message, TEST_APPDATA_MESSAGE.to_owned());
+            Ok(echo_me)
+        },
+    );
+
+    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);
+    let res = handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+    assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
+}

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)
+            .cancel_workflow_execution(wf_name.to_string(), None, "Dieee".to_string())
             .await
             .unwrap();
     };

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

@@ -6,9 +6,12 @@ use temporal_sdk::{
     interceptors::WorkerInterceptor, ActContext, ActivityCancelledError, CancellableFuture,
     LocalActivityOptions, WfContext, WorkflowResult,
 };
-use temporal_sdk_core_protos::coresdk::{
-    common::RetryPolicy, workflow_commands::ActivityCancellationType,
-    workflow_completion::WorkflowActivationCompletion, AsJsonPayloadExt,
+use temporal_sdk_core_protos::{
+    coresdk::{
+        workflow_commands::ActivityCancellationType,
+        workflow_completion::WorkflowActivationCompletion, AsJsonPayloadExt,
+    },
+    temporal::api::common::v1::RetryPolicy,
 };
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio_util::sync::CancellationToken;
@@ -494,12 +497,15 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
     worker.run_until_done().await.unwrap();
 }
 
+#[rstest::rstest]
 #[tokio::test]
-async fn eviction_wont_make_local_act_get_dropped() {
-    let wf_name = "eviction_wont_make_local_act_get_dropped";
-    let mut starter = CoreWfStarter::new(wf_name);
+async fn eviction_wont_make_local_act_get_dropped(#[values(true, false)] short_wft_timeout: bool) {
+    let wf_name = format!(
+        "eviction_wont_make_local_act_get_dropped_{}",
+        short_wft_timeout
+    );
+    let mut starter = CoreWfStarter::new(&wf_name);
     starter.max_cached_workflows(0);
-    starter.wft_timeout(Duration::from_secs(1));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), local_act_then_timer_then_wait);
     worker.register_activity("echo_activity", |_ctx: ActContext, str: String| async {
@@ -507,13 +513,16 @@ async fn eviction_wont_make_local_act_get_dropped() {
         Ok(str)
     });
 
+    let opts = if short_wft_timeout {
+        WorkflowOptions {
+            task_timeout: Some(Duration::from_secs(1)),
+            ..Default::default()
+        }
+    } else {
+        Default::default()
+    };
     worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
+        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![], opts)
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -571,3 +580,55 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn repro_nondeterminism_with_timer_bug() {
+    let wf_name = "repro_nondeterminism_with_timer_bug";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let t1 = ctx.timer(Duration::from_secs(30));
+        let r1 = ctx.local_activity(LocalActivityOptions {
+            activity_type: "delay".to_string(),
+            input: "hi".as_json_payload().expect("serializes fine"),
+            retry_policy: RetryPolicy {
+                initial_interval: Some(Duration::from_micros(15).into()),
+                backoff_coefficient: 1_000.,
+                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_attempts: 4,
+                non_retryable_error_types: vec![],
+            },
+            timer_backoff_threshold: Some(Duration::from_secs(1)),
+            ..Default::default()
+        });
+        tokio::pin!(t1);
+        tokio::select! {
+            _ = &mut t1 => {},
+            _ = r1 => {
+                t1.cancel(&ctx);
+            },
+        };
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(().into())
+    });
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(2)).await;
+        Ok(())
+    });
+
+    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();
+    starter
+        .fetch_history_and_replay(wf_name, run_id, worker.inner_mut())
+        .await
+        .unwrap();
+}