@temporalio/core-bridge 0.16.4 → 0.18.0

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

@@ -1,14 +1,20 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
+use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::{
     coresdk::{
-        activity_result::{self, activity_result as act_res, ActivityResult},
+        activity_result::{
+            self, activity_resolution, activity_resolution as act_res, ActivityExecutionResult,
+            ActivityResolution,
+        },
         activity_task::activity_task as act_task,
         common::Payload,
-        workflow_activation::{wf_activation_job, FireTimer, ResolveActivity, WfActivationJob},
+        workflow_activation::{
+            workflow_activation_job, FireTimer, ResolveActivity, WorkflowActivationJob,
+        },
         workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
-        workflow_completion::WfActivationCompletion,
-        ActivityHeartbeat, ActivityTaskCompletion, IntoCompletion,
+        workflow_completion::WorkflowActivationCompletion,
+        ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
     temporal::api::{
         common::v1::{ActivityType, Payloads},
@@ -16,9 +22,40 @@ use temporal_sdk_core_protos::{
         failure::v1::{failure::FailureInfo, ActivityFailureInfo, Failure},
     },
 };
-use test_utils::{init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers};
+use temporal_sdk_core_test_utils::{
+    init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers, CoreWfStarter,
+};
 use tokio::time::sleep;
 
+pub async fn one_activity_wf(ctx: WfContext) -> WorkflowResult<()> {
+    ctx.activity(ActivityOptions {
+        activity_type: "echo_activity".to_string(),
+        start_to_close_timeout: Some(Duration::from_secs(5)),
+        input: "hi!".as_json_payload().expect("serializes fine"),
+        ..Default::default()
+    })
+    .await;
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn one_activity() {
+    let wf_name = "one_activity";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), one_activity_wf);
+    worker.register_activity(
+        "echo_activity",
+        |echo_me: String| async move { Ok(echo_me) },
+    );
+
+    worker
+        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![])
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
 #[tokio::test]
 async fn activity_workflow() {
     let (core, task_q) = init_core_and_create_wf("activity_workflow").await;
@@ -54,7 +91,7 @@ async fn activity_workflow() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult::ok(response_payload.clone())),
+        result: Some(ActivityExecutionResult::ok(response_payload.clone())),
     })
     .await
     .unwrap();
@@ -63,11 +100,13 @@ async fn activity_workflow() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(
-                    ResolveActivity {seq, result: Some(ActivityResult{
-                    status: Some(act_res::Status::Completed(activity_result::Success{result: Some(r)})),
-                     ..})}
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution{
+                      status: Some(
+                        act_res::Status::Completed(activity_result::Success{result: Some(r)})),
+                        ..
+                    })}
                 )),
             },
         ] => {
@@ -110,13 +149,7 @@ async fn activity_non_retryable_failure() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult {
-            status: Some(activity_result::activity_result::Status::Failed(
-                activity_result::Failure {
-                    failure: Some(failure.clone()),
-                },
-            )),
-        }),
+        result: Some(ActivityExecutionResult::fail(failure.clone())),
     })
     .await
     .unwrap();
@@ -125,9 +158,9 @@ async fn activity_non_retryable_failure() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(
-                    ResolveActivity {seq, result: Some(ActivityResult{
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution{
                     status: Some(act_res::Status::Failed(activity_result::Failure{
                         failure: Some(f),
                     }))})}
@@ -187,13 +220,7 @@ async fn activity_retry() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult {
-            status: Some(activity_result::activity_result::Status::Failed(
-                activity_result::Failure {
-                    failure: Some(failure),
-                },
-            )),
-        }),
+        result: Some(ActivityExecutionResult::fail(failure)),
     })
     .await
     .unwrap();
@@ -213,7 +240,7 @@ async fn activity_retry() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult::ok(response_payload.clone())),
+        result: Some(ActivityExecutionResult::ok(response_payload.clone())),
     })
     .await
     .unwrap();
@@ -222,9 +249,9 @@ async fn activity_retry() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(
-                    ResolveActivity {seq, result: Some(ActivityResult{
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution{
                     status: Some(act_res::Status::Completed(activity_result::Success{result: Some(r)}))})}
                 )),
             },
@@ -276,8 +303,8 @@ async fn activity_cancellation_try_cancel() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::FireTimer(
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(
                     FireTimer { seq }
                 )),
             },
@@ -285,7 +312,7 @@ async fn activity_cancellation_try_cancel() {
             assert_eq!(*seq, 1);
         }
     );
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
@@ -328,11 +355,11 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     let task = core.poll_workflow_activation(&task_q).await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
-        [WfActivationJob {
-            variant: Some(wf_activation_job::Variant::FireTimer(_)),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::FireTimer(_)),
         }]
     );
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
@@ -343,11 +370,11 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     // Should get cancel task
     assert_matches!(
         task.jobs.as_slice(),
-        [WfActivationJob {
-            variant: Some(wf_activation_job::Variant::ResolveActivity(
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::ResolveActivity(
                 ResolveActivity {
-                    result: Some(ActivityResult {
-                        status: Some(activity_result::activity_result::Status::Cancelled(_))
+                    result: Some(ActivityResolution {
+                        status: Some(activity_resolution::Status::Cancelled(_))
                     }),
                     ..
                 }
@@ -356,7 +383,7 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     );
     // We need to complete the wf task to send the activity cancel command to the server, so start
     // another short timer
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![StartTimer {
@@ -371,14 +398,7 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: activity_task.task_token,
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult {
-            status: Some(
-                activity_result::Success {
-                    result: Some(vec![1].into()),
-                }
-                .into(),
-            ),
-        }),
+        result: Some(ActivityExecutionResult::ok([1].into())),
     })
     .await
     .unwrap();
@@ -388,8 +408,8 @@ async fn activity_cancellation_plus_complete_doesnt_double_resolve() {
     let task = core.poll_workflow_activation(&task_q).await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
-        [WfActivationJob {
-            variant: Some(wf_activation_job::Variant::FireTimer(_)),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::FireTimer(_)),
         }]
     );
     core.complete_execution(&task_q, &task.run_id).await;
@@ -427,11 +447,11 @@ async fn started_activity_timeout() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
                         seq,
-                        result: Some(ActivityResult{
+                        result: Some(ActivityResolution{
                             status: Some(
                                 act_res::Status::Failed(
                                     activity_result::Failure{failure: Some(_)}
@@ -490,8 +510,8 @@ async fn activity_cancellation_wait_cancellation_completed() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::FireTimer(
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(
                     FireTimer { seq }
                 )),
             },
@@ -499,7 +519,7 @@ async fn activity_cancellation_wait_cancellation_completed() {
             assert_eq!(*seq, 1);
         }
     );
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
@@ -509,7 +529,7 @@ async fn activity_cancellation_wait_cancellation_completed() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: activity_task.task_token,
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult::cancel_from_details(None)),
+        result: Some(ActivityExecutionResult::cancel_from_details(None)),
     })
     .await
     .unwrap();
@@ -557,8 +577,8 @@ async fn activity_cancellation_abandon() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::FireTimer(
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(
                     FireTimer { seq }
                 )),
             },
@@ -566,7 +586,7 @@ async fn activity_cancellation_abandon() {
             assert_eq!(*seq, 1);
         }
     );
-    core.complete_workflow_activation(WfActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         &task_q,
         task.run_id,
         vec![RequestCancelActivity { seq: 0 }.into()],
@@ -614,7 +634,7 @@ async fn async_activity_completion_workflow() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token.clone(),
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult::will_complete_async()),
+        result: Some(ActivityExecutionResult::will_complete_async()),
     })
     .await
     .unwrap();
@@ -633,9 +653,9 @@ async fn async_activity_completion_workflow() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(
-                    ResolveActivity {seq, result: Some(ActivityResult{
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution {
                     status: Some(act_res::Status::Completed(activity_result::Success{result: Some(r)})),
                      ..})}
                 )),
@@ -650,8 +670,8 @@ async fn async_activity_completion_workflow() {
 
 #[tokio::test]
 async fn activity_cancelled_after_heartbeat_times_out() {
-    let test_name = "activity_cancelled_after_heartbeat_times_out";
-    let (core, task_q) = init_core_and_create_wf(test_name).await;
+    let (core, task_q) =
+        init_core_and_create_wf("activity_cancelled_after_heartbeat_times_out").await;
     let activity_id = "act-1";
     let task = core.poll_workflow_activation(&task_q).await.unwrap();
     // Complete workflow task and schedule activity
@@ -693,7 +713,7 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token.clone(),
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult::cancel_from_details(None)),
+        result: Some(ActivityExecutionResult::cancel_from_details(None)),
     })
     .await
     .unwrap();
@@ -703,7 +723,7 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     core.shutdown().await;
     // Cleanup just in case
     core.server_gateway()
-        .terminate_workflow_execution(test_name.to_string(), None)
+        .terminate_workflow_execution(task_q, None)
         .await
         .unwrap();
 }

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

@@ -1,10 +1,10 @@
-use temporal_sdk_core::prototype_rust_sdk::{WfContext, WorkflowResult};
+use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::common::NamespacedWorkflowExecution;
-use test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::CoreWfStarter;
 
 const RECEIVER_WFID: &str = "sends-cancel-receiver";
 
-async fn cancel_sender(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
     let run_id = std::str::from_utf8(&ctx.get_args()[0].data)
         .unwrap()
         .to_owned();
@@ -49,5 +49,4 @@ async fn sends_cancel_to_other_wf() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
 }

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

@@ -1,7 +1,7 @@
 use std::time::Duration;
-use temporal_sdk_core::prototype_rust_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
-use test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::CoreWfStarter;
 
 async fn cancelled_wf(mut ctx: WfContext) -> WorkflowResult<()> {
     let cancelled = tokio::select! {
@@ -50,6 +50,4 @@ async fn cancel_during_timer() {
         desc.workflow_execution_info.unwrap().status,
         WorkflowExecutionStatus::Canceled as i32
     );
-
-    starter.shutdown().await;
 }

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

@@ -1,7 +1,7 @@
 use anyhow::anyhow;
-use temporal_sdk_core::prototype_rust_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
+use temporal_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::child_workflow::{child_workflow_result, Success};
-use test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::CoreWfStarter;
 
 static PARENT_WF_TYPE: &str = "parent_wf";
 static CHILD_WF_TYPE: &str = "child_wf";
@@ -10,7 +10,7 @@ async fn child_wf(_ctx: WfContext) -> WorkflowResult<()> {
     Ok(().into())
 }
 
-async fn parent_wf(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn parent_wf(ctx: WfContext) -> WorkflowResult<()> {
     let child = ctx.child_workflow(ChildWorkflowOptions {
         workflow_id: "child-1".to_owned(),
         workflow_type: CHILD_WF_TYPE.to_owned(),
@@ -18,7 +18,7 @@ async fn parent_wf(mut ctx: WfContext) -> WorkflowResult<()> {
     });
 
     let started = child
-        .start(&mut ctx)
+        .start(&ctx)
         .await
         .into_started()
         .expect("Child chould start OK");
@@ -42,6 +42,4 @@ async fn child_workflow_happy_path() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-
-    starter.shutdown().await;
 }

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

@@ -1,13 +1,13 @@
 use std::time::Duration;
-use temporal_sdk_core::prototype_rust_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::workflow_commands::ContinueAsNewWorkflowExecution;
-use test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::CoreWfStarter;
 
-async fn continue_as_new_wf(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn continue_as_new_wf(ctx: WfContext) -> WorkflowResult<()> {
     let run_ct = ctx.get_args()[0].data[0];
     ctx.timer(Duration::from_millis(500)).await;
     Ok(if run_ct < 5 {
-        WfExitValue::ContinueAsNew(ContinueAsNewWorkflowExecution {
+        WfExitValue::continue_as_new(ContinueAsNewWorkflowExecution {
             arguments: vec![[run_ct + 1].into()],
             ..Default::default()
         })
@@ -37,6 +37,4 @@ async fn continue_as_new_happy_path() {
         .terminate_workflow_execution(wf_name.to_owned(), None)
         .await
         .unwrap();
-
-    starter.shutdown().await;
 }

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

@@ -2,11 +2,11 @@ use std::{
     sync::atomic::{AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_sdk_core::prototype_rust_sdk::{ActivityOptions, WfContext, WorkflowResult};
-use test_utils::CoreWfStarter;
+use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
+use temporal_sdk_core_test_utils::CoreWfStarter;
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(1);
-pub async fn timer_wf_nondeterministic(mut ctx: WfContext) -> WorkflowResult<()> {
+pub async fn timer_wf_nondeterministic(ctx: WfContext) -> WorkflowResult<()> {
     let run_ct = RUN_CT.fetch_add(1, Ordering::Relaxed);
 
     match run_ct {
@@ -43,7 +43,6 @@ async fn test_determinism_error_then_recovers() {
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
-    starter.shutdown().await;
     // 4 because we still add on the 3rd and final attempt
     assert_eq!(RUN_CT.load(Ordering::Relaxed), 4);
 }