View Javadoc

1   /*
2    * $Id: AbstractScriptConfigBuilderTestCase.java 11554 2008-04-10 07:24:34Z dirk.olmes $
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.tck;
12  
13  import org.mule.AbstractExceptionListener;
14  import org.mule.api.MuleException;
15  import org.mule.api.component.JavaComponent;
16  import org.mule.api.endpoint.ImmutableEndpoint;
17  import org.mule.api.endpoint.InboundEndpoint;
18  import org.mule.api.model.Model;
19  import org.mule.api.routing.InboundRouterCollection;
20  import org.mule.api.routing.NestedRouter;
21  import org.mule.api.routing.NestedRouterCollection;
22  import org.mule.api.routing.OutboundRouter;
23  import org.mule.api.routing.OutboundRouterCollection;
24  import org.mule.api.routing.ResponseRouter;
25  import org.mule.api.routing.ResponseRouterCollection;
26  import org.mule.api.service.Service;
27  import org.mule.api.transformer.Transformer;
28  import org.mule.model.resolvers.LegacyEntryPointResolverSet;
29  import org.mule.routing.ForwardingCatchAllStrategy;
30  import org.mule.routing.filters.MessagePropertyFilter;
31  import org.mule.routing.outbound.OutboundPassThroughRouter;
32  import org.mule.tck.testmodels.fruit.FruitCleaner;
33  import org.mule.tck.testmodels.mule.TestCompressionTransformer;
34  import org.mule.tck.testmodels.mule.TestConnector;
35  import org.mule.tck.testmodels.mule.TestEntryPointResolverSet;
36  import org.mule.tck.testmodels.mule.TestExceptionStrategy;
37  import org.mule.tck.testmodels.mule.TestInboundTransformer;
38  import org.mule.tck.testmodels.mule.TestResponseAggregator;
39  import org.mule.transformer.TransformerUtils;
40  
41  import java.util.List;
42  import java.util.Map;
43  
44  public abstract class AbstractScriptConfigBuilderTestCase extends FunctionalTestCase
45  {
46  
47      // use legacy entry point resolver?
48      private boolean legacy;
49  
50      protected AbstractScriptConfigBuilderTestCase()
51      {
52          this(false);
53      }
54  
55      protected AbstractScriptConfigBuilderTestCase(boolean legacy)
56      {
57          this.legacy = legacy;
58      }
59  
60      public void testManagerConfig() throws Exception
61      {
62          assertEquals("true", muleContext.getRegistry().lookupObject("doCompression"));
63          assertNotNull(muleContext.getTransactionManager());
64      }
65  
66  
67      public void testConnectorConfig() throws Exception
68      {
69          TestConnector c = (TestConnector) muleContext.getRegistry().lookupConnector("dummyConnector");
70          assertNotNull(c);
71          assertNotNull(c.getExceptionListener());
72          assertTrue(c.getExceptionListener() instanceof TestExceptionStrategy);
73      }
74  
75      public void testGlobalEndpointConfig() throws MuleException
76      {
77          ImmutableEndpoint endpoint = muleContext.getRegistry().lookupEndpointFactory().getInboundEndpoint(
78              "fruitBowlEndpoint");
79          assertNotNull(endpoint);
80          assertEquals(endpoint.getEndpointURI().getAddress(), "fruitBowlPublishQ");
81          
82          MessagePropertyFilter filter = (MessagePropertyFilter)endpoint.getFilter();
83          assertNotNull(filter);
84          assertEquals("foo=bar", filter.getExpression());
85  
86          ImmutableEndpoint ep = muleContext.getRegistry().lookupEndpointFactory().getInboundEndpoint("testEPWithCS");
87          assertNotNull(ep);
88      }
89  
90      public void testEndpointConfig() throws MuleException
91      {
92          // test that endpoints have been resolved on endpoints
93          ImmutableEndpoint endpoint = muleContext.getRegistry().lookupEndpointFactory().getInboundEndpoint(
94              "waterMelonEndpoint");
95          assertNotNull(endpoint);
96          // aliases no longer possible
97          assertEquals("test.queue", endpoint.getEndpointURI().getAddress());
98  
99          Service service = muleContext.getRegistry().lookupService("orangeComponent");
100         ImmutableEndpoint ep = service.getInboundRouter().getEndpoint("Orange");
101         assertNotNull(ep);
102         final List responseTransformers = ep.getResponseTransformers();
103         assertNotNull(responseTransformers);
104         assertFalse(responseTransformers.isEmpty());
105         final Object responseTransformer = responseTransformers.get(0);
106         assertTrue(responseTransformer instanceof TestCompressionTransformer);
107     }
108 
109     public void testExceptionStrategy()
110     {
111         Service service = muleContext.getRegistry().lookupService("orangeComponent");
112         assertNotNull(muleContext.getRegistry().lookupModel("main").getExceptionListener());
113         assertNotNull(service.getExceptionListener());
114 
115         assertTrue(((AbstractExceptionListener) service.getExceptionListener()).getEndpoints().size() > 0);
116         ImmutableEndpoint ep = (ImmutableEndpoint) ((AbstractExceptionListener) service.getExceptionListener()).getEndpoints()
117                 .get(0);
118 
119         assertEquals("test://orange.exceptions", ep.getEndpointURI().toString());
120     }
121 
122     public void testTransformerConfig()
123     {
124         Transformer t = muleContext.getRegistry().lookupTransformer("TestCompressionTransformer");
125         assertNotNull(t);
126         assertTrue(t instanceof TestCompressionTransformer);
127         assertEquals(t.getReturnClass(), String.class);
128         assertNotNull(((TestCompressionTransformer) t).getContainerProperty());
129     }
130 
131     public void testModelConfig() throws Exception
132     {
133         Model model = muleContext.getRegistry().lookupModel("main");
134         assertNotNull(model);
135         assertEquals("main", model.getName());
136         if (legacy)
137         {
138             assertTrue(model.getEntryPointResolverSet() instanceof LegacyEntryPointResolverSet);
139         }
140         else
141         {
142             assertTrue(model.getEntryPointResolverSet() instanceof TestEntryPointResolverSet);
143         }
144         assertTrue(model.getExceptionListener() instanceof TestExceptionStrategy);
145 
146         assertTrue(((AbstractExceptionListener) model.getExceptionListener()).getEndpoints().size() > 0);
147         ImmutableEndpoint ep = (ImmutableEndpoint) ((AbstractExceptionListener) model.getExceptionListener()).getEndpoints()
148                 .get(0);
149 
150         assertEquals("test://component.exceptions", ep.getEndpointURI().toString());
151 
152         // assertTrue(model.isComponentRegistered("orangeComponent"));
153     }
154 
155     /*
156      * Since MULE-1933, Service no longer has properties and most properties are set on endpoint.
157      * So lets continue to test properties, but on endpoints instead.
158      */
159     public void testEndpointPropertiesConfig() throws Exception
160     {
161         ImmutableEndpoint endpoint = muleContext.getRegistry().lookupEndpointFactory().getInboundEndpoint(
162             "endpointWithProps");
163 
164         Map props = endpoint.getProperties();
165         assertNotNull(props);
166         assertEquals("9", props.get("segments"));
167         assertEquals("4.21", props.get("radius"));
168         assertEquals("Juicy Baby!", props.get("brand"));
169 
170         assertNotNull(props.get("listProperties"));
171         List list = (List) props.get("listProperties");
172         assertEquals(3, list.size());
173         assertEquals("prop1", list.get(0));
174         assertEquals("prop2", list.get(1));
175         assertEquals("prop3", list.get(2));
176 
177         assertNotNull(props.get("arrayProperties"));
178         list = (List) props.get("arrayProperties");
179         assertEquals(3, list.size());
180         assertEquals("prop4", list.get(0));
181         assertEquals("prop5", list.get(1));
182         assertEquals("prop6", list.get(2));
183 
184         assertNotNull(props.get("mapProperties"));
185         props = (Map) props.get("mapProperties");
186         assertEquals("prop1", props.get("prop1"));
187         assertEquals("prop2", props.get("prop2"));
188 
189         assertEquals(6, endpoint.getProperties().size());
190     }
191 
192     public void testOutboundRouterConfig()
193     {
194         // test outbound message router
195         Service service = muleContext.getRegistry().lookupService("orangeComponent");
196         assertNotNull(service.getOutboundRouter());
197         OutboundRouterCollection router = service.getOutboundRouter();
198         assertNull(router.getCatchAllStrategy());
199         assertEquals(1, router.getRouters().size());
200         // check first Router
201         OutboundRouter route1 = (OutboundRouter) router.getRouters().get(0);
202         assertTrue(route1 instanceof OutboundPassThroughRouter);
203         assertEquals(1, route1.getEndpoints().size());
204     }
205 
206     public void testNestedRouterConfig()
207     {
208         // test outbound message router
209         Service service = muleContext.getRegistry().lookupService("orangeComponent");
210         assertNotNull(service.getComponent());
211         assertTrue(service.getComponent() instanceof JavaComponent);
212         NestedRouterCollection router = ((JavaComponent) service.getComponent()).getNestedRouter();
213         assertNotNull(router);
214 
215         assertEquals(2, router.getRouters().size());
216         // check first Router
217         NestedRouter route1 = (NestedRouter) router.getRouters().get(0);
218         assertEquals(FruitCleaner.class, route1.getInterface());
219         assertEquals("wash", route1.getMethod());
220         assertNotNull(route1.getEndpoint());
221         // check second Router
222         NestedRouter route2 = (NestedRouter) router.getRouters().get(1);
223         assertEquals(FruitCleaner.class, route2.getInterface());
224         assertEquals("polish", route2.getMethod());
225         assertNotNull(route1.getEndpoint());
226     }
227 
228     public void testDescriptorEndpoints()
229     {
230         Service service = muleContext.getRegistry().lookupService("orangeComponent");
231         assertEquals(1, service.getOutboundRouter().getRouters().size());
232         OutboundRouter router = (OutboundRouter)service.getOutboundRouter().getRouters().get(0);
233         assertEquals(1, router.getEndpoints().size());
234         ImmutableEndpoint endpoint = (ImmutableEndpoint) router.getEndpoints().get(0);
235         assertNotNull(endpoint);
236         assertEquals("appleInEndpoint", endpoint.getName());
237         assertNotNull(endpoint.getTransformers());
238         assertTrue(TransformerUtils.firstOrNull(endpoint.getTransformers()) instanceof TestCompressionTransformer);
239 
240         // check the global endpoint
241         try
242         {
243             endpoint = muleContext.getRegistry().lookupEndpointFactory().getInboundEndpoint("appleInEndpoint");
244         }
245         catch (MuleException e)
246         {
247             e.printStackTrace();
248             fail(e.getMessage());
249         }
250         assertNotNull(endpoint);
251         assertEquals(1, endpoint.getTransformers().size());
252         assertTrue(endpoint.getTransformers().get(0) instanceof TestInboundTransformer);
253 
254         assertEquals(2, service.getInboundRouter().getEndpoints().size());
255         assertNotNull(service.getInboundRouter().getCatchAllStrategy());
256         assertTrue(service.getInboundRouter().getCatchAllStrategy() instanceof ForwardingCatchAllStrategy);
257         assertNotNull(service.getInboundRouter().getCatchAllStrategy().getEndpoint());
258         assertEquals("test://catch.all", service.getInboundRouter()
259             .getCatchAllStrategy()
260             .getEndpoint()
261             .getEndpointURI()
262             .toString());
263         endpoint = service.getInboundRouter().getEndpoint("orangeEndpoint");
264         assertNotNull(endpoint);
265         assertEquals("orangeEndpoint", endpoint.getName());
266         assertEquals("orangeQ", endpoint.getEndpointURI().getAddress());
267         assertNotNull(endpoint.getTransformers());
268         assertTrue(TransformerUtils.firstOrNull(endpoint.getTransformers()) instanceof TestCompressionTransformer);
269 
270         // check the global endpoint
271         try
272         {
273             endpoint = muleContext.getRegistry().lookupEndpointFactory().getInboundEndpoint("orangeEndpoint");
274         }
275         catch (MuleException e)
276         {
277             e.printStackTrace();
278             fail(e.getMessage());
279         }
280         assertNotNull(endpoint);
281         assertFalse(endpoint.getTransformers().isEmpty());
282         assertTrue(endpoint.getTransformers().get(0) instanceof TestInboundTransformer);
283     }
284 
285     public void testInboundRouterConfig()
286     {
287         Service service = muleContext.getRegistry().lookupService("orangeComponent");
288         assertNotNull(service.getInboundRouter());
289         InboundRouterCollection messageRouter = service.getInboundRouter();
290         assertNotNull(messageRouter.getCatchAllStrategy());
291         assertEquals(0, messageRouter.getRouters().size());
292         assertTrue(messageRouter.getCatchAllStrategy() instanceof ForwardingCatchAllStrategy);
293         assertEquals(2, messageRouter.getEndpoints().size());
294     }
295 
296     public void testResponseRouterConfig()
297     {
298         Service service = muleContext.getRegistry().lookupService("orangeComponent");
299         assertNotNull(service.getResponseRouter());
300         ResponseRouterCollection messageRouter = service.getResponseRouter();
301         assertNull(messageRouter.getCatchAllStrategy());
302         assertEquals(10001, messageRouter.getTimeout());
303         assertEquals(1, messageRouter.getRouters().size());
304         ResponseRouter router = (ResponseRouter) messageRouter.getRouters().get(0);
305         assertTrue(router instanceof TestResponseAggregator);
306         assertNotNull(messageRouter.getEndpoints());
307         assertEquals(2, messageRouter.getEndpoints().size());
308         ImmutableEndpoint ep = (ImmutableEndpoint) messageRouter.getEndpoints().get(0);
309         assertEquals("response1", ep.getEndpointURI().getAddress());
310         assertTrue(ep instanceof InboundEndpoint);
311         ep = (ImmutableEndpoint) messageRouter.getEndpoints().get(1);
312         assertEquals("AppleResponseQueue", ep.getEndpointURI().getAddress());
313         assertTrue(ep instanceof InboundEndpoint);
314     }
315 }