View Javadoc

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