1
2
3
4
5
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
796 Object result = eval.evaluate(null, message);
797 assertNotNull(result);
798 assertEquals(message, result);
799
800
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
821 }
822 }
823
824
825
826
827
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
859 }
860 }
861
862 @Test
863 public void testMessagePayloadWithNulls() throws Exception
864 {
865 MuleExpressionEvaluator eval = new MuleExpressionEvaluator();
866 eval.setMuleContext(muleContext);
867
868
869 Object result = eval.evaluate(null, null);
870 assertNull(result);
871 }
872
873
874
875
876
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
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
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
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
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
940 muleContext.getRegistry().registerTransformer(new FruitBowlToFruitBasket());
941
942
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
958 muleContext.getRegistry().registerTransformer(new FruitBowlToFruitBasket());
959
960
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
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
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
1055 }
1056
1057
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
1083 }
1084 }
1085
1086 }