Struct MockEndpointInner 

pub struct MockEndpointInner { /* private fields */ }

The actual data behind a mock endpoint. Shared across all MockEndpoint instances created with the same name via MockComponent.

Use get_received_exchanges and assert_exchange_count to inspect recorded exchanges in tests.

Implementations

impl MockEndpointInner

pub async fn get_received_exchanges(&self) -> Vec<Exchange>

Return a snapshot of all exchanges retained so far.

pub async fn received_count(&self) -> usize

Return the number of currently retained exchanges.

pub async fn reset(&self)

Clear all retained exchanges and reset internal counters.

Useful between test cases to reuse the same mock endpoint.

pub async fn assert_exchange_count(&self, expected: usize)

Assert that exactly expected exchanges have been received.

Panics

Panics if the count does not match.

pub async fn await_exchanges(&self, count: usize, timeout: Duration)

Wait until at least count exchanges have been received, or panic on timeout.

Uses tokio::sync::Notify — no polling. Returns immediately if count exchanges are already present.

Panics

Panics if timeout elapses before count exchanges arrive.

pub async fn await_exchanges_with_timeout( &self, count: usize, fallback: Duration, )

Wait for exchanges with a configurable timeout derived from assert_period_ms.

If assert_period_ms is 0, uses the provided fallback duration. Otherwise, waits for assert_period_ms milliseconds before checking.

pub fn exchange(&self, idx: usize) -> ExchangeAssert

Return an ExchangeAssert for the exchange at idx.

Panics

Panics if idx is out of bounds. Always call await_exchanges first to ensure the exchange has been received.

Panics immediately if called from a current-thread tokio runtime. Use #[tokio::test(flavor = "multi_thread")] or the async accessors [get_received_exchanges] / await_exchanges instead.

pub fn expect_count(&self, n: usize)

Set an exact count expectation: assert_satisfied panics unless the number of retained exchanges equals n.

pub fn expect_minimum_count(&self, n: usize)

Set a minimum count expectation: assert_satisfied panics unless at least n exchanges are retained.

pub fn expect_body(&self, body: Body)

Add an expected body to the expectations list.

pub fn expect_header(&self, key: &str, value: impl Into<Value>)

Add an expected header key-value pair to the expectations list.

pub fn expect_header_regex(&self, key: &str, pattern: &str)

Add an expected header regex pattern to the expectations list.

After await_exchanges(), assert_satisfied() checks whether any received exchange has the named header matching the given regex pattern.

pub async fn assert_satisfied(&self)

Assert that all registered expectations are satisfied.

Panics

Panics if an expected exchange count (exact or minimum, see expect_count and expect_minimum_count) is not met, if expected bodies do not match received bodies (in order or any order depending on any_order config), if expected headers are missing, or if header regex patterns do not match.

pub async fn try_assert_satisfied(&self) -> Result<(), MockAssertionError>

Assert that all registered expectations are satisfied without panicking.

Performs the same checks as assert_satisfied (see it for the full list) and evaluates the same fail-fast latch rules, but returns the mismatch as MockAssertionError instead of panicking.

Errors

Returns Err(MockAssertionError) when any expectation is not met or an expectation is malformed (e.g. a header regex pattern that fails to compile). Diagnostic payloads keep the error above the result_large_err size threshold (clippy allow mirrors do_try_segment.rs).

pub fn fail_fast_error(&self) -> Option<CamelError>

Return the stored fail-fast error, if any.

pub fn trigger_fail_fast(&self, error: CamelError)

Manually trip the fail-fast latch.

Sets the internal fail_fast_error to Some(error). The MockProducer treats the presence of any error here as a sentinel — the actual CamelError value is never propagated to the caller; a fixed “fail-fast mode” message is returned instead. Use this hook when a downstream component wants to short-circuit further processing on this endpoint.