1
2
3
4
5
6
7
8
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
799 Object result = eval.evaluate(null, message);
800 assertNotNull(result);
801 assertEquals(message, result);
802
803
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
824 }
825 }
826
827
828
829
830
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
862 }
863 }
864
865 @Test
866 public void testMessagePayloadWithNulls() throws Exception
867 {
868 MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
869 eval.setMuleContext(muleContext);
870
871
872 Object result = eval.evaluate(null, null);
873 assertNull(result);
874 }
875
876
877
878
879
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
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
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
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
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
943 muleContext.getRegistry().registerTransformer(new FruitBowlToFruitBasket());
944
945
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
961 muleContext.getRegistry().registerTransformer(new FruitBowlToFruitBasket());
962
963
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
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
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
1058 }
1059
1060
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
1086 }
1087 }
1088
1089 }