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

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

@@ -2,8 +2,12 @@ use crate::common::{CoreWfStarter, init_core_and_create_wf};
 use assert_matches::assert_matches;
 use futures_util::{FutureExt, StreamExt, future::join_all, stream::FuturesUnordered};
 use std::time::{Duration, Instant};
-use temporalio_client::WorkflowClientTrait;
+use temporalio_client::{
+    NamespacedClient, UntypedQuery, UntypedSignal, UntypedWorkflow, WorkflowExecutionInfo,
+    WorkflowQueryOptions, WorkflowSignalOptions, WorkflowTerminateOptions,
+};
 use temporalio_common::{
+    data_converters::RawValue,
     prost_dur,
     protos::{
         coresdk::{
@@ -11,7 +15,7 @@ use temporalio_common::{
             workflow_commands::{QueryResult, QuerySuccess, StartTimer},
             workflow_completion::WorkflowActivationCompletion,
         },
-        temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery},
+        temporal::api::failure::v1::Failure,
         test_utils::start_timer_cmd,
     },
 };
@@ -45,20 +49,20 @@ 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 {
-        starter
-            .get_client()
-            .await
-            .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()
+        WorkflowExecutionInfo {
+            namespace: starter.get_client().await.namespace(),
+            workflow_id,
+            run_id: Some(task.run_id.to_string()),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(starter.get_client().await.clone())
+        .query(
+            UntypedQuery::new("myquery"),
+            RawValue::empty(),
+            WorkflowQueryOptions::default(),
+        )
+        .await
+        .unwrap()
     };
     let workflow_completions_future = async {
         // Give query a beat to get going
@@ -108,7 +112,7 @@ async fn simple_query_legacy() {
     };
     let (q_resp, _) = join!(query_fut, workflow_completions_future);
     // Ensure query response is as expected
-    assert_eq!(&q_resp.unwrap()[0].data, query_resp);
+    assert_eq!(&q_resp.payloads[0].data, query_resp);
 }
 
 #[rstest]
@@ -192,20 +196,22 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
     for _ in 0..3 {
         let gw = starter.get_client().await.clone();
         let query_fut = async move {
-            let q_resp = gw
-                .query_workflow_execution(
-                    workflow_id.to_string(),
-                    run_id.to_string(),
-                    WorkflowQuery {
-                        query_type: "myquery".to_string(),
-                        query_args: Some(b"hi".into()),
-                        header: None,
-                    },
-                )
-                .await
-                .unwrap();
+            let q_resp: RawValue = WorkflowExecutionInfo {
+                namespace: gw.namespace(),
+                workflow_id: workflow_id.to_string(),
+                run_id: Some(run_id.to_string()),
+                first_execution_run_id: None,
+            }
+            .bind_untyped(gw.clone())
+            .query(
+                UntypedQuery::new("myquery"),
+                RawValue::empty(),
+                WorkflowQueryOptions::default(),
+            )
+            .await
+            .unwrap();
             // Ensure query response is as expected
-            assert_eq!(q_resp.unwrap()[0].data, query_resp);
+            assert_eq!(q_resp.payloads[0].data, query_resp);
         };
 
         query_futs.push(query_fut.boxed());
@@ -232,20 +238,20 @@ async fn fail_legacy_query(#[case] with_nde: bool) {
     core.complete_execution(&task.run_id).await;
     core.handle_eviction().await;
     let query_fut = async {
-        starter
-            .get_client()
-            .await
-            .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()
+        WorkflowExecutionInfo {
+            namespace: starter.get_client().await.namespace(),
+            workflow_id: workflow_id.to_string(),
+            run_id: Some(task.run_id.to_string()),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(starter.get_client().await.clone())
+        .query(
+            UntypedQuery::new("myquery"),
+            RawValue::empty(),
+            WorkflowQueryOptions::default(),
+        )
+        .await
+        .unwrap_err()
     };
     let query_responder = async {
         // Have to replay first since we've evicted
@@ -280,10 +286,11 @@ async fn fail_legacy_query(#[case] with_nde: bool) {
     };
     let (q_resp, _) = join!(query_fut, query_responder);
     // Ensure query response is a failure and has the right message
+    let err_msg = q_resp.to_string();
     if with_nde {
-        assert!(q_resp.message().contains("TMPRL1100"));
+        assert!(err_msg.contains("TMPRL1100"));
     } else {
-        assert_eq!(q_resp.message(), query_err);
+        assert!(err_msg.contains(query_err));
     }
 }
 
@@ -303,18 +310,20 @@ async fn multiple_concurrent_queries_no_new_history() {
     let client = starter.get_client().await;
     let num_queries = 10;
     let query_futs = (1..=num_queries).map(|_| async {
-        client
-            .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();
+        WorkflowExecutionInfo {
+            namespace: client.namespace(),
+            workflow_id: workflow_id.to_string(),
+            run_id: Some(task.run_id.to_string()),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(client.clone())
+        .query(
+            UntypedQuery::new("myquery"),
+            RawValue::empty(),
+            WorkflowQueryOptions::default(),
+        )
+        .await
+        .unwrap();
     });
     let complete_fut = async {
         for _ in 1..=num_queries {
@@ -345,7 +354,8 @@ async fn multiple_concurrent_queries_no_new_history() {
     join!(join_all(query_futs), complete_fut);
     // No need to properly finish
     client
-        .terminate_workflow_execution(workflow_id, None)
+        .get_workflow_handle::<UntypedWorkflow>(workflow_id)
+        .terminate(WorkflowTerminateOptions::default())
         .await
         .unwrap();
     // This test should not take a long time. Things can still work, but if it takes a long time
@@ -370,18 +380,20 @@ async fn queries_handled_before_next_wft() {
     let client = starter.get_client().await;
     // Send two queries so that one of them is buffered
     let query_futs = (1..=2).map(|_| async {
-        client
-            .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();
+        WorkflowExecutionInfo {
+            namespace: client.namespace(),
+            workflow_id: workflow_id.to_string(),
+            run_id: Some(task.run_id.to_string()),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(client.clone())
+        .query(
+            UntypedQuery::new("myquery"),
+            RawValue::empty(),
+            WorkflowQueryOptions::default(),
+        )
+        .await
+        .unwrap();
     });
     let complete_fut = async {
         let task = core.poll_workflow_activation().await.unwrap();
@@ -393,16 +405,20 @@ async fn queries_handled_before_next_wft() {
         );
         // While handling the first query, signal the workflow so a new WFT is generated and the
         // second query is still in the buffer
-        client
-            .signal_workflow_execution(
-                workflow_id.to_string(),
-                task.run_id.to_string(),
-                "blah".to_string(),
-                None,
-                None,
-            )
-            .await
-            .unwrap();
+        WorkflowExecutionInfo {
+            namespace: client.namespace(),
+            workflow_id: workflow_id.to_string(),
+            run_id: Some(task.run_id.to_string()),
+            first_execution_run_id: None,
+        }
+        .bind_untyped(client.clone())
+        .signal(
+            UntypedSignal::new("blah"),
+            RawValue::empty(),
+            WorkflowSignalOptions::default(),
+        )
+        .await
+        .unwrap();
         tokio::time::sleep(Duration::from_millis(500)).await;
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             task.run_id,
@@ -465,13 +481,11 @@ async fn query_should_not_be_sent_if_wft_about_to_fail() {
     let workflow_id = starter.get_task_queue().to_string();
     let client = starter.get_client().await;
     // query straight away
-    let query_fut = client.query_workflow_execution(
-        workflow_id.to_string(),
-        "".to_string(),
-        WorkflowQuery {
-            query_type: "myquery".to_string(),
-            ..Default::default()
-        },
+    let handle = client.get_workflow_handle::<UntypedWorkflow>(workflow_id.to_string());
+    let query_fut = handle.query(
+        UntypedQuery::new("myquery"),
+        RawValue::empty(),
+        WorkflowQueryOptions::default(),
     );
     // Poll for the task and respond with a task failure
     let poll_and_fail_fut = async {
@@ -528,6 +542,6 @@ async fn query_should_not_be_sent_if_wft_about_to_fail() {
         .unwrap();
     };
     let (qres, _) = join!(query_fut, poll_and_fail_fut);
-    let qres = qres.unwrap().query_result.unwrap();
+    let qres = qres.unwrap();
     assert_eq!(qres.payloads[0].data, b"done");
 }