Struct RuleBuilder 

pub struct RuleBuilder<I, O, E> { /* private fields */ }

A builder for creating rules.

This builder provides a fluent API for creating rules with different response types.

Implementations

impl<I, O, E> RuleBuilder<I, O, E>

where I: Debug + Send + Sync + 'static, O: Debug + Send + Sync + 'static, E: Debug + Send + Sync + Error + 'static,

pub fn match_requests<F>(self, filter: F) -> Self

where F: Fn(&I) -> bool + Send + Sync + 'static,

Sets the function that determines if this rule matches a request.

pub fn sequence(self) -> ResponseSequenceBuilder<I, O, E>

Start building a response sequence

A sequence allows a single rule to generate multiple responses which can be used to test retry behavior.

Examples

With repetition using times():

let rule = mock!(Client::get_object)
    .sequence()
    .http_status(503, None)
    .times(2)                                        // First two calls return 503
    .output(|| GetObjectOutput::builder().build())   // Third call succeeds
    .build();

pub fn then_output<F>(self, output_fn: F) -> Rule

where F: Fn() -> O + Send + Sync + 'static,

Creates a rule that returns a modeled output.

pub fn then_error<F>(self, error_fn: F) -> Rule

where F: Fn() -> E + Send + Sync + 'static,

Creates a rule that returns a modeled error.

pub fn then_http_response<F>(self, response_fn: F) -> Rule

where F: Fn() -> HttpResponse + Send + Sync + 'static,

Creates a rule that returns an HTTP response.

pub fn then_compute_output<F>(self, compute_fn: F) -> Rule

where F: Fn(&I) -> O + Send + Sync + 'static,

Creates a rule that computes an output based on the input.

This allows generating responses based on the input request.

Examples

let rule = mock!(Client::get_object)
    .compute_output(|req| {
        GetObjectOutput::builder()
            .body(ByteStream::from_static(format!("content for {}", req.key().unwrap_or("unknown")).as_bytes()))
            .build()
    })
    .build();

pub fn then_compute_response<F>(self, compute_fn: F) -> Rule

where F: Fn(&I) -> MockResponse<O, E> + Send + Sync + 'static,

Creates a rule that computes an arbitrary response based on the input.

This allows generating any type of response (output, error, or HTTP) based on the input request. Unlike then_compute_output, this method can return errors or HTTP responses conditionally.

Examples

let rule = mock!(Client::get_object)
    .then_compute_response(|req| {
        if req.key() == Some("error") {
            MockResponse::Error(GetObjectError::NoSuchKey(NoSuchKey::builder().build()))
        } else {
            MockResponse::Output(GetObjectOutput::builder()
                .body(ByteStream::from_static(b"content"))
                .build())
        }
    })
    .build();