| Commit in servicemix/base on MAIN | |||
| project.xml | +3 | 1.92 -> 1.93 | |
| src/test/java/org/servicemix/jbi/messaging/MEPExchangeTest.java | +422 | added 1.1 | |
| +425 | |||
Add JBI compliance test (currently disabled)
servicemix/base
diff -u -r1.92 -r1.93 --- project.xml 7 Oct 2005 08:40:49 -0000 1.92 +++ project.xml 10 Oct 2005 10:20:33 -0000 1.93 @@ -1053,6 +1053,9 @@
<!-- fails on some platforms due to ActiveCluster issue -->
<exclude>**/ClusterFlowTest.*</exclude>
+ + <!-- JBI compliance disabled for now --> + <exclude>**/MEPExchangeTest.*</exclude>
</excludes>
</unitTest>
<resources>
servicemix/base/src/test/java/org/servicemix/jbi/messaging
MEPExchangeTest.java added at 1.1
diff -N MEPExchangeTest.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ MEPExchangeTest.java 10 Oct 2005 10:20:33 -0000 1.1 @@ -0,0 +1,422 @@
+/**
+ *
+ * Copyright 2005 LogicBlaze, Inc. http://www.logicblaze.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ **/
+package org.servicemix.jbi.messaging;
+
+import javax.jbi.messaging.DeliveryChannel;
+import javax.jbi.messaging.ExchangeStatus;
+import javax.jbi.messaging.InOnly;
+import javax.jbi.messaging.InOptionalOut;
+import javax.jbi.messaging.InOut;
+import javax.jbi.messaging.MessageExchangeFactory;
+import javax.jbi.messaging.MessagingException;
+import javax.jbi.messaging.NormalizedMessage;
+import javax.jbi.messaging.RobustInOnly;
+import javax.xml.namespace.QName;
+
+import junit.framework.TestCase;
+
+import org.servicemix.components.util.ComponentSupport;
+import org.servicemix.jbi.container.JBIContainer;
+import org.servicemix.jbi.jaxp.StringSource;
+
+public class MEPExchangeTest extends TestCase {
+
+ public static final String PAYLOAD = "<payload/>";
+ public static final String RESPONSE = "<response/>";
+
+ private JBIContainer container;
+ private TestComponent provider;
+ private TestComponent consumer;
+
+ public static class TestComponent extends ComponentSupport {
+ public TestComponent(QName service, String endpoint) {
+ super(service, endpoint);
+ }
+ public DeliveryChannel getChannel() throws MessagingException {
+ return getContext().getDeliveryChannel();
+ }
+ }
+
+ public void setUp() throws Exception {
+ // Create jbi container
+ container = new JBIContainer();
+ container.setFlowName("st");
+ container.init();
+ container.start();
+ // Create components
+ provider = new TestComponent(new QName("provider"), "endpoint");
+ consumer = new TestComponent(new QName("consumer"), "endpoint");
+ // Register components
+ container.activateComponent(provider, "provider");
+ container.activateComponent(consumer, "consumer");
+ }
+
+ public void tearDown() throws Exception {
+ if (container != null) {
+ container.shutDown();
+ }
+ container = null;
+ }
+
+ public void testInOnly() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOnly mec = mef.createInOnlyExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ InOnly mep = (InOnly) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ mep.setStatus(ExchangeStatus.DONE);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOnlySync() throws Exception {
+ // Create thread to answer
+ new Thread(new Runnable() {
+ public void run() {
+ try {
+ // Provider side
+ InOnly mep = (InOnly) provider.getChannel().accept(10000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ mep.setStatus(ExchangeStatus.DONE);
+ provider.getChannel().send(mep);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail();
+ }
+ }
+ }).start();
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOnly mec = mef.createInOnlyExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().sendSync(mec, 10000L);
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOut() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOut mec = mef.createInOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ InOut mep = (InOut) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ m = mep.createMessage();
+ m.setContent(new StringSource(RESPONSE));
+ mep.setOutMessage(m);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.ACTIVE, mec.getStatus());
+ mec.setStatus(ExchangeStatus.DONE);
+ consumer.getChannel().send(mec);
+ // Provider site
+ assertSame(mep, provider.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOutSync() throws Exception {
+ // Create thread to answer
+ new Thread(new Runnable() {
+ public void run() {
+ try {
+ // Provider side
+ InOut mep = (InOut) provider.getChannel().accept(10000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ NormalizedMessage m = mep.createMessage();
+ m.setContent(new StringSource(RESPONSE));
+ mep.setOutMessage(m);
+ provider.getChannel().send(mep);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail();
+ }
+ }
+ }).start();
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOut mec = mef.createInOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().sendSync(mec, 10000L);
+ assertEquals(ExchangeStatus.ACTIVE, mec.getStatus());
+ mec.setStatus(ExchangeStatus.DONE);
+ consumer.getChannel().send(mec);
+ // Provider site
+ assertNotNull(provider.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOutSyncSync() throws Exception {
+ // Create thread to answer
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ try {
+ // Provider side
+ InOut mep = (InOut) provider.getChannel().accept(10000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ NormalizedMessage m = mep.createMessage();
+ m.setContent(new StringSource(RESPONSE));
+ mep.setOutMessage(m);
+ provider.getChannel().sendSync(mep);
+ assertEquals(ExchangeStatus.DONE, mep.getStatus());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail();
+ }
+ }
+ });
+ t.start();
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOut mec = mef.createInOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().sendSync(mec, 10000L);
+ assertEquals(ExchangeStatus.ACTIVE, mec.getStatus());
+ mec.setStatus(ExchangeStatus.DONE);
+ consumer.getChannel().send(mec);
+ // Wait until other thread end
+ t.join(1000L);
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOutWithFault() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOut mec = mef.createInOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ InOut mep = (InOut) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ m = mep.createMessage();
+ m.setContent(new StringSource(RESPONSE));
+ mep.setStatus(ExchangeStatus.ERROR);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.ERROR, mec.getStatus());
+ mec.setStatus(ExchangeStatus.DONE);
+ consumer.getChannel().send(mec);
+ // Provider site
+ assertSame(mep, provider.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOptOutWithRep() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOptionalOut mec = mef.createInOptionalOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ InOptionalOut mep = (InOptionalOut) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ m = mep.createMessage();
+ m.setContent(new StringSource(RESPONSE));
+ mep.setOutMessage(m);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.ACTIVE, mec.getStatus());
+ mec.setStatus(ExchangeStatus.DONE);
+ consumer.getChannel().send(mec);
+ // Provider site
+ assertSame(mep, provider.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOptOutWithoutRep() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOptionalOut mec = mef.createInOptionalOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ InOptionalOut mep = (InOptionalOut) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ mep.setStatus(ExchangeStatus.DONE);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOptOutWithProviderFault() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOptionalOut mec = mef.createInOptionalOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ InOptionalOut mep = (InOptionalOut) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ mep.setStatus(ExchangeStatus.ERROR);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.ERROR, mec.getStatus());
+ mec.setStatus(ExchangeStatus.DONE);
+ consumer.getChannel().send(mec);
+ // Provider site
+ assertSame(mep, provider.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testInOptOutWithRepAndConsumerFault() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ InOptionalOut mec = mef.createInOptionalOutExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ InOptionalOut mep = (InOptionalOut) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ m = mep.createMessage();
+ m.setContent(new StringSource(RESPONSE));
+ mep.setOutMessage(m);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.ACTIVE, mec.getStatus());
+ mec.setStatus(ExchangeStatus.ERROR);
+ consumer.getChannel().send(mec);
+ // Provider site
+ assertSame(mep, provider.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.ERROR, mep.getStatus());
+ mep.setStatus(ExchangeStatus.DONE);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testRobustInOnly() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ RobustInOnly mec = mef.createRobustInOnlyExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ RobustInOnly mep = (RobustInOnly) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ mep.setStatus(ExchangeStatus.DONE);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mec.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+ public void testRobustInOnlyWithFault() throws Exception {
+ // Send message exchange
+ MessageExchangeFactory mef = consumer.getChannel().createExchangeFactoryForService(new QName("provider"));
+ RobustInOnly mec = mef.createRobustInOnlyExchange();
+ NormalizedMessage m = mec.createMessage();
+ m.setContent(new StringSource(PAYLOAD));
+ mec.setInMessage(m);
+ consumer.getChannel().send(mec);
+ // Provider side
+ RobustInOnly mep = (RobustInOnly) provider.getChannel().accept(1000L);
+ assertNotNull(mep);
+ assertEquals(ExchangeStatus.ACTIVE, mep.getStatus());
+ mep.setStatus(ExchangeStatus.ERROR);
+ provider.getChannel().send(mep);
+ // Consumer side
+ assertSame(mec, consumer.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.ERROR, mec.getStatus());
+ mec.setStatus(ExchangeStatus.DONE);
+ provider.getChannel().send(mec);
+ // Provider site
+ assertSame(mep, provider.getChannel().accept(1000L));
+ assertEquals(ExchangeStatus.DONE, mep.getStatus());
+ // Nothing left
+ assertNull(consumer.getChannel().accept(1000L)); // receive in
+ assertNull(provider.getChannel().accept(1000L)); // receive in
+ }
+
+}
