View Javadoc

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