1   /*
2    * $Id: AbstractJmsFunctionalTestCase.java 10524 2008-01-24 19:20:11Z akuzmin $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  package org.mule.test.integration.providers.jms.functional;
11  
12  import org.mule.extras.client.MuleClient;
13  import org.mule.tck.FunctionalTestCase;
14  import org.mule.umo.UMOMessage;
15  
16  import javax.jms.Connection;
17  import javax.jms.ConnectionFactory;
18  import javax.jms.JMSException;
19  import javax.jms.Message;
20  import javax.jms.MessageConsumer;
21  import javax.jms.MessageProducer;
22  import javax.jms.Session;
23  import javax.jms.TextMessage;
24  import javax.transaction.HeuristicMixedException;
25  import javax.transaction.HeuristicRollbackException;
26  import javax.transaction.RollbackException;
27  import javax.transaction.SystemException;
28  
29  import org.apache.activemq.ActiveMQConnectionFactory;
30  import org.apache.activemq.command.ActiveMQQueue;
31  
32  /**
33   * The main idea
34   */
35  public abstract class AbstractJmsFunctionalTestCase extends FunctionalTestCase
36  {
37  
38      public static final String DEFAULT_BROKER_URL = "vm://localhost?broker.persistent=false&broker.useJmx=false";
39      public static final String DEFAULT_INPUT_MESSAGE = "INPUT MESSAGE";
40      public static final String DEFAULT_OUTPUT_MESSAGE = "OUTPUT MESSAGE";
41      public static final String DEFAULT_INPUT_MQ_QUEUE_NAME = "in";
42      public static final String DEFAULT_INPUT_MULE_QUEUE_NAME = "jms://" + DEFAULT_INPUT_MQ_QUEUE_NAME;
43      public static final String DEFAULT_OUTPUT_MQ_QUEUE_NAME = "out";
44      public static final String DEFAULT_OUTPUT_MULE_QUEUE_NAME = "jms://" + DEFAULT_OUTPUT_MQ_QUEUE_NAME;
45      public static final long TIMEOUT = 5000;
46      public static final long SMALL_TIMEOUT = 1000;
47      public static final long LOCK_WAIT = 1000;
48      public static final String CONNECTOR_NAME = "MuleMQConnector";
49      private MuleClient client;
50  
51      protected void dispatchMessage() throws Exception
52      {
53          client.dispatch(DEFAULT_INPUT_MULE_QUEUE_NAME, DEFAULT_INPUT_MESSAGE, null);
54      }
55  
56      protected UMOMessage recieveMessage() throws Exception
57      {
58          UMOMessage result = client.receive(DEFAULT_OUTPUT_MULE_QUEUE_NAME, TIMEOUT);
59          assertNotNull(result);
60          assertNotNull(result.getPayload());
61          assertNull(result.getExceptionPayload());
62          assertEquals(DEFAULT_OUTPUT_MESSAGE, result.getPayload());
63          return result;
64  
65      }
66  
67      public void runAsynchronousDispatching() throws Exception
68      {
69          dispatchMessage();
70          recieveMessage();
71          UMOMessage result = client.receive(DEFAULT_OUTPUT_MULE_QUEUE_NAME, SMALL_TIMEOUT);
72          assertNull(result);
73      }
74  
75  
76      protected void doPreFunctionalSetUp() throws Exception
77      {
78          super.doPreFunctionalSetUp();
79          client = new MuleClient();
80      }
81  
82      protected void doFunctionalTearDown() throws Exception
83      {
84          super.doFunctionalTearDown();
85          client.dispose();
86      }
87  
88      protected MuleClient getClient()
89      {
90          return client;
91      }
92  
93      interface Scenario
94      {
95          String getBrokerUrl();
96  
97          String getInputQueue();
98  
99          void setInputQueue(String inputQueue);
100 
101         String getOutputQueue();
102 
103         void setOutputQueue(String outputQueue);
104 
105         int getAcknowledge();
106 
107         void send(Session session, MessageProducer producer) throws JMSException, SystemException, HeuristicMixedException, HeuristicRollbackException, RollbackException;
108 
109         Message receive(Session session, MessageConsumer consumer) throws JMSException, SystemException, HeuristicMixedException, HeuristicRollbackException, RollbackException;
110 
111         boolean isTransacted();
112     }
113 
114     abstract class AbstractScenario implements Scenario
115     {
116 
117         private String inputQueue = DEFAULT_INPUT_MQ_QUEUE_NAME;
118         private String outputQueue = DEFAULT_OUTPUT_MQ_QUEUE_NAME;
119 
120         public String getBrokerUrl()
121         {
122             return DEFAULT_BROKER_URL;
123         }
124 
125         public String getInputQueue()
126         {
127             return inputQueue;
128         }
129 
130         public String getOutputQueue()
131         {
132             return outputQueue;
133         }
134 
135         public void setInputQueue(String inputQueue)
136         {
137             this.inputQueue = inputQueue;
138         }
139 
140         public void setOutputQueue(String outputQueue)
141         {
142             this.outputQueue = outputQueue;
143         }
144 
145         public int getAcknowledge()
146         {
147             return Session.AUTO_ACKNOWLEDGE;
148         }
149 
150         public boolean isTransacted()
151         {
152             return false;
153         }
154 
155         public void send(Session session, MessageProducer producer) throws JMSException, HeuristicMixedException, SystemException, HeuristicRollbackException, RollbackException
156         {
157             throw new UnsupportedOperationException();
158         }
159 
160         public Message receive(Session session, MessageConsumer consumer) throws JMSException, SystemException, HeuristicMixedException, HeuristicRollbackException, RollbackException
161         {
162             throw new UnsupportedOperationException();
163         }
164     }
165 
166     public void send(Scenario scenario) throws Exception
167     {
168         Connection connection = null;
169         try
170         {
171             ConnectionFactory factory = new ActiveMQConnectionFactory(scenario.getBrokerUrl());
172             connection = factory.createConnection();
173             connection.start();
174             Session session = null;
175             try
176             {
177                 session = connection.createSession(scenario.isTransacted(), scenario.getAcknowledge());
178                 ActiveMQQueue destination = new ActiveMQQueue(scenario.getInputQueue());
179                 MessageProducer producer = null;
180                 try
181                 {
182                     producer = session.createProducer(destination);
183                     scenario.send(session, producer);
184                 }
185                 finally
186                 {
187                     if (producer != null)
188                     {
189                         producer.close();
190                     }
191                 }
192             }
193             finally
194             {
195                 if (session != null)
196                 {
197                     session.close();
198                 }
199             }
200         }
201         finally
202         {
203             if (connection != null)
204             {
205                 connection.close();
206             }
207         }
208     }
209 
210 
211     public Message receive(Scenario scenario) throws Exception
212     {
213         Connection connection = null;
214         try
215         {
216             ConnectionFactory factory = new ActiveMQConnectionFactory(scenario.getBrokerUrl());
217             connection = factory.createConnection();
218             connection.start();
219             Session session = null;
220             try
221             {
222                 session = connection.createSession(scenario.isTransacted(), scenario.getAcknowledge());
223                 ActiveMQQueue destination = new ActiveMQQueue(scenario.getOutputQueue());
224                 MessageConsumer consumer = null;
225                 try
226                 {
227                     consumer = session.createConsumer(destination);
228                     return scenario.receive(session, consumer);
229                 }
230                 finally
231                 {
232                     if (consumer != null)
233                     {
234                         consumer.close();
235                     }
236                 }
237             }
238             finally
239             {
240                 if (session != null)
241                 {
242                     session.close();
243                 }
244             }
245         }
246         finally
247         {
248             if (connection != null)
249             {
250                 connection.close();
251             }
252         }
253     }
254 
255     Scenario scenarioRollback = new AbstractScenario()
256     {
257         public void send(Session session, MessageProducer producer) throws JMSException
258         {
259             producer.send(session.createTextMessage(DEFAULT_INPUT_MESSAGE));
260             session.rollback();
261         }
262 
263         public Message receive(Session session, MessageConsumer consumer) throws JMSException
264         {
265             Message message = consumer.receive(TIMEOUT);
266             assertNotNull(message);
267             assertTrue(TextMessage.class.isAssignableFrom(message.getClass()));
268             assertEquals(((TextMessage) message).getText(), DEFAULT_OUTPUT_MESSAGE);
269             session.rollback();
270             return message;
271         }
272 
273         public boolean isTransacted()
274         {
275             return true;
276         }
277     };
278 
279     Scenario scenarioCommit = new AbstractScenario()
280     {
281         public void send(Session session, MessageProducer producer) throws JMSException
282         {
283             producer.send(session.createTextMessage(DEFAULT_INPUT_MESSAGE));
284             session.commit();
285         }
286 
287         public Message receive(Session session, MessageConsumer consumer) throws JMSException
288         {
289             Message message = consumer.receive(TIMEOUT);
290             assertNotNull(message);
291             assertTrue(TextMessage.class.isAssignableFrom(message.getClass()));
292             assertEquals(((TextMessage) message).getText(), DEFAULT_OUTPUT_MESSAGE);
293             session.commit();
294             return message;
295         }
296 
297         public boolean isTransacted()
298         {
299             return true;
300         }
301 
302     };
303 
304     Scenario scenarioNotReceive = new AbstractScenario()
305     {
306         public void send(Session session, MessageProducer producer) throws JMSException
307         {
308             producer.send(session.createTextMessage(DEFAULT_INPUT_MESSAGE));
309         }
310 
311         public Message receive(Session session, MessageConsumer consumer) throws JMSException
312         {
313             Message message = consumer.receive(SMALL_TIMEOUT);
314             assertNull(message);
315             return message;
316         }
317 
318         public boolean isTransacted()
319         {
320             return false;
321         }
322 
323     };
324 
325     Scenario scenarioNoTx = new AbstractScenario()
326     {
327         public void send(Session session, MessageProducer producer) throws JMSException
328         {
329             producer.send(session.createTextMessage(DEFAULT_INPUT_MESSAGE));
330         }
331 
332         public Message receive(Session session, MessageConsumer consumer) throws JMSException
333         {
334             Message message = consumer.receive(TIMEOUT);
335             assertNotNull(message);
336             assertTrue(TextMessage.class.isAssignableFrom(message.getClass()));
337             assertEquals(((TextMessage) message).getText(), DEFAULT_OUTPUT_MESSAGE);
338             return message;
339         }
340     };
341 
342 
343 }