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