View Javadoc

1   /*
2    * $Id: FlowConfigurationFunctionalTestCase.java 20325 2010-11-24 16:27:28Z 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 org.mule.DefaultMuleMessage;
14  import org.mule.api.MuleException;
15  import org.mule.api.MuleMessage;
16  import org.mule.api.MuleMessageCollection;
17  import org.mule.api.config.ThreadingProfile;
18  import org.mule.api.endpoint.InboundEndpoint;
19  import org.mule.api.transport.PropertyScope;
20  import org.mule.construct.SimpleFlowConstruct;
21  import org.mule.endpoint.DefaultInboundEndpoint;
22  import org.mule.source.StartableCompositeMessageSource;
23  import org.mule.tck.FunctionalTestCase;
24  import org.mule.tck.testmodels.fruit.Apple;
25  import org.mule.tck.testmodels.fruit.Banana;
26  import org.mule.tck.testmodels.fruit.FruitBowl;
27  import org.mule.tck.testmodels.fruit.Orange;
28  
29  import java.util.List;
30  
31  public class FlowConfigurationFunctionalTestCase extends FunctionalTestCase
32  {
33  
34      @Override
35      protected String getConfigResources()
36      {
37          return "org/mule/test/construct/flow.xml";
38      }
39  
40      @Override
41      protected void doSetUp() throws Exception
42      {
43          super.setDisposeManagerPerSuite(true);
44          super.doSetUp();
45      }
46  
47      public void testFlow() throws MuleException, Exception
48      {
49          final SimpleFlowConstruct flow = muleContext.getRegistry().lookupObject("flow");
50          assertEquals(DefaultInboundEndpoint.class, flow.getMessageSource().getClass());
51          assertEquals("vm://in", ((InboundEndpoint) flow.getMessageSource()).getEndpointURI()
52              .getUri()
53              .toString());
54          assertEquals(5, flow.getMessageProcessors().size());
55          assertNotNull(flow.getExceptionListener());
56  
57          assertEquals("012xyzabc3", muleContext.getClient().send("vm://in",
58              new DefaultMuleMessage("0", muleContext)).getPayloadAsString());
59  
60      }
61  
62      public void testFlowCompositeSource() throws MuleException, Exception
63      {
64          final SimpleFlowConstruct flow = muleContext.getRegistry().lookupObject("flow2");
65          assertEquals(StartableCompositeMessageSource.class, flow.getMessageSource().getClass());
66          assertEquals(2, flow.getMessageProcessors().size());
67  
68          assertEquals("01xyz", muleContext.getClient().send("vm://in2",
69              new DefaultMuleMessage("0", muleContext)).getPayloadAsString());
70          assertEquals("01xyz", muleContext.getClient().send("vm://in3",
71              new DefaultMuleMessage("0", muleContext)).getPayloadAsString());
72  
73      }
74  
75      public void testInOutFlow() throws MuleException, Exception
76      {
77          muleContext.getClient().send("vm://inout-in", new DefaultMuleMessage("0", muleContext));
78          assertEquals("0", muleContext.getClient()
79              .request("vm://inout-out", RECEIVE_TIMEOUT)
80              .getPayloadAsString());
81      }
82  
83      public void testInOutAppendFlow() throws MuleException, Exception
84      {
85          muleContext.getClient().send("vm://inout-append-in", new DefaultMuleMessage("0", muleContext));
86          assertEquals("0inout", muleContext.getClient()
87              .request("vm://inout-append-out", RECEIVE_TIMEOUT)
88              .getPayloadAsString());
89      }
90  
91      public void testSplitAggregateFlow() throws MuleException, Exception
92      {
93          final Apple apple = new Apple();
94          final Banana banana = new Banana();
95          final Orange orange = new Orange();
96          final FruitBowl fruitBowl = new FruitBowl(apple, banana);
97          fruitBowl.addFruit(orange);
98  
99          muleContext.getClient().send("vm://split-aggregate-in",
100             new DefaultMuleMessage(fruitBowl, muleContext));
101 
102         final MuleMessage result = muleContext.getClient().request("vm://split-aggregate-out",
103             RECEIVE_TIMEOUT);
104 
105         assertNotNull(result);
106         assertTrue(result instanceof MuleMessageCollection);
107         final MuleMessageCollection coll = (MuleMessageCollection) result;
108         assertEquals(3, coll.size());
109         final List<?> results = (List<?>) coll.getPayload();
110 
111         assertTrue(apple.isBitten());
112         assertTrue(banana.isBitten());
113         assertTrue(orange.isBitten());
114 
115         assertTrue(results.contains(apple));
116         assertTrue(results.contains(banana));
117         assertTrue(results.contains(orange));
118     }
119 
120     public void testSplitAggregateListFlow() throws MuleException, Exception
121     {
122         final Apple apple = new Apple();
123         final Banana banana = new Banana();
124         final Orange orange = new Orange();
125         final FruitBowl fruitBowl = new FruitBowl(apple, banana);
126         fruitBowl.addFruit(orange);
127 
128         muleContext.getClient().send("vm://split-aggregate-list-in",
129             new DefaultMuleMessage(fruitBowl.getFruit(), muleContext));
130 
131         final MuleMessage result = muleContext.getClient().request("vm://split-aggregate-list-out",
132             RECEIVE_TIMEOUT);
133 
134         assertNotNull(result);
135         assertTrue(result instanceof MuleMessageCollection);
136         final MuleMessageCollection coll = (MuleMessageCollection) result;
137         assertEquals(3, coll.size());
138         final List<?> results = (List<?>) coll.getPayload();
139 
140         assertTrue(apple.isBitten());
141         assertTrue(banana.isBitten());
142         assertTrue(orange.isBitten());
143 
144         assertTrue(results.contains(apple));
145         assertTrue(results.contains(banana));
146         assertTrue(results.contains(orange));
147     }
148 
149     public void testSplitFilterAggregateFlow() throws MuleException, Exception
150     {
151         final Apple apple = new Apple();
152         final Banana banana = new Banana();
153         final Orange orange = new Orange();
154         final FruitBowl fruitBowl = new FruitBowl(apple, banana);
155         fruitBowl.addFruit(orange);
156 
157         muleContext.getClient().send("vm://split-filter-aggregate-in",
158             new DefaultMuleMessage(fruitBowl, muleContext));
159 
160         final MuleMessage result = muleContext.getClient().request("vm://split-filter-aggregate-out",
161             RECEIVE_TIMEOUT);
162 
163         assertNotNull(result);
164         assertTrue(result instanceof MuleMessageCollection);
165         final MuleMessageCollection coll = (MuleMessageCollection) result;
166         assertEquals(1, coll.size());
167         final List<?> results = (List<?>) coll.getPayload();
168 
169         assertTrue(results.contains(apple));
170         assertFalse(results.contains(banana));
171         assertFalse(results.contains(orange));
172     }
173 
174     public void testMessageChunkSplitAggregateFlow() throws MuleException, Exception
175     {
176         String payload = "";
177         for (int i = 0; i < 100; i++)
178         {
179             payload += TEST_MESSAGE;
180         }
181 
182         muleContext.getClient().send("vm://message-chunk-split-aggregate-in",
183             new DefaultMuleMessage(payload, muleContext));
184 
185         final MuleMessage result = muleContext.getClient().request("vm://message-chunk-split-aggregate-out",
186             RECEIVE_TIMEOUT);
187 
188         assertNotNull(result);
189         assertNotSame(payload, result.getPayload());
190         assertEquals(payload, result.getPayloadAsString());
191     }
192 
193     public void testComponentsFlow() throws MuleException, Exception
194     {
195         final MuleMessage result = muleContext.getClient().send("vm://components",
196             new DefaultMuleMessage(TEST_MESSAGE, muleContext));
197 
198         assertNotNull(result);
199         assertNotSame(TEST_MESSAGE + "test", result.getPayload());
200     }
201 
202     public void testWireTapFlow() throws MuleException, Exception
203     {
204         muleContext.getClient().send("vm://wiretap-in", new DefaultMuleMessage(TEST_MESSAGE, muleContext));
205 
206         final MuleMessage result = muleContext.getClient().request("vm://wiretap-out", RECEIVE_TIMEOUT);
207         final MuleMessage tapResult = muleContext.getClient().request("vm://wiretap-tap", RECEIVE_TIMEOUT);
208 
209         assertNotNull(result);
210         assertNotNull(tapResult);
211         assertNotSame(result, tapResult);
212         assertEquals(TEST_MESSAGE + "inout", result.getPayloadAsString());
213         assertEquals(TEST_MESSAGE + "intap", tapResult.getPayloadAsString());
214     }
215 
216     public void testResponseElement() throws MuleException, Exception
217     {
218         final MuleMessage result = muleContext.getClient().send("vm://response",
219             new DefaultMuleMessage("", muleContext));
220 
221         assertNotNull(result);
222         assertEquals("abcdefghi", result.getPayloadAsString());
223     }
224 
225     public void testAsyncOneWayEndpoint() throws MuleException, Exception
226     {
227         muleContext.getClient().send("vm://async-oneway-in", new DefaultMuleMessage("0", muleContext));
228         final MuleMessage result = muleContext.getClient().request("vm://async-oneway-out", RECEIVE_TIMEOUT);
229         final MuleMessage asyncResult = muleContext.getClient().request("vm://async-async-oneway-out",
230             RECEIVE_TIMEOUT);
231 
232         assertNotNull(result);
233         assertNotNull(asyncResult);
234         assertEquals("0ac", result.getPayloadAsString());
235         assertEquals("0ab", asyncResult.getPayloadAsString());
236     }
237 
238     public void testAsyncRequestResponseEndpoint() throws MuleException, Exception
239     {
240         muleContext.getClient().send("vm://async-requestresponse-in",
241             new DefaultMuleMessage("0", muleContext));
242         final MuleMessage result = muleContext.getClient().request("vm://async-requestresponse-out",
243             RECEIVE_TIMEOUT);
244         final MuleMessage asyncResult = muleContext.getClient().request(
245             "vm://async-async-requestresponse-out", RECEIVE_TIMEOUT);
246 
247         assertNotNull(result);
248         assertNotNull(asyncResult);
249         assertEquals("0ac", result.getPayloadAsString());
250         assertEquals("0ab", asyncResult.getPayloadAsString());
251     }
252 
253     public void testAsyncTransactionalEndpoint() throws MuleException, Exception
254     {
255         MuleMessage response = muleContext.getClient().send("vm://async-tx-in",
256             new DefaultMuleMessage("0", muleContext));
257         assertNotNull(response);
258         assertNotNull(response.getExceptionPayload());
259 
260         final MuleMessage result = muleContext.getClient().request("vm://async-requestresponse-out",
261             RECEIVE_TIMEOUT);
262         final MuleMessage asyncResult = muleContext.getClient().request("vm://async-async-oneway-out",
263             RECEIVE_TIMEOUT);
264 
265         assertNull(result);
266         assertNull(asyncResult);
267     }
268 
269     // public void testTransactional() throws MuleException, Exception
270     // {
271     // muleContext.getClient().dispatch("vm://transactional-in", new
272     // DefaultMuleMessage("", muleContext));
273     //
274     // }
275     //
276     // public void testTransactionalRollback() throws MuleException, Exception
277     // {
278     // muleContext.getClient().dispatch("vm://transactional-rollback-in",
279     // new DefaultMuleMessage("", muleContext));
280     //
281     // }
282 
283     public void testMulticaster() throws MuleException, Exception
284     {
285         muleContext.getClient()
286             .send("vm://multicaster-in", new DefaultMuleMessage(TEST_MESSAGE, muleContext));
287 
288         final MuleMessage result1 = muleContext.getClient().request("vm://multicaster-out1", RECEIVE_TIMEOUT);
289         final MuleMessage result2 = muleContext.getClient().request("vm://multicaster-out2", RECEIVE_TIMEOUT);
290         final MuleMessage result3 = muleContext.getClient().request("vm://multicaster-out3", RECEIVE_TIMEOUT);
291 
292         assertNotNull(result1);
293         assertNotNull(result2);
294         assertNotNull(result3);
295         assertNotSame(result1, result2);
296         assertNotSame(result1, result3);
297         assertNotSame(result2, result3);
298 
299         assertEquals(TEST_MESSAGE, result1.getPayload());
300         assertEquals(TEST_MESSAGE, result1.getPayload());
301         assertEquals(TEST_MESSAGE, result1.getPayload());
302 
303     }
304 
305     public void testRecipientList() throws MuleException, Exception
306     {
307         muleContext.getClient().send("vm://recipient-list-in",
308             new DefaultMuleMessage(TEST_MESSAGE, muleContext));
309 
310         final MuleMessage result1 = muleContext.getClient().request("vm://recipient-list-out1",
311             RECEIVE_TIMEOUT);
312         final MuleMessage result2 = muleContext.getClient().request("vm://recipient-list-out2",
313             RECEIVE_TIMEOUT);
314         final MuleMessage result3 = muleContext.getClient().request("vm://recipient-list-out3",
315             RECEIVE_TIMEOUT);
316 
317         assertNotNull(result1);
318         assertNotNull(result2);
319         assertNotNull(result3);
320         assertNotSame(result1, result2);
321         assertNotSame(result1, result3);
322         assertNotSame(result2, result3);
323 
324         assertEquals(TEST_MESSAGE, result1.getPayload());
325         assertEquals(TEST_MESSAGE, result2.getPayload());
326         assertEquals(TEST_MESSAGE, result3.getPayload());
327 
328     }
329 
330     public void testChoiceWithoutOutboundEndpoints() throws MuleException, Exception
331     {
332         assertEquals("foo Hello foo", muleContext.getClient().send("vm://choice2-in",
333             new DefaultMuleMessage("foo", muleContext)).getPayloadAsString());
334         assertEquals("bar Hello bar", muleContext.getClient().send("vm://choice2-in",
335             new DefaultMuleMessage("bar", muleContext)).getPayloadAsString());
336         assertEquals("egh Hello ?", muleContext.getClient().send("vm://choice2-in",
337             new DefaultMuleMessage("egh", muleContext)).getPayloadAsString());
338     }
339 
340     public void testFlowRef() throws MuleException, Exception
341     {
342         assertEquals("012xyzabc3", muleContext.getClient().send("vm://flow-ref-in",
343             new DefaultMuleMessage("0", muleContext)).getPayloadAsString());
344 
345     }
346 
347     public void testInvoke() throws MuleException, Exception
348     {
349         assertEquals("0recieved", muleContext.getClient().send("vm://invoke-in",
350             new DefaultMuleMessage("0", muleContext)).getPayloadAsString());
351     }
352 
353     public void testInvoke2() throws MuleException, Exception
354     {
355         MuleMessage message = new DefaultMuleMessage("0", muleContext);
356         message.setOutboundProperty("one", "header1val");
357         assertEquals("header1valrecieved", muleContext.getClient()
358             .send("vm://invoke2-in", message)
359             .getPayloadAsString());
360 
361     }
362 
363     public void testInvoke3() throws MuleException, Exception
364     {
365         // ensure multiple arguments work
366         muleContext.getClient().send("vm://invoke3-in", new DefaultMuleMessage("0", muleContext));
367     }
368     
369     public void testEnrichWithAttributes() throws MuleException, Exception
370     {
371         MuleMessage message = new DefaultMuleMessage("0", muleContext);
372         assertEquals("0Hello", muleContext.getClient().send("vm://enrich-in", message).getProperty(
373             "helloHeader", PropertyScope.INBOUND));
374     }
375 
376     public void testEnrichWithElements() throws MuleException, Exception
377     {
378         MuleMessage message = new DefaultMuleMessage("0", muleContext);
379         MuleMessage result = muleContext.getClient().send("vm://enrich2-in", message);
380 
381         assertEquals("0Hello", result.getProperty("helloHeader", PropertyScope.INBOUND));
382         assertEquals("0Hello", result.getProperty("helloHeader2", PropertyScope.INBOUND));
383     }
384     
385     public void testLoggerMessage() throws MuleException, Exception
386     {
387         MuleMessage message = new DefaultMuleMessage("0", muleContext);
388         muleContext.getClient().send("vm://loggermessage-in", message);
389     }
390     
391     public void testLoggerHeader() throws MuleException, Exception
392     {
393         MuleMessage message = new DefaultMuleMessage("0", muleContext);
394         message.setOutboundProperty("toLog", "valueToLog");
395         muleContext.getClient().send("vm://loggerheader-in", message);
396     }
397 
398     static class Pojo
399     {
400 
401         public void method(Object arg1, Object arg2)
402         {
403 
404         }
405     }
406 
407     public void testFlowThreadingProfile() throws MuleException, Exception
408     {
409         SimpleFlowConstruct flow = muleContext.getRegistry().lookupObject("flow-threading-profile");
410         assertTrue(flow.getThreadingProfile().isDoThreading());
411         assertEquals(2, flow.getThreadingProfile().getMaxThreadsActive());
412         assertEquals(1, flow.getThreadingProfile().getMaxThreadsIdle());
413         assertEquals(ThreadingProfile.WHEN_EXHAUSTED_RUN, flow.getThreadingProfile().getPoolExhaustedAction());
414     }
415     
416 }