View Javadoc

1   /*
2    * $Id: FlowConfigurationFunctionalTestCase.java 23203 2011-10-17 21:19:38Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
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         // ensure multiple arguments work
521         muleContext.getClient().send("vm://invoke3-in", new DefaultMuleMessage("0", muleContext));
522     }
523 
524     @Test
525     public void testInvoke4() throws Exception
526     {
527         // ensure no arguments work
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         // MULE-5544
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         // MULE-5544
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             // does nothing
592         }
593 
594         public void method(Object arg1, Object arg2)
595         {
596             // does nothing
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 }