public void testFireAndForgetUsingExpression2() throws Exception {
context.addRoutes(
new RouteBuilder() {
@Override
public void configure() throws Exception {
from("direct:start").wireTap("direct:foo", simple("Bye ${body}")).to("mock:result");
from("direct:foo").to("mock:foo");
}
});
context.start();
MockEndpoint result = getMockEndpoint("mock:result");
result.expectedBodiesReceived("World");
MockEndpoint foo = getMockEndpoint("mock:foo");
foo.expectedBodiesReceived("Bye World");
template.sendBody("direct:start", "World");
assertMockEndpointsSatisfied();
// should be different exchange instances
Exchange e1 = result.getReceivedExchanges().get(0);
Exchange e2 = foo.getReceivedExchanges().get(0);
assertNotSame("Should not be same Exchange", e1, e2);
// should have same from endpoint
assertEquals("direct://start", e1.getFromEndpoint().getEndpointUri());
assertEquals("direct://start", e2.getFromEndpoint().getEndpointUri());
}
public void testManageStatistics() throws Exception {
// JMX tests dont work well on AIX CI servers (hangs them)
if (isPlatform("aix")) {
return;
}
// get the stats for the route
MBeanServer mbeanServer = getMBeanServer();
Set<ObjectName> set = mbeanServer.queryNames(new ObjectName("*:type=routes,*"), null);
assertEquals(1, set.size());
ObjectName on = set.iterator().next();
// use route to get the total time
Long completed = (Long) mbeanServer.getAttribute(on, "ExchangesCompleted");
assertEquals(0, completed.longValue());
MockEndpoint result = getMockEndpoint("mock:result");
result.expectedMessageCount(5);
// send in 5 messages
template.sendBody("direct:start", "A");
template.sendBody("direct:start", "B");
template.sendBody("direct:start", "C");
template.sendBody("direct:start", "D");
template.sendBody("direct:start", "E");
assertMockEndpointsSatisfied();
// should be 5 on the route
completed = (Long) mbeanServer.getAttribute(on, "ExchangesCompleted");
assertEquals(5, completed.longValue());
String first = (String) mbeanServer.getAttribute(on, "FirstExchangeCompletedExchangeId");
assertEquals(result.getReceivedExchanges().get(0).getExchangeId(), first);
String firstFail = (String) mbeanServer.getAttribute(on, "FirstExchangeFailureExchangeId");
assertNull(firstFail);
String last = (String) mbeanServer.getAttribute(on, "LastExchangeCompletedExchangeId");
assertEquals(result.getReceivedExchanges().get(4).getExchangeId(), last);
String lastFail = (String) mbeanServer.getAttribute(on, "LastExchangeFailureExchangeId");
assertNull(lastFail);
// should be 5 on the processors
ObjectName foo =
ObjectName.getInstance(
"org.apache.camel:context=localhost/camel-1,type=processors,name=\"foo\"");
completed = (Long) mbeanServer.getAttribute(foo, "ExchangesCompleted");
assertEquals(5, completed.longValue());
ObjectName mock =
ObjectName.getInstance(
"org.apache.camel:context=localhost/camel-1,type=processors,name=\"mock\"");
completed = (Long) mbeanServer.getAttribute(mock, "ExchangesCompleted");
assertEquals(5, completed.longValue());
}
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 testNotTooOldFilter() throws Exception {
fakeFtpServer.start();
int port = fakeFtpServer.getServerControlPort();
context
.getRouteDefinitions()
.get(0)
.adviceWith(
context,
new AdviceWithRouteBuilder() {
@Override
public void configure() throws Exception {
replaceFromWith(
"ftp://[email protected]:"
+ port
+ "?password=password&filter=#notTooOld&passiveMode=true");
weaveByType(ToDefinition.class).selectFirst().replace().to("mock:end");
}
});
MockEndpoint end = context.getEndpoint("mock:end", MockEndpoint.class);
end.expectedMessageCount(1);
end.assertIsSatisfied();
// Make sure that the received file has the correct file name
String fileName =
(String) end.getReceivedExchanges().get(0).getIn().getHeader(Exchange.FILE_NAME_ONLY);
assertEquals(fileName, "DMI1.nc");
fakeFtpServer.stop();
}
public void testSendingAMessageUsingMulticastReceivesItsOwnExchange() throws Exception {
MockEndpoint resultEndpoint = getMockEndpoint("mock:result");
resultEndpoint.expectedBodiesReceived("James", "Guillaume", "Hiram", "Rob");
// InOnly
template.send(
"direct:seqential",
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();
for (int i = 0; i < 4; i++) {
Exchange exchange = list.get(i);
Message in = exchange.getIn();
assertNotNull("The in message should not be null.", in);
assertProperty(exchange, Exchange.SPLIT_INDEX, i);
assertProperty(exchange, Exchange.SPLIT_SIZE, 4);
}
}
@Test
public void testInOnlyRouteJMSDestinationName() throws Exception {
context.addRoutes(
new RouteBuilder() {
public void configure() throws Exception {
from("activemq:queue:a").to("activemq:queue:b");
from("activemq:queue:b").to("mock:result");
}
});
context.start();
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedBodiesReceived("Hello World");
mock.message(0).header("JMSDestination").isNotNull();
template.sendBodyAndHeader(
"activemq:queue:bar", "Hello World", JmsConstants.JMS_DESTINATION_NAME, "a");
assertMockEndpointsSatisfied();
assertEquals(
"queue://b",
mock.getReceivedExchanges()
.get(0)
.getIn()
.getHeader("JMSDestination", Destination.class)
.toString());
}
@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"));
}
public void testFireAndForgetUsingProcessor() throws Exception {
context.addRoutes(
new RouteBuilder() {
@SuppressWarnings("deprecation")
@Override
public void configure() throws Exception {
// START SNIPPET: e1
from("direct:start")
.wireTap(
"direct:foo",
new Processor() {
public void process(Exchange exchange) throws Exception {
String body = exchange.getIn().getBody(String.class);
exchange.getIn().setBody("Bye " + body);
exchange.getIn().setHeader("foo", "bar");
}
})
.to("mock:result");
from("direct:foo").to("mock:foo");
// END SNIPPET: e1
}
});
context.start();
MockEndpoint result = getMockEndpoint("mock:result");
result.expectedBodiesReceived("World");
MockEndpoint foo = getMockEndpoint("mock:foo");
foo.expectedBodiesReceived("Bye World");
foo.expectedHeaderReceived("foo", "bar");
template.sendBody("direct:start", "World");
assertMockEndpointsSatisfied();
// should be different exchange instances
Exchange e1 = result.getReceivedExchanges().get(0);
Exchange e2 = foo.getReceivedExchanges().get(0);
assertNotSame("Should not be same Exchange", e1, e2);
// should have same from endpoint
assertEquals("direct://start", e1.getFromEndpoint().getEndpointUri());
assertEquals("direct://start", e2.getFromEndpoint().getEndpointUri());
}
public void testTransform() throws Exception {
MockEndpoint resultEndpoint = resolveMandatoryEndpoint("mock:result", MockEndpoint.class);
resultEndpoint.expectedMessageCount(1);
resultEndpoint.assertIsSatisfied();
List<Exchange> list = resultEndpoint.getReceivedExchanges();
Exchange exchange = list.get(0);
Message in = exchange.getIn();
String text = in.getBody(String.class);
log.info("Received: " + text);
}
@Ignore("test manual")
@Test
public void testIrcMessages() throws Exception {
resultEndpoint = (MockEndpoint) context.getEndpoint("mock:result");
resultEndpoint.expectedBodiesReceived(resultEnd);
resultEndpoint.assertIsSatisfied();
List<Exchange> list = resultEndpoint.getReceivedExchanges();
for (Exchange exchange : list) {
log.info("Received exchange: " + exchange + " headers: " + exchange.getIn().getHeaders());
}
}
@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 testBindyMarshalQuoteAndCommaDelimiter() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:in");
mock.expectedMessageCount(1);
Car car = getCar();
template.sendBody("direct:in", car);
assertMockEndpointsSatisfied();
String body = mock.getReceivedExchanges().get(0).getIn().getBody(String.class);
assertEquals(ROW, body);
}
@Test
public void testMarshalBadCharsWithFiltering() throws Exception {
PersonType person = new PersonType();
person.setFirstName("foo\u0004");
person.setLastName("bar");
MockEndpoint resultEndpoint = resolveMandatoryEndpoint("mock:result", MockEndpoint.class);
resultEndpoint.expectedMessageCount(1);
template.sendBody("direct:marshalFilteringEnabled", person);
resultEndpoint.assertIsSatisfied();
String body = resultEndpoint.getReceivedExchanges().get(0).getIn().getBody(String.class);
assertFalse("Non-xml character wasn't replaced", body.contains("\u0004"));
}
@SuppressWarnings("unchecked")
@Test
public void testCsvUnMarshalSingleLine() throws Exception {
result.expectedMessageCount(1);
template.sendBody("direct:start", "123|Camel in Action|1");
assertMockEndpointsSatisfied();
List<List<String>> body = result.getReceivedExchanges().get(0).getIn().getBody(List.class);
assertEquals(1, body.size());
assertEquals("123", body.get(0).get(0));
assertEquals("Camel in Action", body.get(0).get(1));
assertEquals("1", body.get(0).get(2));
}
@Test
public void testBindingMode() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:input");
mock.expectedMessageCount(1);
mock.message(0).body().isInstanceOf(UserJaxbPojo.class);
String body = "<user name=\"Donald Duck\" id=\"123\"></user>";
template.sendBody("netty4-http:http://localhost:" + getPort() + "/users/new", body);
assertMockEndpointsSatisfied();
UserJaxbPojo user = mock.getReceivedExchanges().get(0).getIn().getBody(UserJaxbPojo.class);
assertNotNull(user);
assertEquals(123, user.getId());
assertEquals("Donald Duck", user.getName());
}
@Test
public void testUnmarshalPojo() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:reversePojo");
mock.expectedMessageCount(1);
mock.message(0).body().isInstanceOf(TestPojo.class);
String json = "<pojo name=\"Camel\"/>";
template.sendBodyAndHeader(
"direct:backPojo", json, JacksonXMLConstants.UNMARSHAL_TYPE, TestPojo.class.getName());
assertMockEndpointsSatisfied();
TestPojo pojo = mock.getReceivedExchanges().get(0).getIn().getBody(TestPojo.class);
assertNotNull(pojo);
assertEquals("Camel", pojo.getName());
}
public void testUsingCustomExceptionHandlerWithNoRedeliveries() throws Exception {
b.expectedMessageCount(1);
sendBody("direct:start", "b");
MockEndpoint.assertIsSatisfied(a, b);
List<Exchange> list = b.getReceivedExchanges();
assertTrue("List should not be empty!", !list.isEmpty());
Exchange exchange = list.get(0);
Message in = exchange.getIn();
log.info("Found message with headers: " + in.getHeaders());
assertMessageHeader(in, Exchange.REDELIVERY_COUNTER, 0);
assertMessageHeader(in, Exchange.REDELIVERY_MAX_COUNTER, null);
assertMessageHeader(in, Exchange.REDELIVERED, false);
}
@Test
public void testSplitAggregatesResponses() throws Exception {
String[] array = new String[] {"one", "two", "three"};
MockEndpoint mockOut = getMockEndpoint("mock:out");
mockOut.expectedMessageCount(1);
template.sendBody("direct:in", array);
assertMockEndpointsSatisfied();
Exchange exchange = mockOut.getReceivedExchanges().get(0);
@SuppressWarnings("unchecked")
Set<String> backendResponses =
Collections.checkedSet(exchange.getIn().getBody(Set.class), String.class);
assertTrue(
backendResponses.containsAll(
Arrays.asList("Processed: one", "Processed: two", "Processed: three")));
}
@Test
public void testInOnlyJMSDestinationName() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMessageCount(1);
mock.message(0).header("JMSDestination").isNotNull();
template.sendBodyAndHeader(
"activemq:queue:bar", "Hello World", JmsConstants.JMS_DESTINATION_NAME, "foo");
assertMockEndpointsSatisfied();
assertEquals(
"queue://foo",
mock.getReceivedExchanges()
.get(0)
.getIn()
.getHeader("JMSDestination", Destination.class)
.toString());
}
@Test
public void testForwardingAMessageAcrossJMSKeepingCustomJMSHeaders() throws Exception {
MockEndpoint resultEndpoint = resolveMandatoryEndpoint("mock:result", MockEndpoint.class);
resultEndpoint.expectedBodiesReceived(expectedBody);
AssertionClause firstMessageExpectations = resultEndpoint.message(0);
firstMessageExpectations.header("cheese").isEqualTo(123);
firstMessageExpectations.header("JMSReplyTo").isEqualTo(replyQueue);
firstMessageExpectations.header("JMSCorrelationID").isEqualTo(correlationID);
firstMessageExpectations.header("JMSType").isEqualTo(messageType);
template.sendBodyAndHeader("activemq:test.a", expectedBody, "cheese", 123);
resultEndpoint.assertIsSatisfied();
List<Exchange> list = resultEndpoint.getReceivedExchanges();
Exchange exchange = list.get(0);
String replyTo = exchange.getIn().getHeader("JMSReplyTo", String.class);
assertEquals("ReplyTo", replyQueue.toString(), replyTo);
}
@Test
public void testMocksAreValid() throws Exception {
// lets add more expectations
expectedEndpoint.expectedMessageCount(1);
expectedEndpoint.message(0).header("JMSXGroupID").isEqualTo("ABC");
MockEndpoint.assertIsSatisfied(camelContext);
// lets dump the received messages
List<Exchange> list = expectedEndpoint.getReceivedExchanges();
for (Exchange exchange : list) {
Object body = exchange.getIn().getBody();
LOG.debug(
"Received: body: "
+ body
+ " of type: "
+ ObjectHelper.className(body)
+ " on: "
+ exchange);
}
}
protected void assertErrorHandlingWorks(String route) throws Exception {
MockEndpoint resultEndpoint = getMockEndpoint("mock:result");
MockEndpoint exceptionEndpoint = getMockEndpoint("mock:exception");
resultEndpoint.expectedMessageCount(0);
exceptionEndpoint.expectedBodiesReceived("<exception/>");
try {
template.sendBodyAndHeader("direct:start", "<body/>", "route", route);
fail("Should have thrown exception");
} catch (RuntimeCamelException e) {
assertTrue(e.getCause() instanceof IllegalArgumentException);
assertEquals("Exception thrown intentionally.", e.getCause().getMessage());
}
assertMockEndpointsSatisfied();
List<Exchange> list = exceptionEndpoint.getReceivedExchanges();
Exchange exchange = list.get(0);
LOG.debug("Received: " + exchange.getIn());
}
@Ignore
@Test
@DirtiesContext
public void validHL7IsConvertedAndAckIsSent() throws Exception {
standardHL7XMLEndpoint.expectedMessageCount(1);
t5XMLEndpoint.expectedMessageCount(1);
String hl7Input =
"MSH|^~\\&|SendingApplication|SendingFacility|ReceivingApplication|ReceivingFacility|20120530112345||ORU^R01^ORU_R01|9879790003|P|2.6|||NE|AL|USA|ASCII|EN^English^ISO639||IHE_PCD_ORU_R01^IHE PCD^1.3.6.1.4.1.19376.1.6.1.1.1^ISO\r"
+ "PID|||HO2009001^^^NIST^PI||Hon^Albert^^^^^L|Adams^^^^^^L|19610101|M|||15 N Saguaro^^Tucson^AZ^85701\r"
+ "PV1||I|ICU^2^23\r"
+ "OBR|1|||44616-1^Pulse oximetry panel ^LN|||20120512031234||||||||||||||||||F|||||||||||||||||||252465000^Pulse oximetry^SCT|7087005^Intermittent^SCT\r"
+ "NTE|1||This comment refers to all the results in the battery\r"
+ "OBX|1|NM|8889-8^Heart Rate by Oximetry^LN^149530^ MDC_PULS_OXIM_PULS_RATE^MDC|1.11.2.3|55|{beats}/min^beats per minute^UCUM|35-125||99||R|||20120530112340|||AMEAS^auto-measurement^MDC|0123456789ABCDEF^Pulse_Oximeter_Vendor_X^0123456789ABCDEF^EUI-64||49521004^left ear structure^SCT\n"
+ "NTE|1||This is a comment about pulse";
Parser parser = new PipeParser();
ORU_R01 originalMessage = (ORU_R01) parser.parse(hl7Input);
String encodedHL7 = parser.encode(originalMessage);
String response = minaTemplate.requestBody((Object) encodedHL7, String.class);
ACK responseMessage = (ACK) parser.parse(response);
assertEquals(
AcknowledgmentCode.AA.name(), responseMessage.getMSA().getAcknowledgmentCode().getValue());
standardHL7XMLEndpoint.assertIsSatisfied();
t5XMLEndpoint.assertIsSatisfied();
ORU_R01 outputStandardXMLMessage =
(ORU_R01) parseXMLExchange(standardHL7XMLEndpoint.getReceivedExchanges().get(0));
assertEquals(
originalMessage.getMSH().getMessageType().getName(),
outputStandardXMLMessage.getMSH().getMessageType().getName());
assertEquals(
originalMessage.getMSH().getMessageControlID().getValue(),
outputStandardXMLMessage.getMSH().getMessageControlID().getValue());
}
public void testSplitterWithStreaming() throws Exception {
MockEndpoint resultEndpoint = getMockEndpoint("mock:result");
resultEndpoint.expectedMessageCount(5);
resultEndpoint.expectedHeaderReceived("foo", "bar");
template.request(
"direct:streaming",
new Processor() {
public void process(Exchange exchange) {
Message in = exchange.getIn();
in.setBody("James,Guillaume,Hiram,Rob,Roman");
in.setHeader("foo", "bar");
}
});
assertMockEndpointsSatisfied();
for (Exchange exchange : resultEndpoint.getReceivedExchanges()) {
assertNotNull(exchange.getProperty(Exchange.SPLIT_INDEX));
// this header cannot be set when streaming is used
assertNull(exchange.getProperty(Exchange.SPLIT_SIZE));
}
}
@Test
public void testSimpleBody() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMessageCount(1);
Project pojo = new Project();
pojo.setLicense("XXX");
template.sendBody("direct:simple", pojo);
mock.assertIsSatisfied();
// the result is a List
List<?> received =
assertIsInstanceOf(List.class, mock.getReceivedExchanges().get(0).getIn().getBody());
// and each row in the list is a Map
Map<?, ?> row = assertIsInstanceOf(Map.class, received.get(0));
// and we should be able the get the project from the map that should be Linux
assertEquals("Linux", row.get("PROJECT"));
}
@Test
public void testCamelDropbox() throws Exception {
template.send(
"direct:start",
new Processor() {
@Override
public void process(Exchange exchange) throws Exception {
exchange.getIn().setHeader("test", "test");
}
});
MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMinimumMessageCount(1);
assertMockEndpointsSatisfied();
List<Exchange> exchanges = mock.getReceivedExchanges();
Exchange exchange = exchanges.get(0);
Object header = exchange.getIn().getHeader(DropboxResultHeader.DOWNLOADED_FILE.name());
Object body = exchange.getIn().getBody();
assertNotNull(header);
assertNotNull(body);
}
@Test
public void testEndpoint() throws Exception {
mockEndpoint.reset();
mockEndpoint.expectedBodiesReceived(expectedBody);
template.sendBodyAndHeader(
"https://localhost:" + port + "/test", expectedBody, "Content-Type", "application/xml");
mockEndpoint.assertIsSatisfied();
List<Exchange> list = mockEndpoint.getReceivedExchanges();
Exchange exchange = list.get(0);
TestSupport.assertNotNull("exchange", exchange);
Message in = exchange.getIn();
assertNotNull("in", in);
Map<String, Object> headers = in.getHeaders();
log.info("Headers: " + headers);
assertTrue("Should be more than one header but was: " + headers, headers.size() > 0);
}
@SuppressWarnings("unchecked")
@Test
public void testSendMatchingMessage() throws Exception {
String sender = "sender@localhost";
String rcpt = "rcpt@localhost";
String body = "Subject: test\r\n\r\nTestmail";
SMTPClient client = new SMTPClient();
client.connect("localhost", 2525);
client.helo("localhost");
client.setSender(sender);
client.addRecipient(rcpt);
client.sendShortMessageData(body);
client.quit();
client.disconnect();
resultEndpoint.expectedMessageCount(1);
resultEndpoint.expectedBodyReceived().body(InputStream.class);
Exchange ex = resultEndpoint.getReceivedExchanges().get(0);
Map<String, Object> headers = ex.getIn().getHeaders();
assertEquals(sender, headers.get(MailEnvelopeMessage.SMTP_SENDER_ADRRESS));
assertEquals(rcpt, headers.get(MailEnvelopeMessage.SMTP_RCPT_ADRRESS_LIST));
// check type converter
MimeMessage message = ex.getIn().getBody(MimeMessage.class);
Enumeration<Header> mHeaders = message.getAllHeaders();
Header header = null;
while (mHeaders.hasMoreElements()) {
header = mHeaders.nextElement();
if (header.getName().equals("Subject")) {
break;
}
}
assertNotNull(header);
assertEquals("Subject", header.getName());
assertEquals(header.getValue(), "test");
resultEndpoint.assertIsSatisfied();
}
@Test
public void testBindyUnmarshalQuoteAndCommaDelimiter() throws Exception {
MockEndpoint mock = getMockEndpoint("mock:out");
mock.expectedMessageCount(1);
template.sendBody("direct:out", HEADER + "\n" + ROW);
assertMockEndpointsSatisfied();
Map<?, ?> map1 =
(Map<?, ?>) mock.getReceivedExchanges().get(0).getIn().getBody(List.class).get(0);
Car rec1 = (Car) map1.values().iterator().next();
assertEquals("SS552", rec1.getStockid());
assertEquals("TOYOTA", rec1.getMake());
assertEquals("KLUGER", rec1.getModel());
assertEquals(2005, rec1.getYear());
assertEquals(Double.valueOf("155000.0"), rec1.getKlms(), 0.0001);
assertEquals("EZR05I", rec1.getNvic());
assertEquals("Used", rec1.getStatus());
assertEquals(Car.Colour.BLACK, rec1.getColour());
}
