@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/replay.rs

@@ -1,22 +1,30 @@
-use crate::integ_tests::workflow_tests::patches::changes_wf;
+use crate::{
+    common::{
+        ActivationAssertionsInterceptor, build_fake_sdk, history_from_proto_binary,
+        init_core_replay_preloaded, replay_sdk_worker, replay_sdk_worker_stream,
+    },
+    integ_tests::workflow_tests::patches::changes_wf,
+};
 use assert_matches::assert_matches;
 use parking_lot::Mutex;
 use std::{collections::HashSet, sync::Arc, time::Duration};
-use temporal_sdk::{WfContext, Worker, WorkflowFunction, interceptors::WorkerInterceptor};
-use temporal_sdk_core::replay::{HistoryFeeder, HistoryForReplay};
-use temporal_sdk_core_api::errors::PollError;
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
-    coresdk::{
-        workflow_activation::remove_from_cache::EvictionReason,
-        workflow_commands::{ScheduleActivity, StartTimer},
-        workflow_completion::WorkflowActivationCompletion,
+use temporalio_common::{
+    errors::PollError,
+    prost_dur,
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
+        coresdk::{
+            workflow_activation::remove_from_cache::EvictionReason,
+            workflow_commands::{ScheduleActivity, StartTimer},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::enums::v1::EventType,
     },
-    temporal::api::enums::v1::EventType,
 };
-use temporal_sdk_core_test_utils::{
-    WorkerTestHelpers, canned_histories, history_from_proto_binary, init_core_replay_preloaded,
-    replay_sdk_worker, replay_sdk_worker_stream,
+use temporalio_sdk::{WfContext, Worker, WorkflowFunction, interceptors::WorkerInterceptor};
+use temporalio_sdk_core::{
+    replay::{HistoryFeeder, HistoryForReplay},
+    test_help::{MockPollCfg, ResponseType, WorkerTestHelpers},
 };
 use tokio::join;
 
@@ -25,12 +33,64 @@ fn test_hist_to_replay(t: TestHistoryBuilder) -> HistoryForReplay {
     HistoryForReplay::new(hi, "fake".to_string())
 }
 
+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())
+    })
+}
+
+#[fixture(num_timers = 1)]
+fn fire_happy_hist(num_timers: u32) -> Worker {
+    let func = timers_wf(num_timers);
+    // Add 1 b/c history takes # wf tasks, not timers
+    let t = canned_histories::long_sequential_timers(num_timers as usize);
+    let mut worker = build_fake_sdk(MockPollCfg::from_resps(t, [ResponseType::AllHistory]));
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    worker
+}
+
+#[rstest]
+#[case::one_timer(fire_happy_hist(1), 1)]
+#[case::five_timers(fire_happy_hist(5), 5)]
+#[tokio::test]
+async fn replay_flag_is_correct(#[case] mut worker: Worker, #[case] num_timers: usize) {
+    // Verify replay flag is correct by constructing a workflow manager that already has a complete
+    // history fed into it. It should always be replaying, because history is complete.
+
+    let mut aai = ActivationAssertionsInterceptor::default();
+
+    for _ in 1..=num_timers + 1 {
+        aai.then(|a| assert!(a.is_replaying));
+    }
+
+    worker.set_worker_interceptor(aai);
+    worker.run().await.unwrap();
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn replay_flag_is_correct_partial_history() {
+    let func = timers_wf(1);
+    // Add 1 b/c history takes # wf tasks, not timers
+    let t = canned_histories::long_sequential_timers(2);
+    let mut worker = build_fake_sdk(MockPollCfg::from_resps(t, [1]));
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+
+    let mut aai = ActivationAssertionsInterceptor::default();
+    aai.then(|a| assert!(!a.is_replaying));
+
+    worker.set_worker_interceptor(aai);
+    worker.run().await.unwrap();
+}
+
 #[tokio::test]
 async fn timer_workflow_replay() {
     let core = init_core_replay_preloaded(
         "timer_workflow_replay",
         [HistoryForReplay::new(
-            history_from_proto_binary("histories/timer_workflow_history.bin")
+            history_from_proto_binary("timer_workflow_history.bin")
                 .await
                 .unwrap(),
             "fake".to_owned(),
@@ -87,7 +147,7 @@ async fn workflow_nondeterministic_replay() {
     let core = init_core_replay_preloaded(
         "timer_workflow_replay",
         [HistoryForReplay::new(
-            history_from_proto_binary("histories/timer_workflow_history.bin")
+            history_from_proto_binary("timer_workflow_history.bin")
                 .await
                 .unwrap(),
             "fake".to_owned(),
@@ -242,7 +302,7 @@ async fn multiple_histories_can_handle_dupe_run_ids() {
 #[tokio::test]
 async fn replay_old_patch_format() {
     let mut worker = replay_sdk_worker([HistoryForReplay::new(
-        history_from_proto_binary("histories/old_change_marker_format.bin")
+        history_from_proto_binary("old_change_marker_format.bin")
             .await
             .unwrap(),
         "fake".to_owned(),
@@ -256,7 +316,7 @@ async fn replay_ends_with_empty_wft() {
     let core = init_core_replay_preloaded(
         "SayHelloWorkflow",
         [HistoryForReplay::new(
-            history_from_proto_binary("histories/ends_empty_wft_complete.bin")
+            history_from_proto_binary("ends_empty_wft_complete.bin")
                 .await
                 .unwrap(),
             "fake".to_owned(),
@@ -285,15 +345,6 @@ async fn replay_ends_with_empty_wft() {
     assert!(task.eviction_reason().is_some());
 }
 
-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())
-    })
-}
-
 #[derive(Default)]
 struct UniqueRunsCounter {
     runs: Arc<Mutex<HashSet<String>>>,

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/resets.rs

@@ -1,4 +1,7 @@
-use crate::integ_tests::activity_functions::echo;
+use crate::{
+    common::{CoreWfStarter, NAMESPACE},
+    integ_tests::activity_functions::echo,
+};
 use futures_util::StreamExt;
 use std::{
     sync::{
@@ -7,16 +10,18 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
-use temporal_sdk::{LocalActivityOptions, WfContext};
-use temporal_sdk_core_protos::{
+use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporalio_common::protos::{
     coresdk::AsJsonPayloadExt,
     temporal::api::{
         common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
     },
 };
-use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE};
+
+use temporalio_common::worker::WorkerTaskTypes;
+use temporalio_sdk::{LocalActivityOptions, WfContext};
 use tokio::sync::Notify;
+use tonic::IntoRequest;
 
 const POST_RESET_SIG: &str = "post-reset";
 
@@ -24,7 +29,9 @@ const POST_RESET_SIG: &str = "post-reset";
 async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     worker.fetch_results = false;
     let notify = Arc::new(Notify::new());
@@ -63,17 +70,20 @@ async fn reset_workflow() {
         notify.notified().await;
         // Do the reset
         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()
-            })
+            .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()
+                }
+                .into_request(),
+            )
             .await
             .unwrap();
 
@@ -107,7 +117,12 @@ async fn reset_workflow() {
 async fn reset_randomseed() {
     let wf_name = "reset_randomseed";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: true,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     let mut worker = starter.worker().await;
     worker.fetch_results = false;
     let notify = Arc::new(Notify::new());
@@ -189,16 +204,19 @@ async fn reset_randomseed() {
         notify.notified().await;
         // Reset the workflow to be after first timer has fired
         client
-            .reset_workflow_execution(ResetWorkflowExecutionRequest {
-                namespace: NAMESPACE.to_owned(),
-                workflow_execution: Some(WorkflowExecution {
-                    workflow_id: wf_name.to_owned(),
-                    run_id: run_id.clone(),
-                }),
-                workflow_task_finish_event_id: 14,
-                request_id: "test-req-id".to_owned(),
-                ..Default::default()
-            })
+            .reset_workflow_execution(
+                ResetWorkflowExecutionRequest {
+                    namespace: NAMESPACE.to_owned(),
+                    workflow_execution: Some(WorkflowExecution {
+                        workflow_id: wf_name.to_owned(),
+                        run_id: run_id.clone(),
+                    }),
+                    workflow_task_finish_event_id: 14,
+                    request_id: "test-req-id".to_owned(),
+                    ..Default::default()
+                }
+                .into_request(),
+            )
             .await
             .unwrap();
 

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

@@ -0,0 +1,294 @@
+use crate::common::{ActivationAssertionsInterceptor, CoreWfStarter, build_fake_sdk};
+use futures_util::StreamExt;
+use std::collections::HashMap;
+use temporalio_client::{SignalWithStartOptions, WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::protos::{
+    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+    coresdk::{
+        IntoPayloadsExt,
+        workflow_activation::{
+            ResolveSignalExternalWorkflow, WorkflowActivationJob, workflow_activation_job,
+        },
+    },
+    temporal::api::{
+        command::v1::{Command, command},
+        common::v1::Payload,
+        enums::v1::{CommandType, EventType},
+    },
+};
+
+use temporalio_common::worker::WorkerTaskTypes;
+use temporalio_sdk::{
+    CancellableFuture, ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext,
+    WorkflowResult,
+};
+use temporalio_sdk_core::test_help::MockPollCfg;
+use uuid::Uuid;
+
+const SIGNAME: &str = "signame";
+const RECEIVER_WFID: &str = "sends-signal-signal-receiver";
+
+async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
+    let run_id = std::str::from_utf8(&ctx.get_args()[0].data)
+        .unwrap()
+        .to_owned();
+    let mut dat = SignalWorkflowOptions::new(RECEIVER_WFID, run_id, SIGNAME, [b"hi!"]);
+    dat.with_header("tupac", b"shakur");
+    let sigres = ctx.signal_workflow(dat).await;
+    if ctx.get_args().get(1).is_some() {
+        // We expect failure
+        assert!(sigres.is_err());
+    } else {
+        sigres.unwrap();
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_missing_wf() {
+    let wf_name = "sends_signal_to_missing_wf";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), signal_sender);
+
+    worker
+        .submit_wf(
+            wf_name,
+            wf_name,
+            vec![Uuid::new_v4().to_string().into(), [1].into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
+    let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    assert_eq!(&res.input, &[b"hi!".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
+    Ok(().into())
+}
+
+async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
+    let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    assert_eq!(&res.input, &[b"tada".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_other_wf() {
+    let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
+    let mut worker = starter.worker().await;
+    worker.register_wf("sender", signal_sender);
+    worker.register_wf("receiver", signal_receiver);
+
+    let receiver_run_id = worker
+        .submit_wf(
+            RECEIVER_WFID,
+            "receiver",
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker
+        .submit_wf(
+            "sends-signal-sender",
+            "sender",
+            vec![receiver_run_id.into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+#[tokio::test]
+async fn sends_signal_with_create_wf() {
+    let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
+    let mut worker = starter.worker().await;
+    worker.register_wf("receiver_signal", signal_with_create_wf_receiver);
+
+    let client = starter.get_client().await;
+    let mut header: HashMap<String, Payload> = HashMap::new();
+    header.insert("tupac".into(), "shakur".into());
+    let options = SignalWithStartOptions::builder()
+        .task_queue(worker.inner_mut().task_queue())
+        .workflow_id("sends_signal_with_create_wf")
+        .workflow_type("receiver_signal")
+        .signal_name(SIGNAME)
+        .maybe_signal_input(vec![b"tada".into()].into_payloads())
+        .maybe_signal_header(Some(header.into()))
+        .build();
+    let res = client
+        .signal_with_start_workflow_execution(options, WorkflowOptions::default())
+        .await
+        .expect("request succeeds.qed");
+
+    worker.expect_workflow_completion("sends_signal_with_create_wf", Some(res.run_id));
+    worker.run_until_done().await.unwrap();
+}
+
+async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
+    let started_child = ctx
+        .child_workflow(ChildWorkflowOptions {
+            workflow_id: "my_precious_child".to_string(),
+            workflow_type: "child_receiver".to_string(),
+            ..Default::default()
+        })
+        .start(&ctx)
+        .await
+        .into_started()
+        .expect("Must start ok");
+    let mut sig = Signal::new(SIGNAME, [b"hi!"]);
+    sig.data.with_header("tupac", b"shakur");
+    started_child.signal(&ctx, sig).await.unwrap();
+    started_child.result().await.status.unwrap();
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_signal_to_child() {
+    let mut starter = CoreWfStarter::new("sends_signal_to_child");
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
+    let mut worker = starter.worker().await;
+    worker.register_wf("child_signaler", signals_child);
+    worker.register_wf("child_receiver", signal_receiver);
+
+    worker
+        .submit_wf(
+            "sends-signal-to-child",
+            "child_signaler",
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+async fn signal_sender_canned(ctx: WfContext) -> WorkflowResult<()> {
+    let mut dat = SignalWorkflowOptions::new("fake_wid", "fake_rid", SIGNAME, [b"hi!"]);
+    dat.with_header("tupac", b"shakur");
+    let res = ctx.signal_workflow(dat).await;
+    if res.is_err() {
+        Err(anyhow::anyhow!("Signal fail!"))
+    } else {
+        Ok(().into())
+    }
+}
+
+#[rstest::rstest]
+#[case::succeeds(false)]
+#[case::fails(true)]
+#[tokio::test]
+async fn sends_signal(#[case] fails: bool) {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    let id = t.add_signal_wf(SIGNAME, "fake_wid", "fake_rid");
+    if fails {
+        t.add_external_signal_failed(id);
+    } else {
+        t.add_external_signal_completed(id);
+    }
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+            asserts.then(move |wft| {
+                assert_matches!(wft.commands.as_slice(),
+                    [Command { attributes: Some(
+                        command::Attributes::SignalExternalWorkflowExecutionCommandAttributes(attrs)),..}] => {
+                        assert_eq!(attrs.signal_name, SIGNAME);
+                        assert_eq!(attrs.input.as_ref().unwrap().payloads[0], b"hi!".into());
+                        assert_eq!(*attrs.header.as_ref().unwrap().fields.get("tupac").unwrap(),
+                                   b"shakur".into());
+                    }
+                );
+            }).then(move |wft| {
+                let cmds = &wft.commands;
+                assert_eq!(cmds.len(), 1);
+                if fails {
+                    assert_eq!(cmds[0].command_type(), CommandType::FailWorkflowExecution);
+                } else {
+                    assert_eq!(
+                        cmds[0].command_type(),
+                        CommandType::CompleteWorkflowExecution
+                    );
+                }
+            });
+        });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, signal_sender_canned);
+    worker.run().await.unwrap();
+}
+
+#[tokio::test]
+async fn cancels_before_sending() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    let mut aai = ActivationAssertionsInterceptor::default();
+    aai.skip_one().then(move |act| {
+        assert_matches!(
+            &act.jobs[0],
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveSignalExternalWorkflow(
+                    ResolveSignalExternalWorkflow {
+                        failure: Some(c),
+                        ..
+                    }
+                ))
+            } => c.message == "Signal was cancelled before being sent"
+        );
+    });
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts.then(move |wft| {
+            assert_eq!(wft.commands.len(), 1);
+            assert_eq!(
+                wft.commands[0].command_type(),
+                CommandType::CompleteWorkflowExecution
+            );
+        });
+    });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.set_worker_interceptor(aai);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
+        let sig = ctx.signal_workflow(SignalWorkflowOptions::new(
+            "fake_wid",
+            "fake_rid",
+            SIGNAME,
+            [b"hi!"],
+        ));
+        sig.cancel(&ctx);
+        let _res = sig.await;
+        Ok(().into())
+    });
+    worker.run().await.unwrap();
+}

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/stickyness.rs

@@ -1,12 +1,11 @@
-use crate::integ_tests::workflow_tests::timers::timer_wf;
+use crate::{common::CoreWfStarter, integ_tests::workflow_tests::timers::timer_wf};
 use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_api::worker::PollerBehavior;
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporalio_client::WorkflowOptions;
+use temporalio_common::worker::{PollerBehavior, WorkerTaskTypes};
+use temporalio_sdk::{WfContext, WorkflowResult};
 use tokio::sync::Barrier;
 
 #[tokio::test]
@@ -15,7 +14,7 @@ async fn timer_workflow_not_sticky() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .worker_config
-        .no_remote_activities(true)
+        .task_types(WorkerTaskTypes::workflow_only())
         .max_cached_workflows(0_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
@@ -43,7 +42,9 @@ async fn timer_workflow_timeout_on_sticky() {
     // on a not-sticky queue
     let wf_name = "timer_workflow_timeout_on_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     starter.workflow_options.task_timeout = Some(Duration::from_secs(2));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
@@ -60,7 +61,7 @@ async fn cache_miss_ok() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .worker_config
-        .no_remote_activities(true)
+        .task_types(WorkerTaskTypes::workflow_only())
         .max_outstanding_workflow_tasks(2_usize)
         .max_cached_workflows(0_usize)
         .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize));