View Javadoc

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