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