temporalio 0.1.1 → 0.3.0

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

@@ -1,61 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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");
-    starter.no_remote_activities();
-    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

@@ -1,51 +0,0 @@
-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;
-
-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);
-    starter.no_remote_activities();
-    let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_wf(wf_name.to_string(), cancelled_wf);
-    starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
-
-    let canceller = async {
-        tokio::time::sleep(Duration::from_millis(500)).await;
-        // Cancel the workflow externally
-        client
-            .cancel_workflow_execution(wf_id.clone(), 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_id, 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

@@ -1,51 +0,0 @@
-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");
-    starter.no_remote_activities();
-    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

@@ -1,64 +0,0 @@
-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);
-    starter.no_remote_activities();
-    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
-        .no_remote_activities()
-        .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

@@ -1,47 +0,0 @@
-use std::{
-    sync::atomic::{AtomicUsize, Ordering},
-    time::Duration,
-};
-
-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);
-    starter.no_remote_activities();
-    let mut worker = starter.worker().await;
-
-    worker.register_wf(wf_name.to_owned(), timer_wf_nondeterministic);
-    starter.start_with_worker(wf_name, &mut worker).await;
-    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);
-}