To use Camel's core test support, you need to add a dependency for the camel-test library, which provides the support classes for JUnit testing as well as a transitive dependency on JUnit itself.

Add the following code to the dependencies section of your Maven POM:

<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-test</artifactId>
  <version>${camel-version}</version>
  <scope>test</scope>
</dependency>

The Java code for this recipe is located in the org.camelcookbook.examples.testing.java package.

Let us test a simple route defined as follows:

public class SimpleTransformRouteBuilder extends RouteBuilder {
  @Override
  public void configure() throws Exception {
    from("direct:in")
      .transform(simple("Modified: ${body}"))
      .to("mock:out");
  }
}

The route consumes messages from an in-memory direct: endpoint, prepends the message body with the string Modified: and sends the result to a mock: endpoint.

To test this class, perform the following steps:

The CamelTestSupport class is a convenience base class that prepares a Camel environment for your JUnit tests, without requiring that you repeatedly perform a number of repetitive steps every time you want to test a route.

As you can see from the preceding example, all that you need to do in order to set up a test is to override a base method createRouteBuilder() , and specify which properties you would like injected. Fundamentally, the base support class will perform the following:

If you want to reproduce the preceding behavior from first principles, that is without the support class, you first define a CamelContext variable as a private member of your test:

private CamelContext camelContext;

Before each test, instantiate the context, and initialize it with the RouteBuilder class under test:

@Before
public void setUpContext() throws Exception {
  this.camelContext = new DefaultCamelContext();
  camelContext.addRoutes(new SimpleTransformRouteBuilder());
  camelContext.start();
}

After each test method, shut down the Camel context:

@After
public void cleanUpContext() throws Exception {
  camelContext.stop();
}

You then need to access the Camel context directly, through your private variable, in order to obtain handles on mock endpoints and producer template:

MockEndpoint out = 
    camelContext.getEndpoint("mock:out", MockEndpoint.class);
ProducerTemplate producerTemplate = 
    camelContext.createProducerTemplate();

This first principles approach is useful when you are testing from a framework other than JUnit or TestNG (both of which are supported by Camel), or if for some reason you need to extend a base class that itself does not extend CamelTestSupport. This approach is not used that often, as extending Camel's test support classes has proven easier and has become a best practice.

Testing routes that consume from a direct: endpoint and produce messages to mock: endpoints is easy. In real life though, your routes will be consuming from, and producing to, endpoint technologies such as CXF for SOAP services (see Chapter 12, Web Services), and ActiveMQ for messaging. How then do you go about testing that type of route?

The Reusing routing logic through template routes recipe in Chapter 1, Structuring Routes describes a technique for externalizing endpoints. This allows you to inject real endpoints when your route is deployed, and use direct: and mock: for testing when you instantiate your RouteBuilder in createRouteBuilder() method.

To do this, the previous RouteBuilder implementation should be modified as follows:

public class SimpleTransformDIRouteBuilder extends RouteBuilder {
  private String sourceUri;
  private String targetUri;

  // setters omitted

  @Override
  public void configure() throws Exception {
    from(sourceUri)
      .transform(simple("Modified: ${body}"))
      .to(targetUri);
  }
}

Then, all that is required to test the route is to inject the direct: and mock: endpoints inside the test class:

@Override
protected RouteBuilder createRouteBuilder() throws Exception {
  SimpleTransformDIRouteBuilder routeBuilder = 
    new SimpleTransformDIRouteBuilder();
  routeBuilder.setSourceUri("direct:in");
  routeBuilder.setTargetUri("mock:out");
  return routeBuilder;
}

There are further base methods within CamelTestSupport that you can override to define the details of how the Camel context will be set up. These are all prefixed with create..().

You can override the createCamelContext() method to set up the Camel context in such a way that you can test with components that are not embedded in Camel's core library (activemq:, cxf:, twitter:, leveldb:, and so on). The following example configures the ActiveMQ Component for use in your tests:

@Override
public CamelContext createCamelContext() {
  CamelContext context = new DefaultCamelContext();

  ActiveMQComponent activeMQComponent = new ActiveMQComponent();
  activeMQComponent.setBrokerURL("vm:embeddedBroker");

  context.addComponent("activemq", activeMQComponent);

  return context;
}