1
2
3
4
5
6
7
8
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
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 }