@Test
public void testSendMessage() throws Exception {
MockEndpoint finish = consumerContext.getEndpoint("mock:finish", MockEndpoint.class);
finish.whenAnyExchangeReceived(
new Processor() {
@Override
public void process(Exchange exchange) throws Exception {
throw new RuntimeException("TestException!!!");
}
});
finish.expectedMessageCount(4);
MockEndpoint consumerException =
consumerContext.getEndpoint("mock:exception", MockEndpoint.class);
consumerException.expectedMessageCount(0);
MockEndpoint producerException =
producerContext.getEndpoint("mock:exception", MockEndpoint.class);
producerException.expectedBodiesReceived("1234567890");
ProducerTemplate producerTemplate = producerContext.createProducerTemplate();
try {
producerTemplate.sendBody("direct:start", "1234567890");
fail("CamelExecutionException expected");
} catch (CamelExecutionException e) {
assertEquals("TestException!!!", e.getCause().getMessage());
}
MockEndpoint.assertIsSatisfied(consumerContext);
MockEndpoint.assertIsSatisfied(producerContext);
}
@Test
public void testBlueprintProperties() throws Exception {
// start bundle
getInstalledBundle(name).start();
// must use the camel context from osgi
CamelContext ctx =
getOsgiService(CamelContext.class, "(camel.context.symbolicname=" + name + ")", 10000);
ProducerTemplate myTemplate = ctx.createProducerTemplate();
myTemplate.start();
// do our testing
MockEndpoint foo = ctx.getEndpoint("mock:foo", MockEndpoint.class);
foo.expectedMessageCount(1);
MockEndpoint result = ctx.getEndpoint("mock:result", MockEndpoint.class);
result.expectedMessageCount(1);
myTemplate.sendBody("direct:start", "Hello World");
foo.assertIsSatisfied();
result.assertIsSatisfied();
myTemplate.stop();
}
public void testSplitterWithException() throws Exception {
MockEndpoint resultEndpoint = getMockEndpoint("mock:result");
resultEndpoint.expectedMessageCount(4);
resultEndpoint.expectedHeaderReceived("foo", "bar");
MockEndpoint failedEndpoint = getMockEndpoint("mock:failed");
failedEndpoint.expectedMessageCount(1);
failedEndpoint.expectedHeaderReceived("foo", "bar");
Exchange result =
template.request(
"direct:exception",
new Processor() {
public void process(Exchange exchange) {
Message in = exchange.getIn();
in.setBody("James,Guillaume,Hiram,Rob,Exception");
in.setHeader("foo", "bar");
}
});
assertTrue(
"The result exchange should have a camel exception",
result.getException() instanceof CamelException);
assertMockEndpointsSatisfied();
}
@Test
public void testScheduledStartRoutePolicyWithTwoRoutes() throws Exception {
MockEndpoint success1 = context.getEndpoint("mock:success1", MockEndpoint.class);
MockEndpoint success2 = context.getEndpoint("mock:success2", MockEndpoint.class);
success1.expectedMessageCount(1);
success2.expectedMessageCount(1);
context
.getComponent("quartz2", QuartzComponent.class)
.setPropertiesFile("org/apache/camel/routepolicy/quartz2/myquartz.properties");
context.addRoutes(
new RouteBuilder() {
public void configure() {
CronScheduledRoutePolicy policy = new CronScheduledRoutePolicy();
policy.setRouteStartTime("*/3 * * * * ?");
from("direct:start1").routeId("test1").routePolicy(policy).to("mock:success1");
from("direct:start2").routeId("test2").routePolicy(policy).to("mock:success2");
}
});
context.start();
context.stopRoute("test1", 1000, TimeUnit.MILLISECONDS);
context.stopRoute("test2", 1000, TimeUnit.MILLISECONDS);
Thread.sleep(5000);
assertTrue(context.getRouteStatus("test1") == ServiceStatus.Started);
assertTrue(context.getRouteStatus("test2") == ServiceStatus.Started);
template.sendBody("direct:start1", "Ready or not, Here, I come");
template.sendBody("direct:start2", "Ready or not, Here, I come");
success1.assertIsSatisfied();
success2.assertIsSatisfied();
}
@Test
public void pipelineCompletes() {
end.expectedMessageCount(1);
after.expectedMessageCount(1);
producer.sendBody(3);
assertEquals(1, table.values().size());
assertEquals(3, (int) table.iterator().next());
}
@Test
public void testTransaction() throws InterruptedException {
// Assertions
deletedEndpoint.expectedMessageCount(8);
deletedEndpoint.expectedHeaderReceived(Exchange.HTTP_RESPONSE_CODE, 204);
transactedEndpoint.expectedMessageCount(1);
verifiedEndpoint.expectedMessageCount(3);
midtransactionEndpoint.expectedMessageCount(3);
midtransactionEndpoint.expectedHeaderReceived(Exchange.HTTP_RESPONSE_CODE, 201);
notfoundEndpoint.expectedMessageCount(6);
notfoundEndpoint.expectedHeaderReceived(Exchange.HTTP_RESPONSE_CODE, 404);
// Start the transaction
final Map<String, Object> headers = new HashMap<>();
headers.put(Exchange.HTTP_METHOD, "POST");
headers.put(Exchange.CONTENT_TYPE, "text/turtle");
// Create the object
final String fullPath =
template.requestBodyAndHeaders(
"direct:create", FcrepoTestUtils.getTurtleDocument(), headers, String.class);
assertNotNull(fullPath);
final String identifier = fullPath.replaceAll(FcrepoTestUtils.getFcrepoBaseUrl(), "");
// Test the creation of several objects
template.sendBodyAndHeader("direct:transact", null, "TestIdentifierBase", identifier);
// Test the object
template.sendBodyAndHeader(
"direct:verify", null, FcrepoHeaders.FCREPO_IDENTIFIER, identifier + "/one");
template.sendBodyAndHeader(
"direct:verify", null, FcrepoHeaders.FCREPO_IDENTIFIER, identifier + "/two");
template.sendBodyAndHeader(
"direct:verify", null, FcrepoHeaders.FCREPO_IDENTIFIER, identifier + "/three");
// Teardown
template.sendBodyAndHeader(
"direct:teardown", null, FcrepoHeaders.FCREPO_IDENTIFIER, identifier + "/one");
template.sendBodyAndHeader(
"direct:teardown", null, FcrepoHeaders.FCREPO_IDENTIFIER, identifier + "/two");
template.sendBodyAndHeader(
"direct:teardown", null, FcrepoHeaders.FCREPO_IDENTIFIER, identifier + "/three");
template.sendBodyAndHeader(
"direct:teardown", null, FcrepoHeaders.FCREPO_IDENTIFIER, identifier);
// Confirm assertions
verifiedEndpoint.assertIsSatisfied();
deletedEndpoint.assertIsSatisfied();
transactedEndpoint.assertIsSatisfied();
notfoundEndpoint.assertIsSatisfied();
midtransactionEndpoint.assertIsSatisfied();
}
@Test
public void testFunctions() throws Exception {
raleighEndpoint.expectedMessageCount(1);
tampaEndpoint.expectedMessageCount(0);
template.sendBody("direct:start", "<person name='Hadrian' city='Raleigh'/>");
assertMockEndpointsSatisfied();
}
public void testValidMessage() throws Exception {
validEndpoint.expectedMessageCount(1);
invalidEndpoint.expectedMessageCount(0);
Object result = template.requestBodyAndHeader("direct:start", "<valid/>", "foo", "bar");
assertEquals("validResult", result);
assertMockEndpointsSatisfied();
}
@Test
public void testIdempotent() throws Exception {
String uri = "file:target/test-classes/idempotent?idempotent=true&delay=10";
context
.getRouteDefinitions()
.get(1)
.adviceWith(
context,
new AdviceWithRouteBuilder() {
@Override
public void configure() throws Exception {
replaceFromWith(uri);
weaveByType(ToDefinition.class).selectFirst().replace().to("mock:endpoint");
}
});
MockEndpoint end = context.getEndpoint("mock:endpoint", MockEndpoint.class);
end.expectedMessageCount(1);
producer.sendBodyAndHeader(
"file://target/test-classes/idempotent", Exchange.FILE_NAME, "FCOO1.nc");
end.assertIsSatisfied();
String fileName =
(String) end.getReceivedExchanges().get(0).getIn().getHeader(Exchange.FILE_NAME_ONLY);
assertEquals(fileName, "FCOO1.nc");
// reset the mock
end.reset();
end.expectedMessageCount(0);
// move file back
File file = new File("target/test-classes/idempotent/.camel/FCOO1.nc");
File renamed = new File("target/test-classes/idempotent/FCOO1.nc");
file.renameTo(renamed);
producer.sendBodyAndHeader(
"file://target/test-classes/idempotent", Exchange.FILE_NAME, "FCOO1.nc");
// let some time pass to let the consumer try to consume even though it cannot
Thread.sleep(100);
end.assertIsSatisfied();
FileEndpoint fe = context.getEndpoint(uri, FileEndpoint.class);
assertNotNull(fe);
// Make sure that there are no incoming messages
MemoryIdempotentRepository repo = (MemoryIdempotentRepository) fe.getInProgressRepository();
assertEquals("Should be no in-progress files", 0, repo.getCacheSize());
}
@Test
public void testSqlIdempotentConsumer() throws Exception {
Assert.assertNotNull("DataSource not null", dataSource);
final JdbcMessageIdRepository jdbcMessageIdRepository =
new JdbcMessageIdRepository(dataSource, "myProcessorName");
CamelContext camelctx = new DefaultCamelContext();
camelctx.addRoutes(
new RouteBuilder() {
@Override
public void configure() throws Exception {
from("direct:start")
.idempotentConsumer(simple("${header.messageId}"), jdbcMessageIdRepository)
.to("mock:result");
}
});
camelctx.start();
try {
MockEndpoint mockEndpoint = camelctx.getEndpoint("mock:result", MockEndpoint.class);
mockEndpoint.expectedMessageCount(1);
// Send 5 messages with the same messageId header. Only 1 should be forwarded to the
// mock:result endpoint
ProducerTemplate template = camelctx.createProducerTemplate();
for (int i = 0; i < 5; i++) {
template.requestBodyAndHeader("direct:start", null, "messageId", "12345");
}
mockEndpoint.assertIsSatisfied();
} finally {
camelctx.stop();
}
}
@Test
public void sendLongSubmitSM() throws Exception {
result.expectedMessageCount(2);
Exchange exchange = start.createExchange(ExchangePattern.InOnly);
exchange
.getIn()
.setBody(
"Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! "
+ "Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! "
+ "Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! Hello SMPP World! "); // 270 chars
template.send(start, exchange);
assertMockEndpointsSatisfied();
assertEquals(
SmppMessageType.DeliveryReceipt.toString(),
result.getExchanges().get(0).getIn().getHeader(SmppConstants.MESSAGE_TYPE));
assertEquals(
SmppMessageType.DeliveryReceipt.toString(),
result.getExchanges().get(1).getIn().getHeader(SmppConstants.MESSAGE_TYPE));
assertNotNull(exchange.getIn().getHeader(SmppConstants.ID));
assertEquals(2, exchange.getIn().getHeader(SmppConstants.SENT_MESSAGE_COUNT));
}
@Test
public void testScheduledResumeRoutePolicy() throws Exception {
MockEndpoint success = context.getEndpoint("mock:success", MockEndpoint.class);
success.expectedMessageCount(1);
context
.getComponent("quartz2", QuartzComponent.class)
.setPropertiesFile("org/apache/camel/routepolicy/quartz2/myquartz.properties");
context.addRoutes(
new RouteBuilder() {
public void configure() {
CronScheduledRoutePolicy policy = new CronScheduledRoutePolicy();
policy.setRouteResumeTime("*/3 * * * * ?");
from("direct:start").routeId("test").routePolicy(policy).to("mock:success");
}
});
context.start();
ServiceHelper.suspendService(context.getRoute("test").getConsumer());
Thread.sleep(5000);
assertTrue(context.getRouteStatus("test") == ServiceStatus.Started);
template.sendBody("direct:start", "Ready or not, Here, I come");
success.assertIsSatisfied();
}
public void testSimpleSplitWriteRead() throws Exception {
context.addRoutes(
new RouteBuilder() {
@Override
public void configure() {
from("direct:start")
.to(
"hdfs://localhost:9000/tmp/test/test-camel-simple-write-file?fileSystemType=HDFS&splitStrategy=BYTES:5,IDLE:1000");
from("hdfs://localhost:9000/tmp/test/test-camel-simple-write-file?pattern=seg*&initialDelay=2000&fileSystemType=HDFS&chunkSize=5")
.to("mock:result");
}
});
context.start();
for (int i = 0; i < 10; ++i) {
template.sendBody("direct:start", "CIAO" + i);
}
MockEndpoint resultEndpoint = (MockEndpoint) context.getEndpoint("mock:result");
resultEndpoint.expectedMessageCount(10);
resultEndpoint.assertIsSatisfied();
int i = 0;
List<Exchange> exchanges = resultEndpoint.getExchanges();
for (Exchange exchange : exchanges) {
Assert.assertEquals("CIAO" + i++, exchange.getIn().getBody(String.class));
}
}
@Test
public void testHeaderAndTrailer() throws Exception {
results.expectedMessageCount(1);
results.message(0).body().isInstanceOf(List.class);
results.message(0).header("camelFlatpackCounter").isEqualTo(6);
results.assertIsSatisfied();
List<Map<String, String>> data =
CastUtils.cast(results.getExchanges().get(0).getIn().getBody(List.class));
// assert header
Map<String, String> header = data.get(0);
assertEquals("HBT", header.get("INDICATOR"));
assertEquals("20080817", header.get("DATE"));
// assert body
int counter = 0;
for (Map<String, String> row : data.subList(1, 5)) {
assertEquals("FIRSTNAME", expectedFirstName[counter], row.get("FIRSTNAME"));
LOG.info("Result: " + counter + " = " + row);
counter++;
}
// assert trailer
Map<String, String> trailer = data.get(5);
assertEquals("FBT", trailer.get("INDICATOR"));
assertEquals("SUCCESS", trailer.get("STATUS"));
}
public void testCustomProducerServicePoolInRoute() throws Exception {
context.addEndpoint("my", new MyEndpoint("my", context));
MyPool pool = new MyPool();
pool.start();
context.setProducerServicePool(pool);
context.addRoutes(
new RouteBuilder() {
@Override
public void configure() throws Exception {
from("direct:start").to("my", "mock:result");
}
});
context.start();
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMessageCount(2);
template.sendBody("direct:start", "Hello World");
template.sendBody("direct:start", "Bye World");
assertMockEndpointsSatisfied();
assertEquals(2, counter);
assertEquals(1, pool.size());
}
@DirtiesContext
@Test
public void testSendInvalidData() throws Exception {
resultEndpoint.expectedMessageCount(0);
template.sendBody("CSV\nNullpointerException():100");
resultEndpoint.assertIsSatisfied();
}
@DirtiesContext
@Test
public void testSendCsvDataZeroLines() throws Exception {
resultEndpoint.expectedMessageCount(0);
template.sendBody("only one line");
resultEndpoint.assertIsSatisfied();
}
public void testSendLotsOfMessagesSimultaneouslyButOnly3GetThrough() throws Exception {
MockEndpoint resultEndpoint = resolveMandatoryEndpoint("mock:result", MockEndpoint.class);
resultEndpoint.expectedMessageCount(messageCount);
ExecutorService executor = Executors.newFixedThreadPool(messageCount);
long start = System.currentTimeMillis();
for (int i = 0; i < messageCount; i++) {
executor.execute(
new Runnable() {
public void run() {
template.sendBody("direct:a", "<message>payload</message>");
}
});
}
// let's wait for the exchanges to arrive
resultEndpoint.assertIsSatisfied();
// now assert that they have actually been throttled
long minimumTime = (messageCount - 1) * INTERVAL;
// add a little slack
long delta = System.currentTimeMillis() - start + 200;
assertTrue("Should take at least " + minimumTime + "ms, was: " + delta, delta >= minimumTime);
}
public void testConcurrentPipeline() throws Exception {
int total = 200;
final int group = total / 20;
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMessageCount(total);
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(20);
executor.afterPropertiesSet();
for (int i = 0; i < 20; i++) {
final int threadCount = i;
executor.execute(
new Runnable() {
public void run() {
int start = threadCount * group;
for (int i = 0; i < group; i++) {
try {
// do some random sleep to simulate spread in user activity
Thread.sleep(new Random().nextInt(10));
} catch (InterruptedException e) {
// ignore
}
template.sendBody(uri, "" + (start + i));
}
}
});
}
mock.assertIsSatisfied();
mock.expectsNoDuplicates(body());
executor.shutdown();
}
@Test
public void testFileToFile() throws Exception {
// Body contains two CDs, one DVD and one BOOK.
String bodyOfMessage =
"eminem / cd,harry potter and the deathly hollows / dvd,"
+ "Claus Ibsen - Camel in Action / book,"
+ "Xzibit / cd";
// The TemplateProducer is part of CamelTestSupport. It is used to send messages to Camel
// endpoints.
template.sendBodyAndHeader(
"file://orders/inbox", bodyOfMessage, Exchange.FILE_NAME, "order.csv");
// Mock is included implicitly.
MockEndpoint mock = context.getEndpoint("mock:others", MockEndpoint.class);
// The Mock expects only one message, because it only receives the BOOK order:
mock.expectedMessageCount(1);
mock.setResultWaitTime(1000);
Thread.sleep(3000);
String dvdBody = " harry potter and the deathly hollows / dvd";
File target = new File("orders/outbox/dvd/order.csv");
String content = context.getTypeConverter().convertTo(String.class, target);
// Assertions
mock.assertIsSatisfied();
assertEquals(dvdBody.toUpperCase(), content);
}
@Test
public void testTerserPredicateNull() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:test3");
mock.expectedMessageCount(1);
template.sendBody("direct:test3", createADT01Message());
assertMockEndpointsSatisfied();
}
public void testSendingAMessageUsingMulticastReceivesItsOwnExchangeParallel() throws Exception {
MockEndpoint resultEndpoint = getMockEndpoint("mock:result");
resultEndpoint.expectsNoDuplicates(body());
resultEndpoint.expectedMessageCount(4);
// InOnly
template.send(
"direct:parallel",
new Processor() {
public void process(Exchange exchange) {
Message in = exchange.getIn();
in.setBody("James,Guillaume,Hiram,Rob");
in.setHeader("foo", "bar");
}
});
assertMockEndpointsSatisfied();
List<Exchange> list = resultEndpoint.getReceivedExchanges();
Set<Integer> numbersFound = new TreeSet<Integer>();
final String[] names = {"James", "Guillaume", "Hiram", "Rob"};
for (int i = 0; i < 4; i++) {
Exchange exchange = list.get(i);
Message in = exchange.getIn();
Integer splitCounter = exchange.getProperty(Exchange.SPLIT_INDEX, Integer.class);
numbersFound.add(splitCounter);
assertEquals(names[splitCounter], in.getBody());
assertProperty(exchange, Exchange.SPLIT_SIZE, 4);
}
assertEquals(4, numbersFound.size());
}
@Test
public void testMarshall()
throws InterruptedException, ParserConfigurationException, IOException, SAXException {
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMessageCount(1);
PurchaseOrder purchaseOrder = new PurchaseOrder();
String name = "foo";
purchaseOrder.setName(name);
double price = 49;
purchaseOrder.setPrice(price);
double amount = 3;
purchaseOrder.setAmount(amount);
template.sendBody("direct:start", purchaseOrder);
assertMockEndpointsSatisfied();
String body = mock.getReceivedExchanges().get(0).getIn().getBody(String.class);
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Element root = builder.parse(new InputSource(new StringReader(body))).getDocumentElement();
assertEquals(name, root.getAttribute("name"));
assertEquals(price + "", root.getAttribute("price"));
assertEquals(amount + "", root.getAttribute("amount"));
}
@Test
public void testScheduledStartRoutePolicy() throws Exception {
MockEndpoint success = (MockEndpoint) context.getEndpoint("mock:success");
success.expectedMessageCount(1);
context
.getComponent("quartz", QuartzComponent.class)
.setPropertiesFile("org/apache/camel/routepolicy/quartz/myquartz.properties");
context.getComponent("quartz", QuartzComponent.class).start();
context.addRoutes(
new RouteBuilder() {
public void configure() {
SimpleScheduledRoutePolicy policy = new SimpleScheduledRoutePolicy();
long startTime = System.currentTimeMillis() + 3000L;
policy.setRouteStartDate(new Date(startTime));
policy.setRouteStartRepeatCount(1);
policy.setRouteStartRepeatInterval(3000);
from("direct:start").routeId("test").routePolicy(policy).to("mock:success");
}
});
context.start();
context.stopRoute("test", 0, TimeUnit.MILLISECONDS);
Thread.sleep(5000);
assertTrue(context.getRouteStatus("test") == ServiceStatus.Started);
template.sendBody("direct:start", "Ready or not, Here, I come");
context.getComponent("quartz", QuartzComponent.class).stop();
success.assertIsSatisfied();
}
public void testXPathSplitStream() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:splitted");
mock.expectedMessageCount(size);
mock.expectsNoDuplicates().body();
assertMockEndpointsSatisfied();
}
@Test
/** Operation: CREATE Body contains: Metacard */
public void testCreateWithIngestException() throws Exception {
resetMocks();
// Setup expectations to verify
final MockEndpoint mockVerifierEndpoint = getMockEndpoint("mock:result");
mockVerifierEndpoint.expectedMessageCount(1);
final List<Metacard> metacards = new ArrayList<Metacard>();
metacards.add(metacard1);
// Mock catalog framework
final CreateRequest createRequest = new CreateRequestImpl(metacards);
final CreateResponse createResponse =
new CreateResponseImpl(createRequest, new HashMap(), metacards);
when(catalogFramework.create(any(CreateRequest.class))).thenThrow(new IngestException());
// Exercise the route with a CREATE operation
template.sendBodyAndHeader("direct:sampleInput", metacard1, "Operation", "CREATE");
// Verify that the number of metacards in the exchange after the records
// is identical to the input
assertListSize(mockVerifierEndpoint.getExchanges(), 1);
final Exchange exchange = mockVerifierEndpoint.getExchanges().get(0);
final List<Metacard> cardsCreated = (List<Metacard>) exchange.getIn().getBody();
assertListSize(cardsCreated, 0);
mockVerifierEndpoint.assertIsSatisfied();
}
@Test
public void testBlobStorePut() throws InterruptedException {
MockEndpoint mockEndpoint = resolveMandatoryEndpoint("mock:results", MockEndpoint.class);
mockEndpoint.expectedMessageCount(1);
template.sendBody("direct:put", "Some message");
mockEndpoint.assertIsSatisfied();
}
@Test
/** Operation: DELETE Body contains: 12345678900987654321abcdeffedcba */
public void testDeleteWithIngestException() throws Exception {
resetMocks();
// Setup expectations to verify
final MockEndpoint mockVerifierEndpoint = getMockEndpoint("mock:result");
mockVerifierEndpoint.expectedMessageCount(1);
final List<Metacard> metacards = new ArrayList<Metacard>();
metacards.add(metacard1);
// setup mock catalog framework
final String[] metacardIds = new String[metacards.size()];
for (int i = 0; i < metacards.size(); i++) {
metacardIds[i] = metacards.get(i).getId();
}
DeleteRequest deleteRequest = new DeleteRequestImpl(metacardIds);
DeleteResponse deleteResponse = new DeleteResponseImpl(deleteRequest, new HashMap(), metacards);
when(catalogFramework.delete(any(DeleteRequest.class))).thenThrow(new IngestException());
// Exercise the route with a DELETE operation
template.sendBodyAndHeader("direct:sampleInput", metacardIds, "Operation", "DELETE");
// Verify that the number of metacards in the exchange after the records
// is identical to the input
assertListSize(mockVerifierEndpoint.getExchanges(), 1);
final Exchange exchange = mockVerifierEndpoint.getExchanges().get(0);
final List<Update> cardsDeleted = (List<Update>) exchange.getIn().getBody();
assertListSize(cardsDeleted, 0);
mockVerifierEndpoint.assertIsSatisfied();
}
@Test
public void testInOnlyMultipleJMSHeadersAndExpiration() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMessageCount(1);
mock.message(0).header("JMSPriority").isEqualTo(3);
mock.message(0).header("JMSDeliveryMode").isEqualTo(2);
long ttl = System.currentTimeMillis() + 2000;
Map<String, Object> headers = new HashMap<String, Object>();
headers.put("JMSPriority", 3);
headers.put("JMSDeliveryMode", 2);
headers.put("JMSExpiration", ttl);
template.sendBodyAndHeaders(
"activemq:queue:bar?preserveMessageQos=true", "Hello World", headers);
// sleep just a little
Thread.sleep(50);
Exchange bar = consumer.receive("activemq:queue:bar", 5000);
assertNotNull("Should be a message on queue", bar);
template.send("activemq:queue:foo?preserveMessageQos=true", bar);
Thread.sleep(1000);
assertMockEndpointsSatisfied();
}
@Test
public void sendSubmitSMInOnly() throws Exception {
result.expectedMessageCount(1);
Exchange exchange = start.createExchange(ExchangePattern.InOnly);
exchange.getIn().setBody("Hello SMPP World!");
template.send(start, exchange);
assertMockEndpointsSatisfied();
Exchange resultExchange = result.getExchanges().get(0);
assertEquals(
SmppMessageType.DeliveryReceipt.toString(),
resultExchange.getIn().getHeader(SmppConstants.MESSAGE_TYPE));
assertEquals("Hello SMPP World!", resultExchange.getIn().getBody());
assertNotNull(resultExchange.getIn().getHeader(SmppConstants.ID));
assertEquals(1, resultExchange.getIn().getHeader(SmppConstants.SUBMITTED));
assertEquals(1, resultExchange.getIn().getHeader(SmppConstants.DELIVERED));
assertNotNull(resultExchange.getIn().getHeader(SmppConstants.DONE_DATE));
assertNotNull(resultExchange.getIn().getHeader(SmppConstants.SUBMIT_DATE));
assertNull(resultExchange.getIn().getHeader(SmppConstants.ERROR));
assertNotNull(exchange.getIn().getHeader(SmppConstants.ID));
assertEquals(1, exchange.getIn().getHeader(SmppConstants.SENT_MESSAGE_COUNT));
}
