THIS IS A TEST INSTANCE. ALL YOUR CHANGES WILL BE LOST!!!!
...
Name | Testing Frameworks Supported | Description | Required Camel Test Dependencies |
|---|---|---|---|
|
| Provided by:
These . These base classes provide feature parity with the simple simple |
|
Plain Spring Test |
| Extend Either extend the abstract base classes (:
provided ) provided in Spring Test or use the Spring Test JUnit4 runner. These These approaches support both the Camel annotations and Spring annotations. However, but they do not NOT have feature parity with org with:
|
|
Camel Enhanced Spring Test |
| Either: Use the
| JUnit 3.x (deprecated) - JUnit 4.x - TestNG - |
CamelSpringTestSupport
The following Spring test support classes:
org.apache.camel.test.CamelSpringTestSupport
...
org.apache.camel.test.junit4.CamelSpringTestSupport, andorg.apache.camel.testng.CamelSpringTestSupport
extend CamelSpringTestSupport extend their non-Spring aware counterparts (:
org.apache.camel.test.CamelTestSupport
...
org.apache.camel.test.junit4.CamelTestSupport,
...
- and
org.apache.camel.testng.CamelTestSupport
) and deliver integration with Spring into your test classes.
Instead of instantiating the Instead of instantiating the CamelContext and routes programmatically, these classes rely on a Spring context to wire the needed components together. If your test extends one of these classes, you must provide the Spring context by implementing the following method.
...
You are responsible for the instantiation of the Spring context in the method implementation. All of the features available in the non-Spring aware counterparts from Camel Test are available in your test.
...
In this approach, your test classes directly inherit from the Spring Test abstract test classes or use the JUnit 4.x test runner provided in Spring Test. This approach supports dependency injection into your test class and the full suite of Spring Test annotations but . However, it does not support the features provided by the the CamelSpringTestSupport classes.
Plain Spring Test using JUnit 3.x with XML Config Example
Here is a simple unit test using JUnit 3.x support from Spring Test using XML Config.
...
...
Notice that we use @DirtiesContext on on the test methods to force Spring Testing to automatically reload the CamelContext after each test method - this ensures that the tests don't clash with each other (, e.g., one test method sending to an endpoint that is then reused in another test method).
Also notice the use of @ContextConfiguration to to indicate that by default we should look for the the file FilterTest-context.xml on the classpath to configure the test case which . The test context looks like this
...
:
...
This test will load a Spring XML configuration file calledFilterTestcalled FilterTest-context.xml from xml from the classpath in the same package structure as the the FilterTest class and initialize it along with any Camel routes we define inside it, then inject theCamelContextinstance the CamelContext instance into our test case.
For instance, like this maven folder layout:
...
Plain Spring Test
...
Using JUnit 4.x
...
With Java Config Example
You can completely avoid using an XML configuration file by using Spring Java Config. Here is a unit test using JUnit 4.x support from Spring Test using Java Config.
...
...
This is similar to the XML Config example above except that there is no XML file and instead the nested ContextConfig class does all of the configuration; so your entire test case is contained in a single Java class. We currently have to reference by class name this class in the @ContextConfiguration which is a bit ugly. Please vote for SJC-238 to address this and make Spring Test work more cleanly with Spring JavaConfig.
Plain Spring Test
...
Using JUnit 4.0.x Runner
...
With XML Config
You can avoid extending Spring classes by using the the SpringJUnit4ClassRunner provided by Spring Test. This custom JUnit runner means you are free to choose your own class hierarchy while retaining all the capabilities of Spring Test.
...
This is for Spring 4.0.x. If you use Spring 4.1 or newer, then see the next section.
...
...
Plain Spring Test
...
Using
...
JUnit 4.1.x Runner With XML Config
You can avoid extending Spring classes by using the SpringJUnit4ClassRunner provided by Spring Test. This custom JUnit runner means you are free to choose your own class hierarchy while retaining all the capabilities of Spring Test.
...
From Spring 4.1, you need to use the @BootstrapWith annotation to configure it to use Camel testing, as shown below.
...
Camel Enhanced Spring Test
Using the org.apache.camel.test.junit4.CamelSpringJUnit4ClassRunner runner with the @RunWith annotation or extending apache.camel.test.junit4.CamelSpringJUnit4ClassRunner runner with the @RunWith annotation or extending org.apache.camel.testng.AbstractCamelTestNGSpringContextTests provides the full feature set of Spring Test with support for the feature set provided in the the CamelTestSupport classes.
A A number of Camel specific annotations have been developed in order to provide for declarative manipulation of the Camel context(s) involved in the test. These annotations free your test classes from having to inherit from the the CamelSpringTestSupport classes and also reduce the amount of code required to customize the tests.
Annotation Class | Applies To | Description | Default Behavioir If Not Present | Default Behavior If Present | ||||
|---|---|---|---|---|---|---|---|---|
|
| Indicates if JMX should be globally disabled in the CamelContexts that are bootstrapped during the test through the use of Spring Test loaded application contexts. | JMX is disabled | JMX is disabled | ||||
|
| Indicates if certain route builder classes should be excluded from discovery. Initializes a a | Not enabled and no routes are excluded No routes are excluded and no routes are excluded | No routes are excluded | ||||
|
| Deprecated. Indicates if the CamelContexts that are bootstrapped during the test through the use of Spring Test loaded application contexts should use lazy loading of type converters. | Type converters are not lazy loaded | Type converters are not lazy loaded | ||||
| Class | Indicates if the CamelContexts that are bootstrapped during the test through the use of Spring Test loaded application contexts should use lazy loading of type converters. | Type converters are not lazy loaded |
|
| Triggers the auto-mocking of endpoints whose URIs match the provided filter. The default filter is | Not enabled | All endpoints are sniffed and recorded in a mock endpoint. Type converters are not lazy loaded |
|
| Triggers the auto-mocking of endpoints whose URIs match the provided filter. The default filter is | Not enabled | All endpoints are sniffed and recorded in a mock endpoint. The original endpoint is not invoked. | ||||
|
| Indicates that the annotated method returns an organ | N/A | The returned returned | ||||
|
| Indicates to set the shutdown timeout of all CamelContexts instantiated through the use of Spring Test loaded application contexts. If no annotation is used, the timeout is automatically reduced to 10 seconds by the test framework. | 10 seconds | 10 seconds | ||||
|
| Indicates the use of of The test author is responsible for injecting the Camel contexts into the test and executing executing | CamelContexts do not automatically start. | CamelContexts do not automatically start. | ||||
|
| Camel 2.16:Indicates that the annotated method returns a | Override properties |
The following example illustrates the use of the @MockEndpoints annotation annotation in order to setup mock endpoints as interceptors on all endpoints using the Camel Log component and the @DisableJmx annotation to enable JMX which is disabled during tests by default. Note that
...
Adding
...
More Mock
...
Expectations
If you wish to programmatically add any new assertions to your test you can easily do so with the following. Notice how we use use @EndpointInject to inject a Camel endpoint into our code then the Mock API to add an expectation on a specific message.
...
Further
...
Processing the
...
Received Messages
Sometimes once a Mock endpoint has received some messages you want to then process them further to add further assertions that your test case worked as you expect.
So you can then process the received message exchanges if you like...
...
Sending and
...
Receiving Messages
It might be that the Enterprise Integration Patterns you have defined in either Spring XML or using the Java DSL do all of the sending and receiving and you might just work with the Mock endpoints as described above. However sometimes in a test case its useful to explicitly send or receive messages directly.
To send or receive messages you should use the Bean Integration mechanism. For example to send messages inject a a ProducerTemplate using the the @EndpointInject annotation then call the various send methods on this object to send a message to an endpoint. To consume messages use the the @MessageDriven annotation on a method to have the method invoked when a message is received.
...
See Also
- A real example test case using Mock and Spring along with its Spring XML
- Bean Integration
- Mock endpoint
- Test endpoint