Struct TestProbe 

pub struct TestProbe<M: Send + 'static> { /* private fields */ }

Implementations

impl<M: Send + 'static> TestProbe<M>

pub fn new(name: &str) -> Self

pub fn actor_ref(&self) -> &ActorRef<M>

pub async fn expect_msg( &mut self, timeout: Duration, ) -> Result<M, TestProbeError>

Wait for a single message.

pub async fn expect_msg_pf<F>( &mut self, timeout: Duration, pred: F, ) -> Result<M, TestProbeError>

where F: FnMut(&M) -> bool,

Wait for a message that matches the given predicate.

pub async fn expect_no_msg( &mut self, timeout: Duration, ) -> Result<(), TestProbeError>

Assert that no message arrives within the given timeout.

pub async fn expect_msg_class<T, F>( &mut self, timeout: Duration, extract: F, ) -> Result<T, TestProbeError>

where F: FnOnce(M) -> Option<T>,

Wait for a message and assert it matches the variant returned by extract.where T selects a sub-variant of the message enum. The extract closure returns Some(payload) for the desired variant.

pub async fn receive_n( &mut self, n: usize, timeout: Duration, ) -> Result<Vec<M>, TestProbeError>

Receive exactly n messages or return TestProbeError::Timeout if timeout elapses before they all arrive.

pub async fn receive_while<F>( &mut self, timeout: Duration, pred: F, ) -> Result<Vec<M>, TestProbeError>

where F: FnMut(&M) -> bool,

Receive messages while pred returns true, stopping at the first message for which pred returns false (that message is discarded).

pub async fn fish_for_message<F>( &mut self, timeout: Duration, pred: F, ) -> Result<M, TestProbeError>

where F: FnMut(&M) -> bool,

Drain messages until one matches pred. Discards mismatches.

pub async fn expect_all_of( &mut self, timeout: Duration, expected: Vec<M>, ) -> Result<(), TestProbeError>

where M: PartialEq + Debug,

Receive expected.len() messages and assert that the multi-set of received messages equals expected (order-insensitive).

pub async fn expect_msg_eq( &mut self, timeout: Duration, expected: M, ) -> Result<M, TestProbeError>

where M: PartialEq + Debug,

Wait for a message and assert it equals expected. ExpectMsg<T>(T expected).

pub async fn expect_msg_all_of_in_order( &mut self, timeout: Duration, expected: Vec<M>, ) -> Result<(), TestProbeError>

where M: PartialEq + Debug,

Receive n messages, asserting they appear in the exact order of expected.with sequential matching semantics.