1
2
3
4
5
6
7
8
9
10 package org.mule.expression;
11
12 import org.mule.DefaultMuleMessage;
13 import org.mule.api.MuleMessage;
14 import org.mule.api.config.MuleProperties;
15 import org.mule.api.expression.ExpressionRuntimeException;
16 import org.mule.api.expression.RequiredValueException;
17 import org.mule.api.transport.PropertyScope;
18 import org.mule.routing.correlation.CorrelationPropertiesExpressionEvaluator;
19 import org.mule.tck.junit4.AbstractMuleContextTestCase;
20 import org.mule.util.UUID;
21
22 import java.util.Collections;
23 import java.util.HashMap;
24 import java.util.List;
25 import java.util.Map;
26
27 import org.junit.Test;
28
29 import static org.junit.Assert.assertEquals;
30 import static org.junit.Assert.assertFalse;
31 import static org.junit.Assert.assertNotNull;
32 import static org.junit.Assert.assertNull;
33 import static org.junit.Assert.assertTrue;
34 import static org.junit.Assert.fail;
35
36 public class HeadersExpressionEvaluatorTestCase extends AbstractMuleContextTestCase
37 {
38 private Map<String, Object> props;
39
40 @Override
41 public void doSetUp()
42 {
43 props = new HashMap<String, Object>(3);
44 props.put("foo", "foovalue");
45 props.put("bar", "barvalue");
46 props.put("baz", "bazvalue");
47 }
48
49 @Test
50 public void testSingleHeader() throws Exception
51 {
52 MessageHeaderExpressionEvaluator eval = new MessageHeaderExpressionEvaluator();
53 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
54
55
56 Object result = eval.evaluate("foo", message);
57 assertNotNull(result);
58 assertEquals("foovalue", result);
59
60
61 result = eval.evaluate("foo?", message);
62 assertNotNull(result);
63 assertEquals("foovalue", result);
64
65
66 result = eval.evaluate("fool?", message);
67 assertNull(result);
68
69
70 try
71 {
72 eval.evaluate("fool", message);
73 fail("required value");
74 }
75 catch (Exception e)
76 {
77
78 }
79
80 ((DefaultMuleMessage) message).addInboundProperties(Collections.singletonMap("testProp", (Object) "value"));
81 result = eval.evaluate("testProp?", message);
82 assertNull(result);
83
84 result = eval.evaluate("INBOUND:testProp", message);
85 assertEquals("value", result);
86 }
87
88 @Test
89 public void testMapHeaders() throws Exception
90 {
91 MessageHeadersExpressionEvaluator eval = new MessageHeadersExpressionEvaluator();
92
93 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
94
95
96 Object result = eval.evaluate("foo, baz", message);
97 assertNotNull(result);
98 assertTrue(result instanceof Map);
99 assertEquals(2, ((Map)result).size());
100 assertTrue(((Map)result).values().contains("foovalue"));
101 assertTrue(((Map)result).values().contains("bazvalue"));
102 assertFalse(((Map)result).values().contains("barvalue"));
103
104
105 result = eval.evaluate("foo?, baz", message);
106 assertNotNull(result);
107 assertTrue(result instanceof Map);
108 assertEquals(2, ((Map)result).size());
109 assertTrue(((Map)result).values().contains("foovalue"));
110 assertTrue(((Map)result).values().contains("bazvalue"));
111 assertFalse(((Map)result).values().contains("barvalue"));
112
113
114 result = eval.evaluate("fool?", message);
115 assertNotNull(result);
116 assertTrue(result instanceof Map);
117 assertEquals(0, ((Map)result).size());
118
119
120 try
121 {
122 eval.evaluate("fool", message);
123 fail("required value");
124 }
125 catch (Exception e)
126 {
127
128 }
129
130
131 result = eval.evaluate("*", message);
132 assertNotNull(result);
133 assertTrue(result instanceof Map);
134 assertEquals(3, ((Map)result).size());
135 assertTrue(((Map)result).values().contains("foovalue"));
136 assertTrue(((Map)result).values().contains("bazvalue"));
137 assertTrue(((Map)result).values().contains("barvalue"));
138 }
139
140 @Test
141 public void testHeadersWithScopes() throws Exception
142 {
143 MessageHeadersExpressionEvaluator eval = new MessageHeadersExpressionEvaluator();
144 DefaultMuleMessage message = new DefaultMuleMessage("test", props, muleContext);
145 message.setProperty("faz", "fazvalue", PropertyScope.INVOCATION);
146
147 Object result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz", message);
148 assertNotNull(result);
149 assertTrue(result instanceof Map);
150 assertEquals(2, ((Map)result).size());
151 assertTrue(((Map)result).values().contains("foovalue"));
152 assertTrue(((Map)result).values().contains("bazvalue"));
153
154
155 result = eval.evaluate("OUTBOUND:foo, baz", message);
156 assertNotNull(result);
157 assertTrue(result instanceof Map);
158 assertEquals(2, ((Map)result).size());
159 assertTrue(((Map)result).values().contains("foovalue"));
160 assertTrue(((Map)result).values().contains("bazvalue"));
161
162 result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz, INVOCATION:faz", message);
163 assertNotNull(result);
164 assertTrue(result instanceof Map);
165 assertEquals(3, ((Map)result).size());
166 assertTrue(((Map)result).values().contains("foovalue"));
167 assertTrue(((Map)result).values().contains("bazvalue"));
168 assertTrue(((Map)result).values().contains("fazvalue"));
169
170 result = eval.evaluate("OUTBOUND:foo, baz, INVOCATION:faz", message);
171 assertNotNull(result);
172 assertTrue(result instanceof Map);
173 assertEquals(3, ((Map)result).size());
174 assertTrue(((Map)result).values().contains("foovalue"));
175 assertTrue(((Map)result).values().contains("bazvalue"));
176 assertTrue(((Map)result).values().contains("fazvalue"));
177
178
179 try
180 {
181 eval.evaluate("OUTBOUND:foo, baz, faz", message);
182 fail("faz is not in outbound scope and is not optional");
183 }
184 catch (RequiredValueException e)
185 {
186
187 }
188
189 result = eval.evaluate("OUTBOUND:foo, faz?, baz", message);
190 assertNotNull(result);
191 assertTrue(result instanceof Map);
192 assertEquals(2, ((Map)result).size());
193 assertTrue(((Map)result).values().contains("foovalue"));
194 assertTrue(((Map)result).values().contains("bazvalue"));
195
196 message.setInboundProperty("infoo", "infoovalue");
197 result = eval.evaluate("infoo?", message);
198 assertNotNull(result);
199 assertTrue(result instanceof Map);
200 assertEquals(0, ((Map)result).size());
201 result = eval.evaluate("INBOUND:infoo?", message);
202 assertNotNull(result);
203 assertTrue(result instanceof Map);
204 assertEquals(1, ((Map)result).size());
205 }
206
207
208 @Test
209 public void testListHeaders() throws Exception
210 {
211 MessageHeadersListExpressionEvaluator eval = new MessageHeadersListExpressionEvaluator();
212 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
213
214
215 Object result = eval.evaluate("foo, baz", message);
216 assertNotNull(result);
217 assertTrue(result instanceof List);
218 assertEquals(2, ((List)result).size());
219 assertTrue(((List)result).contains("foovalue"));
220 assertTrue(((List)result).contains("bazvalue"));
221
222 assertFalse(((List)result).contains("barvalue"));
223
224
225 result = eval.evaluate("foo?, baz", message);
226 assertNotNull(result);
227 assertTrue(result instanceof List);
228 assertEquals(2, ((List)result).size());
229 assertTrue(((List)result).contains("foovalue"));
230 assertTrue(((List)result).contains("bazvalue"));
231
232 assertFalse(((List)result).contains("barvalue"));
233
234
235 result = eval.evaluate("fool?", message);
236 assertNotNull(result);
237 assertTrue(result instanceof List);
238 assertEquals(0, ((List)result).size());
239
240
241 try
242 {
243 eval.evaluate("fool", message);
244 fail("required value");
245 }
246 catch (Exception e)
247 {
248
249 }
250 }
251
252 @Test
253 public void testListHeadersWithScopes() throws Exception
254 {
255 MessageHeadersListExpressionEvaluator eval = new MessageHeadersListExpressionEvaluator();
256 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
257 message.setProperty("faz", "fazvalue", PropertyScope.INVOCATION);
258
259 Object result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz", message);
260 assertNotNull(result);
261 assertTrue(result instanceof List);
262 assertEquals(2, ((List)result).size());
263 assertTrue(((List)result).contains("foovalue"));
264 assertTrue(((List)result).contains("bazvalue"));
265
266 assertFalse(((List)result).contains("barvalue"));
267
268
269 result = eval.evaluate("OUTBOUND:foo, baz", message);
270 assertNotNull(result);
271 assertTrue(result instanceof List);
272 assertEquals(2, ((List)result).size());
273 assertTrue(((List)result).contains("foovalue"));
274 assertTrue(((List)result).contains("bazvalue"));
275
276 result = eval.evaluate("OUTBOUND:foo, OUTBOUND:baz, INVOCATION:faz", message);
277 assertNotNull(result);
278 assertTrue(result instanceof List);
279 assertEquals(3, ((List)result).size());
280 assertTrue(((List)result).contains("foovalue"));
281 assertTrue(((List)result).contains("bazvalue"));
282
283 assertTrue(((List)result).contains("fazvalue"));
284
285 try
286 {
287 eval.evaluate("OUTBOUND:foo, baz, faz", message);
288 fail("faz is not in outbound scope and is not optional");
289 }
290 catch (RequiredValueException e)
291 {
292
293 }
294
295 result = eval.evaluate("OUTBOUND:foo, faz?, baz", message);
296 assertNotNull(result);
297 assertTrue(result instanceof List);
298 assertEquals(2, ((List)result).size());
299 assertTrue(((List)result).contains("foovalue"));
300 assertTrue(((List)result).contains("bazvalue"));
301
302 }
303
304 @Test
305 public void testListHeadersWithWildcard() throws Exception
306 {
307 MessageHeadersListExpressionEvaluator eval = new MessageHeadersListExpressionEvaluator();
308 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
309
310
311 Object result = eval.evaluate("*", message);
312 assertNotNull(result);
313 assertTrue(result instanceof List);
314 assertEquals(3, ((List)result).size());
315 assertTrue(((List)result).contains("foovalue"));
316 assertTrue(((List)result).contains("bazvalue"));
317 assertTrue(((List)result).contains("barvalue"));
318
319
320 result = eval.evaluate("ba*", message);
321 assertNotNull(result);
322 assertTrue(result instanceof List);
323 assertEquals(2, ((List)result).size());
324 assertTrue(((List)result).contains("barvalue"));
325 assertTrue(((List)result).contains("bazvalue"));
326
327
328 result = eval.evaluate("x*", message);
329 assertNotNull(result);
330 assertTrue(result instanceof List);
331 assertEquals(0, ((List)result).size());
332
333
334 result = eval.evaluate("ba*, f*", message);
335 assertNotNull(result);
336 assertTrue(result instanceof List);
337 assertEquals(3, ((List)result).size());
338 assertTrue(((List)result).contains("foovalue"));
339 assertTrue(((List)result).contains("bazvalue"));
340 assertTrue(((List)result).contains("barvalue"));
341 }
342
343
344 @Test
345 public void testMapHeadersWithWildcards() throws Exception
346 {
347 MessageHeadersExpressionEvaluator eval = new MessageHeadersExpressionEvaluator();
348
349 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
350
351
352 Object result = eval.evaluate("*", message);
353 assertNotNull(result);
354 assertTrue(result instanceof Map);
355 assertEquals(3, ((Map)result).size());
356 assertTrue(((Map)result).values().contains("foovalue"));
357 assertTrue(((Map)result).values().contains("bazvalue"));
358 assertTrue(((Map)result).values().contains("barvalue"));
359
360
361 result = eval.evaluate("ba*", message);
362 assertNotNull(result);
363 assertTrue(result instanceof Map);
364 assertEquals(2, ((Map)result).size());
365 assertFalse(((Map)result).values().contains("foovalue"));
366 assertTrue(((Map)result).values().contains("bazvalue"));
367 assertTrue(((Map)result).values().contains("barvalue"));
368
369
370 result = eval.evaluate("x*", message);
371 assertNotNull(result);
372 assertTrue(result instanceof Map);
373 assertEquals(0, ((Map)result).size());
374
375
376 result = eval.evaluate("ba*, f*", message);
377 assertNotNull(result);
378 assertTrue(result instanceof Map);
379 assertEquals(3, ((Map)result).size());
380 assertTrue(((Map)result).values().contains("foovalue"));
381 assertTrue(((Map)result).values().contains("bazvalue"));
382 assertTrue(((Map)result).values().contains("barvalue"));
383 }
384
385 @Test
386 public void testSingleHeaderUsingManager() throws Exception
387 {
388 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
389
390
391 Object result = muleContext.getExpressionManager().evaluate("#[header:foo]", message);
392 assertNotNull(result);
393 assertEquals("foovalue", result);
394
395
396 result = muleContext.getExpressionManager().evaluate("#[header:foo?]", message);
397 assertNotNull(result);
398 assertEquals("foovalue", result);
399
400
401 result = muleContext.getExpressionManager().evaluate("#[header:fool?]", message);
402 assertNull(result);
403
404
405 try
406 {
407 muleContext.getExpressionManager().evaluate("#[header:fool]", message);
408 fail("Required value");
409 }
410 catch (ExpressionRuntimeException e)
411 {
412
413 }
414
415 }
416
417 @Test
418 public void testMapHeadersUsingManager() throws Exception
419 {
420
421 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
422
423
424 Object result = muleContext.getExpressionManager().evaluate("#[headers:foo, baz]", message);
425 assertNotNull(result);
426 assertTrue(result instanceof Map);
427 assertEquals(2, ((Map)result).size());
428 assertTrue(((Map)result).values().contains("foovalue"));
429 assertTrue(((Map)result).values().contains("bazvalue"));
430 assertFalse(((Map)result).values().contains("barvalue"));
431
432
433 result = muleContext.getExpressionManager().evaluate("#[headers:foo?, baz]", message);
434 assertNotNull(result);
435 assertTrue(result instanceof Map);
436 assertEquals(2, ((Map)result).size());
437 assertTrue(((Map)result).values().contains("foovalue"));
438 assertTrue(((Map)result).values().contains("bazvalue"));
439 assertFalse(((Map)result).values().contains("barvalue"));
440
441
442 result = muleContext.getExpressionManager().evaluate("#[headers:fool?]", message);
443 assertNotNull(result);
444 assertTrue(result instanceof Map);
445 assertEquals(0, ((Map)result).size());
446
447
448 try
449 {
450 muleContext.getExpressionManager().evaluate("#[headers:fool]", message);
451 fail("Required value");
452 }
453 catch (ExpressionRuntimeException e)
454 {
455
456 }
457
458 }
459
460 @Test
461 public void testMapHeadersWithWildcardsUsingManager() throws Exception
462 {
463
464 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
465
466
467 Object result = muleContext.getExpressionManager().evaluate("#[headers:*]", message);
468 assertNotNull(result);
469 assertTrue(result instanceof Map);
470 assertEquals(3, ((Map)result).size());
471 assertTrue(((Map)result).values().contains("foovalue"));
472 assertTrue(((Map)result).values().contains("bazvalue"));
473 assertTrue(((Map)result).values().contains("barvalue"));
474
475
476 result = muleContext.getExpressionManager().evaluate("#[headers:ba*]", message);
477 assertNotNull(result);
478 assertTrue(result instanceof Map);
479 assertEquals(2, ((Map)result).size());
480 assertFalse(((Map)result).values().contains("foovalue"));
481 assertTrue(((Map)result).values().contains("bazvalue"));
482 assertTrue(((Map)result).values().contains("barvalue"));
483
484
485 result = muleContext.getExpressionManager().evaluate("#[headers:x*]", message);
486 assertNotNull(result);
487 assertTrue(result instanceof Map);
488 assertEquals(0, ((Map)result).size());
489
490
491 result = muleContext.getExpressionManager().evaluate("#[headers:ba*, f*]", message);
492 assertNotNull(result);
493 assertTrue(result instanceof Map);
494 assertEquals(3, ((Map)result).size());
495 assertTrue(((Map)result).values().contains("foovalue"));
496 assertTrue(((Map)result).values().contains("bazvalue"));
497 assertTrue(((Map)result).values().contains("barvalue"));
498
499 }
500
501 @Test
502 public void testListHeadersUsingManager() throws Exception
503 {
504 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
505
506
507 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:foo, baz]", message);
508 assertNotNull(result);
509 assertTrue(result instanceof List);
510 assertEquals(2, ((List)result).size());
511 assertTrue(((List)result).contains("foovalue"));
512 assertTrue(((List)result).contains("bazvalue"));
513 assertFalse(((List)result).contains("barvalue"));
514
515
516 result = muleContext.getExpressionManager().evaluate("#[headers-list:foo?, baz]", message);
517 assertNotNull(result);
518 assertTrue(result instanceof List);
519 assertEquals(2, ((List)result).size());
520 assertTrue(((List)result).contains("foovalue"));
521 assertTrue(((List)result).contains("bazvalue"));
522 assertFalse(((List)result).contains("barvalue"));
523
524
525 result = muleContext.getExpressionManager().evaluate("#[headers-list:fool?]", message);
526 assertNotNull(result);
527 assertTrue(result instanceof List);
528 assertEquals(0, ((List)result).size());
529
530
531 try
532 {
533 muleContext.getExpressionManager().evaluate("#[headers-list:fool]", message);
534 fail("Required value");
535 }
536 catch (ExpressionRuntimeException e)
537 {
538
539 }
540 }
541
542 @Test
543 public void testListHeadersWithWildCardsUsingManager() throws Exception
544 {
545 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
546
547
548 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:*]", message);
549 assertNotNull(result);
550 assertTrue(result instanceof List);
551 assertEquals(3, ((List)result).size());
552 assertTrue(((List)result).contains("foovalue"));
553 assertTrue(((List)result).contains("bazvalue"));
554 assertTrue(((List)result).contains("barvalue"));
555
556
557 result = muleContext.getExpressionManager().evaluate("#[headers-list:ba*]", message);
558 assertNotNull(result);
559 assertTrue(result instanceof List);
560 assertEquals(2, ((List)result).size());
561 assertFalse(((List)result).contains("foovalue"));
562 assertTrue(((List)result).contains("bazvalue"));
563 assertTrue(((List)result).contains("barvalue"));
564
565
566 result = muleContext.getExpressionManager().evaluate("#[headers-list:x*]", message);
567 assertNotNull(result);
568 assertTrue(result instanceof List);
569 assertEquals(0, ((List)result).size());
570
571
572 result = muleContext.getExpressionManager().evaluate("#[headers-list:ba*, f*]", message);
573 assertNotNull(result);
574 assertTrue(result instanceof List);
575 assertEquals(3, ((List)result).size());
576 assertTrue(((List)result).contains("foovalue"));
577 assertTrue(((List)result).contains("bazvalue"));
578 assertTrue(((List)result).contains("barvalue"));
579 }
580
581 @Test
582 public void testCorrelationManagerCorrelationId()
583 {
584 CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
585 String correlationId = UUID.getUUID();
586
587 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
588 message.setCorrelationId(correlationId);
589
590 Object result = evaluator.evaluate(MuleProperties.MULE_CORRELATION_ID_PROPERTY, message);
591 assertNotNull(result);
592 assertEquals(correlationId, result);
593 }
594
595 @Test
596 public void testCorrelationManagerNullResult()
597 {
598 CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
599
600 DefaultMuleMessage message = new DefaultMuleMessage("test", props, muleContext);
601 message.setUniqueId(null);
602
603 try
604 {
605 evaluator.evaluate(MuleProperties.MULE_CORRELATION_ID_PROPERTY, message);
606 fail("Null result on CorrelationPropertiesExpressionEvaluator must throw");
607 }
608 catch (IllegalArgumentException iae)
609 {
610
611 }
612 }
613
614 @Test
615 public void testCorrelationManagerUniqueId()
616 {
617 CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
618
619 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
620 Object result = evaluator.evaluate(MuleProperties.MULE_MESSAGE_ID_PROPERTY, message);
621 assertNotNull(result);
622 assertEquals(message.getUniqueId(), result);
623 }
624
625
626
627
628
629
630
631
632 @Test
633 public void testCorrelationManagerInvalidKey()
634 {
635 CorrelationPropertiesExpressionEvaluator evaluator = new CorrelationPropertiesExpressionEvaluator();
636
637 MuleMessage message = new DefaultMuleMessage("test", props, muleContext);
638 try
639 {
640 evaluator.evaluate("invalid-key", message);
641 fail("invalid key on CorrelationPropertiesExpressionEvaluator must fail");
642 }
643 catch (IllegalArgumentException iax)
644 {
645
646 }
647 }
648 }