@temporalio/core-bridge 0.19.2 → 0.20.2

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

@@ -1,4 +1,5 @@
 use std::time::Duration;
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -20,19 +21,24 @@ async fn cancelled_wf(mut ctx: WfContext) -> WorkflowResult<()> {
 async fn cancel_during_timer() {
     let wf_name = "cancel_during_timer";
     let mut starter = CoreWfStarter::new(wf_name);
-    let core = starter.get_core().await;
     let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
     worker.register_wf(wf_name.to_string(), cancelled_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
 
     let canceller = async {
         tokio::time::sleep(Duration::from_millis(500)).await;
         // Cancel the workflow externally
-        core.server_gateway()
+        client
             .cancel_workflow_execution(wf_name.to_string(), None)
             .await
             .unwrap();
@@ -40,8 +46,7 @@ async fn cancel_during_timer() {
 
     let (_, res) = tokio::join!(canceller, worker.run_until_done());
     res.unwrap();
-    let desc = core
-        .server_gateway()
+    let desc = client
         .describe_workflow_execution(wf_name.to_string(), None)
         .await
         .unwrap();

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

@@ -1,4 +1,5 @@
 use anyhow::anyhow;
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::child_workflow::{child_workflow_result, Success};
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -38,7 +39,12 @@ async fn child_workflow_happy_path() {
     worker.incr_expected_run_count(1); // Expect another WF to be run as child
 
     worker
-        .submit_wf("parent".to_string(), PARENT_WF_TYPE.to_owned(), vec![])
+        .submit_wf(
+            "parent".to_string(),
+            PARENT_WF_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();

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

@@ -1,4 +1,5 @@
 use std::time::Duration;
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::workflow_commands::ContinueAsNewWorkflowExecution;
 use temporal_sdk_core_test_utils::CoreWfStarter;
@@ -24,17 +25,39 @@ async fn continue_as_new_happy_path() {
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 
     worker
-        .submit_wf(wf_name.to_string(), wf_name.to_string(), vec![[1].into()])
+        .submit_wf(
+            wf_name.to_string(),
+            wf_name.to_string(),
+            vec![[1].into()],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
+    // The four additional runs
+    worker.incr_expected_run_count(4);
     worker.run_until_done().await.unwrap();
+}
 
-    // Terminate the continued workflow
-    starter
-        .get_core()
-        .await
-        .server_gateway()
-        .terminate_workflow_execution(wf_name.to_owned(), None)
-        .await
-        .unwrap();
+#[tokio::test]
+async fn continue_as_new_multiple_concurrent() {
+    let wf_name = "continue_as_new_multiple_concurrent";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_cached_workflows(3).max_wft(3);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_string(), continue_as_new_wf);
+
+    let wf_names = (1..=20).map(|i| format!("{}-{}", wf_name, i));
+    for name in wf_names.clone() {
+        worker
+            .submit_wf(
+                name.to_string(),
+                wf_name.to_string(),
+                vec![[1].into()],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+    }
+    worker.incr_expected_run_count(20 * 4);
+    worker.run_until_done().await.unwrap();
 }

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

@@ -2,6 +2,7 @@ use std::{
     sync::atomic::{AtomicUsize, Ordering},
     time::Duration,
 };
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 
@@ -39,7 +40,12 @@ async fn test_determinism_error_then_recovers() {
 
     worker.register_wf(wf_name.to_owned(), timer_wf_nondeterministic);
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .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/local_activities.rs

@@ -1,6 +1,7 @@
 use anyhow::anyhow;
 use futures::future::join_all;
 use std::time::Duration;
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{
     act_cancelled, act_is_cancelled, ActivityCancelledError, CancellableFuture,
     LocalActivityOptions, WfContext, WorkflowResult,
@@ -37,7 +38,12 @@ async fn one_local_activity() {
     worker.register_activity("echo_activity", echo);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -63,7 +69,12 @@ async fn local_act_concurrent_with_timer() {
     worker.register_activity("echo_activity", echo);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -90,7 +101,12 @@ async fn local_act_then_timer_then_wait_result() {
     worker.register_activity("echo_activity", echo);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -109,7 +125,12 @@ async fn long_running_local_act_with_timer() {
     });
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -142,7 +163,12 @@ async fn local_act_fanout() {
     worker.register_activity("echo_activity", echo);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -178,12 +204,17 @@ async fn local_act_retry_timer_backoff() {
     });
 
     let run_id = worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .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, &mut worker)
+        .fetch_history_and_replay(wf_name, run_id, worker.inner_mut())
         .await
         .unwrap();
 }
@@ -229,11 +260,16 @@ async fn cancel_immediate(#[case] cancel_type: ActivityCancellationType) {
     });
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker
-        .run_until_done_shutdown_hook(|| manual_cancel.cancel())
+        .run_until_done_shutdown_hook(move || manual_cancel.cancel())
         .await
         .unwrap();
 }
@@ -318,11 +354,16 @@ async fn cancel_after_act_starts(
     });
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker
-        .run_until_done_shutdown_hook(|| manual_cancel.cancel())
+        .run_until_done_shutdown_hook(move || manual_cancel.cancel())
         .await
         .unwrap();
 }
@@ -376,7 +417,12 @@ async fn x_to_close_timeout(#[case] is_schedule: bool) {
     });
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -421,7 +467,12 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
     });
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -441,7 +492,12 @@ async fn eviction_wont_make_local_act_get_dropped() {
     });
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -489,7 +545,12 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
     });
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .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/patches.rs

@@ -2,6 +2,7 @@ use std::{
     sync::atomic::{AtomicBool, Ordering},
     time::Duration,
 };
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 
@@ -30,7 +31,12 @@ async fn writes_change_markers() {
     worker.register_wf(wf_name.to_owned(), changes_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -65,7 +71,12 @@ async fn can_add_change_markers() {
     worker.register_wf(wf_name.to_owned(), no_change_then_change_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -90,7 +101,12 @@ async fn replaying_with_patch_marker() {
     worker.register_wf(wf_name.to_owned(), replay_with_change_marker_wf);
 
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .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/replay.rs

@@ -1,6 +1,7 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
-use temporal_sdk_core::{replay::mock_gateway_from_history, ServerGatewayApis};
+use temporal_sdk::{WfContext, Worker, WorkflowFunction};
+use temporal_sdk_core::telemetry_init;
 use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -8,24 +9,24 @@ use temporal_sdk_core_protos::{
         workflow_commands::{ScheduleActivity, StartTimer},
         workflow_completion::WorkflowActivationCompletion,
     },
-    temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse,
+    DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    history_from_proto_binary, init_core_replay_preloaded, CoreTestHelpers,
+    canned_histories, get_integ_telem_options, history_from_proto_binary,
+    init_core_replay_preloaded, WorkerTestHelpers,
 };
 use tokio::join;
 
 #[tokio::test]
 async fn timer_workflow_replay() {
-    let (core, task_q) = init_core_replay_preloaded(
+    let (core, _) = init_core_replay_preloaded(
         "timer_workflow_replay",
         &history_from_proto_binary("histories/timer_workflow_history.bin")
             .await
             .unwrap(),
     );
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![StartTimer {
             seq: 0,
@@ -35,70 +36,44 @@ async fn timer_workflow_replay() {
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Verify that an in-progress poll is interrupted by completion finishing processing history
     let act_poll_fut = async {
         assert_matches!(
-            core.poll_activity_task(&task_q).await,
+            core.poll_activity_task().await,
             Err(PollActivityError::ShutDown)
         );
     };
     let poll_fut = async {
         assert_matches!(
-            core.poll_workflow_activation(&task_q).await,
+            core.poll_workflow_activation().await,
             Err(PollWfError::ShutDown)
         );
     };
     let complete_fut = async {
-        core.complete_execution(&task_q, &task.run_id).await;
+        core.complete_execution(&task.run_id).await;
     };
     join!(act_poll_fut, poll_fut, complete_fut);
 
     // Subsequent polls should still return shutdown
     assert_matches!(
-        core.poll_workflow_activation(&task_q).await,
+        core.poll_workflow_activation().await,
         Err(PollWfError::ShutDown)
     );
 
     core.shutdown().await;
 }
 
-// Regression test to verify mock replayers don't interfere with each other
-#[tokio::test]
-async fn two_cores_replay() {
-    let hist = history_from_proto_binary("histories/fail_wf_task.bin")
-        .await
-        .unwrap();
-
-    let mock_1 = mock_gateway_from_history(&hist, "a");
-    let mock_2 = mock_gateway_from_history(&hist, "b");
-    assert_ne!(
-        mock_1
-            .poll_workflow_task("a".to_string(), false)
-            .await
-            .unwrap(),
-        PollWorkflowTaskQueueResponse::default()
-    );
-    assert_ne!(
-        mock_2
-            .poll_workflow_task("b".to_string(), false)
-            .await
-            .unwrap(),
-        PollWorkflowTaskQueueResponse::default()
-    );
-}
-
 #[tokio::test]
 async fn workflow_nondeterministic_replay() {
-    let (core, task_q) = init_core_replay_preloaded(
+    let (core, _) = init_core_replay_preloaded(
         "timer_workflow_replay",
         &history_from_proto_binary("histories/timer_workflow_history.bin")
             .await
             .unwrap(),
     );
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![ScheduleActivity {
             seq: 0,
@@ -110,16 +85,38 @@ async fn workflow_nondeterministic_replay() {
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_eq!(task.eviction_reason(), Some(EvictionReason::Nondeterminism));
     // Complete eviction
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(&task_q, task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
         .await
         .unwrap();
     // Call shutdown explicitly because we saw a nondeterminism eviction
     core.shutdown().await;
     assert_matches!(
-        core.poll_workflow_activation(&task_q).await,
+        core.poll_workflow_activation().await,
         Err(PollWfError::ShutDown)
     );
 }
+
+#[tokio::test]
+async fn replay_using_wf_function() {
+    telemetry_init(&get_integ_telem_options()).unwrap();
+    let num_timers = 10;
+    let t = canned_histories::long_sequential_timers(num_timers as usize);
+    let func = timers_wf(num_timers);
+    let (worker, _) =
+        init_core_replay_preloaded("replay_bench", &t.get_full_history_info().unwrap().into());
+    let mut worker = Worker::new_from_core(worker, "replay_bench".to_string());
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    worker.run().await.unwrap();
+}
+
+fn timers_wf(num_timers: u32) -> WorkflowFunction {
+    WorkflowFunction::new(move |ctx: WfContext| async move {
+        for _ in 1..=num_timers {
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+        Ok(().into())
+    })
+}

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

@@ -0,0 +1,84 @@
+use futures::StreamExt;
+use std::{sync::Arc, time::Duration};
+use temporal_client::{WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporal_sdk::WfContext;
+use temporal_sdk_core_protos::temporal::api::{
+    common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
+};
+use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE};
+use tokio::sync::Notify;
+
+const POST_RESET_SIG: &str = "post-reset";
+
+#[tokio::test]
+async fn reset_workflow() {
+    let wf_name = "reset_me_wf";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    let notify = Arc::new(Notify::new());
+
+    let wf_notify = notify.clone();
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
+        let notify = wf_notify.clone();
+        async move {
+            // Make a couple workflow tasks
+            ctx.timer(Duration::from_secs(1)).await;
+            ctx.timer(Duration::from_secs(1)).await;
+            // Tell outer scope to send the reset
+            notify.notify_one();
+            let _ = ctx
+                .make_signal_channel(POST_RESET_SIG)
+                .next()
+                .await
+                .unwrap();
+            Ok(().into())
+        }
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    let client = starter.get_client().await;
+    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 {
+                    workflow_id: wf_name.to_owned(),
+                    run_id: run_id.clone(),
+                }),
+                // End of first WFT
+                workflow_task_finish_event_id: 4,
+                request_id: "test-req-id".to_owned(),
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+
+        // 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();
+    };
+    let run_fut = worker.run_until_done();
+    let (_, rr) = tokio::join!(resetter_fut, run_fut);
+    rr.unwrap();
+}