View Javadoc

1   /*
2    * $Id: MuleExpressionEvaluatorTestCase.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.RequestContext;
14  import org.mule.api.MuleEvent;
15  import org.mule.api.MuleMessage;
16  import org.mule.api.MuleRuntimeException;
17  import org.mule.api.expression.ExpressionRuntimeException;
18  import org.mule.api.transformer.Transformer;
19  import org.mule.message.DefaultExceptionPayload;
20  import org.mule.tck.junit4.AbstractMuleContextTestCase;
21  import org.mule.tck.testmodels.fruit.Apple;
22  import org.mule.tck.testmodels.fruit.Banana;
23  import org.mule.tck.testmodels.fruit.FruitBasket;
24  import org.mule.tck.testmodels.fruit.FruitBowl;
25  import org.mule.tck.testmodels.fruit.FruitBowlToFruitBasket;
26  import org.mule.util.StringDataSource;
27  
28  import java.io.ByteArrayInputStream;
29  import java.io.ByteArrayOutputStream;
30  import java.util.HashMap;
31  import java.util.List;
32  import java.util.Map;
33  
34  import javax.activation.DataHandler;
35  
36  import org.junit.Test;
37  
38  import static org.junit.Assert.assertEquals;
39  import static org.junit.Assert.assertFalse;
40  import static org.junit.Assert.assertNotNull;
41  import static org.junit.Assert.assertNull;
42  import static org.junit.Assert.assertTrue;
43  import static org.junit.Assert.fail;
44  
45  public class MuleExpressionEvaluatorTestCase extends AbstractMuleContextTestCase
46  {
47      private Map props;
48  
49      @Override
50      protected void doSetUp() throws Exception
51      {
52          MuleEvent event = getTestEvent("testing",
53                  getTestService("apple", Apple.class),
54                  getTestInboundEndpoint("test", "test://foo"));
55          RequestContext.setEvent(event);
56  
57          props = new HashMap(3);
58          props.put("foo", "moo");
59          props.put("bar", "mar");
60          props.put("baz", "maz");
61      }
62  
63      protected MuleMessage createMessageWithAttachments()
64      {
65          try
66          {
67              Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
68              attachments.put("foo", new DataHandler(new StringDataSource("moo")));
69              attachments.put("bar", new DataHandler(new StringDataSource("mar")));
70              attachments.put("baz", new DataHandler(new StringDataSource("maz")));
71              return new DefaultMuleMessage("test", null, attachments, muleContext);
72          }
73          catch (Exception e)
74          {
75              fail(e.getMessage());
76              return null;
77          }
78      }
79  
80      @Test
81      public void testSingleAttachment() throws Exception
82      {
83          MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
84          eval.setMuleContext(muleContext);
85  
86          Object result = eval.evaluate("message.attachment(foo)", createMessageWithAttachments());
87          assertNotNull(result);
88          assertTrue(result instanceof DataHandler);
89          ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
90          ((DataHandler)result).writeTo(baos);
91          assertEquals("moo", baos.toString());
92  
93          result = eval.evaluate("message.attachment(foo?)", createMessageWithAttachments());
94          assertNotNull(result);
95          assertTrue(result instanceof DataHandler);
96          baos = new ByteArrayOutputStream(4);
97          ((DataHandler)result).writeTo(baos);
98          assertEquals("moo", baos.toString());        
99          
100         result = eval.evaluate("message.attachment(fool?)", createMessageWithAttachments());
101         assertNull(result);
102 
103         try
104         {
105             eval.evaluate("message.attachments(fool)", createMessageWithAttachments());
106             fail("Attachment 'fool' is not on the nessage and not defined as optional");
107         }
108         catch (Exception e)
109         {
110             //Expected
111         }
112     }
113 
114     @Test
115     public void testMapAttachments() throws Exception
116     {
117         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
118         eval.setMuleContext(muleContext);
119 
120         Object result = eval.evaluate("message.attachments(foo, baz)", createMessageWithAttachments());
121         assertNotNull(result);
122         assertTrue(result instanceof Map);
123         assertEquals(2, ((Map)result).size());
124 
125         assertNotNull(((Map)result).get("foo"));
126         assertTrue(((Map)result).get("foo") instanceof DataHandler);
127         DataHandler dh = (DataHandler)((Map)result).get("foo");
128         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
129         dh.writeTo(baos);
130         assertEquals("moo", baos.toString());
131 
132         assertNotNull(((Map)result).get("baz"));
133         assertTrue(((Map)result).get("baz") instanceof DataHandler);
134         dh = (DataHandler)((Map)result).get("baz");
135         baos = new ByteArrayOutputStream(4);
136         dh.writeTo(baos);
137         assertEquals("maz", baos.toString());
138 
139         result = eval.evaluate("message.attachments(fool?)", createMessageWithAttachments());
140         assertNotNull(result);
141         assertTrue(result instanceof Map);
142         assertEquals(0, ((Map)result).size());
143 
144         result = eval.evaluate("message.attachments(foo?, baz)", createMessageWithAttachments());
145         assertNotNull(result);
146         assertTrue(result instanceof Map);
147         assertEquals(2, ((Map)result).size());
148 
149         assertNotNull(((Map)result).get("foo"));
150         assertTrue(((Map)result).get("foo") instanceof DataHandler);
151         dh = (DataHandler)((Map)result).get("foo");
152         baos = new ByteArrayOutputStream(4);
153         dh.writeTo(baos);
154         assertEquals("moo", baos.toString());
155 
156         assertNotNull(((Map)result).get("baz"));
157         assertTrue(((Map)result).get("baz") instanceof DataHandler);
158         dh = (DataHandler)((Map)result).get("baz");
159         baos = new ByteArrayOutputStream(4);
160         dh.writeTo(baos);
161         assertEquals("maz", baos.toString());        
162 
163         try
164         {
165             eval.evaluate("message.attachments(fool)", createMessageWithAttachments());
166             fail("Attachment 'fool' is not on the nessage and not defined as optional");
167         }
168         catch (Exception e)
169         {
170             //Expected
171         }
172     }
173 
174     @Test
175     public void testListAttachments() throws Exception
176     {
177         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
178         eval.setMuleContext(muleContext);        
179 
180         Object result = eval.evaluate("message.attachments-list(foo, baz)", createMessageWithAttachments());
181         assertNotNull(result);
182         assertTrue(result instanceof List);
183         assertEquals(2, ((List)result).size());
184 
185         assertTrue(((List)result).get(0) instanceof DataHandler);
186         DataHandler dh = (DataHandler)((List)result).get(0);
187         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
188         dh.writeTo(baos);
189         assertEquals("moo", baos.toString());
190 
191         assertTrue(((List)result).get(1) instanceof DataHandler);
192         dh = (DataHandler)((List)result).get(1);
193         baos = new ByteArrayOutputStream(4);
194         dh.writeTo(baos);
195         assertEquals("maz", baos.toString());
196 
197         result = eval.evaluate("message.attachments-list(fool?)", createMessageWithAttachments());
198         assertNotNull(result);
199         assertTrue(result instanceof List);
200         assertEquals(0, ((List)result).size());
201 
202         result = eval.evaluate("message.attachments-list(foo?, baz)", createMessageWithAttachments());
203         assertNotNull(result);
204         assertTrue(result instanceof List);
205         assertEquals(2, ((List)result).size());
206 
207         assertTrue(((List)result).get(0) instanceof DataHandler);
208         dh = (DataHandler)((List)result).get(0);
209         baos = new ByteArrayOutputStream(4);
210         dh.writeTo(baos);
211         assertEquals("moo", baos.toString());
212 
213         assertTrue(((List)result).get(1) instanceof DataHandler);
214         dh = (DataHandler)((List)result).get(1);
215         baos = new ByteArrayOutputStream(4);
216         dh.writeTo(baos);
217         assertEquals("maz", baos.toString());        
218         
219         result = eval.evaluate("message.attachments-list(fool?)", createMessageWithAttachments());
220         assertEquals(0, ((List)result).size());
221 
222         try
223         {
224             eval.evaluate("message.attachments-list(fool)", createMessageWithAttachments());
225             fail("Attachment 'fool' is not on the message and not defined as optional");
226         }
227         catch (Exception e)
228         {
229             //Expected
230         }
231     }
232 
233     @Test
234     public void testSingleAttachmentUsingManager() throws Exception
235     {
236         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.attachment(foo)]", createMessageWithAttachments());
237         assertNotNull(result);
238         assertTrue(result instanceof DataHandler);
239         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
240         ((DataHandler)result).writeTo(baos);
241         assertEquals("moo", baos.toString());
242 
243         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachment(foo?)]", createMessageWithAttachments());
244         assertNotNull(result);
245         assertTrue(result instanceof DataHandler);
246         baos = new ByteArrayOutputStream(4);
247         ((DataHandler)result).writeTo(baos);
248         assertEquals("moo", baos.toString());        
249         
250         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachment(fool?)]", createMessageWithAttachments());
251         assertNull(result);
252         try
253         {
254             muleContext.getExpressionManager().evaluate("#[mule:message.attachment(fool)]", createMessageWithAttachments());
255             fail("Attachment 'fool' is not on the message and not defined as optional");
256         }
257         catch (Exception e)
258         {
259             //Expected
260         }
261     }
262 
263     @Test
264     public void testMapAttachmentsUsingManager() throws Exception
265     {
266         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments(foo, baz)]", createMessageWithAttachments());
267         assertNotNull(result);
268         assertTrue(result instanceof Map);
269         assertEquals(2, ((Map)result).size());
270 
271         assertNotNull(((Map)result).get("foo"));
272         assertTrue(((Map)result).get("foo") instanceof DataHandler);
273         DataHandler dh = (DataHandler)((Map)result).get("foo");
274         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
275         dh.writeTo(baos);
276         assertEquals("moo", baos.toString());
277 
278         assertNotNull(((Map)result).get("baz"));
279         assertTrue(((Map)result).get("baz") instanceof DataHandler);
280         dh = (DataHandler)((Map)result).get("baz");
281         baos = new ByteArrayOutputStream(4);
282         dh.writeTo(baos);
283         assertEquals("maz", baos.toString());
284 
285         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments(foo?, baz)]", createMessageWithAttachments());
286         assertNotNull(result);
287         assertTrue(result instanceof Map);
288         assertEquals(2, ((Map)result).size());
289 
290         assertNotNull(((Map)result).get("foo"));
291         assertTrue(((Map)result).get("foo") instanceof DataHandler);
292         dh = (DataHandler)((Map)result).get("foo");
293         baos = new ByteArrayOutputStream(4);
294         dh.writeTo(baos);
295         assertEquals("moo", baos.toString());
296 
297         assertNotNull(((Map)result).get("baz"));
298         assertTrue(((Map)result).get("baz") instanceof DataHandler);
299         dh = (DataHandler)((Map)result).get("baz");
300         baos = new ByteArrayOutputStream(4);
301         dh.writeTo(baos);
302         assertEquals("maz", baos.toString());        
303         
304         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments(foo, fool?)]", createMessageWithAttachments());
305         assertNotNull(((Map)result).get("foo"));
306 
307         try
308         {
309              muleContext.getExpressionManager().evaluate("#[mule:message.attachments(foo, fool)]", createMessageWithAttachments());
310             fail("Attachment 'fool' is not on the message and not defined as optional");
311         }
312         catch (Exception e)
313         {
314             //Expected
315         }
316     }
317 
318     @Test
319     public void testListAttachmentsUsingManager() throws Exception
320     {
321         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments-list(foo,baz)]", createMessageWithAttachments());
322         assertNotNull(result);
323         assertTrue(result instanceof List);
324         assertEquals(2, ((List)result).size());
325 
326         assertTrue(((List)result).get(0) instanceof DataHandler);
327         DataHandler dh = (DataHandler)((List)result).get(0);
328         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
329         dh.writeTo(baos);
330         assertEquals("moo", baos.toString());
331 
332         assertTrue(((List)result).get(1) instanceof DataHandler);
333         dh = (DataHandler)((List)result).get(1);
334         baos = new ByteArrayOutputStream(4);
335         dh.writeTo(baos);
336         assertEquals("maz", baos.toString());
337 
338         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments-list(fool?)]", createMessageWithAttachments());
339         assertNotNull(result);
340         assertTrue(result instanceof List);
341         assertEquals(0, ((List)result).size());
342 
343         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments-list(foo?,baz)]", createMessageWithAttachments());
344         assertNotNull(result);
345         assertTrue(result instanceof List);
346         assertEquals(2, ((List)result).size());
347 
348         assertTrue(((List)result).get(0) instanceof DataHandler);
349         dh = (DataHandler)((List)result).get(0);
350         baos = new ByteArrayOutputStream(4);
351         dh.writeTo(baos);
352         assertEquals("moo", baos.toString());
353 
354         assertTrue(((List)result).get(1) instanceof DataHandler);
355         dh = (DataHandler)((List)result).get(1);
356         baos = new ByteArrayOutputStream(4);
357         dh.writeTo(baos);
358         assertEquals("maz", baos.toString());        
359         
360         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments-list(fool?)]", createMessageWithAttachments());
361         assertEquals(0, ((List)result).size());
362 
363         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments-list(foo, fool?)]", createMessageWithAttachments());
364         assertTrue(((List)result).get(0) instanceof DataHandler);
365         assertEquals(1, ((List)result).size());
366 
367         try
368         {
369             muleContext.getExpressionManager().evaluate("#[mule:message.attachments-list(foo, fool)]", createMessageWithAttachments());
370             fail("Attachment 'fool' is not on the message and not defined as optional");
371         }
372         catch (Exception e)
373         {
374             //Expected
375         }
376     }
377 
378     @Test
379     public void testGettingAllAttachments() throws Exception
380     {
381         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
382         eval.setMuleContext(muleContext);
383 
384         Object result = eval.evaluate("message.attachments(*)", createMessageWithAttachments());
385         assertNotNull(result);
386         assertTrue(result instanceof Map);
387         assertEquals(3, ((Map)result).size());
388 
389         result = eval.evaluate("message.attachments-list(*)", createMessageWithAttachments());
390         assertNotNull(result);
391         assertTrue(result instanceof List);
392         assertEquals(3, ((List)result).size());
393 
394     }
395 
396     @Test
397     public void testGettingAllAttachmentsUsingManager() throws Exception
398     {
399         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments(*)]", createMessageWithAttachments());
400         assertNotNull(result);
401         assertTrue(result instanceof Map);
402         assertEquals(3, ((Map)result).size());
403 
404         result = muleContext.getExpressionManager().evaluate("#[mule:message.attachments-list(*)]", createMessageWithAttachments());
405         assertNotNull(result);
406         assertTrue(result instanceof List);
407         assertEquals(3, ((List)result).size());
408 
409     }
410 
411     @Test
412     public void testSingleHeader() throws Exception
413     {
414         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
415         eval.setMuleContext(muleContext);
416         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
417 
418         Object result = eval.evaluate("message.header(foo)", message);
419         assertNotNull(result);
420         assertEquals("moo", result);
421         
422         result = eval.evaluate("message.header(foo?)", message);
423         assertNotNull(result);
424         assertEquals("moo", result);
425 
426         result = eval.evaluate("message.header(fool?)", message);
427         assertNull(result);
428 
429         try
430         {
431             muleContext.getExpressionManager().evaluate("#[mule:message.header(fool)]", createMessageWithAttachments());
432             fail("Header 'fool' is not on the message and not defined as optional");
433         }
434         catch (Exception e)
435         {
436             //Expected
437         }
438     }
439 
440     @Test
441     public void testMapHeaders() throws Exception
442     {
443         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
444         eval.setMuleContext(muleContext);
445 
446         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
447 
448         Object result = eval.evaluate("message.headers(foo, baz)", message);
449         assertNotNull(result);
450         assertTrue(result instanceof Map);
451         assertEquals(2, ((Map)result).size());
452         assertTrue(((Map)result).values().contains("moo"));
453         assertTrue(((Map)result).values().contains("maz"));
454         assertFalse(((Map)result).values().contains("mar"));
455         
456         result = eval.evaluate("message.headers(foo?, baz)", message);
457         assertNotNull(result);
458         assertTrue(result instanceof Map);
459         assertEquals(2, ((Map)result).size());
460         assertTrue(((Map)result).values().contains("moo"));
461         assertTrue(((Map)result).values().contains("maz"));
462         assertFalse(((Map)result).values().contains("mar"));        
463 
464         result = eval.evaluate("message.headers(fool?)", message);
465         assertNotNull(result);
466         assertTrue(result instanceof Map);
467         assertEquals(0, ((Map)result).size());
468 
469         result = eval.evaluate("message.headers(foo, fool?)", message);
470         assertTrue(result instanceof Map);
471         assertEquals("moo", ((Map)result).get("foo"));
472         assertEquals(1, ((Map)result).size());
473 
474         try
475         {
476             eval.evaluate("message.headers(foo, fool)", createMessageWithAttachments());
477             fail("Header 'fool' is not on the message and not defined as optional");
478         }
479         catch (Exception e)
480         {
481             //Expected
482         }
483     }
484 
485     @Test
486     public void testListHeaders() throws Exception
487     {
488         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
489         eval.setMuleContext(muleContext);
490         
491         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
492 
493         Object result = eval.evaluate("message.headers-list(foo, baz)", message);
494         assertNotNull(result);
495         assertTrue(result instanceof List);
496         assertEquals(2, ((List)result).size());
497         assertTrue(((List)result).contains("moo"));
498         assertTrue(((List)result).contains("maz"));
499         assertFalse(((List)result).contains("mar"));
500 
501         result = eval.evaluate("message.headers(fool?)", message);
502         assertNotNull(result);
503         assertTrue(result instanceof Map);
504         assertEquals(0, ((Map)result).size());
505 
506         result = eval.evaluate("message.headers-list(foo?, baz)", message);
507         assertNotNull(result);
508         assertTrue(result instanceof List);
509         assertEquals(2, ((List)result).size());
510         assertTrue(((List)result).contains("moo"));
511         assertTrue(((List)result).contains("maz"));
512         assertFalse(((List)result).contains("mar"));        
513         
514         result = eval.evaluate("message.headers(fool?)", message);
515         assertEquals(0, ((Map)result).size());
516 
517         result = eval.evaluate("message.headers-list(foo, fool?)", message);
518         assertTrue(result instanceof List);
519         assertEquals("moo", ((List)result).get(0));
520         assertEquals(1, ((List)result).size());
521 
522         try
523         {
524             eval.evaluate("message.headers-list(foo, fool)", createMessageWithAttachments());
525             fail("Header 'fool' is not on the message and not defined as optional");
526         }
527         catch (Exception e)
528         {
529             //Expected
530         }
531     }
532 
533     @Test
534     public void testGettingAllHeaders() throws Exception
535     {
536         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
537         eval.setMuleContext(muleContext);
538 
539         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
540 
541         Object result = eval.evaluate("message.headers(*)", message);
542         assertNotNull(result);
543         assertTrue(result instanceof Map);
544         assertEquals(3, ((Map)result).size());
545 
546         result = eval.evaluate("message.headers-list(*)", message);
547         assertNotNull(result);
548         assertTrue(result instanceof List);
549         assertEquals(3, ((List)result).size());
550     }
551 
552     @Test
553     public void testGettingAllHeadersUsingManager() throws Exception
554     {
555         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
556 
557         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.headers(*)]", message);
558         assertNotNull(result);
559         assertTrue(result instanceof Map);
560         assertEquals(3, ((Map)result).size());
561 
562         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers-list(*)]", message);
563         assertNotNull(result);
564         assertTrue(result instanceof List);
565         assertEquals(3, ((List)result).size());
566     }
567 
568     @Test
569     public void testSingleHeaderUsingManager() throws Exception
570     {
571         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
572 
573         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.header(foo)]", message);
574         assertNotNull(result);
575         assertEquals("moo", result);
576 
577         result = muleContext.getExpressionManager().evaluate("#[mule:message.header(foo?)]", message);
578         assertNotNull(result);
579         assertEquals("moo", result);        
580         
581         result = muleContext.getExpressionManager().evaluate("#[mule:message.header(fool?)]", message);
582         assertNull(result);
583 
584         try
585         {
586             muleContext.getExpressionManager().evaluate("#[mule:message.header(fool)]", createMessageWithAttachments());
587             fail("Header 'fool' is not on the message and not defined as optional");
588         }
589         catch (Exception e)
590         {
591             //Expected
592         }
593     }
594 
595     @Test
596     public void testMapHeadersUsingManager() throws Exception
597     {
598 
599         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
600 
601         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.headers(foo, baz)]", message);
602         assertNotNull(result);
603         assertTrue(result instanceof Map);
604         assertEquals(2, ((Map)result).size());
605         assertTrue(((Map)result).values().contains("moo"));
606         assertTrue(((Map)result).values().contains("maz"));
607         assertFalse(((Map)result).values().contains("mar"));
608 
609         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers(fool?)]", message);
610         assertNotNull(result);
611         assertTrue(result instanceof Map);
612         assertEquals(0, ((Map)result).size());
613 
614         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers(foo?, baz)]", message);
615         assertNotNull(result);
616         assertTrue(result instanceof Map);
617         assertEquals(2, ((Map)result).size());
618         assertTrue(((Map)result).values().contains("moo"));
619         assertTrue(((Map)result).values().contains("maz"));
620         assertFalse(((Map)result).values().contains("mar"));        
621         
622         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers(fool?)]", message);
623         assertEquals(0, ((Map)result).size());
624 
625         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers(foo, fool?)]", message);
626         assertTrue(result instanceof Map);
627         assertEquals("moo", ((Map)result).get("foo"));
628         assertEquals(1, ((Map)result).size());
629 
630         try
631         {
632             muleContext.getExpressionManager().evaluate("#[mule:message.headers(foo, fool)]", createMessageWithAttachments());
633             fail("Header 'fool' is not on the message and not defined as optional");
634         }
635         catch (Exception e)
636         {
637             //Expected
638         }
639     }
640 
641     @Test
642     public void testListHeadersUsingManager() throws Exception
643     {
644         MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
645 
646         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.headers-list(foo, baz)]", message);
647         assertNotNull(result);
648         assertTrue(result instanceof List);
649         assertEquals(2, ((List)result).size());
650         assertTrue(((List)result).contains("moo"));
651         assertTrue(((List)result).contains("maz"));
652         assertFalse(((List)result).contains("mar"));
653 
654         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers-list(fool?)]", message);
655         assertNotNull(result);
656         assertTrue(result instanceof List);
657         assertEquals(0, ((List)result).size());
658 
659         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers-list(foo?, baz)]", message);
660         assertNotNull(result);
661         assertTrue(result instanceof List);
662         assertEquals(2, ((List)result).size());
663         assertTrue(((List)result).contains("moo"));
664         assertTrue(((List)result).contains("maz"));
665         assertFalse(((List)result).contains("mar"));        
666         
667         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers(fool?)]", message);
668         assertEquals(0, ((Map)result).size());
669 
670         result = muleContext.getExpressionManager().evaluate("#[mule:message.headers-list(foo, fool?)]", message);
671         assertTrue(result instanceof List);
672         assertEquals("moo", ((List)result).get(0));
673         assertEquals(1, ((List)result).size());
674 
675         try
676         {
677             muleContext.getExpressionManager().evaluate("#[mule:message.headers-list(foo, fool)]", createMessageWithAttachments());
678             fail("Header 'fool' is not on the message and not defined as optional");
679         }
680         catch (Exception e)
681         {
682             //Expected
683         }
684     }
685 
686     @Test
687     public void testContextExpressions() throws Exception
688     {
689         MuleMessage message = new DefaultMuleMessage("test", muleContext);
690         MuleExpressionEvaluator extractor = new MuleExpressionEvaluator();
691         extractor.setMuleContext(muleContext);
692 
693         Object o = extractor.evaluate("context.serviceName", message);
694         assertEquals("apple", o);
695 
696         o = extractor.evaluate("context.modelName", message);
697         assertNotNull(o);
698 
699         o = extractor.evaluate("context.inboundEndpoint", message);
700         assertEquals("test://foo", o.toString());
701 
702         o = extractor.evaluate("context.serverId", message);
703         assertNotNull(o);
704 
705         o = extractor.evaluate("context.clusterId", message);
706         assertNotNull(o);
707 
708         o = extractor.evaluate("context.domainId", message);
709         assertNotNull(o);
710 
711         o = extractor.evaluate("context.workingDir", message);
712         assertNotNull(o);
713 
714         try
715         {
716             extractor.evaluate("context.bork", message);
717             fail("bork is not a valid mule context value");
718         }
719         catch (Exception e)
720         {
721             //expected
722         }
723     }
724 
725     @Test
726     public void testContextExpressionsFromExtractorManager() throws Exception
727     {
728         MuleMessage message = new DefaultMuleMessage("test", muleContext);
729         Object o = muleContext.getExpressionManager().evaluate("mule:context.serviceName", message);
730         assertEquals("apple", o);
731 
732         o = muleContext.getExpressionManager().evaluate("mule:context.modelName", message);
733         assertNotNull(o);
734 
735         o = muleContext.getExpressionManager().evaluate("mule:context.inboundEndpoint", message);
736         assertEquals("test://foo", o.toString());
737 
738         o = muleContext.getExpressionManager().evaluate("mule:context.serverId", message);
739         assertNotNull(o);
740 
741         o = muleContext.getExpressionManager().evaluate("mule:context.clusterId", message);
742         assertNotNull(o);
743 
744         o = muleContext.getExpressionManager().evaluate("mule:context.domainId", message);
745         assertNotNull(o);
746 
747         o = muleContext.getExpressionManager().evaluate("mule:context.workingDir", message);
748         assertNotNull(o);
749 
750         try
751         {
752             muleContext.getExpressionManager().evaluate("mule:context.bork", message);
753             fail("bork is not a valid mule context value");
754         }
755         catch (Exception e)
756         {
757             //expected
758         }
759     }
760 
761     @Test
762     public void testMissingEventContext() throws Exception
763     {
764         RequestContext.clear();
765 
766         MuleMessage message = new DefaultMuleMessage("test", muleContext);
767         MuleExpressionEvaluator extractor = new MuleExpressionEvaluator();
768         extractor.setMuleContext(muleContext);
769 
770         Object o = extractor.evaluate("context.serverId", message);
771         assertNotNull(o);
772 
773         try
774         {
775             extractor.evaluate("context.serviceName", message);
776             fail("There is no current event context");
777         }
778         catch (MuleRuntimeException e)
779         {
780             //expected
781         }
782     }
783 
784     @Test
785     public void testMessagePropertiesUsingEvaluatorDirectly() throws Exception
786     {
787         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
788         eval.setMuleContext(muleContext);
789         MuleMessage message = new DefaultMuleMessage("test", muleContext);
790         message.setCorrelationId(message.getUniqueId());
791         message.setCorrelationSequence(1);
792         message.setCorrelationGroupSize(2);
793         message.setReplyTo("foo");
794         message.setEncoding("UTF-8");
795         Exception e = new Exception("dummy");
796         message.setExceptionPayload(new DefaultExceptionPayload(e));
797 
798         //no expression
799         Object result = eval.evaluate(null, message);
800         assertNotNull(result);
801         assertEquals(message, result);
802 
803         //no expression
804         result = eval.evaluate(null, null);
805         assertNull(result);
806 
807         assertEquals(message.getUniqueId(), eval.evaluate("message.id", message));
808         assertEquals(message.getUniqueId(), eval.evaluate("message.correlationId", message));
809         assertEquals(new Integer(1), eval.evaluate("message.correlationSequence", message));
810         assertEquals(new Integer(2), eval.evaluate("message.correlationGroupSize", message));
811         assertEquals("foo", eval.evaluate("message.replyTo", message));
812         assertEquals(e, eval.evaluate("message.exception", message));
813         assertEquals("UTF-8", eval.evaluate("message.encoding", message));
814         assertEquals("test", eval.evaluate("message.payload", message));
815 
816         try
817         {
818             eval.evaluate("message.xxx", message);
819             fail("message.xxx is not a supported expresion");
820         }
821         catch (Exception e1)
822         {
823             //Expected
824         }
825     }
826 
827     /**
828      * Make sure the evaluator gets registered properly
829      *
830      * @throws Exception if the test fails
831      */
832     @Test
833     public void testMessagePropertiesUsingManager() throws Exception
834     {
835         MuleMessage message = new DefaultMuleMessage("test", muleContext);
836         message.setCorrelationId(message.getUniqueId());
837         message.setCorrelationSequence(1);
838         message.setCorrelationGroupSize(2);
839         message.setReplyTo("foo");
840         message.setEncoding("UTF-8");
841         Exception e = new Exception("dummy");
842         message.setExceptionPayload(new DefaultExceptionPayload(e));
843 
844 
845         assertEquals(message.getUniqueId(), muleContext.getExpressionManager().evaluate("#[mule:message.id]", message));
846         assertEquals(message.getUniqueId(), muleContext.getExpressionManager().evaluate("#[mule:message.correlationId]", message));
847         assertEquals(new Integer(1), muleContext.getExpressionManager().evaluate("#[mule:message.correlationSequence]", message));
848         assertEquals(new Integer(2), muleContext.getExpressionManager().evaluate("#[mule:message.correlationGroupSize]", message));
849         assertEquals("foo", muleContext.getExpressionManager().evaluate("#[mule:message.replyTo]", message));
850         assertEquals(e, muleContext.getExpressionManager().evaluate("#[mule:message.exception]", message));
851         assertEquals("UTF-8", muleContext.getExpressionManager().evaluate("#[mule:message.encoding]", message));
852         assertEquals("test", muleContext.getExpressionManager().evaluate("#[mule:message.payload]", message));
853 
854         try
855         {
856             muleContext.getExpressionManager().evaluate("#[mule:message.xxx]", message, true);
857             fail("xxx is not a supported expresion");
858         }
859         catch (Exception e1)
860         {
861             //Expected
862         }
863     }
864 
865     @Test
866     public void testMessagePayloadWithNulls() throws Exception
867     {
868         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
869         eval.setMuleContext(muleContext);
870 
871         //no expression
872         Object result = eval.evaluate(null, null);
873         assertNull(result);
874     }
875 
876     /**
877      * Make sure the evaluator gets registered properly
878      *
879      * @throws Exception if the test fails
880      */
881     @Test
882     public void testMessagePayloadWithNullsUsingManager() throws Exception
883     {
884         MuleMessage message = new DefaultMuleMessage("test", muleContext);
885 
886         assertFalse(muleContext.getExpressionManager().isValidExpression("${payload:}"));
887         assertTrue(muleContext.getExpressionManager().isValidExpression("#[mule:message.payload]"));
888 
889         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.payload]", message);
890         assertNotNull(result);
891         assertEquals("test", result);
892 
893         result = muleContext.getExpressionManager().evaluate("#[mule:message.payload]", null);
894         assertNull(result);
895     }
896 
897     @Test
898     public void testMessagePayloadWithTransform() throws Exception
899     {
900         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
901         eval.setMuleContext(muleContext);
902         MuleMessage message = new DefaultMuleMessage("test", muleContext);
903 
904         //i.e. ${payload:byte[]}
905         Object result = eval.evaluate("message.payload(byte[])", message);
906         assertNotNull(result);
907         assertTrue(result instanceof byte[]);
908         assertEquals("test", new String((byte[]) result));
909 
910         ByteArrayInputStream bais = new ByteArrayInputStream("test2".getBytes());
911         //i.e. ${payload:java.lang.String}
912         result = eval.evaluate("message.payload(java.lang.String)", new DefaultMuleMessage(bais, muleContext));
913         assertNotNull(result);
914         assertEquals("test2", result);
915     }
916 
917     @Test
918     public void testMessagePayloadWithTransformUsingManager() throws Exception
919     {
920         MuleMessage message = new DefaultMuleMessage("test", muleContext);
921 
922         //i.e. ${payload:byte[]}
923         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.payload(byte[])]", message);
924         assertNotNull(result);
925         assertTrue(result instanceof byte[]);
926         assertEquals("test", new String((byte[]) result));
927 
928         ByteArrayInputStream bais = new ByteArrayInputStream("test2".getBytes());
929         //i.e. ${payload:java.lang.String}
930         result = muleContext.getExpressionManager().evaluate("#[mule:message.payload(java.lang.String)]", new DefaultMuleMessage(bais, muleContext));
931         assertNotNull(result);
932         assertEquals("test2", result);
933     }
934 
935     @Test
936     public void testMessagePayloadWithMoreComplexTransform() throws Exception
937     {
938         MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
939         eval.setMuleContext(muleContext);
940         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), muleContext);
941 
942         //Lets register our transformer so Mule can find it
943         muleContext.getRegistry().registerTransformer(new FruitBowlToFruitBasket());
944 
945         //i.e. ${payload:org.mule.tck.testmodels.fruit.FruitBasket}
946         Object result = eval.evaluate("message.payload(org.mule.tck.testmodels.fruit.FruitBasket)", message);
947         assertNotNull(result);
948         assertTrue(result instanceof FruitBasket);
949         FruitBasket fb = (FruitBasket) result;
950         assertEquals(2, fb.getFruit().size());
951         assertTrue(fb.hasBanana());
952         assertTrue(fb.hasApple());
953     }
954 
955     @Test
956     public void testMessagePayloadWithMoreComplexTransformUsingManager() throws Exception
957     {
958         MuleMessage message = new DefaultMuleMessage(new FruitBowl(new Apple(), new Banana()), muleContext);
959 
960         //Lets register our transformer so Mule can find it
961         muleContext.getRegistry().registerTransformer(new FruitBowlToFruitBasket());
962 
963         //i.e. ${payload:org.mule.tck.testmodels.fruit.FruitBasket}
964         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.payload(org.mule.tck.testmodels.fruit.FruitBasket)]", message);
965         assertNotNull(result);
966         assertTrue(result instanceof FruitBasket);
967         FruitBasket fb = (FruitBasket) result;
968         assertEquals(2, fb.getFruit().size());
969         assertTrue(fb.hasBanana());
970         assertTrue(fb.hasApple());
971     }
972 
973     @Test
974     public void testMapPayloadUsingManager() throws Exception
975     {
976         Map map = new HashMap(1);
977         map.put("foo", "far");
978         map.put("boo", "bar");
979         map.put("zoo", "zar");
980 
981         MuleMessage message = new DefaultMuleMessage(map, muleContext);
982 
983         assertTrue(muleContext.getExpressionManager().isValidExpression("#[mule:message.map-payload(foo)]"));
984 
985         Object result = muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(foo)]", message);
986         assertNotNull(result);
987         assertEquals("far", result);
988         
989         result = muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(foo?)]", message);
990         assertNotNull(result);
991         assertEquals("far", result);
992 
993         result = muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(foot?)]", message);
994         assertNull(result);
995 
996         try
997         {
998             muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(fool)]", message);
999             fail("Map payload does not contain property 'fool' but it is required");
1000         }
1001         catch (ExpressionRuntimeException e)
1002         {
1003             //Expected
1004         }
1005 
1006 
1007         result = muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(foo, boo)]", message);
1008         assertNotNull(result);
1009         assertTrue(result instanceof Map);
1010         assertEquals(2, ((Map)result).size());
1011 
1012         result = muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(foo?, boo)]", message);
1013         assertNotNull(result);
1014         assertTrue(result instanceof Map);
1015         assertEquals(2, ((Map)result).size());        
1016         
1017         result = muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(fool?, boo)]", message);
1018         assertNotNull(result);
1019         assertTrue(result instanceof Map);
1020         assertEquals(1, ((Map)result).size());
1021 
1022         try
1023         {
1024             muleContext.getExpressionManager().evaluate("#[mule:message.map-payload(fool, boo)]", message);
1025             fail("Map payload does not contain property 'fool' but it is required");
1026         }
1027         catch (ExpressionRuntimeException e)
1028         {
1029             //Expected
1030         }
1031     }
1032 
1033     @Test
1034     public void testSimpleRegistryLookup() throws Exception
1035     {
1036         FruitBowlToFruitBasket trans = new FruitBowlToFruitBasket();
1037         trans.setName("bowlToBasket");
1038         muleContext.getRegistry().registerTransformer(trans);
1039 
1040         MuleMessage message = new DefaultMuleMessage(new Apple(), muleContext);
1041         RegistryExpressionEvaluator eval = new RegistryExpressionEvaluator();
1042         eval.setMuleContext(muleContext);
1043         Object o = eval.evaluate("bowlToBasket", message);
1044         assertNotNull(o);
1045         assertTrue(o instanceof Transformer);
1046 
1047         o = eval.evaluate("XXbowlToBasket*", message);
1048         assertNull(o);
1049 
1050         try
1051         {
1052             eval.evaluate("XXbowlToBasket", message);
1053             fail("Object is not optional");
1054         }
1055         catch (Exception e)
1056         {
1057             //expected
1058         }
1059 
1060         //We can't test bean properties since it requires have the XML module on the classpath
1061     }
1062 
1063     @Test
1064     public void testSimpleRegistryLookupUsingMAnager() throws Exception
1065     {
1066         FruitBowlToFruitBasket trans = new FruitBowlToFruitBasket();
1067         trans.setName("bowlToBasket");
1068         muleContext.getRegistry().registerTransformer(trans);
1069 
1070         MuleMessage message = new DefaultMuleMessage(new Apple(), muleContext);
1071         Object o = muleContext.getExpressionManager().evaluate("#[mule:registry.bowlToBasket]", message);
1072         assertNotNull(o);
1073         assertTrue(o instanceof Transformer);
1074 
1075         o = muleContext.getExpressionManager().evaluate("#[mule:registry.XXbowlToBasket*]", message);
1076         assertNull(o);
1077 
1078         try
1079         {
1080             muleContext.getExpressionManager().evaluate("#[mule:registry.XXbowlToBasket]", message);
1081             fail("Object is not optional");
1082         }
1083         catch (Exception e)
1084         {
1085             //expected
1086         }
1087     }
1088 
1089 }