Struct zebra_test::mock_service::ResponseSender

pub struct ResponseSender<Request, Response, Error> {
    request: Request,
    response_sender: Sender<Result<Response, Error>>,
}

A helper type for responding to incoming requests.

An instance of this type is created for each request received by the MockService. It contains the received request and a [oneshot::Sender] that can be used to respond to the request.

If a response is not sent, the channel is closed and a [BoxError] is returned by the service to the caller that sent the request.

Fields

request: Request

response_sender: Sender<Result<Response, Error>>

Implementations

impl<Request, Response, Error> ResponseSender<Request, Response, Error>

fn new(request: Request) -> (Self, Receiver<Result<Response, Error>>)

Create a ResponseSender for a given request.

pub fn request(&self) -> &Request

Access the request that’s awaiting a response.

pub fn respond(self, response: impl ResponseResult<Response, Error>)

Respond to the request using a fixed response value.

The response can be of the Response type or a Result. This allows sending an error representing an error while processing the request.

This method takes ownership of the ResponseSender so that only one response can be sent.

Panics

If one of the respond* methods isn’t called, the MockService might panic with a timeout error.

Example

// Mock a service with a `String` as the service `Error` type.
let mut mock_service: MockService<_, _, _, String> =
    MockService::build().for_unit_tests();

mock_service
    .expect_request(Request)
    .await
    .respond("Received Request".to_owned());

mock_service
    .expect_request(Request)
    .await
    .respond(Err("Duplicate request"));

pub fn respond_with<F, R>(self, response_fn: F)

where F: FnOnce(&Request) -> R, R: ResponseResult<Response, Error>,

Respond to the request by calculating a value from the request.

The response can be of the Response type or a Result. This allows sending an error representing an error while processing the request.

This method takes ownership of the ResponseSender so that only one response can be sent.

Panics

If one of the respond* methods isn’t called, the MockService might panic with a timeout error.

Example

// Mock a service with a `String` as the service `Error` type.
let mut mock_service: MockService<_, _, _, String> =
    MockService::build().for_unit_tests();

mock_service
    .expect_request(Request)
    .await
    .respond_with(|req| format!("Received: {req:?}"));

mock_service
    .expect_request(Request)
    .await
    .respond_with(|req| Err(format!("Duplicate request: {req:?}")));

pub fn respond_error(self, error: Error)

Respond to the request using a fixed error value.

The error must be the Error type. This helps avoid type resolution issues in the compiler.

This method takes ownership of the ResponseSender so that only one response can be sent.

Panics

If one of the respond* methods isn’t called, the MockService might panic with a timeout error.

Example

// Mock a service with a `String` as the service `Error` type.
let mut mock_service: MockService<Request, Response, _, String> =
    MockService::build().for_unit_tests();

mock_service
    .expect_request(Request)
    .await
    .respond_error("Duplicate request".to_string());

pub fn respond_with_error<F>(self, response_fn: F)

where F: FnOnce(&Request) -> Error,

Respond to the request by calculating an error from the request.

The error must be the Error type. This helps avoid type resolution issues in the compiler.

This method takes ownership of the ResponseSender so that only one response can be sent.

Panics

If one of the respond* methods isn’t called, the MockService might panic with a timeout error.

Example

// Mock a service with a `String` as the service `Error` type.
let mut mock_service: MockService<Request, Response, _, String> =
    MockService::build().for_unit_tests();

mock_service
    .expect_request(Request)
    .await
    .respond_with_error(|req| format!("Duplicate request: {req:?}"));