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