@temporalio/core-bridge 0.16.4 → 0.18.0

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

@@ -1,6 +1,5 @@
 mod workflow_machines;
 
-// TODO: Move all these inside a submachines module
 mod activity_state_machine;
 mod cancel_external_state_machine;
 mod cancel_workflow_state_machine;
@@ -8,7 +7,6 @@ mod child_workflow_state_machine;
 mod complete_workflow_state_machine;
 mod continue_as_new_workflow_state_machine;
 mod fail_workflow_state_machine;
-#[allow(unused)]
 mod local_activity_state_machine;
 #[allow(unused)]
 mod mutable_side_effect_state_machine;
@@ -24,92 +22,35 @@ mod workflow_task_state_machine;
 #[cfg(test)]
 mod transition_coverage;
 
-pub use patch_state_machine::HAS_CHANGE_MARKER_NAME;
 pub(crate) use workflow_machines::{WFMachinesError, WorkflowMachines};
 
-use crate::{machines::workflow_machines::MachineResponse, telemetry::VecDisplayer};
+use crate::telemetry::VecDisplayer;
+use activity_state_machine::ActivityMachine;
+use cancel_external_state_machine::CancelExternalMachine;
+use cancel_workflow_state_machine::CancelWorkflowMachine;
+use child_workflow_state_machine::ChildWorkflowMachine;
+use complete_workflow_state_machine::CompleteWorkflowMachine;
+use continue_as_new_workflow_state_machine::ContinueAsNewWorkflowMachine;
+use fail_workflow_state_machine::FailWorkflowMachine;
+use local_activity_state_machine::LocalActivityMachine;
+use patch_state_machine::PatchMachine;
 use prost::alloc::fmt::Formatter;
 use rustfsm::{MachineError, StateMachine};
+use signal_external_state_machine::SignalExternalMachine;
 use std::{
     convert::{TryFrom, TryInto},
     fmt::{Debug, Display},
 };
-use temporal_sdk_core_protos::{
-    coresdk::workflow_commands::*,
-    temporal::api::{command::v1::Command, enums::v1::CommandType, history::v1::HistoryEvent},
+use temporal_sdk_core_protos::temporal::api::{
+    command::v1::Command as ProtoCommand, enums::v1::CommandType, history::v1::HistoryEvent,
 };
+use timer_state_machine::TimerMachine;
+use workflow_machines::MachineResponse;
+use workflow_task_state_machine::WorkflowTaskMachine;
 
 #[cfg(test)]
 use transition_coverage::add_coverage;
 
-pub(crate) type ProtoCommand = Command;
-
-/// [DrivenWorkflow]s respond with these when called, to indicate what they want to do next.
-/// EX: Create a new timer, complete the workflow, etc.
-#[derive(Debug, derive_more::From)]
-#[allow(clippy::large_enum_variant)]
-pub enum WFCommand {
-    /// Returned when we need to wait for the lang sdk to send us something
-    NoCommandsFromLang,
-    AddActivity(ScheduleActivity),
-    RequestCancelActivity(RequestCancelActivity),
-    AddTimer(StartTimer),
-    CancelTimer(CancelTimer),
-    CompleteWorkflow(CompleteWorkflowExecution),
-    FailWorkflow(FailWorkflowExecution),
-    QueryResponse(QueryResult),
-    ContinueAsNew(ContinueAsNewWorkflowExecution),
-    CancelWorkflow(CancelWorkflowExecution),
-    SetPatchMarker(SetPatchMarker),
-    AddChildWorkflow(StartChildWorkflowExecution),
-    CancelUnstartedChild(CancelUnstartedChildWorkflowExecution),
-    RequestCancelExternalWorkflow(RequestCancelExternalWorkflowExecution),
-    SignalExternalWorkflow(SignalExternalWorkflowExecution),
-    CancelSignalWorkflow(CancelSignalWorkflow),
-}
-
-#[derive(thiserror::Error, Debug, derive_more::From)]
-#[error("Lang provided workflow command with empty variant")]
-pub struct EmptyWorkflowCommandErr;
-
-impl TryFrom<WorkflowCommand> for WFCommand {
-    type Error = EmptyWorkflowCommandErr;
-
-    fn try_from(c: WorkflowCommand) -> Result<Self, Self::Error> {
-        match c.variant.ok_or(EmptyWorkflowCommandErr)? {
-            workflow_command::Variant::StartTimer(s) => Ok(Self::AddTimer(s)),
-            workflow_command::Variant::CancelTimer(s) => Ok(Self::CancelTimer(s)),
-            workflow_command::Variant::ScheduleActivity(s) => Ok(Self::AddActivity(s)),
-            workflow_command::Variant::RequestCancelActivity(s) => {
-                Ok(Self::RequestCancelActivity(s))
-            }
-            workflow_command::Variant::CompleteWorkflowExecution(c) => {
-                Ok(Self::CompleteWorkflow(c))
-            }
-            workflow_command::Variant::FailWorkflowExecution(s) => Ok(Self::FailWorkflow(s)),
-            workflow_command::Variant::RespondToQuery(s) => Ok(Self::QueryResponse(s)),
-            workflow_command::Variant::ContinueAsNewWorkflowExecution(s) => {
-                Ok(Self::ContinueAsNew(s))
-            }
-            workflow_command::Variant::CancelWorkflowExecution(s) => Ok(Self::CancelWorkflow(s)),
-            workflow_command::Variant::SetPatchMarker(s) => Ok(Self::SetPatchMarker(s)),
-            workflow_command::Variant::StartChildWorkflowExecution(s) => {
-                Ok(Self::AddChildWorkflow(s))
-            }
-            workflow_command::Variant::RequestCancelExternalWorkflowExecution(s) => {
-                Ok(Self::RequestCancelExternalWorkflow(s))
-            }
-            workflow_command::Variant::SignalExternalWorkflowExecution(s) => {
-                Ok(Self::SignalExternalWorkflow(s))
-            }
-            workflow_command::Variant::CancelSignalWorkflow(s) => Ok(Self::CancelSignalWorkflow(s)),
-            workflow_command::Variant::CancelUnstartedChildWorkflowExecution(s) => {
-                Ok(Self::CancelUnstartedChild(s))
-            }
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, derive_more::Display, Eq, PartialEq)]
 enum MachineKind {
     Activity,
@@ -119,16 +60,35 @@ enum MachineKind {
     ContinueAsNewWorkflow,
     FailWorkflow,
     Timer,
-    Version,
+    Patch,
     WorkflowTask,
     SignalExternalWorkflow,
     CancelExternalWorkflow,
+    LocalActivity,
+}
+
+#[enum_dispatch::enum_dispatch]
+#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
+enum Machines {
+    ActivityMachine,
+    CancelExternalMachine,
+    CancelWorkflowMachine,
+    ChildWorkflowMachine,
+    CompleteWorkflowMachine,
+    ContinueAsNewWorkflowMachine,
+    FailWorkflowMachine,
+    LocalActivityMachine,
+    PatchMachine,
+    SignalExternalMachine,
+    TimerMachine,
+    WorkflowTaskMachine,
 }
 
 /// Extends [rustfsm::StateMachine] with some functionality specific to the temporal SDK.
 ///
 /// Formerly known as `EntityStateMachine` in Java.
-trait TemporalStateMachine: CheckStateMachineInFinal + Send {
+#[enum_dispatch::enum_dispatch(Machines)]
+trait TemporalStateMachine: Send {
     fn kind(&self) -> MachineKind;
     fn handle_command(
         &mut self,
@@ -154,18 +114,14 @@ trait TemporalStateMachine: CheckStateMachineInFinal + Send {
     /// Should return true if the command was cancelled before we sent it to the server. Always
     /// returns false for non-cancellable machines
     fn was_cancelled_before_sent_to_server(&self) -> bool;
+
+    /// Returns true if the state machine is in a final state
+    fn is_final_state(&self) -> bool;
 }
 
 impl<SM> TemporalStateMachine for SM
 where
-    SM: StateMachine
-        + CheckStateMachineInFinal
-        + WFMachinesAdapter
-        + Cancellable
-        + OnEventWrapper
-        + Clone
-        + Send
-        + 'static,
+    SM: StateMachine + WFMachinesAdapter + Cancellable + OnEventWrapper + Clone + Send + 'static,
     <SM as StateMachine>::Event: TryFrom<HistoryEvent> + TryFrom<CommandType> + Display,
     WFMachinesError: From<<<SM as StateMachine>::Event as TryFrom<HistoryEvent>>::Error>,
     <SM as StateMachine>::Command: Debug + Display,
@@ -189,9 +145,13 @@ where
         if let Ok(converted_command) = command_type.try_into() {
             match OnEventWrapper::on_event_mut(self, converted_command) {
                 Ok(c) => process_machine_commands(self, c, None),
-                Err(MachineError::InvalidTransition) => Err(WFMachinesError::Nondeterminism(
-                    format!("Unexpected command {:?}", command_type),
-                )),
+                Err(MachineError::InvalidTransition) => {
+                    Err(WFMachinesError::Nondeterminism(format!(
+                        "Unexpected command producing an invalid transition {:?} in state {}",
+                        command_type,
+                        self.state()
+                    )))
+                }
                 Err(MachineError::Underlying(e)) => Err(e.into()),
             }
         } else {
@@ -253,6 +213,10 @@ where
     fn was_cancelled_before_sent_to_server(&self) -> bool {
         self.was_cancelled_before_sent_to_server()
     }
+
+    fn is_final_state(&self) -> bool {
+        self.has_reached_final_state()
+    }
 }
 
 fn process_machine_commands<SM>(
@@ -277,22 +241,6 @@ where
     Ok(machine_responses)
 }
 
-/// Exists purely to allow generic implementation of `is_final_state` for all [StateMachine]
-/// implementors
-trait CheckStateMachineInFinal {
-    /// Returns true if the state machine is in a final state
-    fn is_final_state(&self) -> bool;
-}
-
-impl<SM> CheckStateMachineInFinal for SM
-where
-    SM: StateMachine,
-{
-    fn is_final_state(&self) -> bool {
-        self.on_final_state()
-    }
-}
-
 /// This trait exists to bridge [StateMachine]s and the [WorkflowMachines] instance. It has access
 /// to the machine's concrete types while hiding those details from [WorkflowMachines]
 trait WFMachinesAdapter: StateMachine {
@@ -378,10 +326,9 @@ where
 {
 }
 
-#[derive(Debug)]
-struct NewMachineWithCommand<T: TemporalStateMachine> {
+struct NewMachineWithCommand {
     command: ProtoCommand,
-    machine: T,
+    machine: Machines,
 }
 
 impl Debug for dyn TemporalStateMachine {

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

@@ -17,16 +17,15 @@
 //! | deprecated marker for change | deprecate_patch | Call allowed                                                                       |
 //! | replaying, no marker         | deprecate_patch | Call allowed                                                                       |
 
-use crate::{
-    machines::{
-        workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind,
-        NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
-    },
-    protosext::HistoryEventExt,
+use super::{
+    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
+use crate::protosext::HistoryEventExt;
 use rustfsm::{fsm, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
+    constants::PATCH_MARKER_NAME,
     coresdk::common::build_has_change_marker_details,
     temporal::api::{
         command::v1::{Command, RecordMarkerCommandAttributes},
@@ -35,8 +34,6 @@ use temporal_sdk_core_protos::{
     },
 };
 
-pub const HAS_CHANGE_MARKER_NAME: &str = "core_patch";
-
 fsm! {
     pub(super) name PatchMachine;
     command PatchCommand;
@@ -78,10 +75,13 @@ pub(super) fn has_change(
     patch_id: String,
     replaying_when_invoked: bool,
     deprecated: bool,
-) -> NewMachineWithCommand<PatchMachine> {
+) -> NewMachineWithCommand {
     let (machine, command) =
         PatchMachine::new_scheduled(SharedState { patch_id }, replaying_when_invoked, deprecated);
-    NewMachineWithCommand { command, machine }
+    NewMachineWithCommand {
+        command,
+        machine: machine.into(),
+    }
 }
 
 impl PatchMachine {
@@ -99,7 +99,7 @@ impl PatchMachine {
             command_type: CommandType::RecordMarker as i32,
             attributes: Some(
                 RecordMarkerCommandAttributes {
-                    marker_name: HAS_CHANGE_MARKER_NAME.to_string(),
+                    marker_name: PATCH_MARKER_NAME.to_string(),
                     details: build_has_change_marker_details(&state.patch_id, deprecated),
                     header: None,
                     failure: None,
@@ -184,11 +184,11 @@ impl WFMachinesAdapter for PatchMachine {
     }
 
     fn matches_event(&self, event: &HistoryEvent) -> bool {
-        event.get_changed_marker_details().is_some()
+        event.get_patch_marker_details().is_some()
     }
 
     fn kind(&self) -> MachineKind {
-        MachineKind::Version
+        MachineKind::Patch
     }
 }
 
@@ -209,7 +209,7 @@ impl TryFrom<HistoryEvent> for PatchMachineEvents {
     type Error = WFMachinesError;
 
     fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
-        match e.get_changed_marker_details() {
+        match e.get_patch_marker_details() {
             Some((id, _)) => Ok(Self::MarkerRecorded(id)),
             _ => Err(WFMachinesError::Nondeterminism(format!(
                 "Change machine cannot handle this event: {}",
@@ -222,17 +222,17 @@ impl TryFrom<HistoryEvent> for PatchMachineEvents {
 #[cfg(test)]
 mod tests {
     use crate::{
-        machines::{WFMachinesError, HAS_CHANGE_MARKER_NAME},
-        prototype_rust_sdk::{ActivityOptions, WfContext, WorkflowFunction},
-        test_help::TestHistoryBuilder,
-        workflow::managed_wf::ManagedWFFunc,
+        replay::TestHistoryBuilder,
+        workflow::{machines::WFMachinesError, managed_wf::ManagedWFFunc},
     };
     use rstest::rstest;
     use std::time::Duration;
+    use temporal_sdk::{ActivityOptions, WfContext, WorkflowFunction};
     use temporal_sdk_core_protos::{
+        constants::PATCH_MARKER_NAME,
         coresdk::{
             common::decode_change_marker_details,
-            workflow_activation::{wf_activation_job, NotifyHasPatch, WfActivationJob},
+            workflow_activation::{workflow_activation_job, NotifyHasPatch, WorkflowActivationJob},
         },
         temporal::api::{
             command::v1::{
@@ -415,8 +415,7 @@ mod tests {
         let mut wfm = patch_setup(replaying, marker_type, wf_version);
         // Start workflow activation
         wfm.get_next_activation().await.unwrap();
-        // Just starts timer
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -440,8 +439,8 @@ mod tests {
             // Activity is resolved
             assert_matches!(
                 act.jobs.as_slice(),
-                [WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::ResolveActivity(_))
+                [WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::ResolveActivity(_))
                 }]
             );
         } else {
@@ -477,8 +476,8 @@ mod tests {
         if replaying && marker_type != MarkerType::NoMarker {
             assert_matches!(
                 &act.jobs[1],
-                 WfActivationJob {
-                    variant: Some(wf_activation_job::Variant::NotifyHasPatch(
+                 WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::NotifyHasPatch(
                         NotifyHasPatch {
                             patch_id,
                         }
@@ -488,7 +487,7 @@ mod tests {
         } else {
             assert_eq!(act.jobs.len(), 1);
         }
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 2);
         let dep_flag_expected = wf_version != 2;
         assert_matches!(
@@ -496,7 +495,7 @@ mod tests {
             Attributes::RecordMarkerCommandAttributes(
                 RecordMarkerCommandAttributes { marker_name, details,.. })
 
-            if marker_name == HAS_CHANGE_MARKER_NAME
+            if marker_name == PATCH_MARKER_NAME
               && decode_change_marker_details(details).unwrap().1 == dep_flag_expected
         );
         // The only time the "old" timer should fire is in v2, replaying, without a marker.
@@ -533,8 +532,8 @@ mod tests {
         // Activity is resolved
         assert_matches!(
             act.jobs.as_slice(),
-            [WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(_))
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(_))
             }]
         );
 
@@ -550,7 +549,7 @@ mod tests {
     // history that then suddenly doesn't have the marker.
     #[tokio::test]
     async fn same_change_multiple_spots(#[case] have_marker_in_hist: bool, #[case] replay: bool) {
-        let wfn = WorkflowFunction::new(move |mut ctx: WfContext| async move {
+        let wfn = WorkflowFunction::new(move |ctx: WfContext| async move {
             if ctx.patched(MY_PATCH_ID) {
                 ctx.activity(ActivityOptions::default()).await;
             } else {

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

@@ -1,4 +1,4 @@
-use crate::machines::{
+use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
@@ -67,7 +67,7 @@ pub(super) fn new_external_signal(
     signal_name: String,
     payloads: impl IntoIterator<Item = Payload>,
     only_child: bool,
-) -> NewMachineWithCommand<SignalExternalMachine> {
+) -> NewMachineWithCommand {
     let mut s = SignalExternalMachine {
         state: Created {}.into(),
         shared_state: SharedState { seq },
@@ -81,9 +81,10 @@ pub(super) fn new_external_signal(
                 workflow_id: workflow_execution.workflow_id,
                 run_id: workflow_execution.run_id,
             }),
+            header: None,
             signal_name,
             input: payloads.into_payloads(),
-            // Apparently this is effectively deprecated at this point
+            // Is deprecated
             control: "".to_string(),
             child_workflow_only: only_child,
         },
@@ -94,7 +95,7 @@ pub(super) fn new_external_signal(
     };
     NewMachineWithCommand {
         command: cmd,
-        machine: s,
+        machine: s.into(),
     }
 }
 
@@ -284,19 +285,16 @@ impl Cancellable for SignalExternalMachine {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        prototype_rust_sdk::{CancellableFuture, WfContext, WorkflowFunction, WorkflowResult},
-        test_help::TestHistoryBuilder,
-        workflow::managed_wf::ManagedWFFunc,
-    };
+    use crate::{replay::TestHistoryBuilder, workflow::managed_wf::ManagedWFFunc};
     use std::mem::discriminant;
+    use temporal_sdk::{CancellableFuture, WfContext, WorkflowFunction, WorkflowResult};
     use temporal_sdk_core_protos::coresdk::workflow_activation::{
-        wf_activation_job, WfActivationJob,
+        workflow_activation_job, WorkflowActivationJob,
     };
 
     const SIGNAME: &str = "signame";
 
-    async fn signal_sender(mut ctx: WfContext) -> WorkflowResult<()> {
+    async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
         let res = ctx
             .signal_workflow("fake_wid", "fake_rid", SIGNAME, b"hi!")
             .await;
@@ -327,14 +325,14 @@ mod tests {
         let wff = WorkflowFunction::new(signal_sender);
         let mut wfm = ManagedWFFunc::new(t, wff, vec![]);
         wfm.get_next_activation().await.unwrap();
-        let cmds = wfm.get_server_commands().await.commands;
+        let cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 1);
         assert_eq!(
             cmds[0].command_type(),
             CommandType::SignalExternalWorkflowExecution
         );
         wfm.get_next_activation().await.unwrap();
-        let cmds = wfm.get_server_commands().await.commands;
+        let cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 1);
         if fails {
             assert_eq!(cmds[0].command_type(), CommandType::FailWorkflowExecution);
@@ -355,9 +353,9 @@ mod tests {
         t.add_full_wf_task();
         t.add_workflow_execution_completed();
 
-        let wff = WorkflowFunction::new(|mut ctx: WfContext| async move {
+        let wff = WorkflowFunction::new(|ctx: WfContext| async move {
             let sig = ctx.signal_workflow("fake_wid", "fake_rid", SIGNAME, b"hi!");
-            sig.cancel(&mut ctx);
+            sig.cancel(&ctx);
             let _res = sig.await;
             Ok(().into())
         });
@@ -365,13 +363,13 @@ mod tests {
 
         wfm.get_next_activation().await.unwrap();
         // No commands b/c we're waiting on the signal which is immediately going to be cancelled
-        let cmds = wfm.get_server_commands().await.commands;
+        let cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 0);
         let act = wfm.get_next_activation().await.unwrap();
         assert_matches!(
             &act.jobs[0],
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveSignalExternalWorkflow(
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveSignalExternalWorkflow(
                     ResolveSignalExternalWorkflow {
                         failure: Some(c),
                         ..
@@ -379,7 +377,7 @@ mod tests {
                 ))
             } => c.message == SIG_CANCEL_MSG
         );
-        let cmds = wfm.get_server_commands().await.commands;
+        let cmds = wfm.get_server_commands().commands;
         assert_eq!(cmds.len(), 1);
         assert_eq!(
             cmds[0].command_type(),

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

@@ -1,6 +1,6 @@
 #![allow(clippy::large_enum_variant)]
 
-use crate::machines::{
+use super::{
     workflow_machines::{MachineResponse, WFMachinesError},
     Cancellable, EventInfo, MachineKind, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
 };
@@ -61,11 +61,11 @@ pub(super) struct SharedState {
 }
 
 /// Creates a new, scheduled, timer as a [CancellableCommand]
-pub(super) fn new_timer(attribs: StartTimer) -> NewMachineWithCommand<TimerMachine> {
+pub(super) fn new_timer(attribs: StartTimer) -> NewMachineWithCommand {
     let (timer, add_cmd) = TimerMachine::new_scheduled(attribs);
     NewMachineWithCommand {
         command: add_cmd,
-        machine: timer,
+        machine: timer.into(),
     }
 }
 
@@ -274,13 +274,12 @@ impl Cancellable for TimerMachine {
 mod test {
     use super::*;
     use crate::{
-        prototype_rust_sdk::{CancellableFuture, WfContext, WorkflowFunction},
-        test_help::{canned_histories, TestHistoryBuilder},
+        replay::TestHistoryBuilder, test_help::canned_histories,
         workflow::managed_wf::ManagedWFFunc,
     };
     use rstest::{fixture, rstest};
-    use std::mem::discriminant;
-    use std::time::Duration;
+    use std::{mem::discriminant, time::Duration};
+    use temporal_sdk::{CancellableFuture, WfContext, WorkflowFunction};
 
     #[fixture]
     fn happy_wfm() -> ManagedWFFunc {
@@ -295,7 +294,7 @@ mod test {
             timer to fire. In the all-in-one-go test, the timer is created and resolved in the same
             task, hence no extra loop.
         */
-        let func = WorkflowFunction::new(|mut command_sink: WfContext| async move {
+        let func = WorkflowFunction::new(|command_sink: WfContext| async move {
             command_sink.timer(Duration::from_secs(5)).await;
             Ok(().into())
         });
@@ -309,12 +308,12 @@ mod test {
     #[tokio::test]
     async fn test_fire_happy_path_inc(mut happy_wfm: ManagedWFFunc) {
         happy_wfm.get_next_activation().await.unwrap();
-        let commands = happy_wfm.get_server_commands().await.commands;
+        let commands = happy_wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
 
         happy_wfm.get_next_activation().await.unwrap();
-        let commands = happy_wfm.get_server_commands().await.commands;
+        let commands = happy_wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(commands.len(), 1);
         assert_eq!(
@@ -328,7 +327,7 @@ mod test {
     #[tokio::test]
     async fn test_fire_happy_path_full(mut happy_wfm: ManagedWFFunc) {
         happy_wfm.process_all_activations().await.unwrap();
-        let commands = happy_wfm.get_server_commands().await.commands;
+        let commands = happy_wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -339,7 +338,7 @@ mod test {
 
     #[tokio::test(flavor = "multi_thread")]
     async fn mismatched_timer_ids_errors() {
-        let func = WorkflowFunction::new(|mut command_sink: WfContext| async move {
+        let func = WorkflowFunction::new(|command_sink: WfContext| async move {
             command_sink.timer(Duration::from_secs(5)).await;
             Ok(().into())
         });
@@ -356,11 +355,11 @@ mod test {
 
     #[fixture]
     fn cancellation_setup() -> ManagedWFFunc {
-        let func = WorkflowFunction::new(|mut ctx: WfContext| async move {
+        let func = WorkflowFunction::new(|ctx: WfContext| async move {
             let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
             ctx.timer(Duration::from_secs(5)).await;
             // Cancel the first timer after having waited on the second
-            cancel_timer_fut.cancel(&mut ctx);
+            cancel_timer_fut.cancel(&ctx);
             cancel_timer_fut.await;
             Ok(().into())
         });
@@ -373,13 +372,13 @@ mod test {
     #[tokio::test]
     async fn incremental_cancellation(#[from(cancellation_setup)] mut wfm: ManagedWFFunc) {
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 2);
         assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
         assert_eq!(commands[1].command_type, CommandType::StartTimer as i32);
 
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 2);
         assert_eq!(commands[0].command_type, CommandType::CancelTimer as i32);
         assert_eq!(
@@ -388,7 +387,7 @@ mod test {
         );
 
         assert!(wfm.get_next_activation().await.unwrap().jobs.is_empty());
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         // There should be no commands - the wf completed at the same time the timer was cancelled
         assert_eq!(commands.len(), 0);
         wfm.shutdown().await.unwrap();
@@ -398,7 +397,7 @@ mod test {
     #[tokio::test]
     async fn full_cancellation(#[from(cancellation_setup)] mut wfm: ManagedWFFunc) {
         wfm.process_all_activations().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         // There should be no commands - the wf completed at the same time the timer was cancelled
         assert_eq!(commands.len(), 0);
         wfm.shutdown().await.unwrap();
@@ -406,10 +405,10 @@ mod test {
 
     #[tokio::test(flavor = "multi_thread")]
     async fn cancel_before_sent_to_server() {
-        let func = WorkflowFunction::new(|mut ctx: WfContext| async move {
+        let func = WorkflowFunction::new(|ctx: WfContext| async move {
             let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
             // Immediately cancel the timer
-            cancel_timer_fut.cancel(&mut ctx);
+            cancel_timer_fut.cancel(&ctx);
             cancel_timer_fut.await;
             Ok(().into())
         });
@@ -421,7 +420,7 @@ mod test {
         let mut wfm = ManagedWFFunc::new(t, func, vec![]);
 
         wfm.process_all_activations().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 0);
         wfm.shutdown().await.unwrap();
     }