@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/sdk-core/tests/integ_tests/workflow_tests/determinism.rs

@@ -1,12 +1,17 @@
-use crate::common::{CoreWfStarter, WorkflowHandleExt, mock_sdk, mock_sdk_cfg};
+use crate::common::{
+    CoreWfStarter, WorkflowHandleExt, activity_functions::StdActivities, mock_sdk, mock_sdk_cfg,
+};
 use std::{
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+    },
     time::Duration,
 };
-use temporalio_client::WorkflowOptions;
+use temporalio_client::WorkflowStartOptions;
 use temporalio_common::{
     protos::{
-        DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder, canned_histories,
+        TestHistoryBuilder, canned_histories,
         coresdk::AsJsonPayloadExt,
         temporal::api::{
             enums::v1::{EventType, WorkflowTaskFailedCause},
@@ -15,85 +20,121 @@ use temporalio_common::{
     },
     worker::WorkerTaskTypes,
 };
+use temporalio_macros::{workflow, workflow_methods};
 use temporalio_sdk::{
-    ActContext, ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WfContext,
-    WorkflowResult,
+    ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WorkflowContext, WorkflowResult,
 };
 use temporalio_sdk_core::{
     replay::DEFAULT_WORKFLOW_TYPE,
     test_help::{CoreInternalFlags, MockPollCfg, ResponseType, mock_worker_client},
 };
 
-static RUN_CT: AtomicUsize = AtomicUsize::new(1);
+#[workflow]
+pub(crate) struct TimerWfNondeterministic {
+    run_ct: Arc<AtomicUsize>,
+}
 
-pub(crate) async fn timer_wf_nondeterministic(ctx: WfContext) -> WorkflowResult<()> {
-    let run_ct = RUN_CT.fetch_add(1, Ordering::Relaxed);
+#[workflow_methods(factory_only)]
+impl TimerWfNondeterministic {
+    #[run]
+    pub(crate) async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let run_ct = ctx.state(|wf| wf.run_ct.fetch_add(1, Ordering::Relaxed));
 
-    match run_ct {
-        1 | 3 => {
-            // If we have not run yet or are on the third attempt, schedule a timer
-            ctx.timer(Duration::from_secs(1)).await;
-            if run_ct == 1 {
-                // on first attempt we need to blow up after the timer fires so we will replay
-                panic!("dying on purpose");
+        match run_ct {
+            1 | 3 => {
+                ctx.timer(Duration::from_secs(1)).await;
+                if run_ct == 1 {
+                    panic!("dying on purpose");
+                }
             }
+            2 => {
+                ctx.start_activity(StdActivities::default, (), ActivityOptions::default())
+                    .await
+                    .map_err(|e| anyhow::anyhow!("{e}"))?;
+            }
+            _ => panic!("Ran too many times"),
         }
-        2 => {
-            // On the second attempt we should cause a nondeterminism error
-            ctx.activity(ActivityOptions {
-                activity_type: "whatever".to_string(),
-                ..Default::default()
-            })
-            .await;
-        }
-        _ => panic!("Ran too many times"),
+        Ok(())
     }
-    Ok(().into())
 }
 
 #[tokio::test]
 async fn test_determinism_error_then_recovers() {
     let wf_name = "test_determinism_error_then_recovers";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let mut worker = starter.worker().await;
 
-    worker.register_wf(wf_name.to_owned(), timer_wf_nondeterministic);
-    starter.start_with_worker(wf_name, &mut worker).await;
+    let run_ct = Arc::new(AtomicUsize::new(1));
+    let run_ct_clone = run_ct.clone();
+    worker.register_workflow_with_factory(move || TimerWfNondeterministic {
+        run_ct: run_ct_clone.clone(),
+    });
+    let task_queue = starter.get_task_queue().to_owned();
+    worker
+        .submit_workflow(
+            TimerWfNondeterministic::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_task_queue().to_owned()).build(),
+        )
+        .await
+        .unwrap();
     worker.run_until_done().await.unwrap();
-    // 4 because we still add on the 3rd and final attempt
-    assert_eq!(RUN_CT.load(Ordering::Relaxed), 4);
+    assert_eq!(run_ct.load(Ordering::Relaxed), 4);
+}
+
+#[workflow]
+struct TaskFailReplayWf {
+    did_fail: Arc<AtomicBool>,
+}
+
+#[workflow_methods(factory_only)]
+impl TaskFailReplayWf {
+    #[run]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        if ctx.state(|wf| wf.did_fail.load(Ordering::Relaxed)) {
+            assert!(ctx.is_replaying());
+        }
+        let _ = ctx
+            .start_activity(
+                StdActivities::echo,
+                "hi!".to_string(),
+                ActivityOptions {
+                    start_to_close_timeout: Some(Duration::from_secs(2)),
+                    ..Default::default()
+                },
+            )
+            .await;
+        if !ctx.state(|wf| wf.did_fail.load(Ordering::Relaxed)) {
+            ctx.state(|wf| wf.did_fail.store(true, Ordering::Relaxed));
+            panic!("Die on purpose");
+        }
+        Ok(())
+    }
 }
 
 #[tokio::test]
 async fn task_fail_causes_replay_unset_too_soon() {
     let wf_name = "task_fail_causes_replay_unset_too_soon";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.sdk_config.register_activities(StdActivities);
     let mut worker = starter.worker().await;
 
-    static DID_FAIL: AtomicBool = AtomicBool::new(false);
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
-        if DID_FAIL.load(Ordering::Relaxed) {
-            assert!(ctx.is_replaying());
-        }
-        ctx.activity(ActivityOptions {
-            activity_type: "echo".to_string(),
-            input: "hi!".as_json_payload().expect("serializes fine"),
-            start_to_close_timeout: Some(Duration::from_secs(2)),
-            ..Default::default()
-        })
-        .await;
-        if !DID_FAIL.load(Ordering::Relaxed) {
-            DID_FAIL.store(true, Ordering::Relaxed);
-            panic!("Die on purpose");
-        }
-        Ok(().into())
-    });
-    worker.register_activity("echo", |_ctx: ActContext, echo_me: String| async move {
-        Ok(echo_me)
+    let did_fail = Arc::new(AtomicBool::new(false));
+    let did_fail_clone = did_fail.clone();
+    worker.register_workflow_with_factory(move || TaskFailReplayWf {
+        did_fail: did_fail_clone.clone(),
     });
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            TaskFailReplayWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_task_queue().to_owned()).build(),
+        )
+        .await
+        .unwrap();
 
     worker.run_until_done().await.unwrap();
     handle
@@ -102,17 +143,27 @@ async fn task_fail_causes_replay_unset_too_soon() {
         .unwrap();
 }
 
-async fn timer_wf_fails_once(ctx: WfContext) -> WorkflowResult<()> {
-    static DID_FAIL: AtomicBool = AtomicBool::new(false);
+#[workflow]
+struct TimerWfFailsOnce {
+    did_fail: Arc<AtomicBool>,
+}
 
-    ctx.timer(Duration::from_secs(1)).await;
-    if DID_FAIL
-        .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
-        .is_ok()
-    {
-        panic!("Ahh");
+#[workflow_methods(factory_only)]
+impl TimerWfFailsOnce {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_secs(1)).await;
+        if ctx
+            .state(|wf| {
+                wf.did_fail
+                    .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+            })
+            .is_ok()
+        {
+            panic!("Ahh");
+        }
+        Ok(())
     }
-    Ok(().into())
 }
 
 /// Verifies that workflow panics (which in this case the Rust SDK turns into workflow activation
@@ -135,19 +186,39 @@ async fn test_panic_wf_task_rejected_properly() {
     });
     let mut worker = mock_sdk(mh);
 
-    worker.register_wf(wf_type.to_owned(), timer_wf_fails_once);
+    let did_fail = Arc::new(AtomicBool::new(false));
+    worker.register_workflow_with_factory(move || TimerWfFailsOnce {
+        did_fail: did_fail.clone(),
+    });
+    let task_queue = "fake_tq".to_owned();
     worker
         .submit_wf(
-            wf_id.to_owned(),
             wf_type.to_owned(),
             vec![],
-            WorkflowOptions::default(),
+            WorkflowStartOptions::new(task_queue, wf_id.to_owned()).build(),
         )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
 
+#[workflow]
+struct NondeterministicTimerWf {
+    started_count: Arc<AtomicUsize>,
+}
+
+#[workflow_methods(factory_only)]
+impl NondeterministicTimerWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        if ctx.state(|wf| wf.started_count.fetch_add(1, Ordering::Relaxed)) == 0 {
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(())
+    }
+}
+
 /// Verifies nondeterministic behavior in workflows results in automatic WFT failure with the
 /// appropriate nondeterminism cause.
 #[rstest::rstest]
@@ -162,11 +233,9 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
-        // Two polls are needed, since the first will fail
         [ResponseType::AllHistory, ResponseType::AllHistory],
         mock,
     );
-    // We should see one wft failure which has nondeterminism cause
     mh.num_expected_fails = 1;
     mh.expect_fail_wft_matcher =
         Box::new(|_, cause, _| matches!(cause, WorkflowTaskFailedCause::NonDeterministicError));
@@ -176,32 +245,73 @@ async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache:
         }
     });
 
-    let started_count: &'static _ = Box::leak(Box::new(AtomicUsize::new(0)));
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
-        // The workflow is replaying all of history, so the when it schedules an extra timer it
-        // should not have, it causes a nondeterminism error.
-        if started_count.fetch_add(1, Ordering::Relaxed) == 0 {
-            ctx.timer(Duration::from_secs(1)).await;
-        }
-        ctx.timer(Duration::from_secs(1)).await;
-        Ok(().into())
+    let started_count = Arc::new(AtomicUsize::new(0));
+    let count_clone = started_count.clone();
+    worker.register_workflow_with_factory(move || NondeterministicTimerWf {
+        started_count: count_clone.clone(),
     });
 
+    let task_queue = "fake_tq".to_owned();
     worker
         .submit_wf(
-            wf_id.to_owned(),
             wf_type.to_owned(),
             vec![],
-            WorkflowOptions::default(),
+            WorkflowStartOptions::new(task_queue, wf_id.to_owned()).build(),
         )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    // Started count is two since we start, restart once due to error, then we unblock the real
-    // timer and proceed without restarting
     assert_eq!(2, started_count.load(Ordering::Relaxed));
 }
 
+#[workflow]
+#[derive(Default)]
+struct ActivityIdOrTypeChangeWf;
+
+#[workflow_methods]
+impl ActivityIdOrTypeChangeWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(
+        ctx: &mut WorkflowContext<Self>,
+        (id_change, local_act): (bool, bool),
+    ) -> WorkflowResult<()> {
+        if local_act {
+            if id_change {
+                ctx.start_local_activity(
+                    StdActivities::default,
+                    (),
+                    LocalActivityOptions {
+                        activity_id: Some("I'm bad and wrong!".to_string()),
+                        ..Default::default()
+                    },
+                )
+                .await
+                .map_err(|e| anyhow::anyhow!("{e}"))?;
+            } else {
+                ctx.start_local_activity(StdActivities::no_op, (), Default::default())
+                    .await
+                    .map_err(|e| anyhow::anyhow!("{e}"))?;
+            }
+        } else if id_change {
+            ctx.start_activity(
+                StdActivities::default,
+                (),
+                ActivityOptions {
+                    activity_id: Some("I'm bad and wrong!".to_string()),
+                    ..Default::default()
+                },
+            )
+            .await
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
+        } else {
+            ctx.start_activity(StdActivities::no_op, (), ActivityOptions::default())
+                .await
+                .map_err(|e| anyhow::anyhow!("{e}"))?;
+        }
+        Ok(())
+    }
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn activity_id_or_type_change_is_nondeterministic(
@@ -217,15 +327,14 @@ async fn activity_id_or_type_change_is_nondeterministic(
         canned_histories::single_activity("1")
     };
     t.set_flags_first_wft(&[CoreInternalFlags::IdAndTypeDeterminismChecks as u32], &[]);
+    t.set_wf_input((id_change, local_act).as_json_payload().unwrap());
     let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
-        // Two polls are needed, since the first will fail
         [ResponseType::AllHistory, ResponseType::AllHistory],
         mock,
     );
-    // We should see one wft failure which has nondeterminism cause
     mh.num_expected_fails = 1;
     mh.expect_fail_wft_matcher = Box::new(move |_, cause, f| {
         let should_contain = if id_change {
@@ -244,52 +353,47 @@ async fn activity_id_or_type_change_is_nondeterministic(
             cfg.max_cached_workflows = 2;
         }
     });
+    worker.register_workflow::<ActivityIdOrTypeChangeWf>();
 
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
-        if local_act {
-            ctx.local_activity(if id_change {
-                LocalActivityOptions {
-                    activity_id: Some("I'm bad and wrong!".to_string()),
-                    activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-                    ..Default::default()
-                }
-            } else {
-                LocalActivityOptions {
-                    activity_type: "not the default act type".to_string(),
-                    ..Default::default()
-                }
-            })
-            .await;
-        } else {
-            ctx.activity(if id_change {
-                ActivityOptions {
-                    activity_id: Some("I'm bad and wrong!".to_string()),
-                    activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-                    ..Default::default()
-                }
-            } else {
-                ActivityOptions {
-                    activity_type: "not the default act type".to_string(),
-                    ..Default::default()
-                }
-            })
-            .await;
-        }
-        Ok(().into())
-    });
-
+    let task_queue = "fake_tq".to_owned();
     worker
         .submit_wf(
-            wf_id.to_owned(),
             wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+            vec![(id_change, local_act).as_json_payload().unwrap()],
+            WorkflowStartOptions::new(task_queue, wf_id.to_owned()).build(),
         )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
 
+#[workflow]
+#[derive(Default)]
+struct ChildWfIdOrTypeChangeWf;
+
+#[workflow_methods]
+impl ChildWfIdOrTypeChangeWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>, id_change: bool) -> WorkflowResult<()> {
+        ctx.child_workflow(if id_change {
+            ChildWorkflowOptions {
+                workflow_id: "I'm bad and wrong!".to_string(),
+                workflow_type: "child".to_string(),
+                ..Default::default()
+            }
+        } else {
+            ChildWorkflowOptions {
+                workflow_id: "1".to_string(),
+                workflow_type: "not the child wf type".to_string(),
+                ..Default::default()
+            }
+        })
+        .start()
+        .await;
+        Ok(())
+    }
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn child_wf_id_or_type_change_is_nondeterministic(
@@ -300,15 +404,14 @@ async fn child_wf_id_or_type_change_is_nondeterministic(
     let wf_type = DEFAULT_WORKFLOW_TYPE;
     let mut t = canned_histories::single_child_workflow("1");
     t.set_flags_first_wft(&[CoreInternalFlags::IdAndTypeDeterminismChecks as u32], &[]);
+    t.set_wf_input(id_change.as_json_payload().unwrap());
     let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(
         wf_id,
         t,
-        // Two polls are needed, since the first will fail
         [ResponseType::AllHistory, ResponseType::AllHistory],
         mock,
     );
-    // We should see one wft failure which has nondeterminism cause
     mh.num_expected_fails = 1;
     mh.expect_fail_wft_matcher = Box::new(move |_, cause, f| {
         let should_contain = if id_change {
@@ -328,37 +431,34 @@ async fn child_wf_id_or_type_change_is_nondeterministic(
         }
     });
 
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
-        ctx.child_workflow(if id_change {
-            ChildWorkflowOptions {
-                workflow_id: "I'm bad and wrong!".to_string(),
-                workflow_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-                ..Default::default()
-            }
-        } else {
-            ChildWorkflowOptions {
-                workflow_id: "1".to_string(),
-                workflow_type: "not the child wf type".to_string(),
-                ..Default::default()
-            }
-        })
-        .start(&ctx)
-        .await;
-        Ok(().into())
-    });
+    worker.register_workflow::<ChildWfIdOrTypeChangeWf>();
 
+    let task_queue = "fake_tq".to_owned();
     worker
         .submit_wf(
-            wf_id.to_owned(),
             wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+            vec![id_change.as_json_payload().unwrap()],
+            WorkflowStartOptions::new(task_queue, wf_id.to_owned()).build(),
         )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
 
+#[workflow]
+#[derive(Default)]
+struct ReproChannelMissingWf;
+
+#[workflow_methods]
+impl ReproChannelMissingWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.patched("wrongid");
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(())
+    }
+}
+
 /// Repros a situation where if, upon completing a task there is some internal error which causes
 /// us to want to auto-fail the workflow task while there is also an outstanding eviction, the wf
 /// would get evicted but then try to send some info down the completion channel afterward, causing
@@ -384,18 +484,14 @@ async fn repro_channel_missing_because_nondeterminism() {
             cfg.ignore_evicts_on_shutdown = false;
         });
 
-        worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
-            ctx.patched("wrongid");
-            ctx.timer(Duration::from_secs(1)).await;
-            Ok(().into())
-        });
+        worker.register_workflow::<ReproChannelMissingWf>();
 
+        let task_queue = "fake_tq".to_owned();
         worker
             .submit_wf(
-                wf_id.to_owned(),
                 wf_type.to_owned(),
                 vec![],
-                WorkflowOptions::default(),
+                WorkflowStartOptions::new(task_queue, wf_id.to_owned()).build(),
             )
             .await
             .unwrap();