@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 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 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 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"); }
@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); }
/** 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 ServiceReference createMockServiceRef() { final ServiceReference serviceReference = mock(ServiceReference.class); when(serviceReference.getInterface()).thenReturn(JavaService.fromClass(MockService.class)); return serviceReference; }
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; }