View Javadoc

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