View Javadoc

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