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