@temporalio/core-bridge 0.23.0 → 1.0.0

package/sdk-core/core/src/{workflow → worker/workflow}/bridge.rs

@@ -1,6 +1,6 @@
 use crate::{
     telemetry::VecDisplayer,
-    workflow::{WFCommand, WorkflowFetcher},
+    worker::workflow::{WFCommand, WorkflowFetcher},
 };
 use std::sync::mpsc::{self, Receiver, Sender};
 

package/sdk-core/core/src/{workflow → worker/workflow}/driven_workflow.rs

@@ -1,4 +1,4 @@
-use crate::workflow::{WFCommand, WorkflowStartedInfo};
+use crate::worker::workflow::{WFCommand, WorkflowStartedInfo};
 use std::collections::VecDeque;
 use temporal_sdk_core_protos::{
     coresdk::workflow_activation::{

package/sdk-core/core/src/{workflow → worker/workflow}/history_update.rs

@@ -5,6 +5,7 @@ use crate::{
 use futures::{future::BoxFuture, stream, stream::BoxStream, FutureExt, Stream, StreamExt};
 use std::{
     collections::VecDeque,
+    fmt::Debug,
     future::Future,
     pin::Pin,
     sync::Arc,
@@ -15,6 +16,7 @@ use temporal_sdk_core_protos::temporal::api::{
     history::v1::{History, HistoryEvent},
     workflowservice::v1::GetWorkflowExecutionHistoryResponse,
 };
+use tracing::Instrument;
 
 /// A slimmed down version of a poll workflow task response which includes just the info needed
 /// by [WorkflowManager]. History events are expected to be consumed from it and applied to the
@@ -28,6 +30,15 @@ pub struct HistoryUpdate {
     buffered: VecDeque<HistoryEvent>,
     pub previous_started_event_id: i64,
 }
+impl Debug for HistoryUpdate {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "HistoryUpdate(previous_started_event_id: {})",
+            self.previous_started_event_id
+        )
+    }
+}
 
 pub struct HistoryPaginator {
     // Potentially this could actually be a ref w/ lifetime here
@@ -130,8 +141,11 @@ impl Stream for HistoryPaginator {
             let gw = self.client.clone();
             let wid = self.wf_id.clone();
             let rid = self.run_id.clone();
-            let resp_fut =
-                async move { gw.get_workflow_execution_history(wid, Some(rid), npt).await };
+            let resp_fut = async move {
+                gw.get_workflow_execution_history(wid, Some(rid), npt)
+                    .instrument(span!(tracing::Level::TRACE, "fetch_history_in_paginator"))
+                    .await
+            };
             self.open_history_request.insert(resp_fut.boxed())
         };
 

package/sdk-core/core/src/{workflow → worker/workflow}/machines/activity_state_machine.rs

@@ -9,13 +9,12 @@ use std::convert::{TryFrom, TryInto};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{self as ar, activity_resolution, ActivityResolution, Cancellation},
-        common::Payload,
         workflow_activation::ResolveActivity,
         workflow_commands::{ActivityCancellationType, ScheduleActivity},
     },
     temporal::api::{
         command::v1::{command, Command, RequestCancelActivityTaskCommandAttributes},
-        common::v1::{ActivityType, Payloads},
+        common::v1::{ActivityType, Payload, Payloads},
         enums::v1::{CommandType, EventType, RetryState},
         failure::v1::{
             self as failure, failure::FailureInfo, ActivityFailureInfo, CanceledFailureInfo,
@@ -77,6 +76,10 @@ fsm! {
         shared on_activity_task_timed_out) --> TimedOut;
     StartedActivityCancelEventRecorded --(ActivityTaskCanceled(ActivityTaskCanceledEventAttributes),
         shared on_activity_task_canceled) --> Canceled;
+
+    Canceled --(ActivityTaskStarted(i64), shared on_activity_task_started) --> Canceled;
+    Canceled --(ActivityTaskCompleted(ActivityTaskCompletedEventAttributes),
+        shared on_activity_task_completed) --> Canceled;
 }
 
 #[derive(Debug, derive_more::Display)]
@@ -637,6 +640,39 @@ pub(super) struct TimedOut {}
 
 #[derive(Default, Clone)]
 pub(super) struct Canceled {}
+impl Canceled {
+    pub(super) fn on_activity_task_started(
+        self,
+        dat: SharedState,
+        seq_num: i64,
+    ) -> ActivityMachineTransition<Canceled> {
+        // Abandoned activities might start anyway. Ignore the result.
+        if dat.cancellation_type == ActivityCancellationType::Abandon {
+            TransitionResult::default()
+        } else {
+            TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                "Non-Abandon cancel mode activities cannot be started after being cancelled. \
+                 Seq: {:?}",
+                seq_num
+            )))
+        }
+    }
+    pub(super) fn on_activity_task_completed(
+        self,
+        dat: SharedState,
+        attrs: ActivityTaskCompletedEventAttributes,
+    ) -> ActivityMachineTransition<Canceled> {
+        // Abandoned activities might complete anyway. Ignore the result.
+        if dat.cancellation_type == ActivityCancellationType::Abandon {
+            TransitionResult::default()
+        } else {
+            TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                "Non-Abandon cancel mode activities cannot be completed after being cancelled: {:?}",
+                attrs
+            )))
+        }
+    }
+}
 
 fn create_request_cancel_activity_task_command<S>(
     dat: SharedState,
@@ -747,8 +783,7 @@ fn convert_payloads(
 mod test {
     use super::*;
     use crate::{
-        replay::TestHistoryBuilder, test_help::canned_histories,
-        workflow::managed_wf::ManagedWFFunc,
+        replay::TestHistoryBuilder, test_help::canned_histories, worker::workflow::ManagedWFFunc,
     };
     use rstest::{fixture, rstest};
     use std::mem::discriminant;

package/sdk-core/core/src/{workflow → worker/workflow}/machines/cancel_external_state_machine.rs

@@ -58,6 +58,7 @@ pub(super) fn new_external_cancel(
     seq: u32,
     workflow_execution: NamespacedWorkflowExecution,
     only_child: bool,
+    reason: String,
 ) -> NewMachineWithCommand {
     let mut s = CancelExternalMachine {
         state: Created {}.into(),
@@ -73,6 +74,7 @@ pub(super) fn new_external_cancel(
             // Apparently this is effectively deprecated at this point
             control: "".to_string(),
             child_workflow_only: only_child,
+            reason,
         },
     );
     let cmd = Command {
@@ -191,7 +193,8 @@ impl WFMachinesAdapter for CancelExternalMachine {
             CancelExternalCommand::Failed(f) => {
                 let reason = match f {
                     CancelExternalWorkflowExecutionFailedCause::Unspecified => "unknown",
-                    CancelExternalWorkflowExecutionFailedCause::ExternalWorkflowExecutionNotFound => "not found"
+                    CancelExternalWorkflowExecutionFailedCause::ExternalWorkflowExecutionNotFound
+                    | CancelExternalWorkflowExecutionFailedCause::NamespaceNotFound  => "not found"
                 };
                 vec![ResolveRequestCancelExternalWorkflow {
                     seq: self.shared_state.seq,
@@ -230,7 +233,7 @@ impl Cancellable for CancelExternalMachine {}
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{replay::TestHistoryBuilder, workflow::managed_wf::ManagedWFFunc};
+    use crate::{replay::TestHistoryBuilder, worker::workflow::ManagedWFFunc};
     use temporal_sdk::{WfContext, WorkflowFunction, WorkflowResult};
 
     async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {

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

@@ -122,7 +122,7 @@ impl Cancellable for CancelWorkflowMachine {}
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{test_help::canned_histories, workflow::managed_wf::ManagedWFFunc};
+    use crate::{test_help::canned_histories, worker::workflow::ManagedWFFunc};
     use std::time::Duration;
     use temporal_sdk::{WfContext, WfExitValue, WorkflowFunction, WorkflowResult};
     use temporal_sdk_core_protos::coresdk::workflow_activation::{

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

@@ -9,7 +9,6 @@ use temporal_sdk_core_protos::{
         child_workflow::{
             self as wfr, child_workflow_result::Status as ChildWorkflowStatus, ChildWorkflowResult,
         },
-        common::Payload,
         workflow_activation::{
             resolve_child_workflow_execution_start, ResolveChildWorkflowExecution,
             ResolveChildWorkflowExecutionStart, ResolveChildWorkflowExecutionStartCancelled,
@@ -19,7 +18,7 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{
         command::v1::Command,
-        common::v1::{Payloads, WorkflowExecution, WorkflowType},
+        common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
         enums::v1::{
             CommandType, EventType, RetryState, StartChildWorkflowExecutionFailedCause, TimeoutType,
         },
@@ -616,8 +615,7 @@ fn convert_payloads(
 mod test {
     use super::*;
     use crate::{
-        replay::TestHistoryBuilder, test_help::canned_histories,
-        workflow::managed_wf::ManagedWFFunc,
+        replay::TestHistoryBuilder, test_help::canned_histories, worker::workflow::ManagedWFFunc,
     };
     use anyhow::anyhow;
     use rstest::{fixture, rstest};

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

@@ -121,7 +121,7 @@ impl Cancellable for ContinueAsNewWorkflowMachine {}
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{test_help::canned_histories, workflow::managed_wf::ManagedWFFunc};
+    use crate::{test_help::canned_histories, worker::workflow::ManagedWFFunc};
     use std::time::Duration;
     use temporal_sdk::{WfContext, WfExitValue, WorkflowFunction, WorkflowResult};
 

package/sdk-core/core/src/{workflow → worker/workflow}/machines/local_activity_state_machine.rs

@@ -105,9 +105,7 @@ impl From<CompleteLocalActivityData> for ResolveDat {
     fn from(d: CompleteLocalActivityData) -> Self {
         ResolveDat {
             result: match d.result {
-                Ok(res) => LocalActivityExecutionResult::Completed(Success {
-                    result: Some(res.into()),
-                }),
+                Ok(res) => LocalActivityExecutionResult::Completed(Success { result: Some(res) }),
                 Err(fail) => {
                     if matches!(fail.failure_info, Some(FailureInfo::CanceledFailureInfo(_))) {
                         LocalActivityExecutionResult::Cancelled(Cancellation {
@@ -784,8 +782,7 @@ impl From<LocalActivityExecutionResult> for ActivityResolution {
 mod tests {
     use super::*;
     use crate::{
-        replay::TestHistoryBuilder, test_help::canned_histories,
-        workflow::managed_wf::ManagedWFFunc,
+        replay::TestHistoryBuilder, test_help::canned_histories, worker::workflow::ManagedWFFunc,
     };
     use rstest::rstest;
     use std::time::Duration;

package/sdk-core/core/src/{workflow → worker/workflow}/machines/mod.rs

@@ -234,7 +234,7 @@ where
 {
     if !commands.is_empty() {
         debug!(commands=%commands.display(), state=%machine.state(),
-               machine_name=%StateMachine::name(machine), "Machine produced commands");
+               machine_name=%TemporalStateMachine::kind(machine), "Machine produced commands");
     }
     let mut machine_responses = vec![];
     for cmd in commands {

package/sdk-core/core/src/{workflow → worker/workflow}/machines/patch_state_machine.rs

@@ -223,7 +223,7 @@ impl TryFrom<HistoryEvent> for PatchMachineEvents {
 mod tests {
     use crate::{
         replay::TestHistoryBuilder,
-        workflow::{machines::WFMachinesError, managed_wf::ManagedWFFunc},
+        worker::workflow::{machines::WFMachinesError, ManagedWFFunc},
     };
     use rstest::rstest;
     use std::time::Duration;

package/sdk-core/core/src/{workflow → worker/workflow}/machines/signal_external_state_machine.rs

@@ -234,7 +234,9 @@ impl WFMachinesAdapter for SignalExternalMachine {
             SignalExternalCommand::Failed(f) => {
                 let reason = match f {
                     SignalExternalWorkflowExecutionFailedCause::Unspecified => "unknown",
-                    SignalExternalWorkflowExecutionFailedCause::ExternalWorkflowExecutionNotFound => "it was not found"
+                    SignalExternalWorkflowExecutionFailedCause::ExternalWorkflowExecutionNotFound
+                    | SignalExternalWorkflowExecutionFailedCause::NamespaceNotFound =>
+                        "it was not found"
                 };
                 vec![ResolveSignalExternalWorkflow {
                     seq: self.shared_state.seq,
@@ -306,7 +308,7 @@ impl Cancellable for SignalExternalMachine {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{replay::TestHistoryBuilder, workflow::managed_wf::ManagedWFFunc};
+    use crate::{replay::TestHistoryBuilder, worker::workflow::ManagedWFFunc};
     use std::mem::discriminant;
     use temporal_sdk::{
         CancellableFuture, SignalWorkflowOptions, WfContext, WorkflowFunction, WorkflowResult,

package/sdk-core/core/src/{workflow → worker/workflow}/machines/timer_state_machine.rs

@@ -274,8 +274,7 @@ impl Cancellable for TimerMachine {
 mod test {
     use super::*;
     use crate::{
-        replay::TestHistoryBuilder, test_help::canned_histories,
-        workflow::managed_wf::ManagedWFFunc,
+        replay::TestHistoryBuilder, test_help::canned_histories, worker::workflow::ManagedWFFunc,
     };
     use rstest::{fixture, rstest};
     use std::{mem::discriminant, time::Duration};

package/sdk-core/core/src/{workflow → worker/workflow}/machines/transition_coverage.rs

@@ -67,7 +67,7 @@ fn spawn_save_coverage_at_end() -> SyncSender<(String, CoveredTransition)> {
 #[cfg(test)]
 mod machine_coverage_report {
     use super::*;
-    use crate::workflow::machines::{
+    use crate::worker::workflow::machines::{
         activity_state_machine::ActivityMachine,
         cancel_external_state_machine::CancelExternalMachine,
         cancel_workflow_state_machine::CancelWorkflowMachine,

package/sdk-core/core/src/{workflow → worker/workflow}/machines/upsert_search_attributes_state_machine.rs

@@ -2,7 +2,7 @@ use super::{
     workflow_machines::{MachineResponse, WFMachinesError},
     NewMachineWithCommand,
 };
-use crate::workflow::machines::{Cancellable, EventInfo, MachineKind, WFMachinesAdapter};
+use crate::worker::workflow::machines::{Cancellable, EventInfo, MachineKind, WFMachinesAdapter};
 use rustfsm::{fsm, TransitionResult};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
@@ -161,16 +161,14 @@ impl From<Created> for CommandIssued {
 
 #[cfg(test)]
 mod tests {
+    use super::{super::OnEventWrapper, *};
+    use crate::{replay::TestHistoryBuilder, worker::workflow::ManagedWFFunc};
     use rustfsm::StateMachine;
     use temporal_sdk::{WfContext, WorkflowFunction};
-    use temporal_sdk_core_protos::{
-        coresdk::common::Payload, temporal::api::command::v1::command::Attributes,
+    use temporal_sdk_core_protos::temporal::api::{
+        command::v1::command::Attributes, common::v1::Payload,
     };
 
-    use crate::{replay::TestHistoryBuilder, workflow::managed_wf::ManagedWFFunc};
-
-    use super::{super::OnEventWrapper, *};
-
     #[tokio::test]
     async fn upsert_search_attrs_from_workflow() {
         let mut t = TestHistoryBuilder::default();

package/sdk-core/core/src/{workflow → worker/workflow}/machines/workflow_machines/local_acts.rs

@@ -7,8 +7,8 @@ use std::{
     collections::{HashMap, HashSet},
     time::SystemTime,
 };
-use temporal_sdk_core_protos::{
-    coresdk::common::WorkflowExecution, temporal::api::history::v1::HistoryEvent,
+use temporal_sdk_core_protos::temporal::api::{
+    common::v1::WorkflowExecution, history::v1::HistoryEvent,
 };
 
 #[derive(Default)]

package/sdk-core/core/src/{workflow → worker/workflow}/machines/workflow_machines.rs

@@ -19,12 +19,12 @@ use crate::{
     protosext::{HistoryEventExt, ValidScheduleLA},
     telemetry::{metrics::MetricsContext, VecDisplayer},
     worker::{
+        workflow::{
+            CommandID, DrivenWorkflow, HistoryUpdate, LocalResolution, WFCommand, WorkflowFetcher,
+            WorkflowStartedInfo,
+        },
         ExecutingLAId, LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution,
     },
-    workflow::{
-        CommandID, DrivenWorkflow, HistoryUpdate, LocalResolution, WFCommand, WorkflowFetcher,
-        WorkflowStartedInfo,
-    },
 };
 use siphasher::sip::SipHasher13;
 use slotmap::SlotMap;
@@ -318,6 +318,20 @@ impl WorkflowMachines {
         if event.is_final_wf_execution_event() {
             self.have_seen_terminal_event = true;
         }
+        if matches!(
+            event.event_type(),
+            EventType::WorkflowExecutionTerminated | EventType::WorkflowExecutionTimedOut
+        ) {
+            return if has_next_event {
+                Err(WFMachinesError::Fatal(
+                    "Machines were fed a history which has an event after workflow execution was \
+                     terminated!"
+                        .to_string(),
+                ))
+            } else {
+                Ok(())
+            };
+        }
 
         if event.is_command_event() {
             self.handle_command_event(event)?;
@@ -525,7 +539,7 @@ impl WorkflowMachines {
             }
             _ => {
                 return Err(WFMachinesError::Fatal(format!(
-                    "The event is non a non-stateful event, but we tried to handle it as one: {}",
+                    "The event is not a non-stateful event, but we tried to handle it as one: {}",
                     event
                 )));
             }
@@ -564,6 +578,7 @@ impl WorkflowMachines {
             timestamp: self.current_wf_time.map(Into::into),
             is_replaying: self.replaying,
             run_id: self.run_id.clone(),
+            history_length: self.last_processed_event as u32,
             jobs,
         }
     }
@@ -598,11 +613,9 @@ impl WorkflowMachines {
     }
 
     /// Apply the next (unapplied) entire workflow task from history to these machines. Will replay
-    /// any events that need to be replayed until caught up to the newest WFT.
+    /// any events that need to be replayed until caught up to the newest WFT. May also fetch
+    /// history from server if needed.
     pub(crate) async fn apply_next_wft_from_history(&mut self) -> Result<usize> {
-        // A much higher-up span (ex: poll) may want this field filled
-        tracing::Span::current().record("run_id", &self.run_id.as_str());
-
         // If we have already seen the terminal event for the entire workflow in a previous WFT,
         // then we don't need to do anything here, and in fact we need to avoid re-applying the
         // final WFT.
@@ -697,8 +710,18 @@ impl WorkflowMachines {
     /// Transfer commands from `current_wf_task_commands` to `commands`, so they may be sent off
     /// to the server. While doing so, [TemporalStateMachine::handle_command] is called on the
     /// machine associated with the command.
-    #[instrument(level = "debug", skip(self))]
     fn prepare_commands(&mut self) -> Result<()> {
+        // It's possible we might prepare commands more than once before completing a WFT. (Because
+        // of local activities, of course). Some commands might have since been cancelled that we
+        // already prepared. Rip them out of the outgoing command list if so.
+        self.commands.retain(|c| {
+            !self
+                .all_machines
+                .get(c.machine)
+                .expect("Machine must exist")
+                .was_cancelled_before_sent_to_server()
+        });
+
         while let Some(c) = self.current_wf_task_commands.pop_front() {
             if !self
                 .machine(c.machine)
@@ -805,11 +828,7 @@ impl WorkflowMachines {
                     self.add_cmd_to_wf_task(new_timer(attrs), Some(CommandID::Timer(seq)));
                 }
                 WFCommand::UpsertSearchAttributes(attrs) => {
-                    let seq = attrs.seq;
-                    self.add_cmd_to_wf_task(
-                        upsert_search_attrs(attrs),
-                        Some(CommandID::Timer(seq)),
-                    );
+                    self.add_cmd_to_wf_task(upsert_search_attrs(attrs), None);
                 }
                 WFCommand::CancelTimer(attrs) => {
                     jobs.extend(self.process_cancellation(CommandID::Timer(attrs.seq))?);
@@ -917,7 +936,12 @@ impl WorkflowMachines {
                         Some(cancel_we::Target::WorkflowExecution(we)) => (we, false),
                     };
                     self.add_cmd_to_wf_task(
-                        new_external_cancel(attrs.seq, we, only_child),
+                        new_external_cancel(
+                            attrs.seq,
+                            we,
+                            only_child,
+                            format!("Cancel requested by workflow with run id {}", self.run_id),
+                        ),
                         Some(CommandID::CancelExternal(attrs.seq)),
                     );
                 }

package/sdk-core/core/src/worker/workflow/managed_run/managed_wf_test.rs

@@ -0,0 +1,198 @@
+use super::*;
+use crate::{
+    replay::TestHistoryBuilder,
+    test_help::TEST_Q,
+    worker::{
+        workflow::{
+            history_update::TestHBExt, machines::WorkflowMachines, WFCommand, WorkflowFetcher,
+        },
+        LocalActRequest, LocalActivityResolution,
+    },
+};
+use std::{convert::TryInto, time::Duration};
+use temporal_sdk::{WorkflowFunction, WorkflowResult};
+use temporal_sdk_core_protos::{
+    coresdk::{
+        activity_result::ActivityExecutionResult,
+        workflow_activation::{create_evict_activation, remove_from_cache::EvictionReason},
+        workflow_completion::{
+            workflow_activation_completion::Status, WorkflowActivationCompletion,
+        },
+    },
+    temporal::api::common::v1::Payload,
+};
+use tokio::{
+    sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
+    task::JoinHandle,
+};
+
+pub(crate) struct WFFutureDriver {
+    completions_rx: UnboundedReceiver<WorkflowActivationCompletion>,
+}
+
+#[async_trait::async_trait]
+impl WorkflowFetcher for WFFutureDriver {
+    async fn fetch_workflow_iteration_output(&mut self) -> Vec<WFCommand> {
+        if let Some(completion) = self.completions_rx.recv().await {
+            debug!("Managed wf completion: {}", completion);
+            completion
+                .status
+                .map(|s| match s {
+                    Status::Successful(s) => s
+                        .commands
+                        .into_iter()
+                        .map(|cmd| cmd.try_into().unwrap())
+                        .collect(),
+                    Status::Failed(_) => panic!("Ahh failed"),
+                })
+                .unwrap_or_default()
+        } else {
+            // Sender went away so nothing to do here. End of wf/test.
+            vec![]
+        }
+    }
+}
+
+#[must_use]
+pub struct ManagedWFFunc {
+    mgr: WorkflowManager,
+    activation_tx: UnboundedSender<WorkflowActivation>,
+    future_handle: Option<JoinHandle<WorkflowResult<()>>>,
+    was_shutdown: bool,
+}
+
+impl ManagedWFFunc {
+    pub fn new(hist: TestHistoryBuilder, func: WorkflowFunction, args: Vec<Payload>) -> Self {
+        Self::new_from_update(hist.as_history_update(), func, args)
+    }
+
+    pub fn new_from_update(
+        hist: HistoryUpdate,
+        func: WorkflowFunction,
+        args: Vec<Payload>,
+    ) -> Self {
+        let (completions_tx, completions_rx) = unbounded_channel();
+        let (wff, activations) = func.start_workflow(
+            "testnamespace".to_string(),
+            TEST_Q.to_string(),
+            args,
+            completions_tx,
+        );
+        let spawned = tokio::spawn(wff);
+        let driver = WFFutureDriver { completions_rx };
+        let state_machines = WorkflowMachines::new(
+            "test_namespace".to_string(),
+            "wfid".to_string(),
+            "wftype".to_string(),
+            "runid".to_string(),
+            hist,
+            Box::new(driver).into(),
+            Default::default(),
+        );
+        let mgr = WorkflowManager::new_from_machines(state_machines);
+        Self {
+            mgr,
+            activation_tx: activations,
+            future_handle: Some(spawned),
+            was_shutdown: false,
+        }
+    }
+
+    #[instrument(level = "debug", skip(self))]
+    pub(crate) async fn get_next_activation(&mut self) -> Result<WorkflowActivation> {
+        let res = self.mgr.get_next_activation().await?;
+        debug!("Managed wf next activation: {}", &res);
+        self.push_activation_to_wf(&res).await?;
+        Ok(res)
+    }
+
+    /// Return outgoing server commands as of the last iteration
+    pub(crate) fn get_server_commands(&mut self) -> OutgoingServerCommands {
+        self.mgr.get_server_commands()
+    }
+
+    pub(crate) fn drain_queued_local_activities(&mut self) -> Vec<LocalActRequest> {
+        self.mgr.drain_queued_local_activities()
+    }
+
+    /// Feed new history, as if received a new poll result. Returns new activation
+    #[instrument(level = "debug", skip(self, update))]
+    pub(crate) async fn new_history(
+        &mut self,
+        update: HistoryUpdate,
+    ) -> Result<WorkflowActivation> {
+        let res = self.mgr.feed_history_from_server(update).await?;
+        self.push_activation_to_wf(&res).await?;
+        Ok(res)
+    }
+
+    /// Say a local activity completed (they always take 1 second in these tests)
+    pub(crate) fn complete_local_activity(
+        &mut self,
+        seq_num: u32,
+        result: ActivityExecutionResult,
+    ) -> Result<bool> {
+        self.mgr
+            .notify_of_local_result(LocalResolution::LocalActivity(LocalActivityResolution {
+                seq: seq_num,
+                // We accept normal execution results and do this conversion because there
+                // are more helpers for constructing them.
+                result: result
+                    .status
+                    .expect("LA result must have a status")
+                    .try_into()
+                    .expect("LA execution result must be a valid LA result"),
+                runtime: Duration::from_secs(1),
+                attempt: 1,
+                backoff: None,
+                // Tests at this level don't use the LA dispatcher, so this is irrelevant
+                original_schedule_time: None,
+            }))
+    }
+
+    /// During testing it can be useful to run through all activations to simulate replay
+    /// easily. Returns the last produced activation with jobs in it, or an activation with no
+    /// jobs if the first call had no jobs.
+    pub(crate) async fn process_all_activations(&mut self) -> Result<WorkflowActivation> {
+        let mut last_act = self.get_next_activation().await?;
+        let mut next_act = self.get_next_activation().await?;
+        while !next_act.jobs.is_empty() {
+            last_act = next_act;
+            next_act = self.get_next_activation().await?;
+        }
+        Ok(last_act)
+    }
+
+    pub async fn shutdown(&mut self) -> WorkflowResult<()> {
+        self.was_shutdown = true;
+        // Send an eviction to ensure wf exits if it has not finished (ex: feeding partial hist)
+        let _ = self.activation_tx.send(create_evict_activation(
+            "not actually important".to_string(),
+            "force shutdown".to_string(),
+            EvictionReason::Unspecified,
+        ));
+        self.future_handle.take().unwrap().await.unwrap()
+    }
+
+    #[instrument(level = "debug", skip(self, res))]
+    async fn push_activation_to_wf(&mut self, res: &WorkflowActivation) -> Result<()> {
+        if res.jobs.is_empty() {
+            // Nothing to do here
+            return Ok(());
+        }
+        self.activation_tx
+            .send(res.clone())
+            .expect("Workflow should not be dropped if we are still sending activations");
+        self.mgr.machines.iterate_machines().await?;
+        Ok(())
+    }
+}
+
+impl Drop for ManagedWFFunc {
+    fn drop(&mut self) {
+        // Double panics cause a SIGILL
+        if !self.was_shutdown && !std::thread::panicking() {
+            panic!("You must call `shutdown` to properly use ManagedWFFunc in tests")
+        }
+    }
+}