View Javadoc

1   /*
2    * $Id: InboundAttachmentsAnnotationTestCase.java 22735 2011-08-25 16:02:35Z dfeist $
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.api.annotations.param;
12  
13  import static org.junit.Assert.assertEquals;
14  import static org.junit.Assert.assertFalse;
15  import static org.junit.Assert.assertNotNull;
16  import static org.junit.Assert.assertNull;
17  import static org.junit.Assert.assertTrue;
18  
19  import org.mule.DefaultMuleMessage;
20  import org.mule.api.MuleMessage;
21  import org.mule.api.expression.RequiredValueException;
22  import org.mule.module.client.MuleClient;
23  import org.mule.tck.AbstractServiceAndFlowTestCase;
24  import org.mule.transformer.types.DataTypeFactory;
25  import org.mule.util.ExceptionUtils;
26  import org.mule.util.StringDataSource;
27  
28  import java.util.Arrays;
29  import java.util.Collection;
30  import java.util.HashMap;
31  import java.util.List;
32  import java.util.Map;
33  
34  import javax.activation.DataHandler;
35  
36  import org.junit.Test;
37  import org.junit.runners.Parameterized.Parameters;
38  
39  public class InboundAttachmentsAnnotationTestCase extends AbstractServiceAndFlowTestCase
40  {
41      private MuleMessage muleMessage;
42  
43      @Parameters
44      public static Collection<Object[]> parameters()
45      {
46          return Arrays.asList(new Object[][]{
47              {ConfigVariant.SERVICE, "org/mule/test/annotations/inbound-attachments-annotation-service.xml"},
48              {ConfigVariant.FLOW, "org/mule/test/annotations/inbound-attachments-annotation-flow.xml"}
49  
50          });
51      }
52  
53      public InboundAttachmentsAnnotationTestCase(ConfigVariant variant, String configResources)
54      {
55          super(variant, configResources);
56          setDisposeContextPerClass(true);
57      }
58  
59      @Override
60      public void doSetUp() throws Exception
61      {
62          super.doSetUp();
63          muleMessage  = createMessage(null, null);
64          //These should really be in core, but the @Transformer annotation is not in core
65          muleContext.getRegistry().registerObject("dataHandlerTransformers", new DataHandlerTransformer());
66      }
67  
68      protected MuleMessage createMessage(Map<String, Object> headers, Map<String, DataHandler> attachments) throws Exception
69      {
70          if(headers==null)
71          {
72              headers = new HashMap<String, Object>();
73              headers.put("foo", "fooValue");
74              headers.put("bar", "barValue");
75              headers.put("baz", "bazValue");
76          }
77  
78          if(attachments==null)
79          {
80              attachments = new HashMap<String, DataHandler>();
81              attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
82              attachments.put("bar", new DataHandler(new StringDataSource("barValue")));
83              attachments.put("baz", new DataHandler(new StringDataSource("bazValue")));
84          }
85          MuleMessage message;
86          message = new DefaultMuleMessage("test", muleContext);
87          for (Map.Entry<String, DataHandler> attachment : attachments.entrySet())
88          {
89              message.addOutboundAttachment(attachment.getKey(), attachment.getValue());
90          }
91          for (String s : headers.keySet())
92          {
93              message.setOutboundProperty(s, headers.get(s));
94          }
95          return message;
96      }
97  
98      @Test
99      public void testSingleAttachment() throws Exception
100     {
101         MuleClient client = new MuleClient(muleContext);
102         MuleMessage message = client.send("vm://attachment", muleMessage);
103         assertNotNull("return message from MuleClient.send() should not be null", message);
104         assertTrue(message.getPayload() instanceof DataHandler);
105         assertEquals("fooValue", ((DataHandler)message.getPayload()).getContent());
106     }
107 
108     @Test
109     public void testSingleAttachmentWithType() throws Exception
110     {
111         MuleClient client = new MuleClient(muleContext);
112         MuleMessage message = client.send("vm://attachmentWithType", muleMessage);
113         assertNotNull("return message from MuleClient.send() should not be null", message);
114         assertTrue(message.getPayload() instanceof String);
115         assertEquals("fooValue", message.getPayload());
116     }
117 
118     @Test
119     public void testSingleAttachmentOptional() throws Exception
120     {
121         MuleClient client = new MuleClient(muleContext);
122         MuleMessage message = client.send("vm://attachmentOptional", muleMessage);
123         assertNotNull("return message from MuleClient.send() should not be null", message);
124         assertEquals("faz not set", message.getPayload());
125     }
126 
127     @Test
128     public void testSingleAttachmentWithTypeNoMatchingTransform() throws Exception
129     {
130         //TODO this test still works because
131         MuleClient client = new MuleClient(muleContext);
132         MuleMessage message = client.send("vm://attachmentWithType", muleMessage);
133         assertNotNull("return message from MuleClient.send() should not be null", message);
134         assertTrue(message.getPayload() instanceof String);
135         assertEquals("fooValue", message.getPayload());
136     }
137 
138     @Test
139     public void testMapAttachments() throws Exception
140     {
141         MuleClient client = new MuleClient(muleContext);
142         MuleMessage message = client.send("vm://attachments", muleMessage);
143         assertNotNull("return message from MuleClient.send() should not be null", message);
144         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
145         Map<String, DataHandler> result = getMapPayload(message);
146         assertEquals(2, result.size());
147         assertEquals("fooValue", result.get("foo").getContent());
148         assertEquals("barValue", result.get("bar").getContent());
149         assertNull(result.get("baz"));
150     }
151 
152     @Test
153     public void testMapAttachmentsMissing() throws Exception
154     {
155         // clear attachments
156         muleMessage = createMessage(null, new HashMap<String, DataHandler>());
157         MuleMessage message = muleContext.getClient().send("vm://attachments", muleMessage);
158         assertNotNull(message);
159         assertNotNull(message.getExceptionPayload());
160         assertEquals(RequiredValueException.class,
161             ExceptionUtils.getRootCause(message.getExceptionPayload().getException()).getClass());
162     }
163 
164     @Test
165     public void testMapSingleAttachment() throws Exception
166     {
167         MuleClient client = new MuleClient(muleContext);
168         MuleMessage message = client.send("vm://singleAttachmentMap", muleMessage);
169         assertNotNull("return message from MuleClient.send() should not be null", message);
170         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
171         Map<String,  DataHandler> result = getMapPayload(message);
172         assertEquals(1, result.size());
173         assertEquals("fooValue", result.get("foo").getContent());
174         assertNull(result.get("bar"));
175         assertNull(result.get("baz"));
176     }
177 
178     @Test
179     public void testMapAttachmentsOptional() throws Exception
180     {
181         //clear baz attachment
182         Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
183         attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
184         attachments.put("bar", new DataHandler(new StringDataSource("barValue")));
185         muleMessage = createMessage(null, attachments);
186 
187         MuleClient client = new MuleClient(muleContext);
188         MuleMessage message = client.send("vm://attachmentsOptional", muleMessage);
189         assertNotNull("return message from MuleClient.send() should not be null", message);
190         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
191         Map<String, DataHandler> result = getMapPayload(message);
192         assertEquals(2, result.size());
193         assertEquals("fooValue", result.get("foo").getContent());
194         assertEquals("barValue", result.get("bar").getContent());
195         assertNull(result.get("baz"));
196     }
197 
198     @Test
199     public void testMapAttachmentsAllOptional() throws Exception
200     {
201         //clear attachments
202         muleMessage = createMessage(null, new HashMap<String, DataHandler>());
203 
204         MuleClient client = new MuleClient(muleContext);
205         MuleMessage message = client.send("vm://attachmentsAllOptional", muleMessage);
206         assertNotNull("return message from MuleClient.send() should not be null", message);
207         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
208         Map<?, ?> result = (Map<?, ?>) message.getPayload();
209         assertEquals(0, result.size());
210     }
211 
212     @Test
213     public void testMapAttachmentsUnmodifiable() throws Exception
214     {
215         MuleMessage message = muleContext.getClient().send("vm://attachmentsUnmodifiable", muleMessage);
216         assertNotNull(message);
217         assertNotNull(message.getExceptionPayload());
218         assertEquals(UnsupportedOperationException.class,
219             ExceptionUtils.getRootCause(message.getExceptionPayload().getException()).getClass());
220     }
221 
222     @Test
223     public void testMapAttachmentsAll() throws Exception
224     {
225         MuleClient client = new MuleClient(muleContext);
226         MuleMessage message = client.send("vm://attachmentsAll", muleMessage);
227         assertNotNull("return message from MuleClient.send() should not be null", message);
228         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
229         Map<String, DataHandler> result = getMapPayload(message);
230         //Will include all Mule attachments too
231         assertTrue(result.size() >= 3);
232         assertEquals("fooValue", result.get("foo").getContent());
233         assertEquals("barValue", result.get("bar").getContent());
234         assertEquals("bazValue", result.get("baz").getContent());
235     }
236 
237     @Test
238     public void testMapAttachmentsWildcard() throws Exception
239     {
240         MuleClient client = new MuleClient(muleContext);
241         MuleMessage message = client.send("vm://attachmentsWildcard", muleMessage);
242         assertNotNull("return message from MuleClient.send() should not be null", message);
243         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
244         Map<?, ?> result = message.getPayload(DataTypeFactory.create(Map.class));
245         //Will match on ba*
246         assertEquals(2, result.size());
247         assertNull(result.get("foo"));
248         assertNotNull(result.get("bar"));
249         assertNotNull(result.get("baz"));
250     }
251 
252     @Test
253     public void testMapAttachmentsMultiWildcard() throws Exception
254     {
255         MuleClient client = new MuleClient(muleContext);
256         MuleMessage message = client.send("vm://attachmentsMultiWildcard", muleMessage);
257         assertNotNull("return message from MuleClient.send() should not be null", message);
258         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
259         Map<?, ?> result = (Map<?, ?>) message.getPayload();
260         //Will match on ba*, f*
261         assertEquals(3, result.size());
262 
263         assertNotNull(result.get("foo"));
264         assertNotNull(result.get("bar"));
265         assertNotNull(result.get("baz"));
266     }
267 
268     @Test
269     public void testListAttachments() throws Exception
270     {
271         MuleClient client = new MuleClient(muleContext);
272         MuleMessage message = client.send("vm://attachmentsList", muleMessage);
273         assertNotNull("return message from MuleClient.send() should not be null", message);
274         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
275         List<?> result = (List<?>) message.getPayload();
276         assertEquals(3, result.size());
277         assertTrue(result.contains("fooValue"));
278         assertTrue(result.contains("barValue"));
279         assertTrue(result.contains("bazValue"));
280     }
281 
282     @Test
283     public void testListAttachmentsWithOptional() throws Exception
284     {
285         //clear baz attachment
286         Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
287         attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
288         attachments.put("bar", new DataHandler(new StringDataSource("barValue")));
289         muleMessage = createMessage(null, attachments);
290 
291         MuleClient client = new MuleClient(muleContext);
292         MuleMessage message = client.send("vm://attachmentsListOptional", muleMessage);
293         assertNotNull("return message from MuleClient.send() should not be null", message);
294         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
295         List<?> result = (List<?>) message.getPayload();
296         assertEquals(2, result.size());
297         assertTrue(result.contains("fooValue"));
298         assertTrue(result.contains("barValue"));
299     }
300 
301     @Test
302     public void testListAttachmentsWithAllOptional() throws Exception
303     {
304         //clear attachments
305         muleMessage = createMessage(null, new HashMap<String, DataHandler>());
306 
307         MuleClient client = new MuleClient(muleContext);
308         MuleMessage message = client.send("vm://attachmentsListAllOptional", muleMessage);
309         assertNotNull("return message from MuleClient.send() should not be null", message);
310         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
311         List<?> result = (List<?>) message.getPayload();
312         assertEquals(0, result.size());
313     }
314 
315     @Test
316     public void testListAttachmentsWithMissing() throws Exception
317     {
318         //clear bar attachment
319         Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
320         attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
321         attachments.put("baz", new DataHandler(new StringDataSource("bazValue")));
322         muleMessage = createMessage(null, attachments);
323         MuleMessage result = muleContext.getClient().send("vm://attachmentsListOptional", muleMessage);
324         assertNotNull(result);
325         assertNotNull(result.getExceptionPayload());
326         assertEquals(RequiredValueException.class,
327             ExceptionUtils.getRootCause(result.getExceptionPayload().getException()).getClass());
328 
329     }
330 
331     @Test
332     public void testSingleListAttachment() throws Exception
333     {
334         MuleClient client = new MuleClient(muleContext);
335         MuleMessage message = client.send("vm://singleAttachmentList", muleMessage);
336         assertNotNull("return message from MuleClient.send() should not be null", message);
337         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
338         List<?> result = (List<?>) message.getPayload();
339         assertEquals(1, result.size());
340         assertTrue(result.contains("fooValue"));
341     }
342 
343     @Test
344     public void testListAttachmentsUnmodifiable() throws Exception
345     {
346         MuleMessage result = muleContext.getClient().send("vm://attachmentsListUnmodifiable", muleMessage);
347         assertNotNull(result);
348         assertNotNull(result.getExceptionPayload());
349         assertEquals(UnsupportedOperationException.class,
350             ExceptionUtils.getRootCause(result.getExceptionPayload().getException()).getClass());
351     }
352 
353     @Test
354     public void testListAttachmentsAll() throws Exception
355     {
356         MuleClient client = new MuleClient(muleContext);
357         MuleMessage message = client.send("vm://attachmentsListAll", muleMessage);
358         assertNotNull("return message from MuleClient.send() should not be null", message);
359         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
360         List<?> result = (List<?>) message.getPayload();
361         //Will include all Mule attachments too
362         assertTrue(result.size() >= 3);
363         assertTrue(result.contains("fooValue"));
364         assertTrue(result.contains("barValue"));
365         assertTrue(result.contains("bazValue"));
366     }
367 
368     @Test
369     public void testListAttachmentsWilcard() throws Exception
370     {
371         MuleClient client = new MuleClient(muleContext);
372         MuleMessage message = client.send("vm://attachmentsListWildcard", muleMessage);
373         assertNotNull("return message from MuleClient.send() should not be null", message);
374         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
375         List<?> result = (List<?>) message.getPayload();
376         //Will match all attachments with ba*
377         assertEquals(2, result.size());
378         assertFalse(result.contains("fooValue"));
379         assertTrue(result.contains("barValue"));
380         assertTrue(result.contains("bazValue"));
381 
382     }
383 
384     @Test
385     public void testListAttachmentsMultiWilcard() throws Exception
386     {
387         MuleClient client = new MuleClient(muleContext);
388         MuleMessage message = client.send("vm://attachmentsListMultiWildcard", muleMessage);
389         assertNotNull("return message from MuleClient.send() should not be null", message);
390         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
391         List<?> result = (List<?>) message.getPayload();
392         //Will match all attachments with ba* and f*
393         assertEquals(3, result.size());
394         assertTrue(result.contains("fooValue"));
395         assertTrue(result.contains("barValue"));
396         assertTrue(result.contains("bazValue"));
397     }
398 
399     @SuppressWarnings("unchecked")
400     private Map<String, DataHandler> getMapPayload(MuleMessage message)
401     {
402         return (Map<String, DataHandler>) message.getPayload();
403     }
404 }