View Javadoc

1   /*
2    * $Id: InboundHeadersAnnotationTestCase.java 19519 2010-09-09 21:36:07Z dzapata $
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.api.MuleMessage;
13  import org.mule.api.config.MuleProperties;
14  import org.mule.api.expression.RequiredValueException;
15  import org.mule.module.client.MuleClient;
16  import org.mule.tck.FunctionalTestCase;
17  import org.mule.tck.testmodels.fruit.Apple;
18  import org.mule.tck.testmodels.fruit.Banana;
19  import org.mule.tck.testmodels.fruit.Orange;
20  
21  import java.util.HashMap;
22  import java.util.Iterator;
23  import java.util.List;
24  import java.util.Map;
25  import java.util.Set;
26  
27  public class InboundHeadersAnnotationTestCase extends FunctionalTestCase
28  {
29      private Map<String, Object> props;
30  
31      public InboundHeadersAnnotationTestCase()
32      {
33          setDisposeManagerPerSuite(true);
34      }
35  
36      @Override
37      protected String getConfigResources()
38      {
39          return "org/mule/test/annotations/inbound-headers-annotation.xml";
40      }
41  
42      @Override
43      public void doSetUp() throws Exception
44      {
45          super.doSetUp();
46          
47          props = new HashMap<String, Object>(3);
48          props.put("foo", "fooValue");
49          props.put("bar", "barValue");
50          props.put("baz", "bazValue");
51      }
52  
53      public void testSingleHeader() throws Exception
54      {
55          MuleClient client = new MuleClient(muleContext);
56          MuleMessage message = client.send("vm://header", null, props);
57          assertNotNull("return message from MuleClient.send() should not be null", message);
58          assertEquals("fooValue", message.getPayload());
59      }
60  
61      public void testSingleHeaderOptional() throws Exception
62      {
63          MuleClient client = new MuleClient(muleContext);
64          MuleMessage message = client.send("vm://headerOptional", null, props);
65          assertNotNull("return message from MuleClient.send() should not be null", message);
66          assertEquals("faz not set", message.getPayload());
67      }
68  
69  
70      public void testSingleHeaderWithType() throws Exception
71      {
72          Apple apple = new Apple();
73          props.put("apple", apple);
74  
75          MuleClient client = new MuleClient(muleContext);
76          MuleMessage message = client.send("vm://headerWithType", null, props);
77          assertNotNull("return message from MuleClient.send() should not be null", message);
78          assertEquals(apple, message.getPayload());
79      }
80  
81      public void testSingleHeaderWithBaseType() throws Exception
82      {
83          Apple apple = new Apple();
84          props.put("apple", apple);
85  
86          MuleClient client = new MuleClient(muleContext);
87          MuleMessage message = client.send("vm://headerWithBaseType", null, props);
88          assertNotNull("return message from MuleClient.send() should not be null", message);
89          assertEquals(apple, message.getPayload());
90      }
91  
92      public void testMapHeaders() throws Exception
93      {
94          MuleClient client = new MuleClient(muleContext);
95          MuleMessage message = client.send("vm://headers", null, props);
96          assertNotNull("return message from MuleClient.send() should not be null", message);
97          assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
98          Map<?, ?> result = (Map<?, ?>) message.getPayload();
99          assertEquals(2, result.size());
100         assertEquals("fooValue", result.get("foo"));
101         assertEquals("barValue", result.get("bar"));
102         assertNull(result.get("baz"));
103     }
104 
105     public void testMapHeadersMissing() throws Exception
106     {
107         props.remove("foo");
108         MuleClient client = new MuleClient(muleContext);
109         MuleMessage message = client.send("vm://headers", null, props);
110         assertNotNull("return message from MuleClient.send() should not be null", message);
111         assertNotNull(message.getExceptionPayload());
112         assertTrue(message.getExceptionPayload().getRootException() instanceof RequiredValueException);
113     }
114 
115     public void testMapSingleHeader() throws Exception
116     {
117         MuleClient client = new MuleClient(muleContext);
118         MuleMessage message = client.send("vm://singleHeaderMap", null, props);
119         assertNotNull("return message from MuleClient.send() should not be null", message);
120         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
121         Map<?, ?> result = (Map<?, ?>) message.getPayload();
122         assertEquals(1, result.size());
123         assertEquals("fooValue", result.get("foo"));
124         assertNull(result.get("bar"));
125         assertNull(result.get("baz"));
126     }
127 
128     public void testMapHeadersOptional() throws Exception
129     {
130         props.remove("baz");
131 
132         MuleClient client = new MuleClient(muleContext);
133         MuleMessage message = client.send("vm://headersOptional", null, props);
134         assertNotNull("return message from MuleClient.send() should not be null", message);
135         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
136         Map<?, ?> result = (Map<?, ?>) message.getPayload();
137         assertEquals(2, result.size());
138         assertEquals("fooValue", result.get("foo"));
139         assertEquals("barValue", result.get("bar"));
140         assertNull(result.get("baz"));
141     }
142 
143     public void testMapHeadersAllOptional() throws Exception
144     {
145         props.clear();
146 
147         MuleClient client = new MuleClient(muleContext);
148         MuleMessage message = client.send("vm://headersAllOptional", null, props);
149         assertNotNull("return message from MuleClient.send() should not be null", message);
150         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
151         Map<?, ?> result = (Map<?, ?>) message.getPayload();
152         //We just wan tot make sure we don't return null collections
153         assertEquals(0, result.size());
154     }
155 
156     public void testMapHeadersUnmodifiable() throws Exception
157     {
158 
159         MuleClient client = new MuleClient(muleContext);
160         MuleMessage message = client.send("vm://headersUnmodifiable", null, props);
161         assertNotNull("return message from MuleClient.send() should not be null", message);
162         assertNotNull("Exception should have been thrown", message.getExceptionPayload());
163         assertTrue(message.getExceptionPayload().getRootException() instanceof UnsupportedOperationException);
164     }
165 
166     public void testMapHeadersAll() throws Exception
167     {
168         MuleClient client = new MuleClient(muleContext);
169         MuleMessage message = client.send("vm://headersAll", null, props);
170         assertNotNull("return message from MuleClient.send() should not be null", message);
171         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
172         Map<?, ?> result = (Map<?, ?>) message.getPayload();
173         //Will include all Mule headers too
174         assertTrue(result.size() >= 3);
175         assertEquals("fooValue", result.get("foo"));
176         assertEquals("barValue", result.get("bar"));
177         assertEquals("bazValue", result.get("baz"));
178     }
179 
180     public void testMapHeadersWildcard() throws Exception
181     {
182         MuleClient client = new MuleClient(muleContext);
183         MuleMessage message = client.send("vm://headersWildcard", null, props);
184         assertNotNull("return message from MuleClient.send() should not be null", message);
185         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
186         Map<?, ?> result = (Map<?, ?>) message.getPayload();
187         printResult(result);
188         //Will match all Mule headers
189         assertEquals(3, result.size());
190         assertEquals("vm://headersWildcard", result.get(MuleProperties.MULE_ENDPOINT_PROPERTY));
191         assertTrue(result.keySet().contains(MuleProperties.MULE_SESSION_PROPERTY));
192     }
193 
194     public void testMapHeadersMultiWildcard() throws Exception
195     {
196         MuleClient client = new MuleClient(muleContext);
197         MuleMessage message = client.send("vm://headersMultiWildcard", null, props);
198         assertNotNull("return message from MuleClient.send() should not be null", message);
199         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
200         Map<?, ?> result = (Map<?, ?>) message.getPayload();
201         printResult(result);        
202         //Will match all Mule headers
203         assertEquals(5, result.size());
204 
205         //Match on MULE_*
206         assertEquals("vm://headersMultiWildcard", result.get(MuleProperties.MULE_ENDPOINT_PROPERTY));
207         assertTrue(result.keySet().contains(MuleProperties.MULE_SESSION_PROPERTY));
208 
209         //Match on ba*
210         assertEquals(result.get("bar"), "barValue");
211         assertEquals(result.get("baz"), "bazValue");
212 
213     }
214 
215     public void testMapHeadersWithGenerics() throws Exception
216     {
217         props.put("apple", new Apple());
218         props.put("banana", new Banana());
219         props.put("orange", new Orange());
220 
221         MuleClient client = new MuleClient(muleContext);
222         MuleMessage message = client.send("vm://headersWithGenerics", null, props);
223         assertNotNull("return message from MuleClient.send() should not be null", message);
224         assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
225         Map<?, ?> result = (Map<?, ?>) message.getPayload();
226         //Will match all Mule headers
227         assertEquals(2, result.size());
228 
229         assertEquals(new Apple(), result.get("apple"));
230         assertEquals(new Orange(), result.get("orange"));
231         assertNull(result.get("banana"));
232     }
233 
234     public void testListHeaders() throws Exception
235     {
236         MuleClient client = new MuleClient(muleContext);
237         MuleMessage message = client.send("vm://headersList", null, props);
238         assertNotNull("return message from MuleClient.send() should not be null", message);
239         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
240         List<?> result = (List<?>) message.getPayload();
241         assertEquals(3, result.size());
242         assertTrue(result.contains("fooValue"));
243         assertTrue(result.contains("barValue"));
244         assertTrue(result.contains("bazValue"));
245     }
246 
247     public void testListHeadersWithOptional() throws Exception
248     {
249         props.remove("baz");
250         MuleClient client = new MuleClient(muleContext);
251         MuleMessage message = client.send("vm://headersListOptional", null, props);
252         assertNotNull("return message from MuleClient.send() should not be null", message);
253         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
254         List<?> result = (List<?>) message.getPayload();
255         assertEquals(2, result.size());
256         assertTrue(result.contains("fooValue"));
257         assertTrue(result.contains("barValue"));
258     }
259 
260     public void testListHeadersWithMissing() throws Exception
261     {
262         props.remove("bar");
263         MuleClient client = new MuleClient(muleContext);
264         MuleMessage message = client.send("vm://headersListOptional", null, props);
265         assertNotNull("return message from MuleClient.send() should not be null", message);
266         assertNotNull(message.getExceptionPayload());
267         assertTrue(message.getExceptionPayload().getRootException() instanceof RequiredValueException);
268     }
269 
270     public void testSingleListHeader() throws Exception
271     {
272         MuleClient client = new MuleClient(muleContext);
273         MuleMessage message = client.send("vm://singleHeaderList", null, props);
274         assertNotNull("return message from MuleClient.send() should not be null", message);
275         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
276         List<?> result = (List<?>) message.getPayload();
277         assertEquals(1, result.size());
278         assertTrue(result.contains("fooValue"));
279     }
280 
281     public void testListHeadersUnmodifiable() throws Exception
282     {
283         MuleClient client = new MuleClient(muleContext);
284         MuleMessage message = client.send("vm://headersListUnmodifiable", null, props);
285         assertNotNull("return message from MuleClient.send() should not be null", message);
286         assertNotNull("Exception should have been thrown", message.getExceptionPayload());
287         assertTrue(message.getExceptionPayload().getRootException() instanceof UnsupportedOperationException);
288     }
289 
290     public void testListHeadersAll() throws Exception
291     {
292         MuleClient client = new MuleClient(muleContext);
293         MuleMessage message = client.send("vm://headersListAll", null, props);
294         assertNotNull("return message from MuleClient.send() should not be null", message);
295         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
296         List<?> result = (List<?>) message.getPayload();
297         //Will include all Mule headers too
298         assertTrue(result.size() >= 3);
299         assertTrue(result.contains("fooValue"));
300         assertTrue(result.contains("barValue"));
301         assertTrue(result.contains("bazValue"));
302     }
303 
304     public void testMapHeadersListAllOptional() throws Exception
305     {
306         props.clear();
307 
308         MuleClient client = new MuleClient(muleContext);
309         MuleMessage message = client.send("vm://headersListAllOptional", null, props);
310         assertNotNull("return message from MuleClient.send() should not be null", message);
311         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
312         List<?> result = (List<?>) message.getPayload();
313         //We just want ot make sure we don't return null collections
314         assertEquals(0, result.size());
315     }
316 
317     public void testListHeadersWilcard() throws Exception
318     {
319         MuleClient client = new MuleClient(muleContext);
320         MuleMessage message = client.send("vm://headersListWildcard", null, props);
321         assertNotNull("return message from MuleClient.send() should not be null", message);
322         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
323         List<?> result = (List<?>) message.getPayload();
324         printResult(result);        
325         //Will match all Mule headers
326         assertEquals(3, result.size());
327 
328         //MULE_ENDPOINT
329         assertTrue(result.contains("vm://headersListWildcard"));
330         //The last value is the encoded session
331     }
332 
333     public void testListHeadersMultiWilcard() throws Exception
334     {
335         MuleClient client = new MuleClient(muleContext);
336         MuleMessage message = client.send("vm://headersListMultiWildcard", null, props);
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         printResult(result);
341         //Will match on MULE_* and ba*
342         assertEquals(5, result.size());
343 
344         //Match on MULE_*
345 
346         //MULE_ENDPOINT
347         assertTrue(result.contains("vm://headersListMultiWildcard"));
348         //The last value is the encoded session
349 
350         //Match on ba*
351         //bar
352         assertTrue(result.contains("barValue"));
353 
354         //baz
355         assertTrue(result.contains("bazValue"));
356     }
357 
358     public void testListHeadersWithGenerics() throws Exception
359     {
360         Apple apple = new Apple();
361         Banana banana = new Banana();
362         Orange orange = new Orange();
363         props.put("apple", apple);
364         props.put("banana", banana);
365         props.put("orange", orange);
366 
367         MuleClient client = new MuleClient(muleContext);
368         MuleMessage message = client.send("vm://headersListWithGenerics", null, props);
369         assertNotNull("return message from MuleClient.send() should not be null", message);
370         assertTrue("Message payload should be a List", message.getPayload() instanceof List);
371         List<?> result = (List<?>) message.getPayload();
372         //Will match all Mule headers
373         assertEquals(2, result.size());
374 
375         assertTrue(result.contains(apple));
376         assertTrue(result.contains(orange));
377         assertFalse(result.contains(banana));
378     }
379 
380     public void printResult(List<?> result)
381     {
382         for(int i = 0; i < result.size(); i++)
383         {
384             System.out.println("result #" + i + ": " + result.get(i));
385         }
386     }    
387     
388     public void printResult(Map<?, ?> result)
389     {
390         Set keys = result.keySet();         // The set of keys in the map.
391         Iterator keyIter = keys.iterator();
392         System.out.println("The map contains the following associations:");
393         while (keyIter.hasNext())
394         {
395            Object key = keyIter.next();  // Get the next key.
396            Object value = result.get(key);  // Get the value for that key.
397            System.out.println( "   (" + key + "," + value + ")" );
398         }    
399     }
400 }