View Javadoc

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