temporalio 0.1.1 → 0.2.0

data/bridge/sdk-core/core/src/core_tests/child_workflows.rs

@@ -1,221 +0,0 @@
-use crate::{
-    replay::DEFAULT_WORKFLOW_TYPE,
-    test_help::{
-        canned_histories, mock_sdk, mock_worker, single_hist_mock_sg, MockPollCfg, ResponseType,
-    },
-    worker::{client::mocks::mock_workflow_client, ManagedWFFunc},
-};
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{ChildWorkflowOptions, Signal, WfContext, WorkflowFunction, WorkflowResult};
-use temporal_sdk_core_api::Worker;
-use temporal_sdk_core_protos::coresdk::{
-    child_workflow::{child_workflow_result, ChildWorkflowCancellationType},
-    workflow_activation::{workflow_activation_job, WorkflowActivationJob},
-    workflow_commands::{
-        CancelChildWorkflowExecution, CompleteWorkflowExecution, StartChildWorkflowExecution,
-    },
-    workflow_completion::WorkflowActivationCompletion,
-};
-use tokio::join;
-
-const SIGNAME: &str = "SIGNAME";
-
-#[rstest::rstest]
-#[case::signal_then_result(true)]
-#[case::signal_and_result_concurrent(false)]
-#[tokio::test]
-async fn signal_child_workflow(#[case] serial: bool) {
-    let wf_id = "fakeid";
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let t = canned_histories::single_child_workflow_signaled("child-id-1", SIGNAME);
-    let mock = mock_workflow_client();
-    let mut worker = mock_sdk(MockPollCfg::from_resp_batches(
-        wf_id,
-        t,
-        [ResponseType::AllHistory],
-        mock,
-    ));
-
-    let wf = move |ctx: WfContext| async move {
-        let child = ctx.child_workflow(ChildWorkflowOptions {
-            workflow_id: "child-id-1".to_string(),
-            workflow_type: "child".to_string(),
-            ..Default::default()
-        });
-
-        let start_res = child
-            .start(&ctx)
-            .await
-            .into_started()
-            .expect("Child should get started");
-        let (sigres, res) = if serial {
-            let sigres = start_res.signal(&ctx, Signal::new(SIGNAME, [b"Hi!"])).await;
-            let res = start_res.result().await;
-            (sigres, res)
-        } else {
-            let sigfut = start_res.signal(&ctx, Signal::new(SIGNAME, [b"Hi!"]));
-            let resfut = start_res.result();
-            join!(sigfut, resfut)
-        };
-        sigres.expect("signal result is ok");
-        res.status.expect("child wf result is ok");
-        Ok(().into())
-    };
-
-    worker.register_wf(wf_type.to_owned(), wf);
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
-async fn parent_cancels_child_wf(ctx: WfContext) -> WorkflowResult<()> {
-    let child = ctx.child_workflow(ChildWorkflowOptions {
-        workflow_id: "child-id-1".to_string(),
-        workflow_type: "child".to_string(),
-        cancel_type: ChildWorkflowCancellationType::WaitCancellationCompleted,
-        ..Default::default()
-    });
-
-    let start_res = child
-        .start(&ctx)
-        .await
-        .into_started()
-        .expect("Child should get started");
-    let cancel_fut = start_res.cancel(&ctx);
-    let resfut = start_res.result();
-    let (cancel_res, res) = join!(cancel_fut, resfut);
-    cancel_res.expect("cancel result is ok");
-    let stat = res.status.expect("child wf result is ok");
-    assert_matches!(stat, child_workflow_result::Status::Cancelled(_));
-    Ok(().into())
-}
-
-#[tokio::test]
-async fn cancel_child_workflow() {
-    let func = WorkflowFunction::new(parent_cancels_child_wf);
-    let t = canned_histories::single_child_workflow_cancelled("child-id-1");
-    let mut wfm = ManagedWFFunc::new(t, func, vec![]);
-    wfm.process_all_activations().await.unwrap();
-    wfm.shutdown().await.unwrap();
-}
-
-#[rstest::rstest]
-#[case::abandon(ChildWorkflowCancellationType::Abandon)]
-#[case::try_cancel(ChildWorkflowCancellationType::TryCancel)]
-#[case::wait_cancel_completed(ChildWorkflowCancellationType::WaitCancellationCompleted)]
-#[tokio::test]
-async fn cancel_child_workflow_lang_thinks_not_started_but_is(
-    #[case] cancellation_type: ChildWorkflowCancellationType,
-) {
-    // Since signal handlers always run first, it's possible lang might try to cancel
-    // a child workflow it thinks isn't started, but we've told it is in the same activation.
-    // It would be annoying for lang to have to peek ahead at jobs to be consistent in that case.
-    let t = match cancellation_type {
-        ChildWorkflowCancellationType::Abandon => {
-            canned_histories::single_child_workflow_abandon_cancelled("child-id-1")
-        }
-        ChildWorkflowCancellationType::TryCancel => {
-            canned_histories::single_child_workflow_try_cancelled("child-id-1")
-        }
-        _ => canned_histories::single_child_workflow_cancelled("child-id-1"),
-    };
-    let mock = mock_workflow_client();
-    let mock = single_hist_mock_sg("fakeid", t, [ResponseType::AllHistory], mock, true);
-    let core = mock_worker(mock);
-    let act = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        act.run_id,
-        StartChildWorkflowExecution {
-            seq: 1,
-            cancellation_type: cancellation_type as i32,
-            ..Default::default()
-        }
-        .into(),
-    ))
-    .await
-    .unwrap();
-    let act = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        act.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecutionStart(_)),
-        }]
-    );
-    // Issue the cancel command
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        act.run_id,
-        CancelChildWorkflowExecution {
-            child_workflow_seq: 1,
-        }
-        .into(),
-    ))
-    .await
-    .unwrap();
-    let act = core.poll_workflow_activation().await.unwrap();
-    // Make sure that a resolve for the "request cancel external workflow" command does *not* appear
-    // since lang didn't actually issue one. The only job should be resolving the child workflow.
-    assert_matches!(
-        act.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecution(_)),
-        }]
-    );
-    // Request cancel external is technically fallible, but the only reasons relate to targeting
-    // a not-found workflow, which couldn't happen in this case.
-}
-
-#[tokio::test]
-async fn cancel_already_complete_child_ignored() {
-    let t = canned_histories::single_child_workflow("child-id-1");
-    let mock = mock_workflow_client();
-    let mock = single_hist_mock_sg("fakeid", t, [ResponseType::AllHistory], mock, true);
-    let core = mock_worker(mock);
-    let act = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        act.run_id,
-        StartChildWorkflowExecution {
-            seq: 1,
-            ..Default::default()
-        }
-        .into(),
-    ))
-    .await
-    .unwrap();
-    let act = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        act.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecutionStart(_)),
-        }]
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
-        .await
-        .unwrap();
-    let act = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        act.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::ResolveChildWorkflowExecution(_)),
-        }]
-    );
-    // Try to cancel post-completion, it should be ignored. Also complete the wf.
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        act.run_id,
-        vec![
-            CancelChildWorkflowExecution {
-                child_workflow_seq: 1,
-            }
-            .into(),
-            CompleteWorkflowExecution { result: None }.into(),
-        ],
-    ))
-    .await
-    .unwrap();
-}

data/bridge/sdk-core/core/src/core_tests/determinism.rs

@@ -1,270 +0,0 @@
-use crate::{
-    internal_flags::CoreInternalFlags,
-    replay::DEFAULT_WORKFLOW_TYPE,
-    test_help::{canned_histories, mock_sdk, mock_sdk_cfg, MockPollCfg, ResponseType},
-    worker::client::mocks::mock_workflow_client,
-};
-use std::{
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
-    time::Duration,
-};
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{
-    ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WfContext, WorkflowResult,
-};
-use temporal_sdk_core_protos::{
-    temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure},
-    DEFAULT_ACTIVITY_TYPE,
-};
-
-static DID_FAIL: AtomicBool = AtomicBool::new(false);
-pub async fn timer_wf_fails_once(ctx: WfContext) -> WorkflowResult<()> {
-    ctx.timer(Duration::from_secs(1)).await;
-    if DID_FAIL
-        .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
-        .is_ok()
-    {
-        panic!("Ahh");
-    }
-    Ok(().into())
-}
-
-/// Verifies that workflow panics (which in this case the Rust SDK turns into workflow activation
-/// failures) are turned into unspecified WFT failures.
-#[tokio::test]
-async fn test_panic_wf_task_rejected_properly() {
-    let wf_id = "fakeid";
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let t = canned_histories::workflow_fails_with_failure_after_timer("1");
-    let mock = mock_workflow_client();
-    let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 2], mock);
-    // We should see one wft failure which has unspecified cause, since panics don't have a defined
-    // type.
-    mh.num_expected_fails = 1;
-    mh.expect_fail_wft_matcher =
-        Box::new(|_, cause, _| matches!(cause, WorkflowTaskFailedCause::Unspecified));
-    let mut worker = mock_sdk(mh);
-
-    worker.register_wf(wf_type.to_owned(), timer_wf_fails_once);
-    worker
-        .submit_wf(
-            wf_id.to_owned(),
-            wf_type.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
-/// Verifies nondeterministic behavior in workflows results in automatic WFT failure with the
-/// appropriate nondeterminism cause.
-#[rstest::rstest]
-#[case::with_cache(true)]
-#[case::without_cache(false)]
-#[tokio::test]
-async fn test_wf_task_rejected_properly_due_to_nondeterminism(#[case] use_cache: bool) {
-    let wf_id = "fakeid";
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let t = canned_histories::single_timer_wf_completes("1");
-    let mock = mock_workflow_client();
-    let mut mh = MockPollCfg::from_resp_batches(
-        wf_id,
-        t,
-        // Two polls are needed, since the first will fail
-        [ResponseType::AllHistory, ResponseType::AllHistory],
-        mock,
-    );
-    // We should see one wft failure which has nondeterminism cause
-    mh.num_expected_fails = 1;
-    mh.expect_fail_wft_matcher =
-        Box::new(|_, cause, _| matches!(cause, WorkflowTaskFailedCause::NonDeterministicError));
-    let mut worker = mock_sdk_cfg(mh, |cfg| {
-        if use_cache {
-            cfg.max_cached_workflows = 2;
-        }
-    });
-
-    let started_count: &'static _ = Box::leak(Box::new(AtomicUsize::new(0)));
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
-        // The workflow is replaying all of history, so the when it schedules an extra timer it
-        // should not have, it causes a nondeterminism error.
-        if started_count.fetch_add(1, Ordering::Relaxed) == 0 {
-            ctx.timer(Duration::from_secs(1)).await;
-        }
-        ctx.timer(Duration::from_secs(1)).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();
-    // Started count is two since we start, restart once due to error, then we unblock the real
-    // timer and proceed without restarting
-    assert_eq!(2, started_count.load(Ordering::Relaxed));
-}
-
-#[rstest::rstest]
-#[tokio::test]
-async fn activity_id_or_type_change_is_nondeterministic(
-    #[values(true, false)] use_cache: bool,
-    #[values(true, false)] id_change: bool,
-    #[values(true, false)] local_act: bool,
-) {
-    let wf_id = "fakeid";
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let mut t = if local_act {
-        canned_histories::single_local_activity("1")
-    } else {
-        canned_histories::single_activity("1")
-    };
-    t.set_flags_first_wft(&[CoreInternalFlags::IdAndTypeDeterminismChecks as u32], &[]);
-    let mock = mock_workflow_client();
-    let mut mh = MockPollCfg::from_resp_batches(
-        wf_id,
-        t,
-        // Two polls are needed, since the first will fail
-        [ResponseType::AllHistory, ResponseType::AllHistory],
-        mock,
-    );
-    // We should see one wft failure which has nondeterminism cause
-    mh.num_expected_fails = 1;
-    mh.expect_fail_wft_matcher = Box::new(move |_, cause, f| {
-        let should_contain = if id_change {
-            "does not match activity id"
-        } else {
-            "does not match activity type"
-        };
-        matches!(cause, WorkflowTaskFailedCause::NonDeterministicError)
-            && matches!(f, Some(Failure {
-                message,
-                ..
-            }) if message.contains(should_contain))
-    });
-    let mut worker = mock_sdk_cfg(mh, |cfg| {
-        if use_cache {
-            cfg.max_cached_workflows = 2;
-        }
-    });
-
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
-        if local_act {
-            ctx.local_activity(if id_change {
-                LocalActivityOptions {
-                    activity_id: Some("I'm bad and wrong!".to_string()),
-                    activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-                    ..Default::default()
-                }
-            } else {
-                LocalActivityOptions {
-                    activity_type: "not the default act type".to_string(),
-                    ..Default::default()
-                }
-            })
-            .await;
-        } else {
-            ctx.activity(if id_change {
-                ActivityOptions {
-                    activity_id: Some("I'm bad and wrong!".to_string()),
-                    activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-                    ..Default::default()
-                }
-            } else {
-                ActivityOptions {
-                    activity_type: "not the default act type".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::rstest]
-#[tokio::test]
-async fn child_wf_id_or_type_change_is_nondeterministic(
-    #[values(true, false)] use_cache: bool,
-    #[values(true, false)] id_change: bool,
-) {
-    let wf_id = "fakeid";
-    let wf_type = DEFAULT_WORKFLOW_TYPE;
-    let mut t = canned_histories::single_child_workflow("1");
-    t.set_flags_first_wft(&[CoreInternalFlags::IdAndTypeDeterminismChecks as u32], &[]);
-    let mock = mock_workflow_client();
-    let mut mh = MockPollCfg::from_resp_batches(
-        wf_id,
-        t,
-        // Two polls are needed, since the first will fail
-        [ResponseType::AllHistory, ResponseType::AllHistory],
-        mock,
-    );
-    // We should see one wft failure which has nondeterminism cause
-    mh.num_expected_fails = 1;
-    mh.expect_fail_wft_matcher = Box::new(move |_, cause, f| {
-        let should_contain = if id_change {
-            "does not match child workflow id"
-        } else {
-            "does not match child workflow type"
-        };
-        matches!(cause, WorkflowTaskFailedCause::NonDeterministicError)
-            && matches!(f, Some(Failure {
-                message,
-                ..
-            }) if message.contains(should_contain))
-    });
-    let mut worker = mock_sdk_cfg(mh, |cfg| {
-        if use_cache {
-            cfg.max_cached_workflows = 2;
-        }
-    });
-
-    worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
-        ctx.child_workflow(if id_change {
-            ChildWorkflowOptions {
-                workflow_id: "I'm bad and wrong!".to_string(),
-                workflow_type: DEFAULT_ACTIVITY_TYPE.to_string(),
-                ..Default::default()
-            }
-        } else {
-            ChildWorkflowOptions {
-                workflow_id: "1".to_string(),
-                workflow_type: "not the child wf type".to_string(),
-                ..Default::default()
-            }
-        })
-        .start(&ctx)
-        .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();
-}