@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/crates/sdk-core/tests/integ_tests/workflow_tests/modify_wf_properties.rs

@@ -0,0 +1,119 @@
+use crate::common::{CoreWfStarter, build_fake_sdk};
+use temporalio_client::WorkflowClientTrait;
+use temporalio_common::{
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+        coresdk::{AsJsonPayloadExt, FromJsonPayloadExt},
+        temporal::api::{
+            command::v1::{Command, command},
+            common::v1::Payload,
+            enums::v1::EventType,
+        },
+    },
+    worker::WorkerTaskTypes,
+};
+use temporalio_sdk::{WfContext, WorkflowResult};
+use temporalio_sdk_core::test_help::MockPollCfg;
+use uuid::Uuid;
+
+static FIELD_A: &str = "cat_name";
+static FIELD_B: &str = "cute_level";
+
+async fn memo_upserter(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.upsert_memo([
+        (FIELD_A.to_string(), "enchi".as_json_payload().unwrap()),
+        (FIELD_B.to_string(), 9001.as_json_payload().unwrap()),
+    ]);
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_modify_wf_props() {
+    let wf_name = "can_upsert_memo";
+    let wf_id = Uuid::new_v4();
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name, memo_upserter);
+    let run_id = worker
+        .submit_wf(wf_id.to_string(), wf_name, vec![], Default::default())
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let memo = starter
+        .get_client()
+        .await
+        .describe_workflow_execution(wf_id.to_string(), Some(run_id))
+        .await
+        .unwrap()
+        .workflow_execution_info
+        .unwrap()
+        .memo
+        .unwrap()
+        .fields;
+    let catname = memo.get(FIELD_A).unwrap();
+    let cuteness = memo.get(FIELD_B).unwrap();
+    for payload in [catname, cuteness] {
+        assert!(payload.is_json_payload());
+    }
+    assert_eq!("enchi", String::from_json_payload(catname).unwrap());
+    assert_eq!(9001, usize::from_json_payload(cuteness).unwrap());
+}
+
+#[tokio::test]
+async fn workflow_modify_props() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let (k1, k2) = ("foo", "bar");
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts.then(|wft| {
+            assert_matches!(
+                wft.commands.as_slice(),
+                [Command {
+                    attributes: Some(
+                        command::Attributes::ModifyWorkflowPropertiesCommandAttributes(msg)
+                    ),
+                    ..
+                }, ..] => {
+                    let fields = &msg.upserted_memo.as_ref().unwrap().fields;
+                    let payload1 = fields.get(k1).unwrap();
+                    let payload2 = fields.get(k2).unwrap();
+                    assert_eq!(payload1.data[0], 0x01);
+                    assert_eq!(payload2.data[0], 0x02);
+                    assert_eq!(fields.len(), 2);
+                }
+            );
+        });
+    });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| async move {
+        ctx.upsert_memo([
+            (
+                String::from(k1),
+                Payload {
+                    data: vec![0x01],
+                    ..Default::default()
+                },
+            ),
+            (
+                String::from(k2),
+                Payload {
+                    data: vec![0x02],
+                    ..Default::default()
+                },
+            ),
+        ]);
+        Ok(().into())
+    });
+    worker.run().await.unwrap();
+}

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/workflow_tests/nexus.rs

@@ -1,34 +1,46 @@
-use crate::integ_tests::mk_nexus_endpoint;
+use crate::{
+    common::{CoreWfStarter, WorkflowHandleExt, rand_6_chars},
+    integ_tests::mk_nexus_endpoint,
+};
 use anyhow::bail;
 use assert_matches::assert_matches;
-use std::time::Duration;
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{CancellableFuture, NexusOperationOptions, WfContext, WfExitValue};
-use temporal_sdk_core_api::errors::PollError;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        FromJsonPayloadExt,
-        nexus::{
-            NexusOperationCancellationType, NexusOperationResult, NexusTaskCancelReason,
-            NexusTaskCompletion, nexus_operation_result, nexus_task, nexus_task_completion,
-        },
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
     },
-    temporal::api::{
-        common::v1::{Callback, callback},
-        enums::v1::NexusHandlerErrorRetryBehavior,
-        failure::v1::{Failure, failure::FailureInfo},
-        nexus,
-        nexus::v1::{
-            CancelOperationResponse, HandlerError, StartOperationResponse, request,
-            start_operation_response, workflow_event_link_from_nexus,
+    time::Duration,
+};
+use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::{
+    errors::PollError,
+    protos::{
+        coresdk::{
+            FromJsonPayloadExt,
+            nexus::{
+                NexusOperationCancellationType, NexusOperationResult, NexusTaskCancelReason,
+                NexusTaskCompletion, nexus_operation_result, nexus_task, nexus_task_completion,
+            },
+        },
+        temporal::api::{
+            common::v1::{Callback, callback},
+            enums::v1::NexusHandlerErrorRetryBehavior,
+            failure::v1::{Failure, failure::FailureInfo},
+            nexus,
+            nexus::v1::{
+                CancelOperationResponse, HandlerError, StartOperationResponse, request,
+                start_operation_response, workflow_event_link_from_nexus,
+            },
         },
     },
+    worker::WorkerTaskTypes,
 };
-use temporal_sdk_core_test_utils::{CoreWfStarter, WorkflowHandleExt, rand_6_chars};
+use temporalio_sdk::{CancellableFuture, NexusOperationOptions, WfContext, WfExitValue};
 use tokio::{
     join,
     sync::{mpsc, watch},
 };
+use tokio_stream::StreamExt;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 enum Outcome {
@@ -46,7 +58,12 @@ async fn nexus_basic(
 ) {
     let wf_name = "nexus_basic";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: false,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
@@ -191,7 +208,12 @@ async fn nexus_async(
 ) {
     let wf_name = "nexus_async";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: false,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
@@ -249,6 +271,16 @@ async fn nexus_async(
     let client = starter.get_client().await.get_client().clone();
     let nexus_task_handle = async {
         let mut nt = core_worker.poll_nexus_task().await.unwrap().unwrap_task();
+        // Verify request header key for timeout exists and is lowercase
+        if outcome == Outcome::Timeout {
+            assert!(
+                nt.request
+                    .as_ref()
+                    .unwrap()
+                    .header
+                    .contains_key("request-timeout")
+            );
+        }
         let start_req = assert_matches!(
             nt.request.unwrap().variant.unwrap(),
             request::Variant::StartOperation(sr) => sr
@@ -408,7 +440,12 @@ async fn nexus_async(
 async fn nexus_cancel_before_start() {
     let wf_name = "nexus_cancel_before_start";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: false,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     let mut worker = starter.worker().await;
 
     let endpoint = mk_nexus_endpoint(&mut starter).await;
@@ -450,7 +487,12 @@ async fn nexus_cancel_before_start() {
 async fn nexus_must_complete_task_to_shutdown(#[values(true, false)] use_grace_period: bool) {
     let wf_name = "nexus_must_complete_task_to_shutdown";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: false,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     if use_grace_period {
         starter
             .worker_config
@@ -550,17 +592,22 @@ async fn nexus_cancellation_types(
 ) {
     let wf_name = "nexus_cancellation_types";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: false,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
     let endpoint = mk_nexus_endpoint(&mut starter).await;
     let schedule_to_close_timeout = Some(Duration::from_secs(5));
 
-    let (cancel_call_completion_tx, cancel_call_completion_rx) = watch::channel(false);
+    let (caller_op_future_tx, caller_op_future_rx) = watch::channel(false);
     worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
         let endpoint = endpoint.clone();
-        let cancel_call_completion_tx = cancel_call_completion_tx.clone();
+        let caller_op_future_tx = caller_op_future_tx.clone();
         async move {
             let options = NexusOperationOptions {
                 endpoint,
@@ -577,42 +624,62 @@ async fn nexus_cancellation_types(
             started.cancel(&ctx);
 
             let res = result.await;
-            cancel_call_completion_tx.send(true).unwrap();
+            caller_op_future_tx.send(true).unwrap();
 
-            // Make sure cancel after completion doesn't cause problems
+            // Make sure cancel after op completion doesn't cause problems
             started.cancel(&ctx);
 
             // We need to wait slightly so that the workflow is not complete at the same time
-            // cancellation is invoked. If it does, the caller workflow will close and the server won't attempt to send the cancellation to the handler
+            // cancellation is invoked. If it does, the caller workflow will close and the server
+            // won't attempt to send the cancellation to the handler
             ctx.timer(Duration::from_millis(1)).await;
             Ok(res.into())
         }
     });
 
-    let (cancellation_wait_tx, cancellation_wait_rx) = watch::channel(false);
+    let cancellation_wait_happened = Arc::new(AtomicBool::new(false));
+    let cancellation_wait_happened_clone = cancellation_wait_happened.clone();
     let (cancellation_tx, mut cancellation_rx) = watch::channel(false);
+    let (handler_exited_tx, mut handler_exited_rx) = watch::channel(false);
     worker.register_wf("async_completer".to_owned(), move |ctx: WfContext| {
         let cancellation_tx = cancellation_tx.clone();
-        let mut cancellation_wait_rx = cancellation_wait_rx.clone();
+        let cancellation_wait_happened = cancellation_wait_happened_clone.clone();
+        let handler_exited_tx = handler_exited_tx.clone();
         async move {
+            // Wait for cancellation
             ctx.cancelled().await;
             cancellation_tx.send(true).unwrap();
+
             if cancellation_type == NexusOperationCancellationType::WaitCancellationCompleted {
-                cancellation_wait_rx.changed().await.unwrap();
+                ctx.wait_condition(|| cancellation_wait_happened.load(Ordering::Relaxed))
+                    .await;
+            } else if cancellation_type == NexusOperationCancellationType::WaitCancellationRequested
+            {
+                // For WAIT_REQUESTED, wait until the caller nexus op future has been resolved. This
+                // allows the test to verify that it resolved due to
+                // NexusOperationCancelRequestCompleted (written after cancel handler responds)
+                // rather than NexusOperationCanceled (written after handler workflow completes as
+                // cancelled).
+                let mut signal_chan = ctx.make_signal_channel("proceed-to-exit");
+                signal_chan.next().await;
             }
+
+            handler_exited_tx.send(true).unwrap();
             Ok(WfExitValue::<()>::Cancelled)
         }
     });
     let submitter = worker.get_submitter_handle();
     let wf_handle = starter.start_with_worker(wf_name, &mut worker).await;
     let client = starter.get_client().await.get_client().clone();
+    let (handler_wf_id_tx, mut handler_wf_id_rx) = tokio::sync::oneshot::channel();
+    let completer_id = &format!("completer-{}", rand_6_chars());
     let nexus_task_handle = async {
         let nt = core_worker.poll_nexus_task().await.unwrap().unwrap_task();
         let start_req = assert_matches!(
             nt.request.unwrap().variant.unwrap(),
             request::Variant::StartOperation(sr) => sr
         );
-        let completer_id = format!("completer-{}", rand_6_chars());
+        let _ = handler_wf_id_tx.send(completer_id.clone());
         let links = start_req
             .links
             .iter()
@@ -668,16 +735,19 @@ async fn nexus_cancellation_types(
         match cancellation_type {
             NexusOperationCancellationType::WaitCancellationCompleted
             | NexusOperationCancellationType::WaitCancellationRequested => {
-                assert!(!*cancel_call_completion_rx.borrow());
+                // The nexus op future should not have been resolved
+                assert!(!*caller_op_future_rx.borrow());
             }
             NexusOperationCancellationType::Abandon | NexusOperationCancellationType::TryCancel => {
                 wf_handle
                     .get_workflow_result(Default::default())
                     .await
                     .unwrap();
-                assert!(*cancel_call_completion_rx.borrow())
+                // The nexus op future should have been resolved
+                assert!(*caller_op_future_rx.borrow())
             }
         }
+        let (cancel_handler_responded_tx, _cancel_handler_responded_rx) = watch::channel(false);
         if cancellation_type != NexusOperationCancellationType::Abandon {
             let nt = core_worker.poll_nexus_task().await.unwrap();
             let nt = nt.unwrap_task();
@@ -686,7 +756,12 @@ async fn nexus_cancellation_types(
                 request::Variant::CancelOperation(_)
             );
             client
-                .cancel_workflow_execution(completer_id, None, "nexus cancel".to_string(), None)
+                .cancel_workflow_execution(
+                    completer_id.to_string(),
+                    None,
+                    "nexus cancel".to_string(),
+                    None,
+                )
                 .await
                 .unwrap();
             core_worker
@@ -702,19 +777,31 @@ async fn nexus_cancellation_types(
                 })
                 .await
                 .unwrap();
+            // Mark that the cancel handler has responded
+            cancel_handler_responded_tx.send(true).unwrap();
         }
 
-        // Confirm the caller WF has not completed even after the handling of the cancel request
+        // Check that the nexus op future resolves only _after_ the handler WF completes
         if cancellation_type == NexusOperationCancellationType::WaitCancellationCompleted {
-            assert!(!*cancel_call_completion_rx.borrow());
-
-            // It only completes after the handler WF terminates
-            cancellation_wait_tx.send(true).unwrap();
+            assert!(!*caller_op_future_rx.borrow());
+
+            cancellation_wait_happened.store(true, Ordering::Relaxed);
+            // Send a signal just to wake up the workflow so it'll check the condition
+            // (it may already have completed, so ignore the result)
+            let _ = client
+                .signal_workflow_execution(
+                    completer_id.to_string(),
+                    "".to_string(),
+                    "wakeupdude".to_string(),
+                    None,
+                    None,
+                )
+                .await;
             wf_handle
                 .get_workflow_result(Default::default())
                 .await
                 .unwrap();
-            assert!(*cancel_call_completion_rx.borrow());
+            assert!(*caller_op_future_rx.borrow());
         }
 
         assert_matches!(
@@ -724,6 +811,38 @@ async fn nexus_cancellation_types(
     };
 
     let shutdown_handle = worker.inner_mut().shutdown_handle();
+
+    let check_caller_op_future_resolved_then_allow_handler_to_complete = async {
+        // The caller nexus op future has been resolved
+        assert!(*caller_op_future_rx.borrow());
+
+        // Verify the handler workflow has not exited yet. This proves that the caller op future
+        // was resolved as a result of NexusOperationCancelRequestCompleted (written after cancel
+        // handler responds), as opposed to NexusOperationCanceled (written after handler workflow
+        // exits).
+        assert!(
+            !*handler_exited_rx.borrow(),
+            "Handler should not have exited yet"
+        );
+
+        let handler_wf_id = handler_wf_id_rx
+            .try_recv()
+            .expect("Should have received handler workflow ID");
+        client
+            .signal_workflow_execution(
+                handler_wf_id,
+                "".to_string(),
+                "proceed-to-exit".to_string(),
+                None,
+                None,
+            )
+            .await
+            .unwrap();
+
+        handler_exited_rx.changed().await.unwrap();
+        assert!(*handler_exited_rx.borrow());
+    };
+
     join!(
         nexus_task_handle,
         async { worker.inner_mut().run().await.unwrap() },
@@ -735,6 +854,9 @@ async fn nexus_cancellation_types(
             if cancellation_type == NexusOperationCancellationType::TryCancel {
                 cancellation_rx.changed().await.unwrap();
             }
+            if cancellation_type == NexusOperationCancellationType::WaitCancellationRequested {
+                check_caller_op_future_resolved_then_allow_handler_to_complete.await;
+            }
             shutdown_handle();
         }
     );
@@ -765,8 +887,14 @@ async fn nexus_cancellation_types(
             );
             assert_eq!(f.message, "Nexus operation cancelled after starting");
         }
-        NexusOperationCancellationType::WaitCancellationRequested
-        | NexusOperationCancellationType::WaitCancellationCompleted => {
+        NexusOperationCancellationType::WaitCancellationRequested => {
+            let f = assert_matches!(
+                res.status,
+                Some(nexus_operation_result::Status::Cancelled(f)) => f
+            );
+            assert_eq!(f.message, "Nexus operation cancellation request completed");
+        }
+        NexusOperationCancellationType::WaitCancellationCompleted => {
             let f = assert_matches!(
                 res.status,
                 Some(nexus_operation_result::Status::Cancelled(f)) => f