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