@Test
public void testAllExchangeEventsReceived() throws Exception {
EventCounter counter = new EventCounter();
_domain.addEventObserver(counter, ExchangeInitiatedEvent.class);
_domain.addEventObserver(counter, ExchangeCompletionEvent.class);
// send 10 in-only messages and check the counters
for (int i = 0; i < 10; i++) {
ServiceReference inOnlyService =
_domain.createInOnlyService(new QName("ExchangeEvent-0" + i));
Exchange inOnly = inOnlyService.createExchange();
inOnly.send(inOnly.createMessage());
}
Assert.assertEquals(10, counter.initiatedCount);
Assert.assertEquals(10, counter.completedCount);
// initialize counters
counter.initiatedCount = 0;
counter.completedCount = 0;
// send 10 in-out and check the count
for (int i = 0; i < 10; i++) {
ServiceReference inOutService =
_domain.createInOutService(
new QName("ExchangeEvent-1" + i), new MockHandler().forwardInToOut());
Exchange inOut = inOutService.createExchange(new MockHandler());
inOut.send(inOut.createMessage());
}
Assert.assertEquals(10, counter.initiatedCount);
Assert.assertEquals(10, counter.completedCount);
}
@Test
public void testPhaseIsInAfterInputMessage() {
ServiceReference service = _domain.createInOnlyService(new QName("InPhase"));
Exchange exchange = service.createExchange();
exchange.send(exchange.createMessage());
Assert.assertEquals(ExchangePhase.IN, exchange.getPhase());
}
@Test
public void testMessageIdSetOnSend() {
ServiceReference service = _domain.createInOnlyService(new QName("IdTest"));
Exchange exchange = service.createExchange();
exchange.send(exchange.createMessage());
Assert.assertNotNull(exchange.getMessage().getContext().getProperty(Exchange.MESSAGE_ID));
}
/** Verify consumer callback is called when fault occurs on InOnly. */
@Test
public void testFaultReportedOnInOnly() {
ServiceReference ref = registerInOnlyService("inOut", new ErrorExchangeHandler());
MockHandler consumer = new MockHandler();
Exchange exchange = ref.createExchange(consumer);
exchange.send(exchange.createMessage().setContent("test"));
Assert.assertEquals(1, consumer.waitForFaultMessage().getFaults().size());
}
@Test
public void testPhaseIsOutAfterFaultMessage() {
MockHandler replyHandler = new MockHandler();
ServiceReference service =
_domain.createInOutService(new QName("FaultPhase"), new MockHandler().forwardInToFault());
Exchange exchange = service.createExchange(replyHandler);
exchange.send(exchange.createMessage());
replyHandler.waitForFaultMessage();
Assert.assertEquals(ExchangePhase.OUT, exchange.getPhase());
}
@Test
public void testExchangeCompletedEvent() {
EventCounter counter = new EventCounter();
_domain.addEventObserver(counter, ExchangeCompletionEvent.class);
// send in-only and check the count
ServiceReference inOnlyService =
_domain.createInOnlyService(new QName("ExchangeCompleteEvent-1"));
Exchange inOnly = inOnlyService.createExchange();
inOnly.send(inOnly.createMessage());
Assert.assertEquals(1, counter.completedCount);
// reset count
counter.completedCount = 0;
// send in-out and check the count
ServiceReference inOutService =
_domain.createInOutService(
new QName("ExchangeCompleteEvent-2"), new MockHandler().forwardInToOut());
Exchange inOut = inOutService.createExchange(new MockHandler());
inOut.send(inOut.createMessage());
Assert.assertEquals(1, counter.completedCount);
}
@Test
public void testRelatesToSetOnReply() {
ServiceReference service =
_domain.createInOutService(new QName("ReplyTest"), new MockHandler().forwardInToOut());
MockHandler replyHandler = new MockHandler();
Exchange exchange = service.createExchange(replyHandler);
Message message = exchange.createMessage();
exchange.send(message);
String requestId = message.getContext().getPropertyValue(Exchange.MESSAGE_ID);
String replyId = exchange.getMessage().getContext().getPropertyValue(Exchange.MESSAGE_ID);
String replyRelatesTo =
exchange.getMessage().getContext().getPropertyValue(Exchange.RELATES_TO);
Assert.assertEquals(requestId, replyRelatesTo);
Assert.assertFalse(requestId.equals(replyId));
}
@Test
public void testNoNPEOnInOnlyFault() throws Exception {
QName serviceName = new QName("testNoNPEOnNoConsumer");
MockHandler provider =
new MockHandler() {
@Override
public void handleMessage(Exchange exchange) throws HandlerException {
throw new HandlerException("explode");
}
};
ServiceReference service = _domain.createInOnlyService(serviceName, provider);
// Don't provide a consumer...
Exchange exchange = service.createExchange();
exchange.send(exchange.createMessage());
}
@Test
public void testFaultWithNoHandler() throws Exception {
final QName serviceName = new QName("testFaultWithNoHandler");
// Provide the service
MockHandler provider =
new MockHandler() {
@Override
public void handleMessage(Exchange exchange) throws HandlerException {
throw new HandlerException("Fault With No Handler!");
}
};
ServiceReference service = _domain.createInOnlyService(serviceName, provider);
// Consume the service
Exchange exchange = service.createExchange();
exchange.send(exchange.createMessage());
// Make sure the exchange is in fault status
Assert.assertEquals(ExchangeState.FAULT, exchange.getState());
}
@Test
public void testExceptionOnNoConsumerOnInOut() throws Exception {
QName serviceName = new QName("testNoNPEOnNoConsumer");
MockHandler provider =
new MockHandler() {
@Override
public void handleMessage(Exchange exchange) throws HandlerException {
throw new HandlerException("explode");
}
};
ServiceReference service = _domain.createInOutService(serviceName, provider);
try {
// Don't provide a consumer...
service.createExchange();
Assert.fail("Should not be able to create an InOut without specifying a reply handler");
} catch (RuntimeException e) {
// exception expected
}
}
@Test
public void testFaultTransformSequence() throws Exception {
final QName serviceName = new QName("testFaultTransformSequence");
// Provide the service
MockHandler provider =
new MockHandler() {
@Override
public void handleMessage(Exchange exchange) throws HandlerException {
Message fault = exchange.createMessage();
fault.setContent(new Exception("testFaultTransformSequence"));
exchange.sendFault(fault);
}
};
InOutOperation providerContract =
new InOutOperation(
"faultOp",
JavaTypes.toMessageType(String.class), // input
JavaTypes.toMessageType(String.class), // output
JavaTypes.toMessageType(Exception.class)); // fault
InOutOperation consumerContract =
new InOutOperation(
"faultOp",
JavaTypes.toMessageType(String.class), // input
JavaTypes.toMessageType(String.class), // output
JavaTypes.toMessageType(String.class)); // fault
_domain.registerService(serviceName, new InOutService(providerContract), provider);
_domain.getTransformerRegistry().addTransformer(new ExceptionToStringTransformer());
ServiceReference service =
_domain.registerServiceReference(serviceName, new InOutService(consumerContract));
// Consume the service
Exchange exchange = service.createExchange(new MockHandler());
exchange.send(exchange.createMessage());
// Make sure the exchange is in fault status
Assert.assertEquals(String.class, exchange.getMessage().getContent().getClass());
Assert.assertEquals(exchange.getMessage().getContent(), "testFaultTransformSequence");
}
/** Make sure that the current message is set correctly when an exchange is sent. */
@Test
public void testGetMessage() throws Exception {
final QName serviceName = new QName("bleh");
final String inMsgContent = "in message";
final String outMsgContent = "out message";
// create a handler to test that the in and out content match
// expected result from getMessage()
ExchangeHandler provider =
new BaseHandler() {
public void handleMessage(Exchange exchange) {
Assert.assertEquals(exchange.getMessage().getContent(), inMsgContent);
Message outMsg = exchange.createMessage();
outMsg.setContent(outMsgContent);
try {
exchange.send(outMsg);
} catch (Exception ex) {
Assert.fail(ex.toString());
}
}
};
ExchangeHandler consumer =
new BaseHandler() {
public void handleMessage(Exchange exchange) {
Assert.assertEquals(exchange.getMessage().getContent(), outMsgContent);
}
};
ServiceReference service = _domain.createInOutService(serviceName, provider);
Exchange exchange = service.createExchange(consumer);
Message inMsg = exchange.createMessage();
inMsg.setContent(inMsgContent);
exchange.send(inMsg);
}
@Test
public void testExceptionOnSendOnFaultExchange() throws Exception {
final QName serviceName = new QName("testExceptionOnSendOnFaultExchange");
// Provide the service
MockHandler provider = new MockHandler().forwardInToFault();
ServiceReference service = _domain.createInOutService(serviceName, provider);
// Consume the service
MockHandler consumer = new MockHandler();
Exchange exchange = service.createExchange(consumer);
exchange.send(exchange.createMessage());
// wait, since this is async
provider.waitForOKMessage();
consumer.waitForFaultMessage();
// Now try send another message on the Exchange... should result in an IllegalStateException...
try {
exchange.send(exchange.createMessage());
} catch (IllegalStateException e) {
Assert.assertEquals("Exchange instance is in a FAULT state.", e.getMessage());
}
}
private Exchange sendMessage(ServiceReference ref, Object content) {
Exchange exchange = ref.createExchange(new MockHandler());
exchange.send(exchange.createMessage().setContent(content));
return exchange;
}
/**
* Send a message hash to the specified operation.
*
* @param operationName The operation name.
* @param rubyHash The message hash.
* @return The response object if an IN_OUT operation was invoked, otherwise null.
* @throws Throwable An exception occurred while invoking the target operation.
*/
public Object send(String operationName, RubyHash rubyHash) throws Throwable {
if (operationName == null) {
throw new IllegalArgumentException("null 'operationName' argument.");
}
if (rubyHash == null) {
throw new IllegalArgumentException("null 'rubyHash' argument.");
}
ServiceOperation operation = _serviceReference.getInterface().getOperation(operationName);
if (operation == null) {
throw new IllegalArgumentException(
"Unknown operation name '"
+ operationName
+ "' on Service '"
+ _serviceReference.getName()
+ "'.");
}
// Clone the RubyHash to convert it to a normal Map based graph. This makes it possible
// to more safely transport the payload data out of the ruby app via a SwitchYard Exchange...
Map<String, Object> payload = deepClone(rubyHash);
// Create the exchange contract...
BaseExchangeContract exchangeContract = new BaseExchangeContract(operation);
// Set the input type...
exchangeContract
.getInvokerInvocationMetaData()
.setInputType(JavaService.toMessageType(payload.getClass()));
if (operation.getExchangePattern() == ExchangePattern.IN_OUT) {
final BlockingQueue<Exchange> responseQueue = new ArrayBlockingQueue<Exchange>(1);
AtomicReference<ExchangeHandler> responseExchangeHandler =
new AtomicReference<ExchangeHandler>(
new ExchangeHandler() {
public void handleMessage(Exchange exchange) throws HandlerException {
responseQueue.offer(exchange);
}
public void handleFault(Exchange exchange) {
responseQueue.offer(exchange);
}
});
Exchange exchange =
_serviceReference.createExchange(exchangeContract, responseExchangeHandler.get());
Message message = exchange.createMessage().setContent(payload);
exchange.send(message);
Exchange exchangeOut = null;
try {
exchangeOut = responseQueue.take();
} catch (InterruptedException e) {
throw new SwitchYardException(
"Operation '"
+ operationName
+ "' on Service '"
+ _serviceReference.getName()
+ "' interrupted.",
e);
}
if (exchangeOut.getState() == ExchangeState.OK) {
return exchangeOut.getMessage().getContent();
} else {
Object failureObj = exchangeOut.getMessage().getContent();
if (failureObj instanceof Throwable) {
if (failureObj instanceof InvocationTargetException) {
throw ((Throwable) failureObj).getCause();
} else {
throw (Throwable) failureObj;
}
} else {
throw new SwitchYardException(
"Service invocation failure. Service '"
+ _serviceReference.getName()
+ "', operation '"
+ operationName
+ "'. Non Throwable failure message payload: "
+ failureObj);
}
}
} else {
Exchange exchange = _serviceReference.createExchange(exchangeContract);
Message message = exchange.createMessage().setContent(payload);
exchange.send(message);
}
return null;
}