1. Overview
Apache Camel is a powerful open-source integration framework implementing a number of the known Enterprise Integration Patterns.
In this tutorial, we’ll learn how to write reliable, self-contained unit tests for our Camel routes.
First, we’ll start by creating a basic Camel application using Spring Boot. Then we’ll take a look at how we can use Camel’s Spring test support API with JUnit 5 to test our application.
2. Dependencies
Assuming we have our project setup and configured to work with Spring Boot and Camel.
Then, we’ll need to add the camel-test-spring-junit5 dependency to our pom.xml:
<dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-test-spring-junit5</artifactId>
<version>4.3.0</version>
<scope>test</scope>
</dependency>
As the name suggests, this dependency is specifically for our unit tests.
3. Defining a Simple Camel Spring Boot Application
Throughout this tutorial, the focus of our tests will be a simple Apache Camel Spring Boot application.
So let’s start by defining our application entry point:
@SpringBootApplication
public class GreetingsFileSpringApplication {
public static void main(String[] args) {
SpringApplication.run(GreetingsFileSpringApplication.class, args);
}
}
As we can see, this is a standard Spring Boot application.
3.1. Creating a Route
Next, we’ll define a fairly elementary route:
@Component
public class GreetingsFileRouter extends RouteBuilder {
@Override
public void configure() throws Exception {
from("direct:start")
.routeId("greetings-route")
.setBody(constant("Hello Baeldung Readers!"))
.to("file:output");
}
}
To quickly recap, a route in Apache Camel is a fundamental building block, normally formed of a sequence of steps, executed in order by Camel, that consumes and processes a message.
As we can see in our trivial example, we configure our route to consume messages from a direct endpoint called start.
Then, we set the message body to contain a string Hello Baeldung Readers! and write the contents of our message exchange using the file component to a file directory called output.
We also give our route an id called greetings-route. Using ids in our routes is generally considered good practice and can help us when we come to test our routes.
3.2. Running Our Application
To conclude this section, if we run our application and send a message to our direct consumer endpoint, we should see our greetings text inside a file in our output directory. If we don’t specify a filename, Camel will create one for us:
$ cat output/D97099B6B2958D2-0000000000000000
Hello Baeldung Readers!
4. A Word on Testing
In general, when writing clean tests, we shouldn’t depend on external services or filesystems that we might not be able to control or might suddenly stop working. This could have adverse effects on our test results.
We also don’t want to write code in our routes specifically for our unit tests. Thankfully Camel has a set of extensions and APIs specifically for testing. So we can think of this as a kind of testing kit.
The kit makes it easier to test our Camel applications by sending messages to routes and checking that messages are received as expected.
5. Testing Using @MockEndpoints
With the last section in mind, let’s go ahead and write our first unit test:
@SpringBootTest
@CamelSpringBootTest
@MockEndpoints("file:output")
class GreetingsFileRouterUnitTest {
@Autowired
private ProducerTemplate template;
@EndpointInject("mock:file:output")
private MockEndpoint mock;
@Test
void whenSendBody_thenGreetingReceivedSuccessfully() throws InterruptedException {
mock.expectedBodiesReceived("Hello Baeldung Readers!");
template.sendBody("direct:start", null);
mock.assertIsSatisfied();
}
}
Let’s walk through the key parts of our test.
First, we start by decorating our test class with three annotations:
- The @SpringBootTest annotation will ensure that our test bootstraps the Spring application context
- We also use the @CamelSpringBootRunner, which brings Spring-based Camel test support to our Boot based tests
- Finally, we add the @MockEndpoints annotation, which tells Camel which endpoints we want to make mocks for
Next, we autowire a ProducerTemplate object, which is an interface that allows us to send message exchanges to endpoints.
Another key component is the MockEndpoint that we inject using @EndpointInject. Using this annotation tells Camel when the route starts, we want to inject our mock endpoint.
Now that we have all of our test setups in place, we can write our test, which consists of three steps:
- First, lets set an expectation that our mock endpoint will receive the given message body
- Then we’ll send a message to our direct:start endpoint using our template. Note, we’ll send a null body as our route doesn’t manipulate the incoming message body
- To conclude our test, we use the assertIsSatisfied method to validate that our initial expectation on our mock endpoint has been satisfied
This confirms that our test is working correctly. Awesome! We now have a way to write self-contained, independent unit tests using Camel test support utilities.
6. Conclusion
In this article, we learned how to test our Apache Camel routes in Spring Boot. First, we’ve learned how to create a simple Camel application with one route using Spring Boot.
Then learned about the recommended approach for testing our routes using some of the features available to us in Apache Camel’s built-in test support project.
As always, the full source code of the article is available over on GitHub.
