1
2
3
4
5
6
7
8
9
10
11 package org.mule.transport.jms.integration;
12
13 import org.mule.RequestContext;
14 import org.mule.tck.testmodels.fruit.Orange;
15 import org.mule.transformer.types.DataTypeFactory;
16 import org.mule.transport.jms.transformers.AbstractJmsTransformer;
17 import org.mule.transport.jms.transformers.JMSMessageToObject;
18 import org.mule.util.FileUtils;
19 import org.mule.util.compression.CompressionStrategy;
20 import org.mule.util.compression.GZipCompression;
21
22 import java.io.File;
23 import java.util.ArrayList;
24 import java.util.Arrays;
25 import java.util.HashMap;
26 import java.util.List;
27 import java.util.Map;
28
29 import javax.jms.BytesMessage;
30 import javax.jms.MapMessage;
31 import javax.jms.ObjectMessage;
32 import javax.jms.Session;
33 import javax.jms.StreamMessage;
34 import javax.jms.TextMessage;
35
36 import org.apache.commons.io.output.ByteArrayOutputStream;
37 import org.junit.Test;
38
39
40
41
42
43 public class JmsTransformersTestCase extends AbstractJmsFunctionalTestCase
44 {
45 private Session session = null;
46
47 @Override
48 protected String getConfigResources()
49 {
50 return "integration/jms-transformers.xml";
51 }
52
53 @Override
54 protected void doSetUp() throws Exception
55 {
56 super.doSetUp();
57
58 session = getConnection(false, false).createSession(false, Session.AUTO_ACKNOWLEDGE);
59 }
60
61 @Override
62 protected void doTearDown() throws Exception
63 {
64 RequestContext.setEvent(null);
65 if (session != null)
66 {
67 session.close();
68 session = null;
69 }
70 }
71
72 @Test
73 public void testTransformObjectMessage() throws Exception
74 {
75 RequestContext.setEvent(getTestEvent("test"));
76
77 ObjectMessage oMsg = session.createObjectMessage();
78 File f = FileUtils.newFile("/some/random/path");
79 oMsg.setObject(f);
80 AbstractJmsTransformer trans = createObject(JMSMessageToObject.class);
81 Object result = trans.transform(oMsg);
82 assertTrue("Transformed object should be a File", result.getClass().equals(File.class));
83
84 AbstractJmsTransformer trans2 = new SessionEnabledObjectToJMSMessage(session);
85 trans2.setReturnDataType(DataTypeFactory.create(ObjectMessage.class));
86 initialiseObject(trans2);
87 Object result2 = trans2.transform(f);
88 assertTrue("Transformed object should be an object message", result2 instanceof ObjectMessage);
89 }
90
91 @Test
92 public void testTransformTextMessage() throws Exception
93 {
94 RequestContext.setEvent(getTestEvent("test"));
95
96 String text = "This is a test TextMessage";
97 TextMessage tMsg = session.createTextMessage();
98 tMsg.setText(text);
99
100 AbstractJmsTransformer trans = createObject(JMSMessageToObject.class);
101 Object result = trans.transform(tMsg);
102 assertTrue("Transformed object should be a string", text.equals(result.toString()));
103
104 AbstractJmsTransformer trans2 = new SessionEnabledObjectToJMSMessage(session);
105 trans2.setReturnDataType(DataTypeFactory.create(TextMessage.class));
106 initialiseObject(trans2);
107 Object result2 = trans2.transform(text);
108 assertTrue("Transformed object should be a TextMessage", result2 instanceof TextMessage);
109 }
110
111 @Test
112 public void testTransformMapMessage() throws Exception
113 {
114 RequestContext.setEvent(getTestEvent("test"));
115
116 Map p = new HashMap();
117 p.put("Key1", "Value1");
118 p.put("Key2", new byte[]{1,2,3});
119 p.put("Key3", new Double(99.999));
120
121 AbstractJmsTransformer trans = new SessionEnabledObjectToJMSMessage(session);
122 trans.setReturnDataType(DataTypeFactory.create(MapMessage.class));
123 initialiseObject(trans);
124 Object result2 = trans.transform(p);
125 assertTrue("Transformed object should be a MapMessage", result2 instanceof MapMessage);
126
127 MapMessage mMsg = (MapMessage) result2;
128 AbstractJmsTransformer trans2 = createObject(JMSMessageToObject.class);
129 trans2.setReturnDataType(DataTypeFactory.create(Map.class));
130 Object result = trans2.transform(mMsg);
131 assertTrue("Transformed object should be a Map", result instanceof Map);
132
133 Map m = (Map)result;
134 assertEquals("Value1", m.get("Key1"));
135 assertTrue(Arrays.equals(new byte[]{1,2,3}, (byte[])m.get("Key2")));
136 assertEquals(new Double(99.999), m.get("Key3"));
137
138 }
139
140 @Test
141 public void testTransformMapToObjectMessage() throws Exception
142 {
143 RequestContext.setEvent(getTestEvent("test"));
144
145 Map p = new HashMap();
146 p.put("Key1", "Value1");
147 p.put("Key2", new byte[]{1,2,3});
148 p.put("Key3", new Double(99.999));
149 p.put("Key4", new Orange());
150
151 AbstractJmsTransformer trans = new SessionEnabledObjectToJMSMessage(session);
152 trans.setReturnDataType(DataTypeFactory.create(ObjectMessage.class));
153 initialiseObject(trans);
154 Object result2 = trans.transform(p);
155 assertTrue("Transformed object should be a ObjectMessage", result2 instanceof ObjectMessage);
156
157 ObjectMessage oMsg = (ObjectMessage) result2;
158 AbstractJmsTransformer trans2 = createObject(JMSMessageToObject.class);
159 trans2.setReturnDataType(DataTypeFactory.create(Map.class));
160 Object result = trans2.transform(oMsg);
161 assertTrue("Transformed object should be a Map", result instanceof Map);
162
163 Map m = (Map)result;
164 assertEquals("Value1", m.get("Key1"));
165 assertTrue(Arrays.equals(new byte[]{1,2,3}, (byte[])m.get("Key2")));
166 assertEquals(new Double(99.999), m.get("Key3"));
167 assertEquals(new Orange(), m.get("Key4"));
168
169 }
170
171 @Test
172 public void testTransformByteMessage() throws Exception
173 {
174 RequestContext.setEvent(getTestEvent("test"));
175
176 AbstractJmsTransformer trans = new SessionEnabledObjectToJMSMessage(session);
177 trans.setReturnDataType(DataTypeFactory.create(BytesMessage.class));
178 initialiseObject(trans);
179 String text = "This is a test BytesMessage";
180 Object result2 = trans.transform(text.getBytes());
181 assertTrue("Transformed object should be a BytesMessage", result2 instanceof BytesMessage);
182
183 AbstractJmsTransformer trans2 = createObject(JMSMessageToObject.class);
184 trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
185 BytesMessage bMsg = (BytesMessage) result2;
186 Object result = trans2.transform(bMsg);
187 assertTrue("Transformed object should be a byte[]", result instanceof byte[]);
188 String res = new String((byte[]) result);
189 assertEquals("Source and result should be equal", text, res);
190 }
191
192 @Test
193 public void testTransformStreamMessage() throws Exception
194 {
195 RequestContext.setEvent(getTestEvent("test"));
196
197 String text = "Test Text";
198 int i = 97823;
199 double d = 0923.2143E124;
200 List list = new ArrayList();
201 list.add(new Integer(i));
202 list.add(new Double(d));
203 list.add(text);
204
205 StreamMessage message = session.createStreamMessage();
206 message.writeString(text);
207 message.writeInt(i);
208 message.writeDouble(d);
209 message.reset();
210
211 AbstractJmsTransformer trans = createObject(JMSMessageToObject.class);
212 Object transformedObject = trans.transform(message);
213 assertTrue("Transformed object should be a List", transformedObject instanceof List);
214
215 final List result = (List) transformedObject;
216 String newText = (String) result.get(0);
217 Integer newI = (Integer) result.get(1);
218 Double newD = (Double) result.get(2);
219 assertEquals(i, newI.intValue());
220 assertEquals(new Double(d), newD);
221 assertEquals(text, newText);
222 }
223
224
225
226
227
228
229
230
231
232 @Test
233 public void testCompressedBytesMessage() throws Exception
234 {
235 RequestContext.setEvent(getTestEvent("test"));
236
237
238 CompressionStrategy compressor = new GZipCompression();
239
240
241 ByteArrayOutputStream baos = new ByteArrayOutputStream();
242 for (int i = 0; i < 5000; i++)
243 {
244 baos.write(i);
245 }
246
247 byte[] originalBytes = baos.toByteArray();
248 byte[] compressedBytes = compressor.compressByteArray(originalBytes);
249 assertTrue("Source compressedBytes should be compressed", compressor.isCompressed(compressedBytes));
250
251
252 AbstractJmsTransformer trans = new SessionEnabledObjectToJMSMessage(session);
253 trans.setReturnDataType(DataTypeFactory.create(BytesMessage.class));
254 initialiseObject(trans);
255 Object result2 = trans.transform(compressedBytes);
256 assertTrue("Transformed object should be a Bytes message", result2 instanceof BytesMessage);
257
258
259 BytesMessage intermediate = (BytesMessage) result2;
260 intermediate.reset();
261 byte[] intermediateBytes = new byte[(int) (intermediate.getBodyLength())];
262 int intermediateSize = intermediate.readBytes(intermediateBytes);
263 assertTrue("Intermediate bytes must be compressed", compressor.isCompressed(intermediateBytes));
264 assertTrue("Intermediate bytes must be equal to compressed source", Arrays.equals(compressedBytes,
265 intermediateBytes));
266 assertEquals("Intermediate bytes and compressed source must have same size", compressedBytes.length,
267 intermediateSize);
268
269
270
271 AbstractJmsTransformer trans2 = createObject(JMSMessageToObject.class);
272 trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
273 BytesMessage bMsg = session.createBytesMessage();
274 bMsg.writeBytes(compressedBytes);
275 Object result = trans2.transform(bMsg);
276 assertTrue("Transformed object should be a byte[]", result instanceof byte[]);
277 assertTrue("Result should be compressed", compressor.isCompressed((byte[]) result));
278 assertTrue("Source and result should be equal", Arrays.equals(compressedBytes, (byte[]) result));
279 }
280
281 }