@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

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

@@ -1,5 +1,7 @@
 use crate::common::{CoreWfStarter, build_fake_sdk, init_core_and_create_wf};
-use std::time::Duration;
+use futures_util::{StreamExt, stream::FuturesUnordered};
+use std::{future::Future, pin::Pin, time::Duration};
+use temporalio_client::WorkflowStartOptions;
 use temporalio_common::{
     prost_dur,
     protos::{
@@ -16,25 +18,41 @@ use temporalio_common::{
     },
     worker::WorkerTaskTypes,
 };
-use temporalio_sdk::{CancellableFuture, WfContext, WorkflowResult};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{CancellableFuture, WorkflowContext, WorkflowResult};
 use temporalio_sdk_core::test_help::{MockPollCfg, WorkerTestHelpers, drain_pollers_and_shutdown};
 
-pub(crate) async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
-    command_sink.timer(Duration::from_secs(1)).await;
-    Ok(().into())
+#[workflow]
+#[derive(Default)]
+pub(crate) struct TimerWf;
+
+#[workflow_methods]
+impl TimerWf {
+    #[run(name = "timer_wf_new")]
+    pub(crate) async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(())
+    }
 }
 
 #[tokio::test]
 async fn timer_workflow_workflow_driver() {
     let wf_name = "timer_wf_new";
     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);
+    worker.register_workflow::<TimerWf>();
 
-    starter.start_with_worker(wf_name, &mut worker).await;
+    let task_queue = starter.get_task_queue().to_owned();
+    let workflow_id = starter.get_task_queue().to_owned();
+    worker
+        .submit_workflow(
+            TimerWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, workflow_id).build(),
+        )
+        .await
+        .unwrap();
     worker.run_until_done().await.unwrap();
 }
 
@@ -42,9 +60,7 @@ async fn timer_workflow_workflow_driver() {
 async fn timer_workflow_manual() {
     let mut starter = init_core_and_create_wf("timer_workflow").await;
     let core = starter.get_worker().await;
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -68,9 +84,7 @@ async fn timer_workflow_manual() {
 async fn timer_cancel_workflow() {
     let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
     let core = starter.get_worker().await;
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -118,30 +132,44 @@ async fn timer_immediate_cancel_workflow() {
     .unwrap();
 }
 
-async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
-    let t1 = command_sink.timer(Duration::from_secs(1));
-    let t2 = command_sink.timer(Duration::from_secs(1));
-    let _ = tokio::join!(t1, t2);
-    Ok(().into())
+#[workflow]
+#[derive(Default)]
+struct ParallelTimerWf;
+
+#[workflow_methods]
+impl ParallelTimerWf {
+    #[run(name = "parallel_timers")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let t1 = ctx.timer(Duration::from_secs(1));
+        let t2 = ctx.timer(Duration::from_secs(1));
+        let _ = temporalio_sdk::workflows::join!(t1, t2);
+        Ok(())
+    }
 }
 
 #[tokio::test]
 async fn parallel_timers() {
     let wf_name = "parallel_timers";
     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(), parallel_timer_wf);
+    worker.register_workflow::<ParallelTimerWf>();
 
     starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
 
-async fn happy_timer(ctx: WfContext) -> WorkflowResult<()> {
-    ctx.timer(Duration::from_secs(5)).await;
-    Ok(().into())
+#[workflow]
+#[derive(Default)]
+struct HappyTimerWf;
+
+#[workflow_methods]
+impl HappyTimerWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_secs(5)).await;
+        Ok(())
+    }
 }
 
 #[tokio::test]
@@ -164,10 +192,23 @@ async fn test_fire_happy_path_inc() {
     });
 
     let mut worker = build_fake_sdk(mock_cfg);
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, happy_timer);
+    worker.register_workflow::<HappyTimerWf>();
     worker.run().await.unwrap();
 }
 
+#[workflow]
+#[derive(Default)]
+struct MismatchedTimerWf;
+
+#[workflow_methods]
+impl MismatchedTimerWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_secs(5)).await;
+        Ok(())
+    }
+}
+
 #[tokio::test]
 async fn mismatched_timer_ids_errors() {
     let t = canned_histories::single_timer("badid");
@@ -179,20 +220,24 @@ async fn mismatched_timer_ids_errors() {
         if message.contains("Timer fired event did not have expected timer id 1"))
     });
     let mut worker = build_fake_sdk(mock_cfg);
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-        ctx.timer(Duration::from_secs(5)).await;
-        Ok(().into())
-    });
+    worker.register_workflow::<MismatchedTimerWf>();
     worker.run().await.unwrap();
 }
 
-async fn cancel_timer(ctx: WfContext) -> WorkflowResult<()> {
-    let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
-    ctx.timer(Duration::from_secs(5)).await;
-    // Cancel the first timer after having waited on the second
-    cancel_timer_fut.cancel(&ctx);
-    cancel_timer_fut.await;
-    Ok(().into())
+#[workflow]
+#[derive(Default)]
+struct CancelTimerWf;
+
+#[workflow_methods]
+impl CancelTimerWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
+        ctx.timer(Duration::from_secs(5)).await;
+        cancel_timer_fut.cancel();
+        cancel_timer_fut.await;
+        Ok(())
+    }
 }
 
 #[tokio::test]
@@ -217,10 +262,25 @@ async fn incremental_cancellation() {
     });
 
     let mut worker = build_fake_sdk(mock_cfg);
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, cancel_timer);
+    worker.register_workflow::<CancelTimerWf>();
     worker.run().await.unwrap();
 }
 
+#[workflow]
+#[derive(Default)]
+struct CancelBeforeSentWf;
+
+#[workflow_methods]
+impl CancelBeforeSentWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
+        cancel_timer_fut.cancel();
+        cancel_timer_fut.await;
+        Ok(())
+    }
+}
+
 #[tokio::test]
 async fn cancel_before_sent_to_server() {
     let mut t = TestHistoryBuilder::default();
@@ -238,12 +298,46 @@ async fn cancel_before_sent_to_server() {
         });
     });
     let mut worker = build_fake_sdk(mock_cfg);
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-        let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
-        // Immediately cancel the timer
-        cancel_timer_fut.cancel(&ctx);
-        cancel_timer_fut.await;
-        Ok(().into())
-    });
+    worker.register_workflow::<CancelBeforeSentWf>();
+    worker.run().await.unwrap();
+}
+
+#[workflow]
+#[derive(Default)]
+struct WaitConditionWakerWf {
+    done: bool,
+}
+
+#[workflow_methods]
+impl WaitConditionWakerWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let mut futs: FuturesUnordered<Pin<Box<dyn Future<Output = ()>>>> = FuturesUnordered::new();
+
+        // Future 1: await timer, then set flag via state_mut
+        let ctx1 = ctx.clone();
+        futs.push(Box::pin(async move {
+            ctx1.timer(Duration::from_millis(500)).await;
+            ctx1.state_mut(|s| s.done = true);
+        }));
+
+        // Future 2: wait_condition on the flag (waker-dependent inside FuturesUnordered)
+        let ctx2 = ctx.clone();
+        futs.push(Box::pin(async move {
+            ctx2.wait_condition(|s| s.done).await;
+        }));
+
+        // Drive both to completion
+        while futs.next().await.is_some() {}
+        Ok(())
+    }
+}
+
+#[tokio::test]
+async fn wait_condition_waker_in_futures_unordered() {
+    let t = canned_histories::single_timer_wf_completes("1");
+    let mock_cfg = MockPollCfg::from_hist_builder(t);
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_workflow::<WaitConditionWakerWf>();
     worker.run().await.unwrap();
 }

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

@@ -2,8 +2,7 @@ use crate::common::{CoreWfStarter, SEARCH_ATTR_INT, SEARCH_ATTR_TXT, build_fake_
 use assert_matches::assert_matches;
 use std::{collections::HashMap, time::Duration};
 use temporalio_client::{
-    GetWorkflowResultOptions, WfClientExt, WorkflowClientTrait, WorkflowExecutionResult,
-    WorkflowOptions,
+    UntypedWorkflow, WorkflowDescribeOptions, WorkflowGetResultOptions, WorkflowStartOptions,
 };
 use temporalio_common::{
     protos::{
@@ -17,28 +16,36 @@ use temporalio_common::{
     },
     worker::WorkerTaskTypes,
 };
-use temporalio_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{WorkflowContext, WorkflowResult, WorkflowTermination};
 use temporalio_sdk_core::test_help::MockPollCfg;
 use uuid::Uuid;
 
-async fn search_attr_updater(ctx: WfContext) -> WorkflowResult<()> {
-    let mut int_val = ctx
-        .search_attributes()
-        .indexed_fields
-        .get(SEARCH_ATTR_INT)
-        .cloned()
-        .unwrap_or_default();
-    let orig_val = int_val.data[0];
-    int_val.data[0] += 1;
-    ctx.upsert_search_attributes([
-        (SEARCH_ATTR_TXT.to_string(), "goodbye".as_json_payload()?),
-        (SEARCH_ATTR_INT.to_string(), int_val),
-    ]);
-    // 49 is ascii 1
-    if orig_val == 49 {
-        Ok(WfExitValue::ContinueAsNew(Box::default()))
-    } else {
-        Ok(().into())
+#[workflow]
+#[derive(Default)]
+struct SearchAttrUpdater;
+
+#[workflow_methods]
+impl SearchAttrUpdater {
+    #[run(name = "sends_upsert_search_attrs")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let mut int_val = ctx
+            .search_attributes()
+            .indexed_fields
+            .get(SEARCH_ATTR_INT)
+            .cloned()
+            .unwrap_or_default();
+        let orig_val = int_val.data[0];
+        int_val.data[0] += 1;
+        ctx.upsert_search_attributes([
+            (SEARCH_ATTR_TXT.to_string(), "goodbye".as_json_payload()?),
+            (SEARCH_ATTR_INT.to_string(), int_val),
+        ]);
+        if orig_val == 49 {
+            Err(WorkflowTermination::continue_as_new(Default::default()))
+        } else {
+            Ok(())
+        }
     }
 }
 
@@ -47,28 +54,25 @@ async fn sends_upsert() {
     let wf_name = "sends_upsert_search_attrs";
     let wf_id = Uuid::new_v4();
     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, search_attr_updater);
+    worker.register_workflow::<SearchAttrUpdater>();
+    let task_queue = starter.get_task_queue().to_owned();
     worker
         .submit_wf(
-            wf_id.to_string(),
             wf_name,
             vec![],
-            WorkflowOptions {
-                search_attributes: Some(HashMap::from([
+            WorkflowStartOptions::new(task_queue, wf_id.to_string())
+                .search_attributes(HashMap::from([
                     (
                         SEARCH_ATTR_TXT.to_string(),
                         "hello".as_json_payload().unwrap(),
                     ),
                     (SEARCH_ATTR_INT.to_string(), 1.as_json_payload().unwrap()),
-                ])),
-                execution_timeout: Some(Duration::from_secs(4)),
-                ..Default::default()
-            },
+                ]))
+                .execution_timeout(Duration::from_secs(4))
+                .build(),
         )
         .await
         .unwrap();
@@ -76,9 +80,11 @@ async fn sends_upsert() {
 
     let client = starter.get_client().await;
     let search_attrs = client
-        .describe_workflow_execution(wf_id.to_string(), None)
+        .get_workflow_handle::<UntypedWorkflow>(wf_id.to_string())
+        .describe(WorkflowDescribeOptions::default())
         .await
         .unwrap()
+        .raw_description
         .workflow_execution_info
         .unwrap()
         .search_attributes
@@ -94,12 +100,41 @@ async fn sends_upsert() {
         String::from_json_payload(txt_attr_payload).unwrap()
     );
     assert_eq!(3, usize::from_json_payload(int_attr_payload).unwrap());
-    let handle = client.get_untyped_workflow_handle(wf_id.to_string(), "");
-    let res = handle
-        .get_workflow_result(GetWorkflowResultOptions::default())
+    let handle = client.get_workflow_handle::<UntypedWorkflow>(wf_id.to_string());
+    handle
+        .get_result(WorkflowGetResultOptions::default())
         .await
         .unwrap();
-    assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
+}
+
+#[workflow]
+#[derive(Default)]
+struct UpsertTestWf;
+
+#[workflow_methods]
+impl UpsertTestWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        const K1: &str = "foo";
+        const K2: &str = "bar";
+        ctx.upsert_search_attributes([
+            (
+                String::from(K1),
+                Payload {
+                    data: vec![0x01],
+                    ..Default::default()
+                },
+            ),
+            (
+                String::from(K2),
+                Payload {
+                    data: vec![0x02],
+                    ..Default::default()
+                },
+            ),
+        ]);
+        Ok(())
+    }
 }
 
 #[tokio::test]
@@ -131,24 +166,6 @@ async fn upsert_search_attrs_from_workflow() {
     });
 
     let mut worker = build_fake_sdk(mock_cfg);
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| async move {
-        ctx.upsert_search_attributes([
-            (
-                String::from(k1),
-                Payload {
-                    data: vec![0x01],
-                    ..Default::default()
-                },
-            ),
-            (
-                String::from(k2),
-                Payload {
-                    data: vec![0x02],
-                    ..Default::default()
-                },
-            ),
-        ]);
-        Ok(().into())
-    });
+    worker.register_workflow::<UpsertTestWf>();
     worker.run().await.unwrap();
 }