temporalio 0.0.0 → 0.0.1

data/bridge/sdk-core/tests/integ_tests/workflow_tests/appdata_propagation.rs

@@ -0,0 +1,61 @@
+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";
+
+struct Data {
+    message: String,
+}
+
+pub async fn appdata_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 appdata_access_in_activities_and_workflows() {
+    let wf_name = "appdata_activity";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.inner_mut().insert_app_data(Data {
+        message: TEST_APPDATA_MESSAGE.to_owned(),
+    });
+
+    let client = starter.get_client().await;
+    worker.register_wf(wf_name.to_owned(), appdata_activity_wf);
+    worker.register_activity(
+        "echo_activity",
+        |ctx: ActContext, echo_me: String| async move {
+            let data = ctx.app_data::<Data>().expect("appdata exists. qed");
+            assert_eq!(data.message, TEST_APPDATA_MESSAGE.to_owned());
+            Ok(echo_me)
+        },
+    );
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    let handle = client.get_untyped_workflow_handle(wf_name, run_id);
+    let res = handle
+        .get_workflow_result(Default::default())
+        .await
+        .unwrap();
+    assert_matches!(res, WorkflowExecutionResult::Succeeded(_));
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/cancel_external.rs

@@ -0,0 +1,59 @@
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::common::NamespacedWorkflowExecution;
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+const RECEIVER_WFID: &str = "sends-cancel-receiver";
+
+async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
+    let run_id = std::str::from_utf8(&ctx.get_args()[0].data)
+        .unwrap()
+        .to_owned();
+    let sigres = ctx
+        .cancel_external(NamespacedWorkflowExecution {
+            workflow_id: RECEIVER_WFID.to_string(),
+            run_id,
+            namespace: ctx.namespace().to_string(),
+        })
+        .await;
+    if ctx.get_args().get(1).is_some() {
+        // We expect failure
+        assert!(sigres.is_err());
+    } else {
+        sigres.unwrap();
+    }
+    Ok(().into())
+}
+
+async fn cancel_receiver(mut ctx: WfContext) -> WorkflowResult<()> {
+    ctx.cancelled().await;
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn sends_cancel_to_other_wf() {
+    let mut starter = CoreWfStarter::new("sends_cancel_to_other_wf");
+    let mut worker = starter.worker().await;
+    worker.register_wf("sender", cancel_sender);
+    worker.register_wf("receiver", cancel_receiver);
+
+    let receiver_run_id = worker
+        .submit_wf(
+            RECEIVER_WFID,
+            "receiver",
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker
+        .submit_wf(
+            "sends-cancel-sender",
+            "sender",
+            vec![receiver_run_id.into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/cancel_wf.rs

@@ -0,0 +1,58 @@
+use std::time::Duration;
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
+use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+async fn cancelled_wf(mut ctx: WfContext) -> WorkflowResult<()> {
+    let cancelled = tokio::select! {
+        _ = ctx.timer(Duration::from_secs(500)) => false,
+        _ = ctx.cancelled() => true
+    };
+
+    if cancelled {
+        Ok(WfExitValue::Cancelled)
+    } else {
+        panic!("Should have been cancelled")
+    }
+}
+
+#[tokio::test]
+async fn cancel_during_timer() {
+    let wf_name = "cancel_during_timer";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+    worker.register_wf(wf_name.to_string(), cancelled_wf);
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    let canceller = async {
+        tokio::time::sleep(Duration::from_millis(500)).await;
+        // Cancel the workflow externally
+        client
+            .cancel_workflow_execution(wf_name.to_string(), None, "Dieee".to_string(), None)
+            .await
+            .unwrap();
+    };
+
+    let (_, res) = tokio::join!(canceller, worker.run_until_done());
+    res.unwrap();
+    let desc = client
+        .describe_workflow_execution(wf_name.to_string(), None)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        desc.workflow_execution_info.unwrap().status,
+        WorkflowExecutionStatus::Canceled as i32
+    );
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/child_workflows.rs

@@ -0,0 +1,50 @@
+use anyhow::anyhow;
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{ChildWorkflowOptions, WfContext, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::child_workflow::{child_workflow_result, Success};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+static PARENT_WF_TYPE: &str = "parent_wf";
+static CHILD_WF_TYPE: &str = "child_wf";
+
+async fn child_wf(_ctx: WfContext) -> WorkflowResult<()> {
+    Ok(().into())
+}
+
+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(),
+        ..Default::default()
+    });
+
+    let started = child
+        .start(&ctx)
+        .await
+        .into_started()
+        .expect("Child chould start OK");
+    match started.result().await.status {
+        Some(child_workflow_result::Status::Completed(Success { .. })) => Ok(().into()),
+        _ => Err(anyhow!("Unexpected child WF status")),
+    }
+}
+
+#[tokio::test]
+async fn child_workflow_happy_path() {
+    let mut starter = CoreWfStarter::new("child-workflows");
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(PARENT_WF_TYPE.to_string(), parent_wf);
+    worker.register_wf(CHILD_WF_TYPE.to_string(), child_wf);
+
+    worker
+        .submit_wf(
+            "parent".to_string(),
+            PARENT_WF_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/continue_as_new.rs

@@ -0,0 +1,60 @@
+use std::time::Duration;
+use temporal_client::WorkflowOptions;
+use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporal_sdk_core_protos::coresdk::workflow_commands::ContinueAsNewWorkflowExecution;
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+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::continue_as_new(ContinueAsNewWorkflowExecution {
+            arguments: vec![[run_ct + 1].into()],
+            ..Default::default()
+        })
+    } else {
+        ().into()
+    })
+}
+
+#[tokio::test]
+async fn continue_as_new_happy_path() {
+    let wf_name = "continue_as_new_happy_path";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_string(), continue_as_new_wf);
+
+    worker
+        .submit_wf(
+            wf_name.to_string(),
+            wf_name.to_string(),
+            vec![[1].into()],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+}
+
+#[tokio::test]
+async fn continue_as_new_multiple_concurrent() {
+    let wf_name = "continue_as_new_multiple_concurrent";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.max_cached_workflows(3).max_wft(3);
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_string(), continue_as_new_wf);
+
+    let wf_names = (1..=20).map(|i| format!("{}-{}", wf_name, i));
+    for name in wf_names.clone() {
+        worker
+            .submit_wf(
+                name.to_string(),
+                wf_name.to_string(),
+                vec![[1].into()],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+    }
+    worker.run_until_done().await.unwrap();
+}

data/bridge/sdk-core/tests/integ_tests/workflow_tests/determinism.rs

@@ -0,0 +1,54 @@
+use std::{
+    sync::atomic::{AtomicUsize, Ordering},
+    time::Duration,
+};
+use temporal_client::WorkflowOptions;
+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(ctx: WfContext) -> WorkflowResult<()> {
+    let run_ct = RUN_CT.fetch_add(1, Ordering::Relaxed);
+
+    match run_ct {
+        1 | 3 => {
+            // If we have not run yet or are on the third attempt, schedule a timer
+            ctx.timer(Duration::from_secs(1)).await;
+            if run_ct == 1 {
+                // on first attempt we need to blow up after the timer fires so we will replay
+                panic!("dying on purpose");
+            }
+        }
+        2 => {
+            // On the second attempt we should cause a nondeterminism error
+            ctx.activity(ActivityOptions {
+                activity_type: "whatever".to_string(),
+                ..Default::default()
+            })
+            .await;
+        }
+        _ => panic!("Ran too many times"),
+    }
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn test_determinism_error_then_recovers() {
+    let wf_name = "test_determinism_error_then_recovers";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_owned(), timer_wf_nondeterministic);
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    // 4 because we still add on the 3rd and final attempt
+    assert_eq!(RUN_CT.load(Ordering::Relaxed), 4);
+}