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

package/sdk-core/crates/sdk-core/tests/integ_tests/worker_versioning_tests.rs

@@ -1,13 +1,10 @@
-use crate::{
-    common::{CoreWfStarter, eventually},
-    integ_tests::activity_functions::echo,
-};
+use crate::common::{CoreWfStarter, activity_functions::StdActivities, eventually};
 use std::time::Duration;
-use temporalio_client::{NamespacedClient, WorkflowOptions, WorkflowService};
+use temporalio_client::{NamespacedClient, WorkflowStartOptions, grpc::WorkflowService};
 use temporalio_common::{
     protos::{
         coresdk::{
-            AsJsonPayloadExt, workflow_commands::CompleteWorkflowExecution, workflow_completion,
+            workflow_commands::CompleteWorkflowExecution, workflow_completion,
             workflow_completion::WorkflowActivationCompletion,
         },
         temporal::api::{
@@ -18,11 +15,10 @@ use temporalio_common::{
             },
         },
     },
-    worker::{
-        WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerTaskTypes, WorkerVersioningStrategy,
-    },
+    worker::{WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerTaskTypes},
 };
-use temporalio_sdk::{ActivityOptions, WfContext};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{ActivityOptions, WorkflowContext, WorkflowResult};
 use temporalio_sdk_core::test_help::WorkerTestHelpers;
 use tokio::join;
 use tonic::IntoRequest;
@@ -37,16 +33,12 @@ async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_defau
         deployment_name: deploy_name.clone(),
         build_id: "1.0".to_string(),
     };
-    starter
-        .worker_config
-        .versioning_strategy(WorkerVersioningStrategy::WorkerDeploymentBased(
-            WorkerDeploymentOptions {
-                version: version.clone(),
-                use_worker_versioning: true,
-                default_versioning_behavior: VersioningBehavior::AutoUpgrade.into(),
-            },
-        ))
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.deployment_options = WorkerDeploymentOptions {
+        version: version.clone(),
+        use_worker_versioning: true,
+        default_versioning_behavior: VersioningBehavior::AutoUpgrade.into(),
+    };
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let core = starter.get_worker().await;
     let client = starter.get_client().await;
 
@@ -77,7 +69,7 @@ async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_defau
         let desc_resp = eventually(
             async || {
                 client
-                    .get_client()
+                    .connection()
                     .clone()
                     .describe_worker_deployment(
                         DescribeWorkerDeploymentRequest {
@@ -96,7 +88,7 @@ async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_defau
 
         #[allow(deprecated)]
         client
-            .get_client()
+            .connection()
             .clone()
             .set_worker_deployment_current_version(
                 SetWorkerDeploymentCurrentVersionRequest {
@@ -153,31 +145,19 @@ async fn activity_has_deployment_stamp() {
     let wf_name = "activity_has_deployment_stamp";
     let mut starter = CoreWfStarter::new(wf_name);
     let deploy_name = format!("deployment-{}", starter.get_task_queue());
-    starter
-        .worker_config
-        .versioning_strategy(WorkerVersioningStrategy::WorkerDeploymentBased(
-            WorkerDeploymentOptions {
-                version: WorkerDeploymentVersion {
-                    deployment_name: deploy_name.clone(),
-                    build_id: "1.0".to_string(),
-                },
-                use_worker_versioning: true,
-                default_versioning_behavior: VersioningBehavior::AutoUpgrade.into(),
-            },
-        ));
+    starter.sdk_config.deployment_options = WorkerDeploymentOptions {
+        version: WorkerDeploymentVersion {
+            deployment_name: deploy_name.clone(),
+            build_id: "1.0".to_string(),
+        },
+        use_worker_versioning: true,
+        default_versioning_behavior: VersioningBehavior::AutoUpgrade.into(),
+    };
+    starter.sdk_config.register_activities(StdActivities);
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        ctx.activity(ActivityOptions {
-            activity_type: "echo_activity".to_string(),
-            start_to_close_timeout: Some(Duration::from_secs(5)),
-            input: "hi!".as_json_payload().expect("serializes fine"),
-            ..Default::default()
-        })
-        .await;
-        Ok(().into())
-    });
-    worker.register_activity("echo_activity", echo);
+
+    worker.register_workflow::<ActivityHasDeploymentStampWf>();
     let submitter = worker.get_submitter_handle();
     let shutdown_handle = worker.inner_mut().shutdown_handle();
 
@@ -185,7 +165,7 @@ async fn activity_has_deployment_stamp() {
         let desc_resp = eventually(
             async || {
                 client
-                    .get_client()
+                    .connection()
                     .clone()
                     .describe_worker_deployment(
                         DescribeWorkerDeploymentRequest {
@@ -204,7 +184,7 @@ async fn activity_has_deployment_stamp() {
 
         #[allow(deprecated)]
         client
-            .get_client()
+            .connection()
             .clone()
             .set_worker_deployment_current_version(
                 SetWorkerDeploymentCurrentVersionRequest {
@@ -219,12 +199,13 @@ async fn activity_has_deployment_stamp() {
             .await
             .unwrap();
 
+        let task_queue = starter.get_task_queue().to_owned();
+        let workflow_id = starter.get_wf_id();
         submitter
             .submit_wf(
-                starter.get_wf_id(),
                 wf_name.to_owned(),
                 vec![],
-                WorkflowOptions::default(),
+                WorkflowStartOptions::new(task_queue, workflow_id).build(),
             )
             .await
             .unwrap();
@@ -252,3 +233,25 @@ async fn activity_has_deployment_stamp() {
     // TODO: Can't actually verify this at the moment as the deployment options are not transferred
     //   to the event.
 }
+
+#[workflow]
+#[derive(Default)]
+struct ActivityHasDeploymentStampWf;
+
+#[workflow_methods]
+impl ActivityHasDeploymentStampWf {
+    #[run(name = "activity_has_deployment_stamp")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let _ = ctx
+            .start_activity(
+                StdActivities::echo,
+                "hi!".to_string(),
+                ActivityOptions {
+                    start_to_close_timeout: Some(Duration::from_secs(5)),
+                    ..Default::default()
+                },
+            )
+            .await;
+        Ok(())
+    }
+}

package/sdk-core/crates/sdk-core/tests/integ_tests/workflow_client_tests.rs

@@ -0,0 +1,180 @@
+use crate::common::{CoreWfStarter, eventually, rand_6_chars};
+use futures::TryStreamExt;
+use std::{collections::HashSet, time::Duration};
+use temporalio_client::{
+    UntypedWorkflow, WorkflowCountOptions, WorkflowListOptions, WorkflowStartOptions,
+    WorkflowTerminateOptions, errors::WorkflowStartError,
+};
+use temporalio_common::{data_converters::RawValue, worker::WorkerTaskTypes};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{WorkflowContext, WorkflowResult};
+
+#[workflow]
+#[derive(Default)]
+struct EmptyWorkflow;
+
+#[workflow_methods]
+impl EmptyWorkflow {
+    #[run]
+    async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+}
+
+#[rstest::rstest]
+#[case::no_limit(None)]
+#[case::with_limit(Some(2))]
+#[tokio::test]
+async fn list_workflows(#[case] limit: Option<usize>) {
+    let test_name = "list_workflows_returns_started_workflows";
+    let mut starter = CoreWfStarter::new(test_name);
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
+    let client = starter.get_client().await;
+    let mut worker = starter.worker().await;
+    worker.register_workflow::<EmptyWorkflow>();
+
+    let suffix = rand_6_chars();
+    let num_workflows = 5;
+    let task_queue = starter.get_task_queue().to_owned();
+    let mut started_workflow_ids = Vec::new();
+    let mut expected_run_ids = Vec::new();
+
+    for i in 0..num_workflows {
+        let wf_id = format!("{test_name}_{suffix}_{i}");
+        started_workflow_ids.push(wf_id.clone());
+        let handle = worker
+            .submit_workflow(
+                EmptyWorkflow::run,
+                (),
+                WorkflowStartOptions::new(task_queue.clone(), wf_id).build(),
+            )
+            .await
+            .unwrap();
+        expected_run_ids.push(handle.info().run_id.clone());
+    }
+
+    worker.run_until_done().await.unwrap();
+
+    let results = eventually(
+        || {
+            let client = client.clone();
+            let expected_ids: HashSet<_> = started_workflow_ids.iter().cloned().collect();
+            let task_queue = task_queue.clone();
+            let expected_count = limit.unwrap_or(num_workflows);
+            async move {
+                let query = format!("TaskQueue = '{task_queue}'");
+                let opts = match limit {
+                    Some(l) => WorkflowListOptions::builder().limit(l).build(),
+                    None => WorkflowListOptions::default(),
+                };
+                let stream = client.list_workflows(query, opts);
+                let results: Vec<_> = stream.try_collect().await.expect("No errors");
+
+                if results.len() != expected_count {
+                    return Err(format!(
+                        "Expected {} workflows, got {}",
+                        expected_count,
+                        results.len()
+                    ));
+                }
+
+                let found_ids: HashSet<_> = results.iter().map(|w| w.id().to_owned()).collect();
+                if !found_ids.is_subset(&expected_ids) {
+                    return Err(format!(
+                        "Found unexpected workflow IDs. Expected subset of: {:?}, Found: {:?}",
+                        expected_ids, found_ids
+                    ));
+                }
+
+                Ok(results)
+            }
+        },
+        Duration::from_secs(10),
+    )
+    .await
+    .unwrap();
+
+    // Verify accessor fields are populated
+    for wf in &results {
+        assert!(
+            started_workflow_ids.contains(&wf.id().to_owned()),
+            "Workflow ID {} not in started list",
+            wf.id()
+        );
+        assert!(!wf.run_id().is_empty(), "run_id should be populated");
+        assert_eq!(wf.task_queue(), task_queue, "task_queue mismatch");
+        assert!(wf.start_time().is_some(), "start_time should be populated");
+        assert!(
+            !wf.workflow_type().is_empty(),
+            "workflow_type should be populated"
+        );
+    }
+
+    // Verify count_workflows works too
+    let workflow_count = eventually(
+        || {
+            let client = client.clone();
+            let task_queue = task_queue.clone();
+            async move {
+                let query = format!("TaskQueue = '{task_queue}'");
+                let count = client
+                    .count_workflows(&query, WorkflowCountOptions::default())
+                    .await
+                    .unwrap();
+                if count.count() != num_workflows {
+                    return Err(format!(
+                        "Expected {} workflows, got {}",
+                        num_workflows,
+                        count.count()
+                    ));
+                }
+                Ok(count.count())
+            }
+        },
+        Duration::from_secs(10),
+    )
+    .await
+    .unwrap();
+    assert!(workflow_count == num_workflows);
+}
+
+#[tokio::test]
+async fn already_started_error_contains_run_id() {
+    let test_name = "already_started_error_contains_run_id";
+    let mut starter = CoreWfStarter::new(test_name);
+    let client = starter.get_client().await;
+    let task_queue = starter.get_task_queue().to_owned();
+    let wf_id = format!("{test_name}_{}", rand_6_chars());
+
+    let handle = client
+        .start_workflow(
+            UntypedWorkflow::new(test_name),
+            RawValue::empty(),
+            WorkflowStartOptions::new(task_queue.clone(), wf_id.clone()).build(),
+        )
+        .await
+        .unwrap();
+    let first_run_id = handle.run_id().unwrap().to_string();
+
+    let err = client
+        .start_workflow(
+            UntypedWorkflow::new(test_name),
+            RawValue::empty(),
+            WorkflowStartOptions::new(task_queue, wf_id).build(),
+        )
+        .await
+        .err()
+        .expect("duplicate wfid should error");
+
+    match err {
+        WorkflowStartError::AlreadyStarted { run_id, .. } => {
+            assert_eq!(run_id.as_deref(), Some(first_run_id.as_str()));
+        }
+        other => panic!("Expected AlreadyStarted, got: {other}"),
+    }
+
+    handle
+        .terminate(WorkflowTerminateOptions::default())
+        .await
+        .unwrap();
+}