View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
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   * <code>JmsTransformersTestCase</code> Tests the JMS transformer implementations.
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     // The following test was disabled for ActiveMQ 3.x because ActiveMQ 3.2.4
223     // unconditionally uncompresses BytesMessages for reading, even if it is not
224     // supposed to do so (the layer doing the message reading seems to have no access
225     // to the Broker configuration and seems to assume that compressed data was
226     // compressed by ActiveMQ for more efficient wire transport).
227     // This was fixed in 4.x.
228     // For more information why this was VERY BAD read:
229     // http://en.wikipedia.org/wiki/Zip_of_death
230     @Test
231     public void testCompressedBytesMessage() throws Exception
232     {
233         RequestContext.setEvent(getTestEvent("test"));
234 
235         // use GZIP
236         CompressionStrategy compressor = new GZipCompression();
237 
238         // create compressible data
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         // now create a BytesMessage from the compressed byte[]
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         // check whether the BytesMessage contains the compressed bytes
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         // now test the other way around: getting the byte[] from a manually created
268         // BytesMessage
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 }