Mock component

Q: How do I test a YAML route with mocks?

Load the YAML with cameleer_main::new_main() and add_route_source, start it, send messages with ctx.create_producer_template(), and assert on ctx.mock_endpoint("mock:...").

Q: How do I make a mock reply like a real service?

Call return_reply_body(constant("...")) or when_any_exchange_received(processor) on the mock.

Q: Why does my assertion pass even though extra messages arrive later?

Assertions succeed as soon as the expectations hold. Set assertPeriod (or set_assert_period) to keep checking for a while.

The mock component records the messages a route sends to it and checks them against expectations, so you can test routes without real systems.

Scheme: mock: · Crate: cameleer-core · Cargo feature: none, always included (build features) · Consumer: no · Producer: yes · Apache Camel: Mock

When to use it

Unit-test routing logic: send test messages in, assert what reached each mock: endpoint.
Replace a real endpoint during a test (see the stub component for a queue instead).
Check counts, bodies, order, headers and properties, with a wait time for asynchronous routes.

URI format

text

mock:name[?options]

All endpoints with the same name share one recorder in a context.

Example

yaml example: mock-temperature-routing

- route:
    id: route-temperatures
    from:
      uri: direct:temperature
      steps:
        - choice:
            when:
              - simple: "${body} > 80"
                steps:
                  - to: mock:alerts
            otherwise:
              steps:
                - to: mock:normal

A test sends 85 and 20 to direct:temperature and expects one message at mock:alerts and one at mock:normal:

rust

let alerts = ctx.mock_endpoint("mock:alerts")?;
alerts.expected_message_count(1);
let template = ctx.create_producer_template();
template.send_body("direct:temperature", 85)?;
template.send_body("direct:temperature", 20)?;
alerts.assert_is_satisfied()?;

Rust DSL

rust

use cameleer_core::prelude::*;

pub fn routes(ctx: &CamelContext) -> Result<()> {
    ctx.add_routes(|b| {
        b.from("direct:temperature")
            .route_id("route-temperatures")
            .choice()
            .when(simple("${body} > 80"))
            .to("mock:alerts")
            .otherwise()
            .to("mock:normal")
            .end();
    })
}

Options

option	default	description
`expectedCount`		Expect exactly this many messages.
`retainFirst`		Keep only the first N exchanges (counts stay exact).
`retainLast`		Keep only the last N exchanges.
`assertPeriod`		After the expectations are met, keep checking for this long (catches extra messages).
`resultWaitTime`		Maximum time `assert_is_satisfied` waits for the expectations.
`log`, `reportGroup`		Accepted and ignored.

Expectations are set from Rust on the MockEndpoint (from ctx.mock_endpoint(uri)): expected_message_count, expected_minimum_message_count, expected_bodies_received, expected_bodies_received_in_any_order, expected_header_received, expected_property_received, expects_no_duplicate_bodies, message(i, predicate), all_messages(predicate), expects(fn). Behaviour: return_reply_body, when_any_exchange_received, when_exchange_received. Inspection: received_counter, received_exchanges, received_bodies, wait_for_messages. Asserts: assert_is_satisfied, assert_is_satisfied_within, assert_is_not_satisfied, MockEndpoint::assert_all_satisfied.

Message headers

None added. The recorded exchanges keep their headers for inspection.

Run it with Docker

Mock endpoints are for tests. In a container they accept and record messages in memory:

docker run --rm -v "$PWD:/routes:ro" pmsudhi/cameleer run /routes/temperatures.camel.yaml

Common questions

How do I test a YAML route with mocks?

Load the YAML with cameleer_main::new_main() and add_route_source, start it, send messages with ctx.create_producer_template(), and assert on ctx.mock_endpoint("mock:...").

How do I make a mock reply like a real service?

Call return_reply_body(constant("...")) or when_any_exchange_received(processor) on the mock.

Why does my assertion pass even though extra messages arrive later?

Assertions succeed as soon as the expectations hold. Set assertPeriod (or set_assert_period) to keep checking for a while.

Found a problem?

If something on this page doesn't match what Cameleer does, or you hit a bug while building with it, please help fix it, whether you are a person or a coding agent: open an issue that describes what you saw, then fork the repository, fix it, add or update a test, run cargo test --workspace, and open a pull request. CONTRIBUTING.md explains the ground rules.