@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/tests/integ_tests/workflow_tests/signals.rs

@@ -1,5 +1,8 @@
 use futures::StreamExt;
-use temporal_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{
+    ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
+};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use uuid::Uuid;
 
@@ -10,9 +13,9 @@ async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
     let run_id = std::str::from_utf8(&ctx.get_args()[0].data)
         .unwrap()
         .to_owned();
-    let sigres = ctx
-        .signal_workflow(RECEIVER_WFID, run_id, SIGNAME, b"hi!")
-        .await;
+    let mut dat = SignalWorkflowOptions::new(RECEIVER_WFID, run_id, SIGNAME, [b"hi!"]);
+    dat.with_header("tupac", b"shakur");
+    let sigres = ctx.signal_workflow(dat).await;
     if ctx.get_args().get(1).is_some() {
         // We expect failure
         assert!(sigres.is_err());
@@ -34,6 +37,7 @@ async fn sends_signal_to_missing_wf() {
             wf_name,
             wf_name,
             vec![Uuid::new_v4().to_string().into(), [1].into()],
+            WorkflowOptions::default(),
         )
         .await
         .unwrap();
@@ -41,7 +45,12 @@ async fn sends_signal_to_missing_wf() {
 }
 
 async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
-    ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    assert_eq!(&res.input, &[b"hi!".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
     Ok(().into())
 }
 
@@ -53,7 +62,12 @@ async fn sends_signal_to_other_wf() {
     worker.register_wf("receiver", signal_receiver);
 
     let receiver_run_id = worker
-        .submit_wf(RECEIVER_WFID, "receiver", vec![])
+        .submit_wf(
+            RECEIVER_WFID,
+            "receiver",
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker
@@ -61,6 +75,7 @@ async fn sends_signal_to_other_wf() {
             "sends-signal-sender",
             "sender",
             vec![receiver_run_id.into()],
+            WorkflowOptions::default(),
         )
         .await
         .unwrap();
@@ -78,7 +93,9 @@ async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
         .await
         .into_started()
         .expect("Must start ok");
-    started_child.signal(&ctx, SIGNAME, b"hiya!").await.unwrap();
+    let mut sig = Signal::new(SIGNAME, [b"hi!"]);
+    sig.data.with_header("tupac", b"shakur");
+    started_child.signal(&ctx, sig).await.unwrap();
     started_child.result().await.status.unwrap();
     Ok(().into())
 }
@@ -92,7 +109,12 @@ async fn sends_signal_to_child() {
 
     worker.incr_expected_run_count(1); // Expect another WF to be run as child
     worker
-        .submit_wf("sends-signal-to-child", "child_signaler", vec![])
+        .submit_wf(
+            "sends-signal-to-child",
+            "child_signaler",
+            vec![],
+            WorkflowOptions::default(),
+        )
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();

package/sdk-core/tests/integ_tests/workflow_tests/stickyness.rs

@@ -3,6 +3,7 @@ use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
 };
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio::sync::Barrier;
@@ -16,7 +17,12 @@ async fn timer_workflow_not_sticky() {
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
     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();
@@ -46,7 +52,12 @@ async fn timer_workflow_timeout_on_sticky() {
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
 
     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();
@@ -69,14 +80,18 @@ async fn cache_miss_ok() {
     });
 
     let run_id = 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();
-    let core = starter.get_core().await;
-    let tq = starter.get_task_queue();
+    let core = starter.get_worker().await;
     let (r1, _) = tokio::join!(worker.run_until_done(), async move {
         barr.wait().await;
-        core.request_workflow_eviction(tq, &run_id);
+        core.request_workflow_eviction(&run_id);
         // We need to signal the barrier again since the wf gets evicted and will hit it again
         barr.wait().await;
     });

package/sdk-core/tests/integ_tests/workflow_tests/timers.rs

@@ -1,11 +1,12 @@
 use std::time::Duration;
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{
     workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
     workflow_completion::WorkflowActivationCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, start_timer_cmd, CoreTestHelpers, CoreWfStarter,
+    init_core_and_create_wf, start_timer_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 
 pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -21,7 +22,12 @@ async fn timer_workflow_workflow_driver() {
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
     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();
@@ -29,10 +35,10 @@ async fn timer_workflow_workflow_driver() {
 
 #[tokio::test]
 async fn timer_workflow_manual() {
-    let (core, task_q) = init_core_and_create_wf("timer_workflow").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("timer_workflow").await;
+    let core = starter.get_worker().await;
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![StartTimer {
             seq: 0,
@@ -42,17 +48,17 @@ async fn timer_workflow_manual() {
     ))
     .await
     .unwrap();
-    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;
     core.shutdown().await;
 }
 
 #[tokio::test]
 async fn timer_cancel_workflow() {
-    let (core, task_q) = init_core_and_create_wf("timer_cancel_workflow").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
+    let core = starter.get_worker().await;
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![
             StartTimer {
@@ -69,9 +75,8 @@ async fn timer_cancel_workflow() {
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![
             CancelTimer { seq: 1 }.into(),
@@ -84,10 +89,10 @@ async fn timer_cancel_workflow() {
 
 #[tokio::test]
 async fn timer_immediate_cancel_workflow() {
-    let (core, task_q) = init_core_and_create_wf("timer_immediate_cancel_workflow").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut starter = init_core_and_create_wf("timer_immediate_cancel_workflow").await;
+    let core = starter.get_worker().await;
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![
             start_timer_cmd(0, Duration::from_secs(1)),
@@ -114,7 +119,12 @@ async fn parallel_timers() {
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);
 
     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/workflow_tests/upsert_search_attrs.rs

@@ -0,0 +1,66 @@
+use std::collections::HashMap;
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporal_sdk_core_test_utils::CoreWfStarter;
+use uuid::Uuid;
+
+// These are initialized on the server as part of the autosetup container which we
+// use for integration tests.
+static TXT_ATTR: &str = "CustomTextField";
+static INT_ATTR: &str = "CustomIntField";
+
+async fn search_attr_updater(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.upsert_search_attributes([
+        (TXT_ATTR.to_string(), "goodbye".as_json_payload().unwrap()),
+        (INT_ATTR.to_string(), 98.as_json_payload().unwrap()),
+    ]);
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_upsert() {
+    let wf_name = "sends_upsert_search_attrs";
+    let wf_id = Uuid::new_v4();
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name, search_attr_updater);
+    let run_id = worker
+        .submit_wf(
+            wf_id.to_string(),
+            wf_name,
+            vec![],
+            WorkflowOptions {
+                search_attributes: Some(HashMap::from([
+                    (TXT_ATTR.to_string(), "hello".as_json_payload().unwrap()),
+                    (INT_ATTR.to_string(), 1.as_json_payload().unwrap()),
+                ])),
+                ..Default::default()
+            },
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let search_attrs = starter
+        .get_client()
+        .await
+        .describe_workflow_execution(wf_id.to_string(), Some(run_id))
+        .await
+        .unwrap()
+        .workflow_execution_info
+        .unwrap()
+        .search_attributes
+        .unwrap()
+        .indexed_fields;
+    let txt_attr_payload = search_attrs.get(TXT_ATTR).unwrap();
+    let int_attr_payload = search_attrs.get(INT_ATTR).unwrap();
+    for payload in [txt_attr_payload, int_attr_payload] {
+        assert_eq!(
+            &b"json/plain".to_vec(),
+            payload.metadata.get("encoding").unwrap()
+        );
+    }
+    assert_eq!("\"goodbye\"", txt_attr_payload.to_string());
+    assert_eq!("98", int_attr_payload.to_string());
+}