1
2
3
4
5
6
7
8
9
10
11 package org.mule.test.construct;
12
13 import static org.junit.Assert.assertEquals;
14 import static org.junit.Assert.assertFalse;
15 import static org.junit.Assert.assertNotNull;
16 import static org.junit.Assert.assertNotSame;
17 import static org.junit.Assert.assertNull;
18 import static org.junit.Assert.assertTrue;
19
20 import org.mule.DefaultMuleMessage;
21 import org.mule.api.MessagingException;
22 import org.mule.api.MuleEvent;
23 import org.mule.api.MuleException;
24 import org.mule.api.MuleMessage;
25 import org.mule.api.MuleMessageCollection;
26 import org.mule.api.endpoint.InboundEndpoint;
27 import org.mule.api.processor.MessageProcessor;
28 import org.mule.api.source.CompositeMessageSource;
29 import org.mule.api.source.MessageSource;
30 import org.mule.api.transformer.Transformer;
31 import org.mule.api.transport.PropertyScope;
32 import org.mule.construct.Flow;
33 import org.mule.endpoint.DefaultInboundEndpoint;
34 import org.mule.source.StartableCompositeMessageSource;
35 import org.mule.tck.junit4.FunctionalTestCase;
36 import org.mule.tck.testmodels.fruit.Apple;
37 import org.mule.tck.testmodels.fruit.Banana;
38 import org.mule.tck.testmodels.fruit.Fruit;
39 import org.mule.tck.testmodels.fruit.FruitBowl;
40 import org.mule.tck.testmodels.fruit.Orange;
41 import org.mule.transformer.simple.StringAppendTransformer;
42
43 import java.util.HashMap;
44 import java.util.List;
45 import java.util.Map;
46
47 import org.junit.Ignore;
48 import org.junit.Test;
49
50 public class FlowConfigurationFunctionalTestCase extends FunctionalTestCase
51 {
52
53 public FlowConfigurationFunctionalTestCase()
54 {
55 setDisposeContextPerClass(true);
56 }
57
58 @Override
59 protected String getConfigResources()
60 {
61 return "org/mule/test/construct/flow.xml";
62 }
63
64 @Test
65 public void testFlow() throws Exception
66 {
67 final Flow flow = muleContext.getRegistry().lookupObject("flow");
68 assertEquals(DefaultInboundEndpoint.class, flow.getMessageSource().getClass());
69 assertEquals("vm://in", ((InboundEndpoint) flow.getMessageSource()).getEndpointURI()
70 .getUri()
71 .toString());
72 assertEquals(5, flow.getMessageProcessors().size());
73 assertNotNull(flow.getExceptionListener());
74
75 assertEquals("012xyzabc3",
76 muleContext.getClient()
77 .send("vm://in", new DefaultMuleMessage("0", muleContext))
78 .getPayloadAsString());
79
80 }
81
82 @Test
83 public void testFlowSynchronous() throws MuleException
84 {
85 muleContext.getClient().send("vm://synchronous", new DefaultMuleMessage("0", muleContext));
86 MuleMessage message = muleContext.getClient().request("vm://synchronous-out", RECEIVE_TIMEOUT);
87 assertNotNull(message);
88 Thread thread = (Thread) message.getPayload();
89 assertNotNull(thread);
90 assertEquals(Thread.currentThread(), thread);
91 }
92
93 @Test
94 public void testFlowAynchronous() throws MuleException
95 {
96 muleContext.getClient().send("vm://asynchronous", new DefaultMuleMessage("0", muleContext));
97 MuleMessage message = muleContext.getClient().request("vm://asynchronous-out", RECEIVE_TIMEOUT);
98 assertNotNull(message);
99 Thread thread = (Thread) message.getPayload();
100 assertNotNull(thread);
101 assertNotSame(Thread.currentThread(), thread);
102 }
103
104 @Test
105 public void testFlowQueuedAsynchronous() throws MuleException
106 {
107 muleContext.getClient().send("vm://queued-asynchronous", new DefaultMuleMessage("0", muleContext));
108 MuleMessage message = muleContext.getClient()
109 .request("vm://queued-asynchronous-out", RECEIVE_TIMEOUT);
110 assertNotNull(message);
111 Thread thread = (Thread) message.getPayload();
112 assertNotNull(thread);
113 assertNotSame(Thread.currentThread(), thread);
114 }
115
116 @Test
117 public void testAsyncAynchronous() throws MuleException
118 {
119 muleContext.getClient().dispatch("vm://asynchronous-async", new DefaultMuleMessage("0", muleContext));
120 MuleMessage message = muleContext.getClient().request("vm://asynchronous-async-out", RECEIVE_TIMEOUT);
121 assertNotNull(message);
122 Thread thread = (Thread) message.getPayload();
123 assertNotNull(thread);
124 assertNotSame(Thread.currentThread(), thread);
125 }
126
127 @Test
128 public void testAsyncQueuedAsynchronous() throws MuleException
129 {
130 muleContext.getClient().dispatch("vm://queued-asynchronous-async",
131 new DefaultMuleMessage("0", muleContext));
132 MuleMessage message = muleContext.getClient().request("vm://queued-asynchronous-async-out",
133 RECEIVE_TIMEOUT);
134 assertNotNull(message);
135 Thread thread = (Thread) message.getPayload();
136 assertNotNull(thread);
137 assertNotSame(Thread.currentThread(), thread);
138 }
139
140 @Test
141 public void testFlowCompositeSource() throws Exception
142 {
143 final Flow flow = muleContext.getRegistry().lookupObject("flow2");
144 assertEquals(StartableCompositeMessageSource.class, flow.getMessageSource().getClass());
145 assertEquals(2, flow.getMessageProcessors().size());
146
147 assertEquals("01xyz",
148 muleContext.getClient()
149 .send("vm://in2", new DefaultMuleMessage("0", muleContext))
150 .getPayloadAsString());
151 assertEquals("01xyz",
152 muleContext.getClient()
153 .send("vm://in3", new DefaultMuleMessage("0", muleContext))
154 .getPayloadAsString());
155 }
156
157 @Test
158 public void testInOutFlow() throws Exception
159 {
160 muleContext.getClient().send("vm://inout-in", new DefaultMuleMessage("0", muleContext));
161 assertEquals("0", muleContext.getClient()
162 .request("vm://inout-out", RECEIVE_TIMEOUT)
163 .getPayloadAsString());
164 }
165
166 @Test
167 public void testInOutAppendFlow() throws Exception
168 {
169 muleContext.getClient().send("vm://inout-append-in", new DefaultMuleMessage("0", muleContext));
170 assertEquals("0inout", muleContext.getClient()
171 .request("vm://inout-append-out", RECEIVE_TIMEOUT)
172 .getPayloadAsString());
173 }
174
175 @Test
176 public void testSplitAggregateFlow() throws Exception
177 {
178 final Apple apple = new Apple();
179 final Banana banana = new Banana();
180 final Orange orange = new Orange();
181 final FruitBowl fruitBowl = new FruitBowl(apple, banana);
182 fruitBowl.addFruit(orange);
183
184 muleContext.getClient().send("vm://split-aggregate-in",
185 new DefaultMuleMessage(fruitBowl, muleContext));
186
187 final MuleMessage result = muleContext.getClient().request("vm://split-aggregate-out",
188 RECEIVE_TIMEOUT);
189
190 assertNotNull(result);
191 assertTrue(result instanceof MuleMessageCollection);
192 final MuleMessageCollection coll = (MuleMessageCollection) result;
193 assertEquals(3, coll.size());
194 final List<?> results = (List<?>) coll.getPayload();
195
196 assertTrue(apple.isBitten());
197 assertTrue(banana.isBitten());
198 assertTrue(orange.isBitten());
199
200 assertTrue(results.contains(apple));
201 assertTrue(results.contains(banana));
202 assertTrue(results.contains(orange));
203 }
204
205 @Test
206 public void testSplitAggregateListFlow() throws Exception
207 {
208 final Apple apple = new Apple();
209 final Banana banana = new Banana();
210 final Orange orange = new Orange();
211 final FruitBowl fruitBowl = new FruitBowl(apple, banana);
212 fruitBowl.addFruit(orange);
213
214 muleContext.getClient().send("vm://split-aggregate-list-in",
215 new DefaultMuleMessage(fruitBowl.getFruit(), muleContext));
216
217 final MuleMessage result = muleContext.getClient().request("vm://split-aggregate-list-out",
218 RECEIVE_TIMEOUT);
219
220 assertNotNull(result);
221 assertTrue(result instanceof MuleMessageCollection);
222 final MuleMessageCollection coll = (MuleMessageCollection) result;
223 assertEquals(3, coll.size());
224 final List<?> results = (List<?>) coll.getPayload();
225
226 assertTrue(apple.isBitten());
227 assertTrue(banana.isBitten());
228 assertTrue(orange.isBitten());
229
230 assertTrue(results.contains(apple));
231 assertTrue(results.contains(banana));
232 assertTrue(results.contains(orange));
233 }
234
235 @Test
236 public void testSplitAggregateMapFlow() throws Exception
237 {
238 Map<String, Fruit> map = new HashMap<String, Fruit>();
239 final Apple apple = new Apple();
240 final Banana banana = new Banana();
241 final Orange orange = new Orange();
242 map.put("apple", apple);
243 map.put("banana", banana);
244 map.put("orange", orange);
245
246 MuleEvent result = ((Flow) muleContext.getRegistry().lookupFlowConstruct("split-map")).process(getTestEvent(map));
247
248 assertNotNull(result);
249 assertTrue(result.getMessage() instanceof MuleMessageCollection);
250
251 final MuleMessageCollection coll = (MuleMessageCollection) result.getMessage();
252 assertEquals(3, coll.size());
253 final MuleMessage[] results = coll.getMessagesAsArray();
254
255 assertTrue(apple.isBitten());
256 assertTrue(banana.isBitten());
257 assertTrue(orange.isBitten());
258
259 assertNotNull(results[0].getProperty("key", PropertyScope.INVOCATION));
260 assertNotNull(results[1].getProperty("key", PropertyScope.INVOCATION));
261 assertNotNull(results[2].getProperty("key", PropertyScope.INVOCATION));
262 }
263
264 @Test
265 public void testSplitFilterAggregateFlow() throws Exception
266 {
267 final Apple apple = new Apple();
268 final Banana banana = new Banana();
269 final Orange orange = new Orange();
270 final FruitBowl fruitBowl = new FruitBowl(apple, banana);
271 fruitBowl.addFruit(orange);
272
273 muleContext.getClient().send("vm://split-filter-aggregate-in",
274 new DefaultMuleMessage(fruitBowl, muleContext));
275
276 final MuleMessage result = muleContext.getClient().request("vm://split-filter-aggregate-out",
277 RECEIVE_TIMEOUT);
278
279 assertNotNull(result);
280 assertTrue(result instanceof MuleMessageCollection);
281 final MuleMessageCollection coll = (MuleMessageCollection) result;
282 assertEquals(1, coll.size());
283 final List<?> results = (List<?>) coll.getPayload();
284
285 assertTrue(results.contains(apple));
286 assertFalse(results.contains(banana));
287 assertFalse(results.contains(orange));
288 }
289
290 @Test
291 public void testMessageChunkSplitAggregateFlow() throws Exception
292 {
293 String payload = "";
294 for (int i = 0; i < 100; i++)
295 {
296 payload += TEST_MESSAGE;
297 }
298
299 muleContext.getClient().send("vm://message-chunk-split-aggregate-in",
300 new DefaultMuleMessage(payload, muleContext));
301
302 final MuleMessage result = muleContext.getClient().request("vm://message-chunk-split-aggregate-out",
303 RECEIVE_TIMEOUT);
304
305 assertNotNull(result);
306 assertNotSame(payload, result.getPayload());
307 assertEquals(payload, result.getPayloadAsString());
308 }
309
310 @Test
311 public void testComponentsFlow() throws Exception
312 {
313 final MuleMessage result = muleContext.getClient().send("vm://components",
314 new DefaultMuleMessage(TEST_MESSAGE, muleContext));
315
316 assertNotNull(result);
317 assertNotSame(TEST_MESSAGE + "test", result.getPayload());
318 }
319
320 @Test
321 public void testWireTapFlow() throws Exception
322 {
323 muleContext.getClient().send("vm://wiretap-in", new DefaultMuleMessage(TEST_MESSAGE, muleContext));
324
325 final MuleMessage result = muleContext.getClient().request("vm://wiretap-out", RECEIVE_TIMEOUT);
326 final MuleMessage tapResult = muleContext.getClient().request("vm://wiretap-tap", RECEIVE_TIMEOUT);
327
328 assertNotNull(result);
329 assertNotNull(tapResult);
330 assertNotSame(result, tapResult);
331 assertEquals(TEST_MESSAGE + "inout", result.getPayloadAsString());
332 assertEquals(TEST_MESSAGE + "intap", tapResult.getPayloadAsString());
333 }
334
335 @Test
336 public void testResponseElement() throws Exception
337 {
338 final MuleMessage result = muleContext.getClient().send("vm://response",
339 new DefaultMuleMessage("", muleContext));
340
341 assertNotNull(result);
342 assertEquals("abcdefghi", result.getPayloadAsString());
343 }
344
345 @Test
346 public void testAsyncOneWayEndpoint() throws Exception
347 {
348 muleContext.getClient().send("vm://async-oneway-in", new DefaultMuleMessage("0", muleContext));
349 final MuleMessage result = muleContext.getClient().request("vm://async-oneway-out", RECEIVE_TIMEOUT);
350 final MuleMessage asyncResult = muleContext.getClient().request("vm://async-async-oneway-out",
351 RECEIVE_TIMEOUT);
352
353 assertNotNull(result);
354 assertNotNull(asyncResult);
355 assertEquals("0ac", result.getPayloadAsString());
356 assertEquals("0ab", asyncResult.getPayloadAsString());
357 }
358
359 @Test
360 public void testAsyncSedaOneWayEndpoint() throws Exception
361 {
362 muleContext.getClient().send("vm://async-seda-oneway-in", new DefaultMuleMessage("0", muleContext));
363 final MuleMessage result = muleContext.getClient().request("vm://async-seda-oneway-out",
364 RECEIVE_TIMEOUT);
365 final MuleMessage asyncResult = muleContext.getClient().request("vm://async-async-seda-oneway-out",
366 RECEIVE_TIMEOUT);
367
368 assertNotNull(result);
369 assertNotNull(asyncResult);
370 assertEquals("0ac", result.getPayloadAsString());
371 assertEquals("0ab", asyncResult.getPayloadAsString());
372 }
373
374 @Test
375 public void testAsyncRequestResponseEndpoint() throws Exception
376 {
377 muleContext.getClient().send("vm://async-requestresponse-in",
378 new DefaultMuleMessage("0", muleContext));
379 final MuleMessage result = muleContext.getClient().request("vm://async-requestresponse-out",
380 RECEIVE_TIMEOUT);
381 final MuleMessage asyncResult = muleContext.getClient().request(
382 "vm://async-async-requestresponse-out", RECEIVE_TIMEOUT);
383
384 assertNotNull(result);
385 assertNotNull(asyncResult);
386 assertEquals("0ac", result.getPayloadAsString());
387 assertEquals("0ab", asyncResult.getPayloadAsString());
388 }
389
390 @Test
391 public void testAsyncTransactionalEndpoint() throws Exception
392 {
393 MuleMessage message = muleContext.getClient().send("vm://async-tx-in",
394 new DefaultMuleMessage("0", muleContext));
395 assertNotNull(message);
396 assertNotNull(message.getExceptionPayload());
397 assertEquals(MessagingException.class, message.getExceptionPayload().getException().getClass());
398
399 final MuleMessage result = muleContext.getClient().request("vm://async-requestresponse-out",
400 RECEIVE_TIMEOUT);
401 final MuleMessage asyncResult = muleContext.getClient().request("vm://async-async-oneway-out",
402 RECEIVE_TIMEOUT);
403
404 assertNull(result);
405 assertNull(asyncResult);
406 }
407
408 @Ignore
409 @Test
410 public void testTransactional() throws Exception
411 {
412 muleContext.getClient().dispatch("vm://transactional-in", new DefaultMuleMessage("", muleContext));
413 }
414
415 @Ignore
416 @Test
417 public void testTransactionalRollback() throws Exception
418 {
419 muleContext.getClient().dispatch("vm://transactional-rollback-in",
420 new DefaultMuleMessage("", muleContext));
421 }
422
423 @Test
424 public void testMulticaster() throws Exception
425 {
426 muleContext.getClient()
427 .send("vm://multicaster-in", new DefaultMuleMessage(TEST_MESSAGE, muleContext));
428
429 final MuleMessage result1 = muleContext.getClient().request("vm://multicaster-out1", RECEIVE_TIMEOUT);
430 final MuleMessage result2 = muleContext.getClient().request("vm://multicaster-out2", RECEIVE_TIMEOUT);
431 final MuleMessage result3 = muleContext.getClient().request("vm://multicaster-out3", RECEIVE_TIMEOUT);
432
433 assertNotNull(result1);
434 assertNotNull(result2);
435 assertNotNull(result3);
436 assertNotSame(result1, result2);
437 assertNotSame(result1, result3);
438 assertNotSame(result2, result3);
439
440 assertEquals(TEST_MESSAGE, result1.getPayload());
441 assertEquals(TEST_MESSAGE, result1.getPayload());
442 assertEquals(TEST_MESSAGE, result1.getPayload());
443
444 }
445
446 @Test
447 public void testRecipientList() throws Exception
448 {
449 muleContext.getClient().send("vm://recipient-list-in",
450 new DefaultMuleMessage(TEST_MESSAGE, muleContext));
451
452 final MuleMessage result1 = muleContext.getClient().request("vm://recipient-list-out1",
453 RECEIVE_TIMEOUT);
454 final MuleMessage result2 = muleContext.getClient().request("vm://recipient-list-out2",
455 RECEIVE_TIMEOUT);
456 final MuleMessage result3 = muleContext.getClient().request("vm://recipient-list-out3",
457 RECEIVE_TIMEOUT);
458
459 assertNotNull(result1);
460 assertNotNull(result2);
461 assertNotNull(result3);
462 assertNotSame(result1, result2);
463 assertNotSame(result1, result3);
464 assertNotSame(result2, result3);
465
466 assertEquals(TEST_MESSAGE, result1.getPayload());
467 assertEquals(TEST_MESSAGE, result2.getPayload());
468 assertEquals(TEST_MESSAGE, result3.getPayload());
469
470 }
471
472 @Test
473 public void testChoiceWithoutOutboundEndpoints() throws Exception
474 {
475 assertEquals("foo Hello foo",
476 muleContext.getClient()
477 .send("vm://choice2-in", new DefaultMuleMessage("foo", muleContext))
478 .getPayloadAsString());
479 assertEquals("bar Hello bar",
480 muleContext.getClient()
481 .send("vm://choice2-in", new DefaultMuleMessage("bar", muleContext))
482 .getPayloadAsString());
483 assertEquals("egh Hello ?",
484 muleContext.getClient()
485 .send("vm://choice2-in", new DefaultMuleMessage("egh", muleContext))
486 .getPayloadAsString());
487 }
488
489 @Test
490 public void testFlowRef() throws Exception
491 {
492 assertEquals("012xyzabc312xyzabc3",
493 muleContext.getClient()
494 .send("vm://flow-ref-in", new DefaultMuleMessage("0", muleContext))
495 .getPayloadAsString());
496 }
497
498 @Test
499 public void testInvoke() throws Exception
500 {
501 assertEquals("0recieved",
502 muleContext.getClient()
503 .send("vm://invoke-in", new DefaultMuleMessage("0", muleContext))
504 .getPayloadAsString());
505 }
506
507 @Test
508 public void testInvoke2() throws Exception
509 {
510 MuleMessage message = new DefaultMuleMessage("0", muleContext);
511 message.setOutboundProperty("one", "header1val");
512 assertEquals("header1valrecieved", muleContext.getClient()
513 .send("vm://invoke2-in", message)
514 .getPayloadAsString());
515 }
516
517 @Test
518 public void testInvoke3() throws Exception
519 {
520
521 muleContext.getClient().send("vm://invoke3-in", new DefaultMuleMessage("0", muleContext));
522 }
523
524 @Test
525 public void testInvoke4() throws Exception
526 {
527
528 muleContext.getClient().send("vm://invoke4-in", new DefaultMuleMessage("0", muleContext));
529 }
530
531 @Test
532 public void testEnrichWithAttributes() throws Exception
533 {
534 MuleMessage message = new DefaultMuleMessage("0", muleContext);
535 assertEquals(
536 "0Hello",
537 muleContext.getClient()
538 .send("vm://enrich-in", message)
539 .getProperty("helloHeader", PropertyScope.INBOUND));
540 }
541
542 @Test
543 public void testEnrichWithElements() throws Exception
544 {
545 MuleMessage message = new DefaultMuleMessage("0", muleContext);
546 MuleMessage result = muleContext.getClient().send("vm://enrich2-in", message);
547
548 assertEquals("0Hello", result.getProperty("helloHeader", PropertyScope.INBOUND));
549 assertEquals("0Hello", result.getProperty("helloHeader2", PropertyScope.INBOUND));
550 }
551
552 @Test
553 public void testEnrichUsingComponent() throws Exception
554 {
555
556 MuleMessage message = new DefaultMuleMessage("0", muleContext);
557 MuleMessage result = muleContext.getClient().send("vm://enrichcomponent-in", message);
558
559 assertEquals("0", result.getProperty("echoHeader", PropertyScope.INBOUND));
560 }
561
562 @Test
563 public void testEnrichUsingComponent2() throws Exception
564 {
565
566 MuleMessage message = new DefaultMuleMessage("0", muleContext);
567 MuleMessage result = muleContext.getClient().send("vm://enrichcomponent2-in", message);
568
569 assertEquals("0", result.getProperty("echoHeader", PropertyScope.INBOUND));
570 }
571
572 @Test
573 public void testLoggerMessage() throws Exception
574 {
575 MuleMessage message = new DefaultMuleMessage("0", muleContext);
576 muleContext.getClient().send("vm://loggermessage-in", message);
577 }
578
579 @Test
580 public void testLoggerHeader() throws Exception
581 {
582 MuleMessage message = new DefaultMuleMessage("0", muleContext);
583 message.setOutboundProperty("toLog", "valueToLog");
584 muleContext.getClient().send("vm://loggerheader-in", message);
585 }
586
587 public static class Pojo
588 {
589 public void method()
590 {
591
592 }
593
594 public void method(Object arg1, Object arg2)
595 {
596
597 }
598 }
599
600 @Test
601 public void testCustomMessageRouter() throws Exception
602 {
603 MuleMessage message = new DefaultMuleMessage("", muleContext);
604 MuleMessage result = muleContext.getClient().send("vm://customRouter-in", message);
605 assertEquals("abc", result.getPayloadAsString());
606 }
607
608 @Test
609 public void testPoll() throws Exception
610 {
611 MuleMessage message = muleContext.getClient().request("vm://poll-out", RECEIVE_TIMEOUT);
612 assertNotNull(message);
613 assertEquals(" Hello fooout", message.getPayloadAsString());
614 }
615
616 @Test
617 public void testPollFlowRef() throws Exception
618 {
619 MuleMessage message = muleContext.getClient().request("vm://poll2-out", RECEIVE_TIMEOUT);
620 assertNotNull(message);
621 assertEquals("pollappendout", message.getPayloadAsString());
622 }
623
624 @Test
625 public void testSubFlowMessageFilter() throws Exception
626 {
627 muleContext.getClient().dispatch("vm://messagefiltersubflow-in",
628 new DefaultMuleMessage("0", muleContext));
629 MuleMessage message = muleContext.getClient().request("vm://messagefiltersubflow-out", 5000);
630 assertNotNull(message);
631 }
632
633 @Test
634 public void testCustomMessageSource() throws Exception
635 {
636 Flow flow = (Flow) muleContext.getRegistry().lookupFlowConstruct("customMessageSource");
637 TestMessageSource source = (TestMessageSource) flow.getMessageSource();
638
639 MuleEvent result = source.fireEvent(getTestEvent("a"));
640 assertEquals("abcd", result.getMessageAsString());
641 }
642
643 @Test
644 public void testCustomMessageSourceInComposite() throws Exception
645 {
646 Flow flow = (Flow) muleContext.getRegistry().lookupFlowConstruct("customMessageSourceInComposite");
647 CompositeMessageSource compositeSource = (CompositeMessageSource) flow.getMessageSource();
648 TestMessageSource source = (TestMessageSource) compositeSource.getSources().get(0);
649
650 MuleEvent result = source.fireEvent(getTestEvent("a"));
651 assertEquals("abcd", result.getMessageAsString());
652 }
653
654
655 public static class TestMessageSource implements MessageSource
656 {
657 private MessageProcessor listener;
658 private String appendBefore;
659 private String appendAfter;
660
661 MuleEvent fireEvent(MuleEvent event) throws MuleException
662 {
663 Transformer before = new StringAppendTransformer(appendBefore);
664 Transformer after = new StringAppendTransformer(appendAfter);
665 return after.process(listener.process(before.process(event)));
666 }
667
668 public void setAppendBefore(String appendBefore)
669 {
670 this.appendBefore = appendBefore;
671 }
672
673 public void setAppendAfter(String appendAfter)
674 {
675 this.appendAfter = appendAfter;
676 }
677
678 @Override
679 public void setListener(MessageProcessor listener)
680 {
681 this.listener = listener;
682 }
683
684 }
685
686 public static class ThreadSensingMessageProcessor implements MessageProcessor
687 {
688 @Override
689 public MuleEvent process(MuleEvent event) throws MuleException
690 {
691 event.getMessage().setPayload(Thread.currentThread());
692 return event;
693 }
694 }
695
696 }