@temporalio/core-bridge 1.15.0 → 1.16.1

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

@@ -1,8 +1,4 @@
-use crate::{
-    common::{CoreWfStarter, NAMESPACE},
-    integ_tests::activity_functions::echo,
-};
-use futures_util::StreamExt;
+use crate::common::{CoreWfStarter, NAMESPACE, activity_functions::StdActivities};
 use std::{
     sync::{
         Arc,
@@ -10,60 +6,73 @@ use std::{
     },
     time::Duration,
 };
-use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
-use temporalio_common::protos::{
-    coresdk::AsJsonPayloadExt,
-    temporal::api::{
-        common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
-    },
+use temporalio_client::{
+    WorkflowSignalOptions, WorkflowStartOptions, errors::WorkflowGetResultError,
+    grpc::WorkflowService,
+};
+use temporalio_common::protos::temporal::api::{
+    common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
 };
 
 use temporalio_common::worker::WorkerTaskTypes;
-use temporalio_sdk::{LocalActivityOptions, WfContext};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{LocalActivityOptions, SyncWorkflowContext, WorkflowContext, WorkflowResult};
 use tokio::sync::Notify;
 use tonic::IntoRequest;
 
+const POST_FAIL_SIG: &str = "post-fail";
 const POST_RESET_SIG: &str = "post-reset";
 
+#[workflow]
+struct ResetMeWf {
+    notify: Arc<Notify>,
+    post_reset_received: bool,
+}
+
+#[workflow_methods(factory_only)]
+impl ResetMeWf {
+    #[run(name = "reset_me_wf")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_secs(1)).await;
+        ctx.timer(Duration::from_secs(1)).await;
+        ctx.state(|wf| wf.notify.notify_one());
+        ctx.wait_condition(|s| s.post_reset_received).await;
+        Ok(())
+    }
+
+    #[signal(name = POST_RESET_SIG)]
+    fn post_reset(&mut self, _ctx: &mut SyncWorkflowContext<Self>) {
+        self.post_reset_received = true;
+    }
+}
+
 #[tokio::test]
 async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     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.fetch_results = false;
-    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 notify = Arc::new(Notify::new());
+    let notify_clone = notify.clone();
+    worker.register_workflow_with_factory(move || ResetMeWf {
+        notify: notify_clone.clone(),
+        post_reset_received: false,
     });
 
-    let run_id = worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            ResetMeWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, wf_name).build(),
         )
         .await
         .unwrap();
+    let run_id = handle.info().run_id.clone().unwrap();
 
     let mut client = starter.get_client().await;
-    let client = Arc::make_mut(&mut client);
     let resetter_fut = async {
         notify.notified().await;
         // Do the reset
@@ -73,7 +82,7 @@ async fn reset_workflow() {
                     namespace: NAMESPACE.to_owned(),
                     workflow_execution: Some(WorkflowExecution {
                         workflow_id: wf_name.to_owned(),
-                        run_id: run_id.clone(),
+                        run_id,
                     }),
                     // End of first WFT
                     workflow_task_finish_event_id: 4,
@@ -86,24 +95,15 @@ async fn reset_workflow() {
             .unwrap();
 
         // Unblock the workflow by sending the signal. Run ID will have changed after reset so
-        // we use empty run id
-        WorkflowClientTrait::signal_workflow_execution(
-            client,
-            wf_name.to_owned(),
-            "".to_owned(),
-            POST_RESET_SIG.to_owned(),
-            None,
-            None,
-        )
-        .await
-        .unwrap();
-
-        // Wait for the now-reset workflow to finish
-        client
-            .get_untyped_workflow_handle(wf_name.to_owned(), "")
-            .get_workflow_result(Default::default())
+        // we re-obtain handle.
+        let handle = client.get_workflow_handle::<reset_me_wf::Run>(wf_name.to_owned());
+        handle
+            .signal(ResetMeWf::post_reset, (), WorkflowSignalOptions::default())
             .await
             .unwrap();
+
+        // Wait for the now-reset workflow to finish
+        handle.get_result(Default::default()).await.unwrap();
         starter.shutdown().await;
     };
     let run_fut = worker.run_until_done();
@@ -111,11 +111,72 @@ async fn reset_workflow() {
     rr.unwrap();
 }
 
+#[workflow]
+struct ResetRandomseedWf {
+    did_fail: Arc<AtomicBool>,
+    rand_seed: Arc<AtomicU64>,
+    notify: Arc<Notify>,
+    post_fail_received: bool,
+    post_reset_received: bool,
+}
+
+#[workflow_methods(factory_only)]
+impl ResetRandomseedWf {
+    #[run(name = "reset_randomseed")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let _ = ctx.state(|wf| {
+            wf.rand_seed.compare_exchange(
+                0,
+                ctx.random_seed(),
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            )
+        });
+        ctx.timer(Duration::from_millis(100)).await;
+        ctx.timer(Duration::from_millis(100)).await;
+        if ctx
+            .state(|wf| {
+                wf.did_fail
+                    .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+            })
+            .is_ok()
+        {
+            ctx.state(|wf| wf.notify.notify_one());
+            panic!("Ahh");
+        }
+        if ctx.state(|wf| wf.rand_seed.load(Ordering::Relaxed)) == ctx.random_seed() {
+            ctx.timer(Duration::from_millis(100)).await;
+        } else {
+            ctx.start_local_activity(
+                StdActivities::echo,
+                "hi!".to_string(),
+                LocalActivityOptions::default(),
+            )
+            .await
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
+        }
+        ctx.wait_condition(|s| s.post_fail_received).await;
+        ctx.state(|wf| wf.notify.notify_one());
+        ctx.wait_condition(|s| s.post_reset_received).await;
+        Ok(())
+    }
+
+    #[signal(name = POST_FAIL_SIG)]
+    fn post_fail(&mut self, _ctx: &mut SyncWorkflowContext<Self>) {
+        self.post_fail_received = true;
+    }
+
+    #[signal(name = POST_RESET_SIG)]
+    fn post_reset(&mut self, _ctx: &mut SyncWorkflowContext<Self>) {
+        self.post_reset_received = true;
+    }
+}
+
 #[tokio::test]
 async fn reset_randomseed() {
     let wf_name = "reset_randomseed";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.task_types = WorkerTaskTypes {
+    starter.sdk_config.task_types = WorkerTaskTypes {
         enable_workflows: true,
         enable_local_activities: true,
         enable_remote_activities: false,
@@ -123,82 +184,42 @@ async fn reset_randomseed() {
     };
     let mut worker = starter.worker().await;
     worker.fetch_results = false;
-    let notify = Arc::new(Notify::new());
 
-    const POST_FAIL_SIG: &str = "post-fail";
-    static DID_FAIL: AtomicBool = AtomicBool::new(false);
-    static RAND_SEED: AtomicU64 = AtomicU64::new(0);
-
-    let wf_notify = notify.clone();
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
-        let notify = wf_notify.clone();
-        async move {
-            let _ = RAND_SEED.compare_exchange(
-                0,
-                ctx.random_seed(),
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            );
-            // Make a couple workflow tasks
-            ctx.timer(Duration::from_millis(100)).await;
-            ctx.timer(Duration::from_millis(100)).await;
-            if DID_FAIL
-                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
-                .is_ok()
-            {
-                // Tell outer scope to send the post-task-failure-signal
-                notify.notify_one();
-                panic!("Ahh");
-            }
-            // Make a command that is one thing with the initial seed, but another after reset
-            if RAND_SEED.load(Ordering::Relaxed) == ctx.random_seed() {
-                ctx.timer(Duration::from_millis(100)).await;
-            } else {
-                ctx.local_activity(LocalActivityOptions {
-                    activity_type: "echo".to_string(),
-                    input: "hi!".as_json_payload().expect("serializes fine"),
-                    ..Default::default()
-                })
-                .await;
-            }
-            // Wait for the post-task-fail signal
-            let _ = ctx.make_signal_channel(POST_FAIL_SIG).next().await.unwrap();
-            // Tell outer scope to send the reset
-            notify.notify_one();
-            let _ = ctx
-                .make_signal_channel(POST_RESET_SIG)
-                .next()
-                .await
-                .unwrap();
-            Ok(().into())
-        }
+    let did_fail = Arc::new(AtomicBool::new(false));
+    let rand_seed = Arc::new(AtomicU64::new(0));
+    let notify = Arc::new(Notify::new());
+    let notify_clone = notify.clone();
+    worker.register_workflow_with_factory(move || ResetRandomseedWf {
+        did_fail: did_fail.clone(),
+        rand_seed: rand_seed.clone(),
+        notify: notify_clone.clone(),
+        post_fail_received: false,
+        post_reset_received: false,
     });
-    worker.register_activity("echo", echo);
-
-    let run_id = worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
+    worker.register_activities(StdActivities);
+
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            ResetRandomseedWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, wf_name).build(),
         )
         .await
         .unwrap();
+    let run_id = handle.info().run_id.clone().unwrap();
 
     let mut client = starter.get_client().await;
-    let client = Arc::make_mut(&mut client);
     let client_fur = async {
         notify.notified().await;
-        WorkflowClientTrait::signal_workflow_execution(
-            client,
-            wf_name.to_owned(),
-            run_id.clone(),
-            POST_FAIL_SIG.to_string(),
-            None,
-            None,
-        )
-        .await
-        .unwrap();
+        handle
+            .signal(
+                ResetRandomseedWf::post_fail,
+                (),
+                WorkflowSignalOptions::default(),
+            )
+            .await
+            .unwrap();
         notify.notified().await;
         // Reset the workflow to be after first timer has fired
         client
@@ -219,24 +240,20 @@ async fn reset_randomseed() {
             .unwrap();
 
         // Unblock the workflow by sending the signal. Run ID will have changed after reset so
-        // we use empty run id
-        WorkflowClientTrait::signal_workflow_execution(
-            client,
-            wf_name.to_owned(),
-            "".to_owned(),
-            POST_RESET_SIG.to_owned(),
-            None,
-            None,
-        )
-        .await
-        .unwrap();
-
-        // Wait for the now-reset workflow to finish
+        // we re-obtain the handle.
         client
-            .get_untyped_workflow_handle(wf_name.to_owned(), "")
-            .get_workflow_result(Default::default())
+            .get_workflow_handle::<reset_randomseed_wf::Run>(wf_name.to_owned())
+            .signal(
+                ResetRandomseedWf::post_reset,
+                (),
+                WorkflowSignalOptions::default(),
+            )
             .await
             .unwrap();
+
+        // Wait for the now-reset workflow to finish
+        let result = handle.get_result(Default::default()).await;
+        assert_matches!(result, Err(WorkflowGetResultError::Terminated { .. }));
         starter.shutdown().await;
     };
     let run_fut = worker.run_until_done();