@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/tests/integ_tests/polling_tests.rs

@@ -1,6 +1,7 @@
 use assert_matches::assert_matches;
 use futures::future::join_all;
 use std::time::Duration;
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
     activity_task::activity_task as act_task,
@@ -10,21 +11,23 @@ use temporal_sdk_core_protos::coresdk::{
     IntoCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers, CoreWfStarter,
+    init_core_and_create_wf, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::timeout;
 
 #[tokio::test]
 async fn out_of_order_completion_doesnt_hang() {
-    let (core, task_q) = init_core_and_create_wf("out_of_order_completion_doesnt_hang").await;
+    let mut starter = init_core_and_create_wf("out_of_order_completion_doesnt_hang").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue();
     let activity_id = "act-1";
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity and a timer that fires immediately
     core.complete_workflow_activation(
         vec![
             schedule_activity_cmd(
                 0,
-                &task_q,
+                task_q,
                 activity_id,
                 ActivityCancellationType::TryCancel,
                 Duration::from_secs(60),
@@ -36,13 +39,13 @@ async fn out_of_order_completion_doesnt_hang() {
             }
             .into(),
         ]
-        .into_completion(task_q.clone(), task.run_id),
+        .into_completion(task.run_id),
     )
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled with correct parameters, we don't expect to
     // complete it in this test as activity is try-cancelled.
-    let activity_task = core.poll_activity_task(&task_q).await.unwrap();
+    let activity_task = core.poll_activity_task().await.unwrap();
     assert_matches!(
         activity_task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
@@ -50,7 +53,7 @@ async fn out_of_order_completion_doesnt_hang() {
         }
     );
     // Poll workflow task and verify that activity has failed.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [
@@ -66,10 +69,9 @@ async fn out_of_order_completion_doesnt_hang() {
 
     // Start polling again *before* we complete the WFT
     let cc = core.clone();
-    let tq = task_q.clone();
     let jh = tokio::spawn(async move {
         // We want to fail the test if this takes too long -- we should not hit long poll timeout
-        let task = timeout(Duration::from_secs(1), cc.poll_workflow_activation(&tq))
+        let task = timeout(Duration::from_secs(1), cc.poll_workflow_activation())
             .await
             .expect("Poll should come back right away")
             .unwrap();
@@ -79,14 +81,13 @@ async fn out_of_order_completion_doesnt_hang() {
                 variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
             }]
         );
-        cc.complete_execution(&tq, &task.run_id).await;
+        cc.complete_execution(&task.run_id).await;
     });
 
     tokio::time::sleep(Duration::from_millis(100)).await;
     // Then complete the (last) WFT with a request to cancel the AT, which should produce a
     // pending activation, unblocking the (already started) poll
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
     ))
@@ -120,7 +121,12 @@ async fn can_paginate_long_history() {
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), many_parallel_timers_longhist);
     worker
-        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();

package/sdk-core/tests/integ_tests/queries_tests.rs

@@ -1,6 +1,7 @@
 use assert_matches::assert_matches;
 use futures::{prelude::stream::FuturesUnordered, FutureExt, StreamExt};
 use std::time::Duration;
+use temporal_client::WorkflowClientTrait;
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_activation::{workflow_activation_job, WorkflowActivationJob},
@@ -9,16 +10,16 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery},
 };
-use temporal_sdk_core_test_utils::{init_core_and_create_wf, CoreTestHelpers, CoreWfStarter};
+use temporal_sdk_core_test_utils::{init_core_and_create_wf, CoreWfStarter, WorkerTestHelpers};
 
 #[tokio::test]
 async fn simple_query_legacy() {
     let query_resp = b"response";
-    let (core, task_q) = init_core_and_create_wf("simple_query_legacy").await;
-    let workflow_id = task_q.clone();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("simple_query_legacy").await;
+    let core = starter.get_worker().await;
+    let workflow_id = starter.get_task_queue().to_string();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id.clone(),
         vec![
             StartTimer {
@@ -38,7 +39,9 @@ async fn simple_query_legacy() {
     tokio::time::sleep(Duration::from_secs(1)).await;
     // Query after timer should have fired and there should be new WFT
     let query_fut = async {
-        core.server_gateway()
+        starter
+            .get_client()
+            .await
             .query_workflow_execution(
                 workflow_id,
                 task.run_id.to_string(),
@@ -56,7 +59,7 @@ async fn simple_query_legacy() {
         tokio::time::sleep(Duration::from_millis(400)).await;
         // This poll *should* have the `queries` field populated, but doesn't, seemingly due to
         // a server bug. So, complete the WF task of the first timer firing with empty commands
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             task.jobs.as_slice(),
             [WorkflowActivationJob {
@@ -64,13 +67,12 @@ async fn simple_query_legacy() {
             }]
         );
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            &task_q,
             task.run_id,
             vec![],
         ))
         .await
         .unwrap();
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
         // Poll again, and we end up getting a `query` field query response
         let query = assert_matches!(
             task.jobs.as_slice(),
@@ -80,7 +82,6 @@ async fn simple_query_legacy() {
         );
         // Complete the query
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-            &task_q,
             task.run_id,
             QueryResult {
                 query_id: query.query_id.clone(),
@@ -96,8 +97,8 @@ async fn simple_query_legacy() {
         .await
         .unwrap();
         // Finish the workflow
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
-        core.complete_execution(&task_q, &task.run_id).await;
+        let task = core.poll_workflow_activation().await.unwrap();
+        core.complete_execution(&task.run_id).await;
     };
     let (q_resp, _) = tokio::join!(query_fut, workflow_completions_future);
     // Ensure query response is as expected
@@ -110,13 +111,14 @@ async fn simple_query_legacy() {
 #[tokio::test]
 async fn query_after_execution_complete(#[case] do_evict: bool) {
     let query_resp = b"response";
-    let (ref core, ref task_q) =
+    let mut starter =
         init_core_and_create_wf(&format!("after_done_query_evict-{}", do_evict)).await;
-    let workflow_id = task_q.as_str();
+    let core = &starter.get_worker().await;
+    let workflow_id = &starter.get_task_queue().to_string();
 
     let do_workflow = |go_until_query: bool| async move {
         loop {
-            let task = core.poll_workflow_activation(task_q).await.unwrap();
+            let task = core.poll_workflow_activation().await.unwrap();
 
             // When we see the query, handle it.
             if go_until_query {
@@ -125,7 +127,6 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
                 }] = task.jobs.as_slice()
                 {
                     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-                        task_q,
                         task.run_id,
                         QueryResult {
                             query_id: query.query_id.clone(),
@@ -150,12 +151,9 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
                     variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
                 }]
             ) {
-                core.complete_workflow_activation(WorkflowActivationCompletion::empty(
-                    task_q,
-                    task.run_id,
-                ))
-                .await
-                .unwrap();
+                core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+                    .await
+                    .unwrap();
                 continue;
             }
             assert_matches!(
@@ -165,10 +163,10 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
                 }]
             );
             let run_id = task.run_id.clone();
-            core.complete_timer(task_q, &task.run_id, 1, Duration::from_millis(500))
+            core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
                 .await;
-            let task = core.poll_workflow_activation(task_q).await.unwrap();
-            core.complete_execution(task_q, &task.run_id).await;
+            let task = core.poll_workflow_activation().await.unwrap();
+            core.complete_execution(&task.run_id).await;
             if !go_until_query {
                 break run_id;
             }
@@ -179,13 +177,13 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
     assert!(!run_id.is_empty());
 
     if do_evict {
-        core.request_workflow_eviction(task_q, run_id);
+        core.request_workflow_eviction(run_id);
     }
     // Spam some queries (sending multiple queries after WF closed covers a possible path where
     // we could screw-up re-applying the final WFT)
     let mut query_futs = FuturesUnordered::new();
     for _ in 0..3 {
-        let gw = core.server_gateway().clone();
+        let gw = starter.get_client().await.clone();
         let query_fut = async move {
             let q_resp = gw
                 .query_workflow_execution(
@@ -218,20 +216,20 @@ async fn repros_query_dropped_on_floor() {
     let mut wf_starter = CoreWfStarter::new("repros_query_dropped_on_floor");
     // Easiest way I discovered to reliably trigger new query path is with a WFT timeout
     wf_starter.wft_timeout(Duration::from_secs(1));
-    let core = wf_starter.get_core().await;
-    let task_q = wf_starter.get_task_queue();
+    let core = wf_starter.get_worker().await;
+    let task_q = wf_starter.get_task_queue().to_string();
     wf_starter.start_wf().await;
+    let client = wf_starter.get_client().await;
 
-    let task = core.poll_workflow_activation(task_q).await.unwrap();
-    core.complete_timer(task_q, &task.run_id, 1, Duration::from_millis(500))
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
         .await;
 
     // Poll for a task we will time out
-    let task = core.poll_workflow_activation(task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     tokio::time::sleep(Duration::from_secs(2)).await;
     // Complete now-timed-out task (add a new timer)
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task_q,
         task.run_id.clone(),
         vec![],
     ))
@@ -240,9 +238,9 @@ async fn repros_query_dropped_on_floor() {
 
     let run_id = task.run_id.to_string();
     let q1_fut = async {
-        core.server_gateway()
+        client
             .query_workflow_execution(
-                task_q.to_string(),
+                task_q.clone(),
                 run_id,
                 WorkflowQuery {
                     query_type: "query_1".to_string(),
@@ -255,9 +253,9 @@ async fn repros_query_dropped_on_floor() {
     };
     let run_id = task.run_id.to_string();
     let q2_fut = async {
-        core.server_gateway()
+        client
             .query_workflow_execution(
-                task_q.to_string(),
+                task_q.clone(),
                 run_id,
                 WorkflowQuery {
                     query_type: "query_2".to_string(),
@@ -272,7 +270,7 @@ async fn repros_query_dropped_on_floor() {
         let mut seen_q1 = false;
         let mut seen_q2 = false;
         while !seen_q1 || !seen_q2 {
-            let task = core.poll_workflow_activation(task_q).await.unwrap();
+            let task = core.poll_workflow_activation().await.unwrap();
 
             if matches!(
                 task.jobs[0],
@@ -280,8 +278,8 @@ async fn repros_query_dropped_on_floor() {
                     variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
                 }
             ) {
-                let task = core.poll_workflow_activation(task_q).await.unwrap();
-                core.complete_timer(task_q, &task.run_id, 1, Duration::from_millis(500))
+                let task = core.poll_workflow_activation().await.unwrap();
+                core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
                     .await;
                 continue;
             }
@@ -293,7 +291,7 @@ async fn repros_query_dropped_on_floor() {
                 }
             ) {
                 // If we get the timer firing after replay, be done.
-                core.complete_execution(task_q, &task.run_id).await;
+                core.complete_execution(&task.run_id).await;
             }
 
             // There should be a query job (really, there should be both... server only sends one?)
@@ -312,7 +310,6 @@ async fn repros_query_dropped_on_floor() {
             };
             // Complete the query
             core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-                task_q,
                 task.run_id,
                 vec![QueryResult {
                     query_id: query.query_id.clone(),
@@ -338,11 +335,11 @@ async fn repros_query_dropped_on_floor() {
 #[tokio::test]
 async fn fail_legacy_query() {
     let query_err = "oh no broken";
-    let (core, task_q) = init_core_and_create_wf("fail_legacy_query").await;
-    let workflow_id = task_q.clone();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("fail_legacy_query").await;
+    let core = starter.get_worker().await;
+    let workflow_id = starter.get_task_queue().to_string();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id.clone(),
         vec![
             StartTimer {
@@ -362,7 +359,9 @@ async fn fail_legacy_query() {
     tokio::time::sleep(Duration::from_secs(1)).await;
     // Query after timer should have fired and there should be new WFT
     let query_fut = async {
-        core.server_gateway()
+        starter
+            .get_client()
+            .await
             .query_workflow_execution(
                 workflow_id.to_string(),
                 task.run_id.to_string(),
@@ -380,7 +379,7 @@ async fn fail_legacy_query() {
         tokio::time::sleep(Duration::from_millis(400)).await;
         // This poll *should* have the `queries` field populated, but doesn't, seemingly due to
         // a server bug. So, complete the WF task of the first timer firing with empty commands
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             task.jobs.as_slice(),
             [WorkflowActivationJob {
@@ -388,13 +387,12 @@ async fn fail_legacy_query() {
             }]
         );
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            &task_q,
             task.run_id,
             vec![],
         ))
         .await
         .unwrap();
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
         // Poll again, and we end up getting a `query` field query response
         assert_matches!(
             task.jobs.as_slice(),
@@ -404,7 +402,6 @@ async fn fail_legacy_query() {
         );
         // Fail this task
         core.complete_workflow_activation(WorkflowActivationCompletion::fail(
-            &task_q,
             task.run_id,
             Failure {
                 message: query_err.to_string(),
@@ -414,8 +411,8 @@ async fn fail_legacy_query() {
         .await
         .unwrap();
         // Finish the workflow
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
-        core.complete_execution(&task_q, &task.run_id).await;
+        let task = core.poll_workflow_activation().await.unwrap();
+        core.complete_execution(&task.run_id).await;
     };
     let (q_resp, _) = tokio::join!(query_fut, workflow_completions_future);
     // Ensure query response is a failure and has the right message