@temporalio/core-bridge 0.17.2 → 0.18.0

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

@@ -1,15 +1,17 @@
 use assert_matches::assert_matches;
 use futures::future::join_all;
 use std::time::Duration;
-use temporal_sdk_core::prototype_rust_sdk::{WfContext, WorkflowResult};
+use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
     activity_task::activity_task as act_task,
-    workflow_activation::{wf_activation_job, FireTimer, WfActivationJob},
+    workflow_activation::{workflow_activation_job, FireTimer, WorkflowActivationJob},
     workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
-    workflow_completion::WfActivationCompletion,
+    workflow_completion::WorkflowActivationCompletion,
     IntoCompletion,
 };
-use test_utils::{init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers, CoreWfStarter};
+use temporal_sdk_core_test_utils::{
+    init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers, CoreWfStarter,
+};
 use tokio::time::timeout;
 
 #[tokio::test]
@@ -52,8 +54,8 @@ async fn out_of_order_completion_doesnt_hang() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::FireTimer(
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(
                     FireTimer { seq: t_seq }
                 )),
             },
@@ -73,8 +75,8 @@ async fn out_of_order_completion_doesnt_hang() {
             .unwrap();
         assert_matches!(
             task.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
             }]
         );
         cc.complete_execution(&tq, &task.run_id).await;
@@ -83,7 +85,7 @@ async fn out_of_order_completion_doesnt_hang() {
     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(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
@@ -94,7 +96,7 @@ async fn out_of_order_completion_doesnt_hang() {
     jh.await.unwrap();
 }
 
-pub async fn many_parallel_timers_longhist(mut ctx: WfContext) -> WorkflowResult<()> {
+pub async fn many_parallel_timers_longhist(ctx: WfContext) -> WorkflowResult<()> {
     for _ in 0..20 {
         let mut futs = vec![];
         for _ in 0..1000 {
@@ -122,5 +124,4 @@ async fn can_paginate_long_history() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }

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

@@ -3,21 +3,21 @@ use futures::{prelude::stream::FuturesUnordered, FutureExt, StreamExt};
 use std::time::Duration;
 use temporal_sdk_core_protos::{
     coresdk::{
-        workflow_activation::{wf_activation_job, WfActivationJob},
+        workflow_activation::{workflow_activation_job, WorkflowActivationJob},
         workflow_commands::{QueryResult, QuerySuccess, StartTimer},
-        workflow_completion::WfActivationCompletion,
+        workflow_completion::WorkflowActivationCompletion,
     },
     temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery},
 };
-use test_utils::{init_core_and_create_wf, with_gw, CoreTestHelpers, CoreWfStarter, GwApi};
+use temporal_sdk_core_test_utils::{init_core_and_create_wf, CoreTestHelpers, CoreWfStarter};
 
 #[tokio::test]
 async fn simple_query_legacy() {
-    let workflow_id = "simple_query";
     let query_resp = b"response";
-    let (core, task_q) = init_core_and_create_wf(workflow_id).await;
+    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();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id.clone(),
         vec![
@@ -37,18 +37,20 @@ async fn simple_query_legacy() {
     .unwrap();
     tokio::time::sleep(Duration::from_secs(1)).await;
     // Query after timer should have fired and there should be new WFT
-    let query_fut = with_gw(core.as_ref(), |gw: GwApi| async move {
-        gw.query_workflow_execution(
-            workflow_id.to_string(),
-            task.run_id.to_string(),
-            WorkflowQuery {
-                query_type: "myquery".to_string(),
-                query_args: Some(b"hi".into()),
-            },
-        )
-        .await
-        .unwrap()
-    });
+    let query_fut = async {
+        core.server_gateway()
+            .query_workflow_execution(
+                workflow_id,
+                task.run_id.to_string(),
+                WorkflowQuery {
+                    query_type: "myquery".to_string(),
+                    query_args: Some(b"hi".into()),
+                    header: None,
+                },
+            )
+            .await
+            .unwrap()
+    };
     let workflow_completions_future = async {
         // Give query a beat to get going
         tokio::time::sleep(Duration::from_millis(400)).await;
@@ -57,11 +59,11 @@ async fn simple_query_legacy() {
         let task = core.poll_workflow_activation(&task_q).await.unwrap();
         assert_matches!(
             task.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::FireTimer(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(_)),
             }]
         );
-        core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             &task_q,
             task.run_id,
             vec![],
@@ -72,12 +74,12 @@ async fn simple_query_legacy() {
         // Poll again, and we end up getting a `query` field query response
         let query = assert_matches!(
             task.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::QueryWorkflow(q)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
             }] => q
         );
         // Complete the query
-        core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             &task_q,
             task.run_id,
             QueryResult {
@@ -107,9 +109,10 @@ async fn simple_query_legacy() {
 #[case::with_eviction(true)]
 #[tokio::test]
 async fn query_after_execution_complete(#[case] do_evict: bool) {
-    let workflow_id = &format!("after_done_query_evict-{}", do_evict);
     let query_resp = b"response";
-    let (ref core, ref task_q) = init_core_and_create_wf(workflow_id).await;
+    let (ref core, ref task_q) =
+        init_core_and_create_wf(&format!("after_done_query_evict-{}", do_evict)).await;
+    let workflow_id = task_q.as_str();
 
     let do_workflow = |go_until_query: bool| async move {
         loop {
@@ -117,11 +120,11 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
 
             // When we see the query, handle it.
             if go_until_query {
-                if let [WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::QueryWorkflow(query)),
+                if let [WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(query)),
                 }] = task.jobs.as_slice()
                 {
-                    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+                    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
                         task_q,
                         task.run_id,
                         QueryResult {
@@ -143,11 +146,11 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
 
             if matches!(
                 task.jobs.as_slice(),
-                [WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+                [WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
                 }]
             ) {
-                core.complete_workflow_activation(WfActivationCompletion::empty(
+                core.complete_workflow_activation(WorkflowActivationCompletion::empty(
                     task_q,
                     task.run_id,
                 ))
@@ -157,8 +160,8 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
             }
             assert_matches!(
                 task.jobs.as_slice(),
-                [WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::StartWorkflow(_)),
+                [WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
                 }]
             );
             let run_id = task.run_id.clone();
@@ -191,6 +194,7 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
                     WorkflowQuery {
                         query_type: "myquery".to_string(),
                         query_args: Some(b"hi".into()),
+                        header: None,
                     },
                 )
                 .await
@@ -209,11 +213,9 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
 #[tokio::test]
 async fn repros_query_dropped_on_floor() {
     // This test reliably repros the server dropping one of the two simultaneously issued queries.
-
-    let workflow_id = "queries_in_wf_task";
     let q1_resp = b"query_1_resp";
     let q2_resp = b"query_2_resp";
-    let mut wf_starter = CoreWfStarter::new(workflow_id);
+    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;
@@ -228,7 +230,7 @@ async fn repros_query_dropped_on_floor() {
     let task = core.poll_workflow_activation(task_q).await.unwrap();
     tokio::time::sleep(Duration::from_secs(2)).await;
     // Complete now-timed-out task (add a new timer)
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task_q,
         task.run_id.clone(),
         vec![],
@@ -237,35 +239,35 @@ async fn repros_query_dropped_on_floor() {
     .unwrap();
 
     let run_id = task.run_id.to_string();
-    let q1_fut = with_gw(core.as_ref(), |gw: GwApi| async move {
-        let res = gw
+    let q1_fut = async {
+        core.server_gateway()
             .query_workflow_execution(
-                workflow_id.to_string(),
+                task_q.to_string(),
                 run_id,
                 WorkflowQuery {
                     query_type: "query_1".to_string(),
                     query_args: Some(b"hi 1".into()),
+                    header: None,
                 },
             )
             .await
-            .unwrap();
-        res
-    });
+            .unwrap()
+    };
     let run_id = task.run_id.to_string();
-    let q2_fut = with_gw(core.as_ref(), |gw: GwApi| async move {
-        let res = gw
+    let q2_fut = async {
+        core.server_gateway()
             .query_workflow_execution(
-                workflow_id.to_string(),
+                task_q.to_string(),
                 run_id,
                 WorkflowQuery {
                     query_type: "query_2".to_string(),
                     query_args: Some(b"hi 2".into()),
+                    header: None,
                 },
             )
             .await
-            .unwrap();
-        res
-    });
+            .unwrap()
+    };
     let workflow_completions_future = async {
         let mut seen_q1 = false;
         let mut seen_q2 = false;
@@ -274,8 +276,8 @@ async fn repros_query_dropped_on_floor() {
 
             if matches!(
                 task.jobs[0],
-                WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
                 }
             ) {
                 let task = core.poll_workflow_activation(task_q).await.unwrap();
@@ -286,8 +288,8 @@ async fn repros_query_dropped_on_floor() {
 
             if matches!(
                 task.jobs[0],
-                WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::FireTimer(_)),
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
                 }
             ) {
                 // If we get the timer firing after replay, be done.
@@ -297,8 +299,8 @@ async fn repros_query_dropped_on_floor() {
             // There should be a query job (really, there should be both... server only sends one?)
             let query = assert_matches!(
                 task.jobs.as_slice(),
-                [WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::QueryWorkflow(q)),
+                [WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
                 }] => q
             );
             let resp = if query.query_type == "query_1" {
@@ -309,7 +311,7 @@ async fn repros_query_dropped_on_floor() {
                 q2_resp
             };
             // Complete the query
-            core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+            core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
                 task_q,
                 task.run_id,
                 vec![QueryResult {
@@ -335,11 +337,11 @@ async fn repros_query_dropped_on_floor() {
 
 #[tokio::test]
 async fn fail_legacy_query() {
-    let workflow_id = "fail_legacy_query";
     let query_err = "oh no broken";
-    let (core, task_q) = init_core_and_create_wf(workflow_id).await;
+    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();
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id.clone(),
         vec![
@@ -359,18 +361,20 @@ async fn fail_legacy_query() {
     .unwrap();
     tokio::time::sleep(Duration::from_secs(1)).await;
     // Query after timer should have fired and there should be new WFT
-    let query_fut = with_gw(core.as_ref(), |gw: GwApi| async move {
-        gw.query_workflow_execution(
-            workflow_id.to_string(),
-            task.run_id.to_string(),
-            WorkflowQuery {
-                query_type: "myquery".to_string(),
-                query_args: Some(b"hi".into()),
-            },
-        )
-        .await
-        .unwrap_err()
-    });
+    let query_fut = async {
+        core.server_gateway()
+            .query_workflow_execution(
+                workflow_id.to_string(),
+                task.run_id.to_string(),
+                WorkflowQuery {
+                    query_type: "myquery".to_string(),
+                    query_args: Some(b"hi".into()),
+                    header: None,
+                },
+            )
+            .await
+            .unwrap_err()
+    };
     let workflow_completions_future = async {
         // Give query a beat to get going
         tokio::time::sleep(Duration::from_millis(400)).await;
@@ -379,11 +383,11 @@ async fn fail_legacy_query() {
         let task = core.poll_workflow_activation(&task_q).await.unwrap();
         assert_matches!(
             task.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::FireTimer(_)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(_)),
             }]
         );
-        core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             &task_q,
             task.run_id,
             vec![],
@@ -394,12 +398,12 @@ async fn fail_legacy_query() {
         // Poll again, and we end up getting a `query` field query response
         assert_matches!(
             task.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::QueryWorkflow(q)),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
             }] => q
         );
         // Fail this task
-        core.complete_workflow_activation(WfActivationCompletion::fail(
+        core.complete_workflow_activation(WorkflowActivationCompletion::fail(
             &task_q,
             task.run_id,
             Failure {