Struct Driver 

pub struct Driver<'cluster> {
    runner: ClusterRunner<'cluster>,
    emulated_time: bool,
}

Fields

runner: ClusterRunner<'cluster>

emulated_time: bool

Implementations

impl<'cluster> Driver<'cluster>

pub fn new(runner: ClusterRunner<'cluster>) -> Self

pub fn with_emulated_time(runner: ClusterRunner<'cluster>) -> Self

async fn sleep(&self, duration: Duration)

pub async fn wait_for( &mut self, duration: Duration, f: impl FnMut(ClusterNodeId, &Event, &State) -> bool, ) -> Result<Option<(ClusterNodeId, Event)>>

Waits for a specific event that satisfies the given predicate, executing all events encountered along the way.

Arguments

• duration - Maximum time to wait for the event
• f - A predicate function that takes a node ID, event, and state, returning true when the desired event is found

Returns

Returns a Result containing:

• Some((node_id, event)) - If an event satisfying the predicate is found before the timeout
• None - If no matching event is found within the timeout period

Example

driver.wait_for(Duration::from_secs(5), |node_id, event, state| {
    matches!(event, Event::BlockReceived { .. })
}).await?;

pub async fn run_until( &mut self, duration: Duration, f: impl FnMut(ClusterNodeId, &Event, &State) -> bool, ) -> Result<bool>

pub async fn exec_steps_until( &mut self, duration: Duration, f: impl FnMut(ClusterNodeId, &Event, &State) -> bool, ) -> Result<bool>

Executes all events as steps, until the predicate f reports true. The predicate is checked each time after executing an event step.

pub fn next_event(&mut self) -> Option<(ClusterNodeId, Event)>

pub async fn trace_steps(&mut self) -> Result<()>

pub async fn run(&mut self, duration: Duration) -> Result<()>

pub async fn idle(&mut self, duration: Duration) -> Result<()>

pub async fn exec_step(&mut self, step: ScenarioStep) -> Result<bool>

pub async fn exec_even_step( &mut self, __arg1: (ClusterNodeId, Event), ) -> Result<Option<&State>>

pub fn add_rust_node( &mut self, testing_config: RustNodeTestingConfig, ) -> (ClusterNodeId, PeerId)

pub fn add_rust_node_with<Item, F>( &mut self, testing_config: RustNodeTestingConfig, f: F, ) -> (ClusterNodeId, Item)

where F: FnMut(&State) -> Item,

pub fn inner(&self) -> &ClusterRunner<'_>

pub fn inner_mut(&mut self) -> &mut ClusterRunner<'cluster>

pub fn into_inner(self) -> ClusterRunner<'cluster>