View Javadoc

1   /*
2    * $Id: HeadersExpressionEvaluatorTestCase.java 22377 2011-07-11 12:41:42Z dirk.olmes $
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.expression;
11  
12  import org.mule.DefaultMuleMessage;
13  import org.mule.api.MuleMessage;
14  import org.mule.api.config.MuleProperties;
15  import org.mule.api.expression.ExpressionRuntimeException;
16  import org.mule.api.expression.RequiredValueException;
17  import org.mule.api.transport.PropertyScope;
18  import org.mule.routing.correlation.CorrelationPropertiesExpressionEvaluator;
19  import org.mule.tck.junit4.AbstractMuleContextTestCase;
20  import org.mule.util.UUID;
21  
22  import java.util.Collections;
23  import java.util.HashMap;
24  import java.util.List;
25  import java.util.Map;
26  
27  import org.junit.Test;
28  
29  import static org.junit.Assert.assertEquals;
30  import static org.junit.Assert.assertFalse;
31  import static org.junit.Assert.assertNotNull;
32  import static org.junit.Assert.assertNull;
33  import static org.junit.Assert.assertTrue;
34  import static org.junit.Assert.fail;
35  
36  public class HeadersExpressionEvaluatorTestCase extends AbstractMuleContextTestCase
37  {
38      private Map<String, Object> props;
39  
40      @Override
41      public void doSetUp()
42      {
43          props = new HashMap<String, Object>(3);
44          props.put("foo", "foovalue");
45          props.put("bar", "barvalue");
46          props.put("baz", "bazvalue");
47      }
48  
49      @Test
50      public void testSingleHeader() throws Exception
51      {
52          MessageHeaderExpressionEvaluator eval = new MessageHeaderExpressionEvaluator();
53          MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
54  
55          // Value required + found
56          Object result = eval.evaluate("foo", message);
57          assertNotNull(result);
58          assertEquals("foovalue", result);
59  
60          // Value not required + found
61          result = eval.evaluate("foo?", message);
62          assertNotNull(result);
63          assertEquals("foovalue", result);
64  
65          // Value not required + not found
66          result = eval.evaluate("fool?", message);
67          assertNull(result);
68  
69          // Value required + not found (throws exception)
70          try
71          {
72              eval.evaluate("fool", message);
73              fail("required value");
74          }
75          catch (Exception e)
76          {
77              //Expected
78          }
79  
80          ((DefaultMuleMessage) message).addInboundProperties(Collections.singletonMap("testProp", (Object) "value"));
81          result = eval.evaluate("testProp?", message);
82          assertNull(result);
83  
84          result = eval.evaluate("INBOUND:testProp", message);
85          assertEquals("value", result);
86      }
87  
88      @Test
89      public void testMapHeaders() throws Exception
90      {
91          MessageHeadersExpressionEvaluator eval = new MessageHeadersExpressionEvaluator();
92  
93          MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
94  
95          // Value required + found
96          Object result = eval.evaluate("foo, baz", message);
97          assertNotNull(result);
98          assertTrue(result instanceof Map);
99          assertEquals(2, ((Map)result).size());
100         assertTrue(((Map)result).values().contains("foovalue"));
101         assertTrue(((Map)result).values().contains("bazvalue"));
102         assertFalse(((Map)result).values().contains("barvalue"));
103 
104         // Value not required + found
105         result = eval.evaluate("foo?, baz", message);
106         assertNotNull(result);        
107         assertTrue(result instanceof Map);
108         assertEquals(2, ((Map)result).size());
109         assertTrue(((Map)result).values().contains("foovalue"));
110         assertTrue(((Map)result).values().contains("bazvalue"));
111         assertFalse(((Map)result).values().contains("barvalue"));
112         
113         // Value not required + not found
114         result = eval.evaluate("fool?", message);
115         assertNotNull(result);
116         assertTrue(result instanceof Map);
117         assertEquals(0, ((Map)result).size());
118 
119         // Value required + not found (throws exception)
120         try
121         {
122             eval.evaluate("fool", message);
123             fail("required value");
124         }
125         catch (Exception e)
126         {
127             //Expected
128         }
129 
130         //Test all
131         result = eval.evaluate("*", message);
132         assertNotNull(result);
133         assertTrue(result instanceof Map);
134         assertEquals(3, ((Map)result).size());
135         assertTrue(((Map)result).values().contains("foovalue"));
136         assertTrue(((Map)result).values().contains("bazvalue"));
137         assertTrue(((Map)result).values().contains("barvalue"));
138     }
139 
140 @Test
141     public void testHeadersWithScopes() throws Exception
142     {
143         MessageHeadersExpressionEvaluator eval = new MessageHeadersExpressionEvaluator();
144         DefaultMuleMessage message = new DefaultMuleMessage("test", props, muleContext);
145         message.setProperty("faz", "fazvalue", PropertyScope.INVOCATION);
146 
147         Object result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz", message);
148         assertNotNull(result);
149         assertTrue(result instanceof Map);
150         assertEquals(2, ((Map)result).size());
151         assertTrue(((Map)result).values().contains("foovalue"));
152         assertTrue(((Map)result).values().contains("bazvalue"));
153 
154         //Setting the scope once will set the default for following names
155         result = eval.evaluate("OUTBOUND:foo, baz", message);
156         assertNotNull(result);
157         assertTrue(result instanceof Map);
158         assertEquals(2, ((Map)result).size());
159         assertTrue(((Map)result).values().contains("foovalue"));
160         assertTrue(((Map)result).values().contains("bazvalue"));
161 
162         result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz, INVOCATION:faz", message);
163         assertNotNull(result);
164         assertTrue(result instanceof Map);
165         assertEquals(3, ((Map)result).size());
166         assertTrue(((Map)result).values().contains("foovalue"));
167         assertTrue(((Map)result).values().contains("bazvalue"));
168         assertTrue(((Map)result).values().contains("fazvalue"));
169 
170         result = eval.evaluate("OUTBOUND:foo, baz, INVOCATION:faz", message);
171         assertNotNull(result);
172         assertTrue(result instanceof Map);
173         assertEquals(3, ((Map)result).size());
174         assertTrue(((Map)result).values().contains("foovalue"));
175         assertTrue(((Map)result).values().contains("bazvalue"));
176         assertTrue(((Map)result).values().contains("fazvalue"));
177 
178 
179         try
180         {
181             eval.evaluate("OUTBOUND:foo, baz, faz", message);
182             fail("faz is not in outbound scope and is not optional");
183         }
184         catch (RequiredValueException e)
185         {
186             //expected
187         }
188 
189         result = eval.evaluate("OUTBOUND:foo, faz?, baz", message);
190         assertNotNull(result);
191         assertTrue(result instanceof Map);
192         assertEquals(2, ((Map)result).size());
193         assertTrue(((Map)result).values().contains("foovalue"));
194         assertTrue(((Map)result).values().contains("bazvalue"));
195 
196         message.setInboundProperty("infoo", "infoovalue");
197         result = eval.evaluate("infoo?", message);
198         assertNotNull(result);
199         assertTrue(result instanceof Map);
200         assertEquals(0, ((Map)result).size());
201         result = eval.evaluate("INBOUND:infoo?", message);
202         assertNotNull(result);
203         assertTrue(result instanceof Map);
204         assertEquals(1, ((Map)result).size());
205     }
206 
207 
208     @Test
209     public void testListHeaders() throws Exception
210     {
211         MessageHeadersListExpressionEvaluator eval = new MessageHeadersListExpressionEvaluator();
212         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
213 
214         // Value required + found
215         Object result = eval.evaluate("foo, baz", message);
216         assertNotNull(result);
217         assertTrue(result instanceof List);
218         assertEquals(2, ((List)result).size());
219         assertTrue(((List)result).contains("foovalue"));
220         assertTrue(((List)result).contains("bazvalue"));
221         // redundant since we already know that the map is of size 2
222         assertFalse(((List)result).contains("barvalue"));
223 
224         // Value not required + found
225         result = eval.evaluate("foo?, baz", message);
226         assertNotNull(result);
227         assertTrue(result instanceof List);
228         assertEquals(2, ((List)result).size());
229         assertTrue(((List)result).contains("foovalue"));
230         assertTrue(((List)result).contains("bazvalue"));
231         // redundant since we already know that the map is of size 2
232         assertFalse(((List)result).contains("barvalue"));        
233 
234         // Value not required + not found
235         result = eval.evaluate("fool?", message);
236         assertNotNull(result);
237         assertTrue(result instanceof List);
238         assertEquals(0, ((List)result).size());
239 
240         // Value required + not found (throws exception)
241         try
242         {
243             eval.evaluate("fool", message);
244             fail("required value");
245         }
246         catch (Exception e)
247         {
248             //Expected
249         }
250     }
251 
252     @Test
253     public void testListHeadersWithScopes() throws Exception
254     {
255         MessageHeadersListExpressionEvaluator eval = new MessageHeadersListExpressionEvaluator();
256         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
257         message.setProperty("faz", "fazvalue", PropertyScope.INVOCATION);
258 
259         Object result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz", message);
260         assertNotNull(result);
261         assertTrue(result instanceof List);
262         assertEquals(2, ((List)result).size());
263         assertTrue(((List)result).contains("foovalue"));
264         assertTrue(((List)result).contains("bazvalue"));
265         // redundant since we already know that the map is of size 2
266         assertFalse(((List)result).contains("barvalue"));
267 
268         //Setting the scope once will set the default for following names
269         result = eval.evaluate("OUTBOUND:foo, baz", message);
270         assertNotNull(result);
271         assertTrue(result instanceof List);
272         assertEquals(2, ((List)result).size());
273         assertTrue(((List)result).contains("foovalue"));
274         assertTrue(((List)result).contains("bazvalue"));
275 
276         result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz, INVOCATION:faz", message);
277         assertNotNull(result);
278         assertTrue(result instanceof List);
279         assertEquals(3, ((List)result).size());
280         assertTrue(((List)result).contains("foovalue"));
281         assertTrue(((List)result).contains("bazvalue"));
282         // redundant since we already know that the map is of size 2
283         assertTrue(((List)result).contains("fazvalue"));
284 
285         try
286         {
287             eval.evaluate("OUTBOUND:foo, baz, faz", message);
288             fail("faz is not in outbound scope and is not optional");
289         }
290         catch (RequiredValueException e)
291         {
292             //expected
293         }
294 
295         result = eval.evaluate("OUTBOUND:foo, faz?, baz", message);
296         assertNotNull(result);
297         assertTrue(result instanceof List);
298         assertEquals(2, ((List)result).size());
299         assertTrue(((List)result).contains("foovalue"));
300         assertTrue(((List)result).contains("bazvalue"));
301 
302     }
303 
304     @Test
305     public void testListHeadersWithWildcard() throws Exception
306     {
307         MessageHeadersListExpressionEvaluator eval = new MessageHeadersListExpressionEvaluator();
308         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
309 
310         // Wildcard match all
311         Object result = eval.evaluate("*", message);
312         assertNotNull(result);
313         assertTrue(result instanceof List);
314         assertEquals(3, ((List)result).size());
315         assertTrue(((List)result).contains("foovalue"));
316         assertTrue(((List)result).contains("bazvalue"));
317         assertTrue(((List)result).contains("barvalue"));
318 
319         // Wildcard
320         result = eval.evaluate("ba*", message);
321         assertNotNull(result);
322         assertTrue(result instanceof List);
323         assertEquals(2, ((List)result).size());
324         assertTrue(((List)result).contains("barvalue"));
325         assertTrue(((List)result).contains("bazvalue"));
326 
327         // Wildcard no match
328         result = eval.evaluate("x*", message);
329         assertNotNull(result);
330         assertTrue(result instanceof List);
331         assertEquals(0, ((List)result).size());
332 
333         // Comma separated Wildcards
334         result = eval.evaluate("ba*, f*", message);
335         assertNotNull(result);
336         assertTrue(result instanceof List);
337         assertEquals(3, ((List)result).size());
338         assertTrue(((List)result).contains("foovalue"));
339         assertTrue(((List)result).contains("bazvalue"));
340         assertTrue(((List)result).contains("barvalue"));
341     }
342 
343 
344     @Test
345     public void testMapHeadersWithWildcards() throws Exception
346     {
347         MessageHeadersExpressionEvaluator eval = new MessageHeadersExpressionEvaluator();
348 
349         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
350 
351         //Test all
352         Object result = eval.evaluate("*", message);
353         assertNotNull(result);
354         assertTrue(result instanceof Map);
355         assertEquals(3, ((Map)result).size());
356         assertTrue(((Map)result).values().contains("foovalue"));
357         assertTrue(((Map)result).values().contains("bazvalue"));
358         assertTrue(((Map)result).values().contains("barvalue"));
359 
360         // Wildcard
361         result = eval.evaluate("ba*", message);
362         assertNotNull(result);
363         assertTrue(result instanceof Map);
364         assertEquals(2, ((Map)result).size());
365         assertFalse(((Map)result).values().contains("foovalue"));
366         assertTrue(((Map)result).values().contains("bazvalue"));
367         assertTrue(((Map)result).values().contains("barvalue"));
368 
369         // Wildcard no match
370         result = eval.evaluate("x*", message);
371         assertNotNull(result);
372         assertTrue(result instanceof Map);
373         assertEquals(0, ((Map)result).size());
374 
375         //Test comma separated list of wildcards
376         result = eval.evaluate("ba*, f*", message);
377         assertNotNull(result);
378         assertTrue(result instanceof Map);
379         assertEquals(3, ((Map)result).size());
380         assertTrue(((Map)result).values().contains("foovalue"));
381         assertTrue(((Map)result).values().contains("bazvalue"));
382         assertTrue(((Map)result).values().contains("barvalue"));
383     }
384     
385     @Test
386     public void testSingleHeaderUsingManager() throws Exception
387     {
388         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
389 
390         // Value required + found
391         Object result = muleContext.getExpressionManager().evaluate("#[header:foo]", message);
392         assertNotNull(result);
393         assertEquals("foovalue", result);
394 
395         // Value not required + found
396         result = muleContext.getExpressionManager().evaluate("#[header:foo?]", message);
397         assertNotNull(result);
398         assertEquals("foovalue", result);
399 
400         // Value not required + not found
401         result = muleContext.getExpressionManager().evaluate("#[header:fool?]", message);
402         assertNull(result);
403 
404         // Value required + not found (throws exception)
405         try
406         {
407             muleContext.getExpressionManager().evaluate("#[header:fool]", message);
408             fail("Required value");
409         }
410         catch (ExpressionRuntimeException e)
411         {
412             //expected
413         }
414 
415     }
416 
417     @Test
418     public void testMapHeadersUsingManager() throws Exception
419     {
420 
421         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
422 
423         // Value required + found
424         Object result = muleContext.getExpressionManager().evaluate("#[headers:foo, baz]", message);
425         assertNotNull(result);
426         assertTrue(result instanceof Map);
427         assertEquals(2, ((Map)result).size());
428         assertTrue(((Map)result).values().contains("foovalue"));
429         assertTrue(((Map)result).values().contains("bazvalue"));
430         assertFalse(((Map)result).values().contains("barvalue"));
431 
432         // Value not required + found
433         result = muleContext.getExpressionManager().evaluate("#[headers:foo?, baz]", message);
434         assertNotNull(result);
435         assertTrue(result instanceof Map);
436         assertEquals(2, ((Map)result).size());
437         assertTrue(((Map)result).values().contains("foovalue"));
438         assertTrue(((Map)result).values().contains("bazvalue"));
439         assertFalse(((Map)result).values().contains("barvalue"));
440         
441         // Value not required + not found
442         result = muleContext.getExpressionManager().evaluate("#[headers:fool?]", message);
443         assertNotNull(result);
444         assertTrue(result instanceof Map);
445         assertEquals(0, ((Map)result).size());
446 
447         // Value required + not found (throws exception)
448         try
449         {
450             muleContext.getExpressionManager().evaluate("#[headers:fool]", message);
451             fail("Required value");
452         }
453         catch (ExpressionRuntimeException e)
454         {
455             //expected
456         }
457 
458     }
459 
460     @Test
461     public void testMapHeadersWithWildcardsUsingManager() throws Exception
462     {
463 
464         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
465 
466         // All headers
467         Object result = muleContext.getExpressionManager().evaluate("#[headers:*]", message);
468         assertNotNull(result);
469         assertTrue(result instanceof Map);
470         assertEquals(3, ((Map)result).size());
471         assertTrue(((Map)result).values().contains("foovalue"));
472         assertTrue(((Map)result).values().contains("bazvalue"));
473         assertTrue(((Map)result).values().contains("barvalue"));
474 
475         // Wildcard headers
476         result = muleContext.getExpressionManager().evaluate("#[headers:ba*]", message);
477         assertNotNull(result);
478         assertTrue(result instanceof Map);
479         assertEquals(2, ((Map)result).size());
480         assertFalse(((Map)result).values().contains("foovalue"));
481         assertTrue(((Map)result).values().contains("bazvalue"));
482         assertTrue(((Map)result).values().contains("barvalue"));
483 
484         //Wildcard no match
485         result = muleContext.getExpressionManager().evaluate("#[headers:x*]", message);
486         assertNotNull(result);
487         assertTrue(result instanceof Map);
488         assertEquals(0, ((Map)result).size());
489 
490         // comma-separated list of wildcards
491         result = muleContext.getExpressionManager().evaluate("#[headers:ba*, f*]", message);
492         assertNotNull(result);
493         assertTrue(result instanceof Map);
494         assertEquals(3, ((Map)result).size());
495         assertTrue(((Map)result).values().contains("foovalue"));
496         assertTrue(((Map)result).values().contains("bazvalue"));
497         assertTrue(((Map)result).values().contains("barvalue"));
498 
499     }
500 
501     @Test
502     public void testListHeadersUsingManager() throws Exception
503     {
504         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
505 
506         // Value required + found
507         Object result = muleContext.getExpressionManager().evaluate("#[headers-list:foo, baz]", message);
508         assertNotNull(result);
509         assertTrue(result instanceof List);
510         assertEquals(2, ((List)result).size());
511         assertTrue(((List)result).contains("foovalue"));
512         assertTrue(((List)result).contains("bazvalue"));
513         assertFalse(((List)result).contains("barvalue"));
514 
515         // Value not required + found
516         result = muleContext.getExpressionManager().evaluate("#[headers-list:foo?, baz]", message);
517         assertNotNull(result);
518         assertTrue(result instanceof List);
519         assertEquals(2, ((List)result).size());
520         assertTrue(((List)result).contains("foovalue"));
521         assertTrue(((List)result).contains("bazvalue"));
522         assertFalse(((List)result).contains("barvalue"));        
523 
524         // Value not required + not found
525         result = muleContext.getExpressionManager().evaluate("#[headers-list:fool?]", message);
526         assertNotNull(result);
527         assertTrue(result instanceof List);
528         assertEquals(0, ((List)result).size());
529 
530         // Value required + not found (throws exception)
531         try
532         {
533             muleContext.getExpressionManager().evaluate("#[headers-list:fool]", message);
534             fail("Required value");
535         }
536         catch (ExpressionRuntimeException e)
537         {
538             //expected
539         }
540     }
541 
542     @Test
543     public void testListHeadersWithWildCardsUsingManager() throws Exception
544     {
545         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
546 
547         // All
548         Object result = muleContext.getExpressionManager().evaluate("#[headers-list:*]", message);
549         assertNotNull(result);
550         assertTrue(result instanceof List);
551         assertEquals(3, ((List)result).size());
552         assertTrue(((List)result).contains("foovalue"));
553         assertTrue(((List)result).contains("bazvalue"));
554         assertTrue(((List)result).contains("barvalue"));
555 
556         // wildcard
557         result = muleContext.getExpressionManager().evaluate("#[headers-list:ba*]", message);
558         assertNotNull(result);
559         assertTrue(result instanceof List);
560         assertEquals(2, ((List)result).size());
561         assertFalse(((List)result).contains("foovalue"));
562         assertTrue(((List)result).contains("bazvalue"));
563         assertTrue(((List)result).contains("barvalue"));
564 
565         // wildcard no match
566         result = muleContext.getExpressionManager().evaluate("#[headers-list:x*]", message);
567         assertNotNull(result);
568         assertTrue(result instanceof List);
569         assertEquals(0, ((List)result).size());
570 
571         // Comma list of wildcards
572         result = muleContext.getExpressionManager().evaluate("#[headers-list:ba*, f*]", message);
573         assertNotNull(result);
574         assertTrue(result instanceof List);
575         assertEquals(3, ((List)result).size());
576         assertTrue(((List)result).contains("foovalue"));
577         assertTrue(((List)result).contains("bazvalue"));
578         assertTrue(((List)result).contains("barvalue"));
579     }
580     
581     @Test
582     public void testCorrelationManagerCorrelationId()
583     {
584         CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
585         String correlationId = UUID.getUUID();
586         
587         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
588         message.setCorrelationId(correlationId);
589         
590         Object result = evaluator.evaluate(MuleProperties.MULE_CORRELATION_ID_PROPERTY, message);
591         assertNotNull(result);
592         assertEquals(correlationId, result);
593     }
594     
595     @Test
596     public void testCorrelationManagerNullResult()
597     {
598         CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
599         
600         DefaultMuleMessage message = new DefaultMuleMessage("test", props, muleContext);
601         message.setUniqueId(null);
602         
603         try
604         {
605             evaluator.evaluate(MuleProperties.MULE_CORRELATION_ID_PROPERTY, message);
606             fail("Null result on CorrelationPropertiesExpressionEvaluator must throw");
607         }
608         catch (IllegalArgumentException iae)
609         {
610             // this one was expected
611         }
612     }    
613     
614     @Test
615     public void testCorrelationManagerUniqueId()
616     {
617         CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
618         
619         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);        
620         Object result = evaluator.evaluate(MuleProperties.MULE_MESSAGE_ID_PROPERTY, message);
621         assertNotNull(result);
622         assertEquals(message.getUniqueId(), result);
623     }
624     
625 //    @Test
626 //    public void testCorrelationManagerNullInput()
627 //    {
628 //        CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
629 //        evaluator.evaluate(MuleProperties.MULE_CORRELATION_ID_PROPERTY, null);
630 //    }
631     
632     @Test
633     public void testCorrelationManagerInvalidKey()
634     {
635         CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
636 
637         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
638         try
639         {
640             evaluator.evaluate("invalid-key", message);
641             fail("invalid key on CorrelationPropertiesExpressionEvaluator must fail");
642         }
643         catch (IllegalArgumentException iax)
644         {
645             // this one was expected
646         }
647     }
648 }