Struct MockHandler 

pub struct MockHandler<R: RoleId> { /* private fields */ }

A mock handler that records operations and provides scripted responses

Implementations

impl<R: RoleId> MockHandler<R>

pub fn new(role: R) -> Self

pub fn add_response(&mut self, response: MockResponse<<R as RoleId>::Label>)

pub fn operations(&self) -> &[MockOperation<R>]

pub fn clear_operations(&mut self)

Trait Implementations

impl<R: RoleId + 'static> ChoreoHandler for MockHandler<R>

type Role = R

The role type for this choreography

type Endpoint = ()

The endpoint type maintaining connection state

fn send<'life0, 'life1, 'life2, 'async_trait, M>( &'life0 mut self, _ep: &'life1 mut Self::Endpoint, to: Self::Role, _msg: &'life2 M, ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where M: 'async_trait + Serialize + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send a message to a specific role

fn recv<'life0, 'life1, 'async_trait, M>( &'life0 mut self, _ep: &'life1 mut Self::Endpoint, from: Self::Role, ) -> Pin<Box<dyn Future<Output = ChoreoResult<M>> + Send + 'async_trait>>

where M: 'async_trait + DeserializeOwned + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Receive a strongly-typed message from a specific role

fn choose<'life0, 'life1, 'async_trait>( &'life0 mut self, _ep: &'life1 mut Self::Endpoint, at: Self::Role, label: <Self::Role as RoleId>::Label, ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Internal choice: broadcast a label selection

fn offer<'life0, 'life1, 'async_trait>( &'life0 mut self, _ep: &'life1 mut Self::Endpoint, from: Self::Role, ) -> Pin<Box<dyn Future<Output = ChoreoResult<<Self::Role as RoleId>::Label>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

External choice: receive a label selection

fn with_timeout<'life0, 'life1, 'async_trait, F, T>( &'life0 mut self, _ep: &'life1 mut Self::Endpoint, _at: Self::Role, _dur: Duration, body: F, ) -> Pin<Box<dyn Future<Output = ChoreoResult<T>> + Send + 'async_trait>>

where F: Future<Output = ChoreoResult<T>> + Send + 'async_trait, T: 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a future with a timeout

fn broadcast<'life0, 'life1, 'life2, 'life3, 'async_trait, M>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, recipients: &'life2 [Self::Role], msg: &'life3 M, ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where M: 'async_trait + Serialize + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Broadcast a message to multiple recipients

fn parallel_send<'life0, 'life1, 'life2, 'async_trait, M>( &'life0 mut self, ep: &'life1 mut Self::Endpoint, sends: &'life2 [(Self::Role, M)], ) -> Pin<Box<dyn Future<Output = ChoreoResult<()>> + Send + 'async_trait>>

where M: 'async_trait + Serialize + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send messages to multiple recipients in parallel

impl<R: RoleId> DocumentedHandlerContract for MockHandler<R>

fn contract_profile() -> HandlerContractProfile