Struct Expectation 

pub struct Expectation {

    pub id: Option<String>,
    pub priority: Option<i32>,
    pub http_request: HttpRequest,
    pub http_response: Option<HttpResponse>,
    pub http_forward: Option<HttpForward>,
    pub http_response_template: Option<HttpTemplate>,
    pub http_forward_template: Option<HttpTemplate>,
    pub http_error: Option<HttpError>,
    pub http_response_class_callback: Option<HttpClassCallback>,
    pub http_forward_class_callback: Option<HttpClassCallback>,
    pub http_response_object_callback: Option<HttpObjectCallback>,
    pub http_forward_object_callback: Option<HttpObjectCallback>,
    pub http_sse_response: Option<HttpSseResponse>,
    pub http_web_socket_response: Option<HttpWebSocketResponse>,
    pub dns_response: Option<DnsResponse>,
    pub binary_response: Option<BinaryResponse>,
    pub grpc_stream_response: Option<GrpcStreamResponse>,
    pub times: Option<Times>,
    pub time_to_live: Option<TimeToLive>,
    pub scenario_name: Option<String>,
    pub scenario_state: Option<String>,
    pub new_scenario_state: Option<String>,
    pub http_responses: Option<Vec<HttpResponse>>,
    pub response_mode: Option<ResponseMode>,
    pub response_weights: Option<Vec<i32>>,
    pub switch_after: Option<i32>,
    pub cross_protocol_scenarios: Option<Vec<CrossProtocolScenario>>,
}

A full expectation combining a request matcher with an action.

Fields

id: Option<String>

priority: Option<i32>

http_request: HttpRequest

http_response: Option<HttpResponse>

http_forward: Option<HttpForward>

http_response_template: Option<HttpTemplate>

http_forward_template: Option<HttpTemplate>

http_error: Option<HttpError>

http_response_class_callback: Option<HttpClassCallback>

Class callback that produces the response (serialized as httpResponseClassCallback).

http_forward_class_callback: Option<HttpClassCallback>

Class callback that produces the request to forward (serialized as httpForwardClassCallback).

http_response_object_callback: Option<HttpObjectCallback>

Object/closure callback that produces the response (serialized as httpResponseObjectCallback).

http_forward_object_callback: Option<HttpObjectCallback>

Object/closure callback that produces the request to forward (serialized as httpForwardObjectCallback).

http_sse_response: Option<HttpSseResponse>

http_web_socket_response: Option<HttpWebSocketResponse>

dns_response: Option<DnsResponse>

binary_response: Option<BinaryResponse>

grpc_stream_response: Option<GrpcStreamResponse>

times: Option<Times>

time_to_live: Option<TimeToLive>

scenario_name: Option<String>

Name of the state-machine this expectation participates in.

scenario_state: Option<String>

State the scenario must be in for this expectation to match.

new_scenario_state: Option<String>

State the scenario transitions to after this expectation matches.

http_responses: Option<Vec<HttpResponse>>

Multiple responses; takes priority over the singular Expectation::http_response.

response_mode: Option<ResponseMode>

How a response is selected from Expectation::http_responses.

response_weights: Option<Vec<i32>>

Index-aligned relative weights for ResponseMode::Weighted.

switch_after: Option<i32>

Requests per response block before advancing under ResponseMode::Switch (default 1).

cross_protocol_scenarios: Option<Vec<CrossProtocolScenario>>

Cross-protocol scenario correlations that advance scenario state on protocol events.

Implementations

impl Expectation

pub fn new(request: HttpRequest) -> Self

Create a new expectation with the given request matcher.

pub fn id(self, id: impl Into<String>) -> Self

Set the expectation ID (for upsert semantics).

pub fn priority(self, priority: i32) -> Self

Set the priority (higher = matched first).

pub fn respond(self, response: HttpResponse) -> Self

Set a response action.

pub fn forward(self, forward: HttpForward) -> Self

Set a forward action.

pub fn respond_template(self, template: HttpTemplate) -> Self

Set a response template action.

pub fn forward_template(self, template: HttpTemplate) -> Self

Set a forward template action.

pub fn error(self, error: HttpError) -> Self

Set an error action.

pub fn respond_with_class_callback( self, callback_class: impl Into<String>, ) -> Self

Respond via a server-side class callback (httpResponseClassCallback).

The named class must implement MockServer’s callback interface and be on the server’s classpath. Convenience over building an HttpClassCallback directly; use respond_class_callback for the full builder (delay, primary).

pub fn respond_class_callback(self, callback: HttpClassCallback) -> Self

Respond via a pre-built HttpClassCallback (httpResponseClassCallback).

pub fn forward_with_class_callback( self, callback_class: impl Into<String>, ) -> Self

Forward via a server-side class callback (httpForwardClassCallback).

pub fn forward_class_callback(self, callback: HttpClassCallback) -> Self

Forward via a pre-built HttpClassCallback (httpForwardClassCallback).

pub fn respond_object_callback(self, callback: HttpObjectCallback) -> Self

Respond via an object/closure callback (httpResponseObjectCallback).

Most users should call MockServerClient::mock_with_callback instead, which opens the callback WebSocket, registers the closure, and fills in the client_id automatically.

pub fn forward_object_callback(self, callback: HttpObjectCallback) -> Self

Forward via an object/closure callback (httpForwardObjectCallback).

pub fn respond_sse(self, sse: HttpSseResponse) -> Self

Set a Server-Sent Events (SSE) response action.

pub fn respond_web_socket(self, ws: HttpWebSocketResponse) -> Self

Set a WebSocket response action.

pub fn respond_dns(self, dns: DnsResponse) -> Self

Set a DNS response action.

pub fn respond_binary(self, binary: BinaryResponse) -> Self

Set a raw binary response action.

pub fn respond_grpc_stream(self, grpc: GrpcStreamResponse) -> Self

Set a gRPC streaming response action.

pub fn times(self, times: Times) -> Self

Set the number of times this expectation matches.

pub fn time_to_live(self, ttl: TimeToLive) -> Self

Set the time-to-live.

pub fn scenario_name(self, name: impl Into<String>) -> Self

Set the scenario (state-machine) name this expectation participates in.

pub fn scenario_state(self, state: impl Into<String>) -> Self

Set the state the scenario must be in for this expectation to match.

pub fn new_scenario_state(self, state: impl Into<String>) -> Self

Set the state the scenario transitions to after this expectation matches.

pub fn respond_with(self, response: HttpResponse) -> Self

Append a response to the multiple-responses list (http_responses).

When set, http_responses takes priority over the singular respond action.

pub fn http_responses(self, responses: Vec<HttpResponse>) -> Self

Replace all multiple responses (http_responses).

pub fn response_mode(self, mode: ResponseMode) -> Self

Set how a response is selected from http_responses.

pub fn response_weights(self, weights: Vec<i32>) -> Self

Set the index-aligned relative weights for ResponseMode::Weighted.

pub fn switch_after(self, switch_after: i32) -> Self

Set the number of requests per response block before advancing under ResponseMode::Switch.

pub fn cross_protocol_scenario(self, scenario: CrossProtocolScenario) -> Self

Append a CrossProtocolScenario correlation.

pub fn cross_protocol_scenarios( self, scenarios: Vec<CrossProtocolScenario>, ) -> Self

Replace all cross-protocol scenario correlations.

Trait Implementations

impl Clone for Expectation

fn clone(&self) -> Expectation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expectation

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

Formats the value using the given formatter.

impl Default for Expectation

fn default() -> Expectation

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Expectation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expectation

fn eq(&self, other: &Expectation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Expectation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expectation