View Javadoc

1   /*
2    * $Id: FlowProcessingStrategyConfigTestCase.java 22864 2011-09-05 17:18:46Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.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.config.spring.flow;
12  
13  import org.mule.api.MuleContext;
14  import org.mule.api.processor.MessageProcessor;
15  import org.mule.api.processor.MessageProcessorChainBuilder;
16  import org.mule.api.processor.ProcessingStrategy;
17  import org.mule.construct.Flow;
18  import org.mule.construct.flow.DefaultFlowProcessingStrategy;
19  import org.mule.processor.AsyncDelegateMessageProcessor;
20  import org.mule.processor.strategy.AsynchronousProcessingStrategy;
21  import org.mule.processor.strategy.QueuedAsynchronousProcessingStrategy;
22  import org.mule.processor.strategy.SynchronousProcessingStrategy;
23  import org.mule.tck.FunctionalTestCase;
24  
25  import java.util.List;
26  
27  public class FlowProcessingStrategyConfigTestCase extends FunctionalTestCase
28  {
29  
30      @Override
31      protected String getConfigResources()
32      {
33          return "org/mule/test/config/spring/flow/flow-processing-strategies.xml";
34      }
35  
36      public void testDefault() throws Exception
37      {
38          assertEquals(DefaultFlowProcessingStrategy.class,
39              getFlowProcessingStrategy("defaultFlow").getClass());
40      }
41  
42      public void testSynchronous() throws Exception
43      {
44          assertEquals(SynchronousProcessingStrategy.class,
45              getFlowProcessingStrategy("synchronousFlow").getClass());
46      }
47  
48      public void testAsynchronous() throws Exception
49      {
50          assertEquals(AsynchronousProcessingStrategy.class,
51              getFlowProcessingStrategy("asynchronousFlow").getClass());
52      }
53  
54      public void testQueuedAsynchronous() throws Exception
55      {
56          assertEquals(QueuedAsynchronousProcessingStrategy.class,
57              getFlowProcessingStrategy("queuedAsynchronousFlow").getClass());
58      }
59  
60      public void testCustomAsynchronous() throws Exception
61      {
62          ProcessingStrategy processingStrategy = getFlowProcessingStrategy("customAsynchronousFlow");
63  
64          assertEquals(AsynchronousProcessingStrategy.class, processingStrategy.getClass());
65  
66          assertAsynchronousStrategyConfig((AsynchronousProcessingStrategy) processingStrategy);
67      }
68  
69      public void testCustomQueuedAsynchronous() throws Exception
70      {
71          ProcessingStrategy processingStrategy = getFlowProcessingStrategy("customQueuedAsynchronousFlow");
72  
73          assertEquals(QueuedAsynchronousProcessingStrategy.class, processingStrategy.getClass());
74  
75          assertAsynchronousStrategyConfig((AsynchronousProcessingStrategy) processingStrategy);
76  
77          assertEquals(100, ((QueuedAsynchronousProcessingStrategy) processingStrategy).getQueueTimeout()
78              .intValue());
79          assertEquals(10, ((QueuedAsynchronousProcessingStrategy) processingStrategy).getMaxQueueSize()
80              .intValue());
81  
82      }
83  
84      public void testCustom() throws Exception
85      {
86          ProcessingStrategy processingStrategy = getFlowProcessingStrategy("customProcessingStrategyFlow");
87          assertEquals(CustomProcessingStrategy.class, processingStrategy.getClass());
88  
89          assertEquals("bar", (((CustomProcessingStrategy) processingStrategy).foo));
90      }
91  
92      public void testDefaultAsync() throws Exception
93      {
94          assertEquals(QueuedAsynchronousProcessingStrategy.class,
95              getAsyncProcessingStrategy("defaultAsync").getClass());
96      }
97  
98      public void testAsynchronousAsync() throws Exception
99      {
100         assertEquals(AsynchronousProcessingStrategy.class,
101             getAsyncProcessingStrategy("asynchronousAsync").getClass());
102     }
103 
104     public void testQueuedAsynchronousAsync() throws Exception
105     {
106         assertEquals(QueuedAsynchronousProcessingStrategy.class,
107             getAsyncProcessingStrategy("queuedAsynchronousAsync").getClass());
108     }
109 
110     public void testCustomAsynchronousAsync() throws Exception
111     {
112         ProcessingStrategy processingStrategy = getAsyncProcessingStrategy("customAsynchronousAsync");
113 
114         assertEquals(AsynchronousProcessingStrategy.class, processingStrategy.getClass());
115 
116         assertAsynchronousStrategyConfig((AsynchronousProcessingStrategy) processingStrategy);
117     }
118 
119     public void testCustomQueuedAsynchronousAsync() throws Exception
120     {
121         ProcessingStrategy processingStrategy = getAsyncProcessingStrategy("customQueuedAsynchronousAsync");
122 
123         assertEquals(QueuedAsynchronousProcessingStrategy.class, processingStrategy.getClass());
124 
125         assertAsynchronousStrategyConfig((AsynchronousProcessingStrategy) processingStrategy);
126 
127         assertEquals(100, ((QueuedAsynchronousProcessingStrategy) processingStrategy).getQueueTimeout()
128             .intValue());
129         assertEquals(10, ((QueuedAsynchronousProcessingStrategy) processingStrategy).getMaxQueueSize()
130             .intValue());
131 
132     }
133 
134     public void testCustomAsync() throws Exception
135     {
136         ProcessingStrategy processingStrategy = getAsyncProcessingStrategy("customProcessingStrategyAsync");
137         assertEquals(CustomProcessingStrategy.class, processingStrategy.getClass());
138 
139         assertEquals("bar", (((CustomProcessingStrategy) processingStrategy).foo));
140     }
141 
142     private void assertAsynchronousStrategyConfig(AsynchronousProcessingStrategy processingStrategy)
143     {
144         assertEquals(10, processingStrategy.getMaxThreads().intValue());
145         assertEquals(5, processingStrategy.getMinThreads().intValue());
146         assertEquals(100, processingStrategy.getThreadTTL().intValue());
147         assertEquals(10, processingStrategy.getMaxBufferSize().intValue());
148 
149     }
150 
151     private ProcessingStrategy getFlowProcessingStrategy(String flowName) throws Exception
152     {
153         Flow flow = (Flow) getFlowConstruct(flowName);
154         return flow.getProcessingStrategy();
155     }
156 
157     private ProcessingStrategy getAsyncProcessingStrategy(String flowName) throws Exception
158     {
159         Flow flow = (Flow) getFlowConstruct(flowName);
160         MessageProcessor processor = flow.getMessageProcessors().get(0);
161         assertEquals(AsyncDelegateMessageProcessor.class, processor.getClass());
162         return ((AsyncDelegateMessageProcessor) processor).getProcessingStrategy();
163     }
164 
165     public static class CustomProcessingStrategy implements ProcessingStrategy
166     {
167 
168         String foo;
169 
170         @Override
171         public void configureProcessors(List<MessageProcessor> processors,
172                                         StageNameSource nameSource,
173                                         MessageProcessorChainBuilder chainBuilder,
174                                         MuleContext muleContext)
175         {
176             // TODO Auto-generated method stub
177         }
178 
179         public void setFoo(String foo)
180         {
181             this.foo = foo;
182 
183         }
184     }
185 
186 }