temporalio 0.0.1

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

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

@@ -0,0 +1,107 @@
+use crate::{
+    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::{WfContext, WorkflowResult};
+use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowTaskFailedCause;
+
+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));
+}