@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/core/src/worker/workflow/machines/cancel_workflow_state_machine.rs

@@ -96,70 +96,3 @@ impl WFMachinesAdapter for CancelWorkflowMachine {
         Ok(vec![])
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_help::{MockPollCfg, build_fake_sdk, canned_histories};
-    use std::time::Duration;
-    use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-    use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
-        coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-    };
-    use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor;
-
-    async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
-        ctx.timer(Duration::from_millis(500)).await;
-        Ok(WfExitValue::Cancelled)
-    }
-
-    #[tokio::test]
-    async fn wf_completing_with_cancelled() {
-        let t = canned_histories::timer_wf_cancel_req_cancelled("1");
-
-        let mut aai = ActivationAssertionsInterceptor::default();
-        aai.then(|a| {
-            assert_matches!(
-                a.jobs.as_slice(),
-                [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
-                }]
-            )
-        });
-        aai.then(|a| {
-            assert_matches!(
-                a.jobs.as_slice(),
-                [
-                    WorkflowActivationJob {
-                        variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-                    },
-                    WorkflowActivationJob {
-                        variant: Some(workflow_activation_job::Variant::CancelWorkflow(_)),
-                    }
-                ]
-            );
-        });
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts
-                .then(|wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(wft.commands[0].command_type(), CommandType::StartTimer);
-                })
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(
-                        wft.commands[0].command_type(),
-                        CommandType::CancelWorkflowExecution
-                    );
-                });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, wf_with_timer);
-        worker.set_worker_interceptor(aai);
-        worker.run().await.unwrap();
-    }
-}

package/sdk-core/core/src/worker/workflow/machines/child_workflow_state_machine.rs

@@ -779,199 +779,8 @@ fn convert_payloads(
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{
-        internal_flags::InternalFlags,
-        replay::TestHistoryBuilder,
-        test_help::{MockPollCfg, build_fake_sdk, canned_histories},
-    };
-    use anyhow::anyhow;
-    use rstest::{fixture, rstest};
+    use crate::internal_flags::InternalFlags;
     use std::{cell::RefCell, mem::discriminant, rc::Rc};
-    use temporal_sdk::{CancellableFuture, ChildWorkflowOptions, WfContext, WorkflowResult};
-    use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
-        coresdk::{
-            child_workflow::child_workflow_result,
-            workflow_activation::resolve_child_workflow_execution_start::Status as StartStatus,
-        },
-        temporal::api::history::v1::StartChildWorkflowExecutionInitiatedEventAttributes,
-    };
-
-    #[derive(Clone, Copy)]
-    enum Expectation {
-        Success,
-        Failure,
-        StartFailure,
-    }
-
-    impl Expectation {
-        const fn try_from_u8(x: u8) -> Option<Self> {
-            Some(match x {
-                0 => Self::Success,
-                1 => Self::Failure,
-                2 => Self::StartFailure,
-                _ => return None,
-            })
-        }
-    }
-
-    #[fixture]
-    fn child_workflow_happy_hist() -> MockPollCfg {
-        let mut t = canned_histories::single_child_workflow("child-id-1");
-        t.set_wf_input(Payload::from([Expectation::Success as u8]));
-        MockPollCfg::from_hist_builder(t)
-    }
-
-    #[fixture]
-    fn child_workflow_fail_hist() -> MockPollCfg {
-        let mut t = canned_histories::single_child_workflow_fail("child-id-1");
-        t.set_wf_input(Payload::from([Expectation::Failure as u8]));
-        MockPollCfg::from_hist_builder(t)
-    }
-
-    async fn parent_wf(ctx: WfContext) -> WorkflowResult<()> {
-        let expectation = Expectation::try_from_u8(ctx.get_args()[0].data[0]).unwrap();
-        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;
-        match (expectation, &start_res.status) {
-            (Expectation::Success | Expectation::Failure, StartStatus::Succeeded(_)) => {}
-            (Expectation::StartFailure, StartStatus::Failed(_)) => return Ok(().into()),
-            _ => return Err(anyhow!("Unexpected start status")),
-        };
-        match (
-            expectation,
-            start_res.into_started().unwrap().result().await.status,
-        ) {
-            (Expectation::Success, Some(child_workflow_result::Status::Completed(_))) => {
-                Ok(().into())
-            }
-            (Expectation::Failure, _) => Ok(().into()),
-            _ => Err(anyhow!("Unexpected child WF status")),
-        }
-    }
-
-    #[rstest(
-        mock_cfg,
-        case::success(child_workflow_happy_hist()),
-        case::failure(child_workflow_fail_hist())
-    )]
-    #[tokio::test]
-    async fn single_child_workflow_until_completion(mut mock_cfg: MockPollCfg) {
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts
-                .then(|wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(
-                        wft.commands[0].command_type(),
-                        CommandType::StartChildWorkflowExecution
-                    );
-                })
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 0);
-                })
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(
-                        wft.commands[0].command_type(),
-                        CommandType::CompleteWorkflowExecution
-                    );
-                });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, parent_wf);
-        worker.run().await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn single_child_workflow_start_fail() {
-        let child_wf_id = "child-id-1";
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.set_wf_input(Payload::from([Expectation::StartFailure as u8]));
-        t.add_full_wf_task();
-        let initiated_event_id = t.add(StartChildWorkflowExecutionInitiatedEventAttributes {
-            workflow_id: child_wf_id.to_owned(),
-            workflow_type: Some("child".into()),
-            ..Default::default()
-        });
-        t.add(StartChildWorkflowExecutionFailedEventAttributes {
-            workflow_id: child_wf_id.to_owned(),
-            initiated_event_id,
-            cause: StartChildWorkflowExecutionFailedCause::WorkflowAlreadyExists as i32,
-            ..Default::default()
-        });
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts
-                .then(|wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(
-                        wft.commands[0].command_type(),
-                        CommandType::StartChildWorkflowExecution
-                    );
-                })
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(
-                        wft.commands[0].command_type(),
-                        CommandType::CompleteWorkflowExecution
-                    );
-                });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, parent_wf);
-        worker.run().await.unwrap();
-    }
-
-    async fn cancel_before_send_wf(ctx: WfContext) -> WorkflowResult<()> {
-        let workflow_id = "child-id-1";
-        let child = ctx.child_workflow(ChildWorkflowOptions {
-            workflow_id: workflow_id.to_string(),
-            workflow_type: "child".to_string(),
-            ..Default::default()
-        });
-        let start = child.start(&ctx);
-        start.cancel(&ctx);
-        match start.await.status {
-            StartStatus::Cancelled(_) => Ok(().into()),
-            _ => Err(anyhow!("Unexpected start status")),
-        }
-    }
-
-    #[tokio::test]
-    async fn single_child_workflow_cancel_before_sent() {
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts.then(move |wft| {
-                // Workflow starts and cancels the child workflow, no commands should be sent besides
-                // workflow completion
-                assert_eq!(wft.commands.len(), 1);
-                assert_matches!(
-                    wft.commands[0].command_type(),
-                    CommandType::CompleteWorkflowExecution
-                );
-            });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, cancel_before_send_wf);
-        worker.run().await.unwrap();
-    }
 
     #[test]
     fn cancels_ignored_terminal() {

package/sdk-core/core/src/worker/workflow/machines/continue_as_new_workflow_state_machine.rs

@@ -104,46 +104,3 @@ impl WFMachinesAdapter for ContinueAsNewWorkflowMachine {
         Ok(vec![])
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_help::{MockPollCfg, build_fake_sdk, canned_histories};
-    use std::time::Duration;
-    use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-    use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE;
-
-    async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
-        ctx.timer(Duration::from_millis(500)).await;
-        Ok(WfExitValue::continue_as_new(
-            ContinueAsNewWorkflowExecution {
-                arguments: vec![[1].into()],
-                ..Default::default()
-            },
-        ))
-    }
-
-    #[tokio::test]
-    async fn wf_completing_with_continue_as_new() {
-        let t = canned_histories::timer_then_continue_as_new("1");
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts
-                .then(|wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(wft.commands[0].command_type(), CommandType::StartTimer);
-                })
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_matches!(
-                        wft.commands[0].command_type(),
-                        CommandType::ContinueAsNewWorkflowExecution
-                    );
-                });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, wf_with_timer);
-        worker.run().await.unwrap();
-    }
-}