View Javadoc

1   /*
2    * $Id: EndpointTranformersInAttributesTestCase.java 22551 2011-07-25 06:32:00Z mike.schilling $
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.config.spring.parsers.endpoint;
12  
13  import static org.junit.Assert.assertEquals;
14  import static org.junit.Assert.assertNotNull;
15  import static org.junit.Assert.assertTrue;
16  
17  import org.mule.api.MuleException;
18  import org.mule.api.endpoint.ImmutableEndpoint;
19  import org.mule.api.processor.MessageProcessor;
20  import org.mule.api.processor.MessageProcessorChain;
21  import org.mule.api.routing.OutboundRouterCollection;
22  import org.mule.api.service.Service;
23  import org.mule.api.transformer.Transformer;
24  import org.mule.construct.Flow;
25  import org.mule.routing.outbound.OutboundPassThroughRouter;
26  import org.mule.service.ServiceCompositeMessageSource;
27  import org.mule.tck.AbstractServiceAndFlowTestCase;
28  import org.mule.tck.testmodels.mule.TestInboundTransformer;
29  import org.mule.tck.testmodels.mule.TestResponseTransformer;
30  import org.mule.transformer.simple.MessagePropertiesTransformer;
31  import org.mule.transformer.simple.StringAppendTransformer;
32  
33  import java.util.Arrays;
34  import java.util.Collection;
35  import java.util.List;
36  
37  import org.junit.Test;
38  import org.junit.runners.Parameterized.Parameters;
39  
40  public class EndpointTranformersInAttributesTestCase extends AbstractServiceAndFlowTestCase
41  {    
42      public EndpointTranformersInAttributesTestCase(ConfigVariant variant, String configResources)
43      {
44          super(variant, configResources);
45      }
46  
47      @Parameters
48      public static Collection<Object[]> parameters()
49      {
50          return Arrays.asList(new Object[][]{
51              {ConfigVariant.SERVICE, "org/mule/config/spring/parsers/endpoint/endpoint-attribute-transformers-service.xml"},
52              {ConfigVariant.FLOW, "org/mule/config/spring/parsers/endpoint/endpoint-attribute-transformers-flow.xml"}
53          });
54      }      
55      
56      @Test
57      public void testGlobalEndpoint1() throws MuleException
58      {
59          ImmutableEndpoint endpoint = muleContext.getEndpointFactory().getInboundEndpoint("ep1");
60  
61          List<MessageProcessor> processors = endpoint.getMessageProcessors();
62          assertNotNull(processors);
63          assertEquals(2, processors.size());
64          assertTrue(processors.get(0) instanceof TestInboundTransformer);
65          // For backwards-compatibility only
66          List<Transformer> transformers = endpoint.getTransformers();
67          assertNotNull(transformers);
68          assertEquals(1, transformers.size());
69          assertTrue(transformers.get(0) instanceof TestInboundTransformer);
70  
71          processors = endpoint.getResponseMessageProcessors();
72          assertNotNull(processors);
73          assertEquals(1, processors.size());
74          assertTrue(processors.get(0) instanceof TestResponseTransformer);
75          // For backwards-compatibility only
76          transformers = endpoint.getResponseTransformers();
77          assertNotNull(transformers);
78          assertEquals(1, transformers.size());
79          assertTrue(transformers.get(0) instanceof TestResponseTransformer);
80      }
81  
82      @Test
83      public void testGlobalEndpoint2() throws MuleException
84      {
85          ImmutableEndpoint endpoint = muleContext.getEndpointFactory().getInboundEndpoint("ep2");
86  
87          List<MessageProcessor> processors = endpoint.getMessageProcessors();
88          assertNotNull(processors);
89          assertEquals(3, processors.size());
90          assertTrue(processors.get(0) instanceof TestInboundTransformer);
91          assertTrue(processors.get(1) instanceof TestInboundTransformer);
92          // For backwards-compatibility only
93          List<Transformer> transformers = endpoint.getTransformers();
94          assertNotNull(transformers);
95          assertEquals(2, transformers.size());
96          assertTrue(transformers.get(0) instanceof TestInboundTransformer);
97          assertTrue(transformers.get(1) instanceof TestInboundTransformer);
98  
99          processors = endpoint.getResponseMessageProcessors();
100         assertNotNull(processors);
101         assertEquals(2, processors.size());
102         assertTrue(processors.get(0) instanceof TestResponseTransformer);
103         assertTrue(processors.get(1) instanceof TestResponseTransformer);
104         // For backwards-compatibility only
105         transformers = endpoint.getResponseTransformers();
106         assertNotNull(transformers);
107         assertEquals(2, transformers.size());
108         assertTrue(transformers.get(0) instanceof TestResponseTransformer);
109         assertTrue(transformers.get(1) instanceof TestResponseTransformer);
110     }
111 
112     @Test
113     public void testGlobalEndpoints() throws MuleException
114     {
115         ImmutableEndpoint endpoint;        
116         Object service = muleContext.getRegistry().lookupObject("globalEndpoints");
117         
118         if (variant.equals(ConfigVariant.FLOW))
119         {            
120             endpoint = (ImmutableEndpoint) ((Flow) service).getMessageSource();
121         }
122         else
123         {         
124             endpoint = ((ServiceCompositeMessageSource) ((Service) service).getMessageSource()).getEndpoints()
125                             .get(0);
126         }            
127 
128         List<MessageProcessor> processors = endpoint.getMessageProcessors();
129         assertNotNull(processors);
130         assertEquals(2, processors.size());
131         assertTrue(processors.get(0) instanceof TestInboundTransformer);
132         // For backwards-compatibility only
133         List<Transformer> transformers = endpoint.getTransformers();
134         assertNotNull(transformers);
135         assertEquals(1, transformers.size());
136         assertTrue(transformers.get(0) instanceof TestInboundTransformer);
137 
138         processors = endpoint.getResponseMessageProcessors();
139         assertNotNull(processors);
140         assertEquals(1, processors.size());
141         assertTrue(processors.get(0) instanceof TestResponseTransformer);
142         // For backwards-compatibility only
143         transformers = endpoint.getResponseTransformers();
144         assertNotNull(transformers);
145         assertEquals(1, transformers.size());
146         assertTrue(transformers.get(0) instanceof TestResponseTransformer);
147 
148         if (variant.equals(ConfigVariant.FLOW))
149         {
150             endpoint = (ImmutableEndpoint) ((Flow) service).getMessageProcessors().get(0); 
151         }
152         else
153         {            
154             endpoint = (ImmutableEndpoint) ((OutboundPassThroughRouter) ((OutboundRouterCollection) ((Service) service).getOutboundMessageProcessor()).getRoutes()
155                 .get(0)).getRoutes().get(0);
156         }          
157  
158         processors = endpoint.getMessageProcessors();
159         assertNotNull(processors);
160         assertEquals(2, processors.size());
161         assertTrue(processors.get(0) instanceof TestInboundTransformer);
162         assertTrue(processors.get(1) instanceof TestInboundTransformer);
163         // For backwards-compatibility only
164         transformers = endpoint.getTransformers();
165         assertNotNull(transformers);
166         assertEquals(2, transformers.size());
167         assertTrue(transformers.get(0) instanceof TestInboundTransformer);
168         assertTrue(transformers.get(1) instanceof TestInboundTransformer);
169 
170         processors = endpoint.getResponseMessageProcessors();
171         assertNotNull(processors);
172         assertEquals(2, processors.size());
173         assertTrue(processors.get(0) instanceof TestResponseTransformer);
174         assertTrue(processors.get(1) instanceof TestResponseTransformer);
175         // For backwards-compatibility only
176         transformers = endpoint.getResponseTransformers();
177         assertNotNull(transformers);
178         assertEquals(2, transformers.size());
179         assertTrue(transformers.get(0) instanceof TestResponseTransformer);
180         assertTrue(transformers.get(1) instanceof TestResponseTransformer);
181     }
182 
183     @Test
184     public void testLocalEndpoints() throws MuleException
185     {
186         ImmutableEndpoint endpoint;        
187         Object service = muleContext.getRegistry().lookupObject("localEndpoints");
188         
189         if (variant.equals(ConfigVariant.FLOW))
190         {            
191             endpoint = (ImmutableEndpoint) ((Flow) service).getMessageSource();
192         }
193         else
194         {         
195             endpoint = ((ServiceCompositeMessageSource) ((Service) service).getMessageSource()).getEndpoints()
196                             .get(0);
197         }                            
198 
199         List<MessageProcessor> processors = endpoint.getMessageProcessors();
200         assertNotNull(processors);
201         assertEquals(2, processors.size());
202         assertTrue(processors.get(0) instanceof TestInboundTransformer);
203         // For backwards-compatibility only
204         List<Transformer> transformers = endpoint.getTransformers();
205         assertNotNull(transformers);
206         assertEquals(1, transformers.size());
207         assertTrue(transformers.get(0) instanceof TestInboundTransformer);
208 
209         processors = endpoint.getResponseMessageProcessors();
210         assertNotNull(processors);
211         assertEquals(1, processors.size());
212         assertTrue(processors.get(0) instanceof TestResponseTransformer);
213         // For backwards-compatibility only
214         transformers = endpoint.getResponseTransformers();
215         assertNotNull(transformers);
216         assertEquals(1, transformers.size());
217         assertTrue(transformers.get(0) instanceof TestResponseTransformer);
218 
219         if (variant.equals(ConfigVariant.FLOW))
220         {
221             endpoint = (ImmutableEndpoint) ((Flow) service).getMessageProcessors().get(0); 
222         }
223         else
224         {            
225             endpoint = (ImmutableEndpoint) ((OutboundPassThroughRouter) ((OutboundRouterCollection) ((Service) service).getOutboundMessageProcessor()).getRoutes()
226                 .get(0)).getRoutes().get(0);
227         }           
228         
229         processors = endpoint.getMessageProcessors();
230         assertNotNull(processors);
231         assertEquals(1, processors.size());
232         assertTrue(processors.get(0) instanceof TestInboundTransformer);
233         // For backwards-compatibility only
234         transformers = endpoint.getTransformers();
235         assertNotNull(transformers);
236         assertEquals(1, transformers.size());
237         assertTrue(transformers.get(0) instanceof TestInboundTransformer);
238 
239         processors = endpoint.getResponseMessageProcessors();
240         assertNotNull(processors);
241         assertEquals(1, processors.size());
242         assertTrue(processors.get(0) instanceof TestResponseTransformer);
243         // For backwards-compatibility only
244         transformers = endpoint.getResponseTransformers();
245         assertNotNull(transformers);
246         assertEquals(1, transformers.size());
247         assertTrue(transformers.get(0) instanceof TestResponseTransformer);
248     }
249 
250     @Test
251     public void testTransformerRefsWithChildProcessors() throws MuleException
252     {
253         ImmutableEndpoint endpoint;
254         
255         Object service = muleContext.getRegistry().lookupObject("transformerRefsWithChildProcessors");
256         
257         if (variant.equals(ConfigVariant.FLOW))
258         {            
259             endpoint = (ImmutableEndpoint) ((Flow) service).getMessageSource();
260         }
261         else
262         {         
263             endpoint = ((ServiceCompositeMessageSource) ((Service) service).getMessageSource()).getEndpoints()
264                             .get(0);
265         }                            
266 
267         List<MessageProcessor> processors = endpoint.getMessageProcessors();
268         assertNotNull(processors);
269         assertEquals(3, processors.size());
270         assertTrue(processors.get(0) instanceof StringAppendTransformer);
271         assertTrue(processors.get(1) instanceof TestInboundTransformer);
272 
273         processors = endpoint.getResponseMessageProcessors();
274         assertNotNull(processors);
275         assertEquals(2, processors.size());
276         assertTrue(processors.get(0) instanceof MessageProcessorChain);
277         assertTrue(((MessageProcessorChain)processors.get(0)).getMessageProcessors().get(0) instanceof StringAppendTransformer);
278         assertTrue(processors.get(1) instanceof TestResponseTransformer);
279 
280         if (variant.equals(ConfigVariant.FLOW))
281         {
282             endpoint = (ImmutableEndpoint) ((Flow) service).getMessageProcessors().get(0); 
283         }
284         else
285         {            
286             endpoint = (ImmutableEndpoint) ((OutboundPassThroughRouter) ((OutboundRouterCollection) ((Service) service).getOutboundMessageProcessor()).getRoutes()
287                 .get(0)).getRoutes().get(0);
288         }                          
289 
290         processors = endpoint.getMessageProcessors();
291         assertNotNull(processors);
292         assertEquals(2, processors.size());
293         assertTrue(processors.get(0) instanceof MessagePropertiesTransformer);
294         assertTrue(processors.get(1) instanceof TestInboundTransformer);
295 
296         processors = endpoint.getResponseMessageProcessors();
297         assertNotNull(processors);
298         assertEquals(2, processors.size());
299         assertTrue(processors.get(0) instanceof MessageProcessorChain);
300         assertTrue(((MessageProcessorChain)processors.get(0)).getMessageProcessors().get(0) instanceof MessagePropertiesTransformer);
301         assertTrue(processors.get(1) instanceof TestResponseTransformer);
302     }
303 
304 }