View Javadoc

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