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