View Javadoc

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