1
2
3
4
5
6
7 package org.mule.transport.jms.integration;
8
9 import org.mule.RequestContext;
10 import org.mule.tck.testmodels.fruit.Orange;
11 import org.mule.transformer.types.DataTypeFactory;
12 import org.mule.transport.jms.transformers.AbstractJmsTransformer;
13 import org.mule.transport.jms.transformers.JMSMessageToObject;
14 import org.mule.util.FileUtils;
15 import org.mule.util.compression.CompressionStrategy;
16 import org.mule.util.compression.GZipCompression;
17
18 import java.io.File;
19 import java.util.ArrayList;
20 import java.util.Arrays;
21 import java.util.HashMap;
22 import java.util.List;
23 import java.util.Map;
24
25 import javax.jms.BytesMessage;
26 import javax.jms.MapMessage;
27 import javax.jms.ObjectMessage;
28 import javax.jms.Session;
29 import javax.jms.StreamMessage;
30 import javax.jms.TextMessage;
31
32 import org.apache.commons.io.output.ByteArrayOutputStream;
33 import org.junit.Test;
34
35 import static org.junit.Assert.assertEquals;
36 import static org.junit.Assert.assertTrue;
37
38
39
40
41
42 public class JmsTransformersTestCase extends AbstractJmsFunctionalTestCase
43 {
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 @Test
140 public void testTransformMapToObjectMessage() throws Exception
141 {
142 RequestContext.setEvent(getTestEvent("test"));
143
144 Map p = new HashMap();
145 p.put("Key1", "Value1");
146 p.put("Key2", new byte[]{1,2,3});
147 p.put("Key3", new Double(99.999));
148 p.put("Key4", new Orange());
149
150 AbstractJmsTransformer trans = new SessionEnabledObjectToJMSMessage(session);
151 trans.setReturnDataType(DataTypeFactory.create(ObjectMessage.class));
152 initialiseObject(trans);
153 Object result2 = trans.transform(p);
154 assertTrue("Transformed object should be a ObjectMessage", result2 instanceof ObjectMessage);
155
156 ObjectMessage oMsg = (ObjectMessage) result2;
157 AbstractJmsTransformer trans2 = createObject(JMSMessageToObject.class);
158 trans2.setReturnDataType(DataTypeFactory.create(Map.class));
159 Object result = trans2.transform(oMsg);
160 assertTrue("Transformed object should be a Map", result instanceof Map);
161
162 Map m = (Map)result;
163 assertEquals("Value1", m.get("Key1"));
164 assertTrue(Arrays.equals(new byte[]{1,2,3}, (byte[])m.get("Key2")));
165 assertEquals(new Double(99.999), m.get("Key3"));
166 assertEquals(new Orange(), m.get("Key4"));
167 }
168
169 @Test
170 public void testTransformByteMessage() throws Exception
171 {
172 RequestContext.setEvent(getTestEvent("test"));
173
174 AbstractJmsTransformer trans = new SessionEnabledObjectToJMSMessage(session);
175 trans.setReturnDataType(DataTypeFactory.create(BytesMessage.class));
176 initialiseObject(trans);
177 String text = "This is a test BytesMessage";
178 Object result2 = trans.transform(text.getBytes());
179 assertTrue("Transformed object should be a BytesMessage", result2 instanceof BytesMessage);
180
181 AbstractJmsTransformer trans2 = createObject(JMSMessageToObject.class);
182 trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
183 BytesMessage bMsg = (BytesMessage) result2;
184 Object result = trans2.transform(bMsg);
185 assertTrue("Transformed object should be a byte[]", result instanceof byte[]);
186 String res = new String((byte[]) result);
187 assertEquals("Source and result should be equal", text, res);
188 }
189
190 @Test
191 public void testTransformStreamMessage() throws Exception
192 {
193 RequestContext.setEvent(getTestEvent("test"));
194
195 String text = "Test Text";
196 int i = 97823;
197 double d = 0923.2143E124;
198 List list = new ArrayList();
199 list.add(new Integer(i));
200 list.add(new Double(d));
201 list.add(text);
202
203 StreamMessage message = session.createStreamMessage();
204 message.writeString(text);
205 message.writeInt(i);
206 message.writeDouble(d);
207 message.reset();
208
209 AbstractJmsTransformer trans = createObject(JMSMessageToObject.class);
210 Object transformedObject = trans.transform(message);
211 assertTrue("Transformed object should be a List", transformedObject instanceof List);
212
213 final List result = (List) transformedObject;
214 String newText = (String) result.get(0);
215 Integer newI = (Integer) result.get(1);
216 Double newD = (Double) result.get(2);
217 assertEquals(i, newI.intValue());
218 assertEquals(new Double(d), newD);
219 assertEquals(text, newText);
220 }
221
222
223
224
225
226
227
228
229
230 @Test
231 public void testCompressedBytesMessage() throws Exception
232 {
233 RequestContext.setEvent(getTestEvent("test"));
234
235
236 CompressionStrategy compressor = new GZipCompression();
237
238
239 ByteArrayOutputStream baos = new ByteArrayOutputStream();
240 for (int i = 0; i < 5000; i++)
241 {
242 baos.write(i);
243 }
244
245 byte[] originalBytes = baos.toByteArray();
246 byte[] compressedBytes = compressor.compressByteArray(originalBytes);
247 assertTrue("Source compressedBytes should be compressed", compressor.isCompressed(compressedBytes));
248
249
250 AbstractJmsTransformer trans = new SessionEnabledObjectToJMSMessage(session);
251 trans.setReturnDataType(DataTypeFactory.create(BytesMessage.class));
252 initialiseObject(trans);
253 Object result2 = trans.transform(compressedBytes);
254 assertTrue("Transformed object should be a Bytes message", result2 instanceof BytesMessage);
255
256
257 BytesMessage intermediate = (BytesMessage) result2;
258 intermediate.reset();
259 byte[] intermediateBytes = new byte[(int) (intermediate.getBodyLength())];
260 int intermediateSize = intermediate.readBytes(intermediateBytes);
261 assertTrue("Intermediate bytes must be compressed", compressor.isCompressed(intermediateBytes));
262 assertTrue("Intermediate bytes must be equal to compressed source", Arrays.equals(compressedBytes,
263 intermediateBytes));
264 assertEquals("Intermediate bytes and compressed source must have same size", compressedBytes.length,
265 intermediateSize);
266
267
268
269 AbstractJmsTransformer trans2 = createObject(JMSMessageToObject.class);
270 trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
271 BytesMessage bMsg = session.createBytesMessage();
272 bMsg.writeBytes(compressedBytes);
273 Object result = trans2.transform(bMsg);
274 assertTrue("Transformed object should be a byte[]", result instanceof byte[]);
275 assertTrue("Result should be compressed", compressor.isCompressed((byte[]) result));
276 assertTrue("Source and result should be equal", Arrays.equals(compressedBytes, (byte[]) result));
277 }
278
279 }