View Javadoc

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