View Javadoc

1   /*
2    * $Id: JmsTransformersTestCase.java 22431 2011-07-18 07:40:35Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.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  
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   * <code>JmsTransformersTestCase</code> Tests the JMS transformer implementations.
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     // The following test was disabled for ActiveMQ 3.x because ActiveMQ 3.2.4
227     // unconditionally uncompresses BytesMessages for reading, even if it is not
228     // supposed to do so (the layer doing the message reading seems to have no access
229     // to the Broker configuration and seems to assume that compressed data was
230     // compressed by ActiveMQ for more efficient wire transport).
231     // This was fixed in 4.x.
232     // For more information why this was VERY BAD read:
233     // http://en.wikipedia.org/wiki/Zip_of_death
234     @Test
235     public void testCompressedBytesMessage() throws Exception
236     {
237         RequestContext.setEvent(getTestEvent("test"));
238 
239         // use GZIP
240         CompressionStrategy compressor = new GZipCompression();
241 
242         // create compressible data
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         // now create a BytesMessage from the compressed byte[]
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         // check whether the BytesMessage contains the compressed bytes
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         // now test the other way around: getting the byte[] from a manually created
272         // BytesMessage
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 }