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