Struct TestExecutionOrchestrator 

pub struct TestExecutionOrchestrator<I, O>
where
    I: DeserializeOwned + Send + Serialize + 'static,
    O: Serialize + DeserializeOwned + Send + 'static,
{ /* private fields */ }

Orchestrates test execution lifecycle, polling, and handler invocation.

This struct manages the full execution lifecycle including:

• Starting executions via checkpoint API
• Polling for checkpoint updates
• Processing operation updates (waits, callbacks, retries)
• Scheduling handler re-invocations
• Resolving execution when complete

Implementations

impl<I, O> TestExecutionOrchestrator<I, O>

where I: DeserializeOwned + Send + Serialize + Clone + 'static, O: Serialize + DeserializeOwned + Send + 'static,

pub fn new<F, Fut>( handler: F, operation_storage: Arc<RwLock<OperationStorage>>, checkpoint_api: Arc<CheckpointWorkerManager>, skip_time_config: SkipTimeConfig, ) -> Self

where F: Fn(I, DurableContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<O, DurableError>> + Send + 'static,

Create a new orchestrator.

Arguments

• handler - The handler function to execute
• operation_storage - Shared storage for operations
• checkpoint_api - The checkpoint API client
• skip_time_config - Configuration for time skipping

pub fn with_handles( self, handles: Vec<OperationHandle>, shared_operations: Arc<RwLock<Vec<Operation>>>, callback_sender: Option<Arc<dyn CallbackSender>>, ) -> Self

Set the pre-registered operation handles for lazy population during execution.

Arguments

• handles - The pre-registered operation handles
• shared_operations - Shared operations list for child enumeration
• callback_sender - Callback sender for populating callback handles

pub fn is_time_skipping_enabled(&self) -> bool

Check if time skipping is enabled.

pub fn execution_id(&self) -> Option<&str>

Get the current execution ID.

pub fn checkpoint_token(&self) -> Option<&str>

Get the current checkpoint token.

pub fn is_execution_complete(&self) -> bool

Check if execution is complete.

pub fn is_invocation_active(&self) -> bool

Check if an invocation is currently active.

impl<I, O> TestExecutionOrchestrator<I, O>

where I: DeserializeOwned + Send + Serialize + Clone + 'static, O: Serialize + DeserializeOwned + Send + 'static,

pub async fn execute_handler( &mut self, payload: I, ) -> Result<TestExecutionResult<O>, TestError>

Execute the handler and return the result.

This method orchestrates the full execution lifecycle:

1. Start execution via checkpoint API
2. Begin polling for checkpoint updates
3. Invoke handler
4. Process operation updates (waits, callbacks, retries)
5. Schedule re-invocations as needed
6. Return result when execution completes

Arguments

• payload - The input payload to pass to the handler

pub fn schedule_invocation_at_timestamp( &mut self, timestamp_ms: i64, execution_id: &str, operation_id: &str, )

Schedule handler re-invocation at a specific timestamp.

This method schedules a handler re-invocation via the scheduler. When time skipping is enabled, it advances tokio time before invocation. It also updates checkpoint data (marks the operation as SUCCEEDED) before re-invoking.

Arguments

• timestamp_ms - The timestamp in milliseconds since epoch when to invoke
• execution_id - The execution ID
• operation_id - The operation ID to mark as SUCCEEDED before re-invoking

pub fn schedule_invocation_with_update( &mut self, timestamp: Option<DateTime<Utc>>, update_checkpoint: Option<CheckpointUpdateFn>, )

Schedule handler re-invocation at a specific timestamp with a custom checkpoint update.

This is a more flexible version that allows specifying a custom checkpoint update function.

Arguments

• timestamp - The timestamp when to invoke (optional, None for immediate)
• update_checkpoint - Optional function to update checkpoint data before invocation

pub fn has_scheduled_functions(&self) -> bool

Check if there are scheduled functions pending.

Returns

true if there are scheduled functions waiting to be executed.

pub async fn invoke_handler( &mut self, payload: I, execution_id: &str, is_initial: bool, ) -> Result<InvokeHandlerResult<O>, TestError>

Invoke the handler and process the result.

This method handles a single handler invocation, including:

• Checking for active invocations (prevents concurrent invocations in time-skip mode)
• Starting invocation via checkpoint API
• Invoking handler with checkpoint token and operations
• Processing handler result (PENDING, SUCCEEDED, FAILED)
• Scheduling re-invocation if dirty operations exist

Arguments

• payload - The input payload to pass to the handler
• execution_id - The execution ID
• is_initial - Whether this is the initial invocation (vs a re-invocation)

Returns

An InvokeHandlerResult indicating the outcome of the invocation.

pub fn flush_scheduled_functions(&mut self)

Flush all scheduled functions without executing them.

This is useful for cleanup when execution completes or is cancelled.

pub async fn process_next_scheduled(&mut self) -> bool

Process the next scheduled function.

Returns

true if a function was processed, false if the queue is empty.