Struct Builder

pub struct Builder<R, T, RequestState> { /* private fields */ }

Builder for creating crate::mock::Mock services and testing them with a tower_async_layer::Layer.

This generic builder is designed to make it easy to test your own tower_async_layer::Layer in a type-safe and guided manner. It achieves this by using the “Builder” pattern and a secure state flow guided by the Rust type system.

Flow

                              define another cycle
                              ┌───────┐
                              │       │
                              │       │
┌───────────────┐     ┌───────▼───────┴───────┐              ┌─────────────────────────┐
│Define         │     │Define <Response>      │              │Execute and await the    │
│<Input> Request├─────►or <Error> to send from├──────────────►test using the previously│
└───────────────┘     │within the Mock Service│              │defined flow and using   │
                      │to your Layer.         │   ┌──────────►the passed in Layer to   │
                      └──────▲─────┬──────────┘   │          │generate the service used│
                             │     │              │          │for testing.             │
                   define    │     │              │          └─────────────┬───────────┘
                   another   │     │              │                        │
                   cycle     │     │              │                        │
                       ┌─────┴─────▼──────────────┴─┐        ┌─────────────▼─────────────┐
                       │Define the expected         │        │Optionally expect the final│
                       │<Request> received by       │        │Output or Error (Result).  │
                       │the Mock Service (Optional).│        │                           │
                       └────────────────────────────┘        └───────────────────────────┘

Examples

use tower_async_test::Builder;
use tower_async_layer::Identity;

#[tokio::main]
async fn main() {
    Builder::new("ping")
        .send_response("pong")
        .expect_request("ping")
        .test(Identity::new())
        .await
        .expect_response("pong");
}

Implementations

impl<R> Builder<R, None, None>

Virgin Builder

pub fn new(request: R) -> Self

Creates a new builder with the given request.

pub fn send_response<Response>( self, response: Response, ) -> Builder<R, Vec<Test<R, Ok<Response>>>, None>

Register the sending of a (successful) response.

pub fn send_error<Error>( self, error: Error, ) -> Builder<R, Vec<Test<R, Err<Error>>>, None>

Register the sending of an error.

impl<R, Response, RequestState> Builder<R, Vec<Test<R, Ok<Response>>>, RequestState>

Ok-only test builder

pub fn send_response( self, response: Response, ) -> Builder<R, Vec<Test<R, Ok<Response>>>, None>

Register the sending of an additional (successful) response.

pub fn send_error<Error>( self, error: Error, ) -> Builder<R, Vec<Test<R, Result<Response, Error>>>, None>

Register the sending of an additional error.

impl<R, Response, RequestState> Builder<R, Vec<Test<R, Ok<Response>>>, RequestState>

where R: Send + Sync + Debug + PartialEq, Response: Send + Sync,

pub async fn test<L>( self, layer: L, ) -> ResponseTester<<<L as Layer<Mock<R, Response, Infallible>>>::Service as Service<R>>::Response, <<L as Layer<Mock<R, Response, Infallible>>>::Service as Service<R>>::Error>

where L: Layer<Mock<R, Response, Infallible>>, L::Service: Service<R>,

Test the given tower_async_layer::Layer with the previously registered tests.

Panics

Panics if there are less requests returned then there are responses+errors registered.

impl<R, Response> Builder<R, Vec<Test<R, Ok<Response>>>, None>

pub fn expect_request( self, request: R, ) -> Builder<R, Vec<Test<R, Ok<Response>>>, Defined>

Register the expectation of a request, for the same cycle as the previously added successful response.

impl<R, Error, RequestState> Builder<R, Vec<Test<R, Err<Error>>>, RequestState>

Error-only test builder

pub fn send_response<Response>( self, response: Response, ) -> Builder<R, Vec<Test<R, Result<Response, Error>>>, None>

Register the sending of an additional (successful) response.

pub fn send_error( self, error: Error, ) -> Builder<R, Vec<Test<R, Err<Error>>>, None>

Register the sending of an additional error.

impl<R, Error, RequestState> Builder<R, Vec<Test<R, Err<Error>>>, RequestState>

where R: Send + Sync + Debug + PartialEq, Error: Send + Sync,

pub async fn test<L>( self, layer: L, ) -> ResponseTester<<<L as Layer<Mock<R, (), Error>>>::Service as Service<R>>::Response, <<L as Layer<Mock<R, (), Error>>>::Service as Service<R>>::Error>

where L: Layer<Mock<R, (), Error>>, L::Service: Service<R>,

Test the given layer with the previously registered tests.

Panics

Panics if there are less requests returned then there are responses+errors registered.

impl<R, Error> Builder<R, Vec<Test<R, Err<Error>>>, None>

pub fn expect_request( self, request: R, ) -> Builder<R, Vec<Test<R, Err<Error>>>, Defined>

Register the expectation of a request, for the same cycle as the previously added error.

impl<R, Response, Error, RequestState> Builder<R, Vec<Test<R, Result<Response, Error>>>, RequestState>

Full Result (Ok+Err mix) test builder

pub fn send_response( self, response: Response, ) -> Builder<R, Vec<Test<R, Result<Response, Error>>>, None>

Register the sending of an additional (successful) response.

pub fn send_error( self, error: Error, ) -> Builder<R, Vec<Test<R, Result<Response, Error>>>, None>

Register the sending of an additional error.

impl<R, Response, Error, RequestState> Builder<R, Vec<Test<R, Result<Response, Error>>>, RequestState>

where R: Send + Sync + Debug + PartialEq, Response: Send + Sync, Error: Send + Sync,

pub async fn test<L>( self, layer: L, ) -> ResponseTester<<<L as Layer<Mock<R, Response, Error>>>::Service as Service<R>>::Response, <<L as Layer<Mock<R, Response, Error>>>::Service as Service<R>>::Error>

where L: Layer<Mock<R, Response, Error>>, L::Service: Service<R>,

Test the given layer with the previously registered tests.

Panics

Panics if there are less requests returned then there are responses+errors registered.

impl<R, Response, Error> Builder<R, Vec<Test<R, Result<Response, Error>>>, None>

pub fn expect_request( self, request: R, ) -> Builder<R, Vec<Test<R, Result<Response, Error>>>, Defined>

Register the expectation of a request, for the same cycle as the previously added result.

Trait Implementations

impl<R: Debug, T: Debug, RequestState: Debug> Debug for Builder<R, T, RequestState>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.