@temporalio/core-bridge 1.13.0 → 1.13.2

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

@@ -1,7 +1,16 @@
+use crate::common::{CoreWfStarter, build_fake_sdk};
 use temporal_client::WorkflowClientTrait;
 use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporal_sdk_core::test_help::MockPollCfg;
+use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+    coresdk::{AsJsonPayloadExt, FromJsonPayloadExt},
+    temporal::api::{
+        command::v1::{Command, command},
+        common::v1::Payload,
+        enums::v1::EventType,
+    },
+};
 use uuid::Uuid;
 
 static FIELD_A: &str = "cat_name";
@@ -49,3 +58,57 @@ async fn sends_modify_wf_props() {
     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/integ_tests/workflow_tests/nexus.rs

@@ -1,7 +1,16 @@
-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 std::{
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{CancellableFuture, NexusOperationOptions, WfContext, WfExitValue};
 use temporal_sdk_core_api::errors::PollError;
@@ -24,11 +33,11 @@ use temporal_sdk_core_protos::{
         },
     },
 };
-use temporal_sdk_core_test_utils::{CoreWfStarter, WorkflowHandleExt, rand_6_chars};
 use tokio::{
     join,
     sync::{mpsc, watch},
 };
+use tokio_stream::StreamExt;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 enum Outcome {
@@ -249,6 +258,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
@@ -557,10 +576,10 @@ async fn nexus_cancellation_types(
     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 +596,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 +707,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 +728,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 +749,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 +783,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 +826,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 +859,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