@temporalio/core-bridge 1.13.0 → 1.13.2

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

@@ -1,7 +1,11 @@
-use crate::integ_tests::activity_functions::echo;
+use crate::{
+    common::{CoreWfStarter, eventually},
+    integ_tests::activity_functions::echo,
+};
 use std::time::Duration;
 use temporal_client::{NamespacedClient, WorkflowOptions, WorkflowService};
 use temporal_sdk::{ActivityOptions, WfContext};
+use temporal_sdk_core::test_help::WorkerTestHelpers;
 use temporal_sdk_core_api::worker::{
     WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerVersioningStrategy,
 };
@@ -18,8 +22,8 @@ use temporal_sdk_core_protos::{
         },
     },
 };
-use temporal_sdk_core_test_utils::{CoreWfStarter, WorkerTestHelpers, eventually};
 use tokio::join;
+use tonic::IntoRequest;
 
 #[rstest::rstest]
 #[tokio::test]
@@ -73,10 +77,13 @@ async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_defau
                 client
                     .get_client()
                     .clone()
-                    .describe_worker_deployment(DescribeWorkerDeploymentRequest {
-                        namespace: client.namespace().to_string(),
-                        deployment_name: deploy_name.clone(),
-                    })
+                    .describe_worker_deployment(
+                        DescribeWorkerDeploymentRequest {
+                            namespace: client.namespace(),
+                            deployment_name: deploy_name.clone(),
+                        }
+                        .into_request(),
+                    )
                     .await
             },
             Duration::from_secs(5),
@@ -89,13 +96,16 @@ async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_defau
         client
             .get_client()
             .clone()
-            .set_worker_deployment_current_version(SetWorkerDeploymentCurrentVersionRequest {
-                namespace: client.namespace().to_owned(),
-                deployment_name: deploy_name.clone(),
-                version: format!("{deploy_name}.1.0"),
-                conflict_token: desc_resp.conflict_token,
-                ..Default::default()
-            })
+            .set_worker_deployment_current_version(
+                SetWorkerDeploymentCurrentVersionRequest {
+                    namespace: client.namespace(),
+                    deployment_name: deploy_name.clone(),
+                    version: format!("{deploy_name}.1.0"),
+                    conflict_token: desc_resp.conflict_token,
+                    ..Default::default()
+                }
+                .into_request(),
+            )
             .await
             .unwrap();
 
@@ -175,10 +185,13 @@ async fn activity_has_deployment_stamp() {
                 client
                     .get_client()
                     .clone()
-                    .describe_worker_deployment(DescribeWorkerDeploymentRequest {
-                        namespace: client.namespace().to_string(),
-                        deployment_name: deploy_name.clone(),
-                    })
+                    .describe_worker_deployment(
+                        DescribeWorkerDeploymentRequest {
+                            namespace: client.namespace(),
+                            deployment_name: deploy_name.clone(),
+                        }
+                        .into_request(),
+                    )
                     .await
             },
             Duration::from_secs(50),
@@ -191,13 +204,16 @@ async fn activity_has_deployment_stamp() {
         client
             .get_client()
             .clone()
-            .set_worker_deployment_current_version(SetWorkerDeploymentCurrentVersionRequest {
-                namespace: client.namespace().to_owned(),
-                deployment_name: deploy_name.clone(),
-                version: format!("{deploy_name}.1.0"),
-                conflict_token: desc_resp.conflict_token,
-                ..Default::default()
-            })
+            .set_worker_deployment_current_version(
+                SetWorkerDeploymentCurrentVersionRequest {
+                    namespace: client.namespace(),
+                    deployment_name: deploy_name.clone(),
+                    version: format!("{deploy_name}.1.0"),
+                    conflict_token: desc_resp.conflict_token,
+                    ..Default::default()
+                }
+                .into_request(),
+            )
             .await
             .unwrap();
 

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

@@ -1,4 +1,10 @@
-use crate::integ_tests::activity_functions::echo;
+use crate::{
+    common::{
+        ActivationAssertionsInterceptor, CoreWfStarter, INTEG_CLIENT_IDENTITY, build_fake_sdk,
+        eventually, init_core_and_create_wf, mock_sdk, mock_sdk_cfg,
+    },
+    integ_tests::activity_functions::echo,
+};
 use anyhow::anyhow;
 use assert_matches::assert_matches;
 use futures_util::future::join_all;
@@ -9,14 +15,17 @@ use std::{
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
 use temporal_sdk::{
     ActContext, ActExitValue, ActivityError, ActivityOptions, CancellableFuture, WfContext,
-    WfExitValue, WorkflowResult,
+    WfExitValue, WorkflowFunction, WorkflowResult,
+};
+use temporal_sdk_core::test_help::{
+    MockPollCfg, ResponseType, WorkerTestHelpers, drain_pollers_and_shutdown, mock_worker_client,
 };
 use temporal_sdk_core_api::worker::PollerBehavior;
 use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, TaskToken,
+    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TaskToken, TestHistoryBuilder, canned_histories,
     coresdk::{
         ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
-        IntoCompletion,
+        IntoCompletion, IntoPayloadsExt,
         activity_result::{
             self, ActivityExecutionResult, ActivityResolution, activity_resolution as act_res,
         },
@@ -29,15 +38,14 @@ use temporal_sdk_core_protos::{
         },
         workflow_completion::WorkflowActivationCompletion,
     },
+    prost_dur,
     temporal::api::{
         common::v1::{ActivityType, Payload, Payloads, RetryPolicy},
-        enums::v1::RetryState,
+        enums::v1::{CommandType, EventType, RetryState},
         failure::v1::{ActivityFailureInfo, Failure, failure::FailureInfo},
+        sdk::v1::UserMetadata,
     },
-};
-use temporal_sdk_core_test_utils::{
-    CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf,
-    schedule_activity_cmd,
+    test_utils::schedule_activity_cmd,
 };
 use tokio::{join, sync::Semaphore, time::sleep};
 
@@ -198,7 +206,7 @@ async fn activity_non_retryable_failure() {
                     }),
                     scheduled_event_id: 5,
                     started_event_id: 6,
-                    identity: "integ_tester".to_owned(),
+                    identity: INTEG_CLIENT_IDENTITY.to_owned(),
                     retry_state: RetryState::NonRetryableFailure as i32,
                 })),
                 ..Default::default()
@@ -265,7 +273,7 @@ async fn activity_non_retryable_failure_with_error() {
                     }),
                     scheduled_event_id: 5,
                     started_event_id: 6,
-                    identity: "integ_tester".to_owned(),
+                    identity: INTEG_CLIENT_IDENTITY.to_owned(),
                     retry_state: RetryState::NonRetryableFailure as i32,
                 })),
                 ..Default::default()
@@ -790,6 +798,86 @@ async fn activity_cancelled_after_heartbeat_times_out() {
         .unwrap();
 }
 
+#[ignore] // Currently skipped because of https://github.com/temporalio/temporal/issues/8376
+#[tokio::test]
+async fn activity_heartbeat_not_flushed_on_success() {
+    let mut starter = init_core_and_create_wf("activity_heartbeat_not_flushed_on_success").await;
+    let core = starter.get_worker().await;
+    let task_q = starter.get_task_queue().to_string();
+    let activity_id = "act-1";
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        ScheduleActivity {
+            seq: 0,
+            activity_id: activity_id.to_string(),
+            activity_type: "dontcare".to_string(),
+            task_queue: task_q.clone(),
+            schedule_to_close_timeout: Some(prost_dur!(from_secs(60))),
+            heartbeat_timeout: Some(prost_dur!(from_secs(10))),
+            retry_policy: Some(RetryPolicy {
+                maximum_attempts: 2,
+                initial_interval: Some(prost_dur!(from_secs(5))),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }
+        .into(),
+    ))
+    .await
+    .unwrap();
+    // Poll activity and verify that it's been scheduled
+    let task = core.poll_activity_task().await.unwrap();
+    assert_matches!(task.variant, Some(act_task::Variant::Start(_)));
+    // heartbeat 1 (will send immediately)
+    core.record_activity_heartbeat(ActivityHeartbeat {
+        task_token: task.task_token.clone(),
+        details: vec!["one".into()],
+    });
+    // heartbeat 2 (would be throttled if not flushed)
+    core.record_activity_heartbeat(ActivityHeartbeat {
+        task_token: task.task_token.clone(),
+        details: vec!["two".into()],
+    });
+    // Complete activity with fail
+    let failure = Failure::application_failure("activity failed".to_string(), false);
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: task.task_token,
+        result: Some(ActivityExecutionResult::fail(failure)),
+    })
+    .await
+    .unwrap();
+    // The activity is still in the pending state since it has retries left
+    let client = starter.get_client().await;
+    eventually(
+        || async {
+            // Verify pending details has the flushed heartbeat
+            let details = client
+                .describe_workflow_execution(starter.get_wf_id().to_string(), None)
+                .await
+                .unwrap();
+            let last_deets = details
+                .pending_activities
+                .into_iter()
+                .find(|i| i.activity_id == activity_id)
+                .and_then(|i| i.heartbeat_details);
+            if last_deets == ["two".into()].into_payloads() {
+                Ok(())
+            } else {
+                Err("details don't yet match")
+            }
+        },
+        Duration::from_secs(5),
+    )
+    .await
+    .unwrap();
+    client
+        .terminate_workflow_execution(task_q, None)
+        .await
+        .unwrap();
+    drain_pollers_and_shutdown(&core).await;
+}
+
 #[tokio::test]
 async fn one_activity_abandon_cancelled_before_started() {
     let wf_name = "one_activity_abandon_cancelled_before_started";
@@ -1114,3 +1202,148 @@ async fn long_activity_timeout_repro() {
     starter.start_with_worker(wf_name, &mut worker).await;
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn pass_activity_summary_to_metadata() {
+    let t = canned_histories::single_activity("1");
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    let wf_id = mock_cfg.hists[0].wf_id.clone();
+    let wf_type = DEFAULT_WORKFLOW_TYPE;
+    let expected_user_metadata = Some(UserMetadata {
+        summary: Some(b"activity summary".into()),
+        details: None,
+    });
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(
+                    wft.commands[0].command_type(),
+                    CommandType::ScheduleActivityTask
+                );
+                assert_eq!(wft.commands[0].user_metadata, expected_user_metadata)
+            })
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_eq!(
+                    wft.commands[0].command_type(),
+                    CommandType::CompleteWorkflowExecution
+                );
+            });
+    });
+
+    let mut worker = mock_sdk_cfg(mock_cfg, |_| {});
+    worker.register_wf(wf_type, |ctx: WfContext| async move {
+        ctx.activity(ActivityOptions {
+            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+            summary: Some("activity summary".to_string()),
+            ..Default::default()
+        })
+        .await;
+        Ok(().into())
+    });
+    worker
+        .submit_wf(
+            wf_id.to_owned(),
+            wf_type.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+#[rstest(hist_batches, case::incremental(&[1, 2, 3, 4]), case::replay(&[4]))]
+#[tokio::test]
+async fn abandoned_activities_ignore_start_and_complete(hist_batches: &'static [usize]) {
+    let wfid = "fake_wf_id";
+    let wf_type = DEFAULT_WORKFLOW_TYPE;
+    let activity_id = "1";
+
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    let act_scheduled_event_id = t.add_activity_task_scheduled(activity_id);
+    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
+    t.add_timer_fired(timer_started_event_id, "1".to_string());
+    t.add_full_wf_task();
+    let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
+    let act_started_event_id = t.add_activity_task_started(act_scheduled_event_id);
+    t.add_activity_task_completed(
+        act_scheduled_event_id,
+        act_started_event_id,
+        Default::default(),
+    );
+    t.add_full_wf_task();
+    t.add_timer_fired(timer_started_event_id, "2".to_string());
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+    let mock = mock_worker_client();
+    let mut worker = mock_sdk(MockPollCfg::from_resp_batches(wfid, t, hist_batches, mock));
+
+    worker.register_wf(wf_type.to_owned(), |ctx: WfContext| async move {
+        let act_fut = ctx.activity(ActivityOptions {
+            activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            cancellation_type: ActivityCancellationType::Abandon,
+            ..Default::default()
+        });
+        ctx.timer(Duration::from_secs(1)).await;
+        act_fut.cancel(&ctx);
+        ctx.timer(Duration::from_secs(3)).await;
+        act_fut.await;
+        Ok(().into())
+    });
+    worker
+        .submit_wf(wfid, wf_type, vec![], Default::default())
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+#[tokio::test]
+async fn immediate_activity_cancelation() {
+    let func = WorkflowFunction::new(|ctx: WfContext| async move {
+        let cancel_activity_future = ctx.activity(ActivityOptions::default());
+        // Immediately cancel the activity
+        cancel_activity_future.cancel(&ctx);
+        cancel_activity_future.await;
+        Ok(().into())
+    });
+
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+    let mut worker = build_fake_sdk(MockPollCfg::from_resps(t, [ResponseType::AllHistory]));
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+
+    let mut aai = ActivationAssertionsInterceptor::default();
+    aai.then(|a| {
+        assert_matches!(
+            a.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
+            }]
+        )
+    });
+    aai.then(|a| {
+        assert_matches!(
+            a.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {
+                        result: Some(ActivityResolution {
+                            status: Some(act_res::Status::Cancelled(_))
+                        }),
+                        ..
+                    }
+                )),
+            },]
+        )
+    });
+
+    worker.set_worker_interceptor(aai);
+    worker.run().await.unwrap();
+}

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

@@ -1,9 +1,9 @@
+use crate::common::CoreWfStarter;
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_client::{WfClientExt, WorkflowExecutionResult, WorkflowOptions};
 use temporal_sdk::{ActContext, ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
-use temporal_sdk_core_test_utils::CoreWfStarter;
 
 const TEST_APPDATA_MESSAGE: &str = "custom app data, yay";
 

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

@@ -1,7 +1,12 @@
+use crate::common::{CoreWfStarter, build_fake_sdk};
 use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::{FromJsonPayloadExt, common::NamespacedWorkflowExecution};
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporal_sdk_core::test_help::MockPollCfg;
+use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+    coresdk::{FromJsonPayloadExt, common::NamespacedWorkflowExecution},
+    temporal::api::enums::v1::{CommandType, EventType},
+};
 
 const RECEIVER_WFID: &str = "sends-cancel-receiver";
 
@@ -72,3 +77,74 @@ async fn sends_cancel_to_other_wf() {
     assert!(res.contains("Cancel requested by workflow"));
     assert!(res.contains("cancel-reason"));
 }
+
+async fn cancel_sender_canned(ctx: WfContext) -> WorkflowResult<()> {
+    let res = ctx
+        .cancel_external(
+            NamespacedWorkflowExecution {
+                namespace: "some_namespace".to_string(),
+                workflow_id: "fake_wid".to_string(),
+                run_id: "fake_rid".to_string(),
+            },
+            "cancel reason".to_string(),
+        )
+        .await;
+    if res.is_err() {
+        Err(anyhow::anyhow!("Cancel fail!"))
+    } else {
+        Ok(().into())
+    }
+}
+
+#[rstest::rstest]
+#[case::succeeds(false)]
+#[case::fails(true)]
+#[tokio::test]
+async fn sends_cancel_canned(#[case] fails: bool) {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    let id = t.add_cancel_external_wf(NamespacedWorkflowExecution {
+        namespace: "some_namespace".to_string(),
+        workflow_id: "fake_wid".to_string(),
+        run_id: "fake_rid".to_string(),
+    });
+    if fails {
+        t.add_cancel_external_wf_failed(id);
+    } else {
+        t.add_cancel_external_wf_completed(id);
+    }
+    t.add_full_wf_task();
+    if fails {
+        t.add_workflow_execution_failed();
+    } else {
+        t.add_workflow_execution_completed();
+    }
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(|wft| {
+                assert_matches!(
+                    wft.commands[0].command_type(),
+                    CommandType::RequestCancelExternalWorkflowExecution
+                );
+            })
+            .then(move |wft| {
+                if fails {
+                    assert_eq!(
+                        wft.commands[0].command_type(),
+                        CommandType::FailWorkflowExecution
+                    );
+                } else {
+                    assert_eq!(
+                        wft.commands[0].command_type(),
+                        CommandType::CompleteWorkflowExecution
+                    );
+                }
+            });
+    });
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, cancel_sender_canned);
+    worker.run().await.unwrap();
+}

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

@@ -1,8 +1,13 @@
+use crate::common::{ActivationAssertionsInterceptor, CoreWfStarter, build_fake_sdk};
 use std::time::Duration;
 use temporal_client::WorkflowClientTrait;
 use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporal_sdk_core::test_help::MockPollCfg;
+use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, canned_histories,
+    coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+    temporal::api::enums::v1::{CommandType, WorkflowExecutionStatus},
+};
 
 async fn cancelled_wf(ctx: WfContext) -> WorkflowResult<()> {
     let mut reason = "".to_string();
@@ -55,3 +60,57 @@ async fn cancel_during_timer() {
         WorkflowExecutionStatus::Canceled as i32
     );
 }
+
+async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.timer(Duration::from_millis(500)).await;
+    Ok(WfExitValue::Cancelled)
+}
+
+#[tokio::test]
+async fn wf_completing_with_cancelled() {
+    let t = canned_histories::timer_wf_cancel_req_cancelled("1");
+
+    let mut aai = ActivationAssertionsInterceptor::default();
+    aai.then(|a| {
+        assert_matches!(
+            a.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
+            }]
+        )
+    });
+    aai.then(|a| {
+        assert_matches!(
+            a.jobs.as_slice(),
+            [
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
+                },
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::CancelWorkflow(_)),
+                }
+            ]
+        );
+    });
+
+    let mut mock_cfg = MockPollCfg::from_hist_builder(t);
+    mock_cfg.completion_asserts_from_expectations(|mut asserts| {
+        asserts
+            .then(|wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_matches!(wft.commands[0].command_type(), CommandType::StartTimer);
+            })
+            .then(move |wft| {
+                assert_eq!(wft.commands.len(), 1);
+                assert_matches!(
+                    wft.commands[0].command_type(),
+                    CommandType::CancelWorkflowExecution
+                );
+            });
+    });
+
+    let mut worker = build_fake_sdk(mock_cfg);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, wf_with_timer);
+    worker.set_worker_interceptor(aai);
+    worker.run().await.unwrap();
+}