Beispiel #1
0
  @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);
  }
Beispiel #2
0
 @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());
 }
Beispiel #3
0
 @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));
 }
Beispiel #4
0
  /** 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());
  }
Beispiel #5
0
 @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());
 }
Beispiel #6
0
  @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);
  }
Beispiel #7
0
  @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));
  }
Beispiel #8
0
  @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());
  }
Beispiel #9
0
  @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());
  }
Beispiel #10
0
  @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
    }
  }
Beispiel #11
0
  @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");
  }
Beispiel #12
0
  /** 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);
  }
Beispiel #13
0
  @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());
    }
  }
Beispiel #14
0
 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;
  }