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

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

@@ -1,46 +1,58 @@
 use crate::common::{CoreWfStarter, build_fake_sdk};
-use std::time::Duration;
-use temporalio_client::WorkflowOptions;
+use std::{sync::Arc, time::Duration};
+use temporalio_client::WorkflowStartOptions;
 use temporalio_common::{
     protos::{
         DEFAULT_WORKFLOW_TYPE, canned_histories,
-        coresdk::workflow_commands::ContinueAsNewWorkflowExecution,
-        temporal::api::enums::v1::CommandType,
+        coresdk::{AsJsonPayloadExt, workflow_commands::ContinueAsNewWorkflowExecution},
+        temporal::api::{
+            command::v1::command::Attributes,
+            enums::v1::{CommandType, ContinueAsNewVersioningBehavior},
+            history::v1::history_event,
+        },
     },
     worker::WorkerTaskTypes,
 };
-use temporalio_sdk::{WfContext, WfExitValue, WorkflowResult};
-use temporalio_sdk_core::test_help::MockPollCfg;
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{WorkflowContext, WorkflowResult, WorkflowTermination};
+use temporalio_sdk_core::{TunerHolder, test_help::MockPollCfg};
+
+#[workflow]
+#[derive(Default)]
+struct ContinueAsNewWf;
 
-async fn continue_as_new_wf(ctx: WfContext) -> WorkflowResult<()> {
-    let run_ct = ctx.get_args()[0].data[0];
-    ctx.timer(Duration::from_millis(500)).await;
-    Ok(if run_ct < 5 {
-        WfExitValue::continue_as_new(ContinueAsNewWorkflowExecution {
-            arguments: vec![[run_ct + 1].into()],
-            ..Default::default()
-        })
-    } else {
-        ().into()
-    })
+#[workflow_methods]
+impl ContinueAsNewWf {
+    #[run]
+    async fn run(ctx: &mut WorkflowContext<Self>, run_ct: u8) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_millis(500)).await;
+        if run_ct < 5 {
+            Err(WorkflowTermination::continue_as_new(
+                ContinueAsNewWorkflowExecution {
+                    arguments: vec![(run_ct + 1).as_json_payload().unwrap()],
+                    ..Default::default()
+                },
+            ))
+        } else {
+            Ok(())
+        }
+    }
 }
 
 #[tokio::test]
 async fn continue_as_new_happy_path() {
     let wf_name = "continue_as_new_happy_path";
     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_string(), continue_as_new_wf);
+    worker.register_workflow::<ContinueAsNewWf>();
 
+    let task_queue = starter.get_task_queue().to_owned();
     worker
-        .submit_wf(
-            wf_name.to_string(),
-            wf_name.to_string(),
-            vec![[1].into()],
-            WorkflowOptions::default(),
+        .submit_workflow(
+            ContinueAsNewWf::run,
+            1u8,
+            WorkflowStartOptions::new(task_queue, wf_name.to_string()).build(),
         )
         .await
         .unwrap();
@@ -51,22 +63,20 @@ async fn continue_as_new_happy_path() {
 async fn continue_as_new_multiple_concurrent() {
     let wf_name = "continue_as_new_multiple_concurrent";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only())
-        .max_cached_workflows(5_usize)
-        .max_outstanding_workflow_tasks(5_usize);
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
+    starter.sdk_config.max_cached_workflows = 5_usize;
+    starter.sdk_config.tuner = Arc::new(TunerHolder::fixed_size(5, 1, 1, 1));
     let mut worker = starter.worker().await;
-    worker.register_wf(wf_name.to_string(), continue_as_new_wf);
+    worker.register_workflow::<ContinueAsNewWf>();
 
+    let task_queue = starter.get_task_queue().to_owned();
     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(),
+            .submit_workflow(
+                ContinueAsNewWf::run,
+                1u8,
+                WorkflowStartOptions::new(task_queue.clone(), name).build(),
             )
             .await
             .unwrap();
@@ -74,14 +84,23 @@ async fn continue_as_new_multiple_concurrent() {
     worker.run_until_done().await.unwrap();
 }
 
-async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
-    ctx.timer(Duration::from_millis(500)).await;
-    Ok(WfExitValue::continue_as_new(
-        ContinueAsNewWorkflowExecution {
-            arguments: vec![[1].into()],
-            ..Default::default()
-        },
-    ))
+#[workflow]
+#[derive(Default)]
+struct WfWithTimer;
+
+#[workflow_methods]
+impl WfWithTimer {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        ctx.timer(Duration::from_millis(500)).await;
+        Err(WorkflowTermination::continue_as_new(
+            ContinueAsNewWorkflowExecution {
+                arguments: vec![[1].into()],
+                initial_versioning_behavior: ContinueAsNewVersioningBehavior::AutoUpgrade.into(),
+                ..Default::default()
+            },
+        ))
+    }
 }
 
 #[tokio::test]
@@ -100,10 +119,55 @@ async fn wf_completing_with_continue_as_new() {
                     wft.commands[0].command_type(),
                     CommandType::ContinueAsNewWorkflowExecution
                 );
+                assert_matches!(
+                    wft.commands[0].attributes.as_ref().unwrap(),
+                    Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(can_attrs)
+                        if can_attrs.initial_versioning_behavior == ContinueAsNewVersioningBehavior::AutoUpgrade as i32
+                );
             });
     });
 
     let mut worker = build_fake_sdk(mock_cfg);
-    worker.register_wf(DEFAULT_WORKFLOW_TYPE, wf_with_timer);
+    worker.register_workflow::<WfWithTimer>();
+    worker.run().await.unwrap();
+}
+
+#[workflow]
+#[derive(Default)]
+struct ContinueAsNewSuggestedWf;
+
+#[workflow_methods]
+impl ContinueAsNewSuggestedWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        // First WFT: flag should be false
+        assert!(!ctx.continue_as_new_suggested());
+        ctx.timer(Duration::from_millis(500)).await;
+        // Second WFT: flag should be true (set on WFT started event 8)
+        assert!(ctx.continue_as_new_suggested());
+        Err(WorkflowTermination::continue_as_new(
+            ContinueAsNewWorkflowExecution {
+                arguments: vec![[1].into()],
+                ..Default::default()
+            },
+        ))
+    }
+}
+
+#[tokio::test]
+async fn continue_as_new_suggested_flag_exposed() {
+    let mut t = canned_histories::timer_then_continue_as_new("1");
+    // Modify the second WFT started event (event 8) to suggest continue-as-new
+    t.modify_event(8, |he| {
+        if let Some(history_event::Attributes::WorkflowTaskStartedEventAttributes(ref mut attrs)) =
+            he.attributes
+        {
+            attrs.suggest_continue_as_new = true;
+        }
+    });
+
+    let mock_cfg = MockPollCfg::from_hist_builder(t);
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_workflow::<ContinueAsNewSuggestedWf>();
     worker.run().await.unwrap();
 }