Coverage Report - org.mule.tck.AbstractConfigBuilderTestCase
 
Classes in this File Line Coverage Branch Coverage Complexity
AbstractConfigBuilderTestCase
100%
189/189
75%
6/8
1
 
 1  
 /*
 2  
  * $Id: AbstractConfigBuilderTestCase.java 9206 2007-10-18 15:38:38Z holger $
 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.MuleException;
 14  
 import org.mule.MuleManager;
 15  
 import org.mule.config.PoolingProfile;
 16  
 import org.mule.config.QueueProfile;
 17  
 import org.mule.config.ThreadingProfile;
 18  
 import org.mule.config.pool.CommonsPoolFactory;
 19  
 import org.mule.impl.DefaultExceptionStrategy;
 20  
 import org.mule.impl.MuleDescriptor;
 21  
 import org.mule.impl.endpoint.MuleEndpoint;
 22  
 import org.mule.interceptors.LoggingInterceptor;
 23  
 import org.mule.interceptors.TimerInterceptor;
 24  
 import org.mule.providers.AbstractConnector;
 25  
 import org.mule.providers.SimpleRetryConnectionStrategy;
 26  
 import org.mule.providers.service.TransportFactory;
 27  
 import org.mule.routing.filters.PayloadTypeFilter;
 28  
 import org.mule.routing.filters.RegExFilter;
 29  
 import org.mule.routing.filters.logic.AndFilter;
 30  
 import org.mule.routing.filters.xml.JXPathFilter;
 31  
 import org.mule.routing.inbound.IdempotentReceiver;
 32  
 import org.mule.routing.inbound.SelectiveConsumer;
 33  
 import org.mule.routing.outbound.FilteringOutboundRouter;
 34  
 import org.mule.tck.testmodels.mule.TestCatchAllStrategy;
 35  
 import org.mule.tck.testmodels.mule.TestCompressionTransformer;
 36  
 import org.mule.tck.testmodels.mule.TestConnector;
 37  
 import org.mule.tck.testmodels.mule.TestExceptionStrategy;
 38  
 import org.mule.tck.testmodels.mule.TestTransactionFactory;
 39  
 import org.mule.umo.UMODescriptor;
 40  
 import org.mule.umo.UMOFilter;
 41  
 import org.mule.umo.UMOInterceptorStack;
 42  
 import org.mule.umo.UMOTransactionConfig;
 43  
 import org.mule.umo.endpoint.UMOEndpoint;
 44  
 import org.mule.umo.model.UMOModel;
 45  
 import org.mule.umo.routing.UMOInboundRouter;
 46  
 import org.mule.umo.routing.UMOInboundRouterCollection;
 47  
 import org.mule.umo.routing.UMOOutboundRouter;
 48  
 import org.mule.umo.routing.UMOOutboundRouterCollection;
 49  
 import org.mule.umo.transformer.UMOTransformer;
 50  
 import org.mule.util.ObjectPool;
 51  
 
 52  
 import java.util.Map;
 53  
 
 54  132
 public abstract class AbstractConfigBuilderTestCase extends AbstractScriptConfigBuilderTestCase
 55  
 {
 56  
 
 57  
     // @Override
 58  
     public void testManagerConfig() throws Exception
 59  
     {
 60  4
         super.testManagerConfig();
 61  
 
 62  4
         assertNotNull(MuleManager.getInstance().getTransactionManager());
 63  4
     }
 64  
 
 65  
     // @Override
 66  
     public void testConnectorConfig() throws Exception
 67  
     {
 68  4
         super.testConnectorConfig();
 69  
 
 70  4
         TestConnector c = (TestConnector)MuleManager.getInstance().lookupConnector("dummyConnector");
 71  4
         assertNotNull(c);
 72  4
         assertNotNull(c.getExceptionListener());
 73  4
         assertTrue(c.getExceptionListener() instanceof TestExceptionStrategy);
 74  4
         assertNotNull(c.getConnectionStrategy());
 75  4
         assertTrue(c.getConnectionStrategy() instanceof SimpleRetryConnectionStrategy);
 76  4
         assertEquals(4, ((SimpleRetryConnectionStrategy)c.getConnectionStrategy()).getRetryCount());
 77  4
         assertEquals(3000, ((SimpleRetryConnectionStrategy)c.getConnectionStrategy()).getFrequency());
 78  4
     }
 79  
 
 80  
     // @Override
 81  
     public void testGlobalEndpointConfig()
 82  
     {
 83  4
         super.testGlobalEndpointConfig();
 84  
 
 85  4
         UMOEndpoint endpoint = MuleManager.getInstance().lookupEndpoint("fruitBowlEndpoint");
 86  4
         assertNotNull(endpoint);
 87  4
         assertEquals(endpoint.getEndpointURI().getAddress(), "fruitBowlPublishQ");
 88  4
         assertNotNull(endpoint.getFilter());
 89  4
         JXPathFilter filter = (JXPathFilter)endpoint.getFilter();
 90  4
         assertEquals("name", filter.getExpression());
 91  4
         assertEquals("bar", filter.getExpectedValue());
 92  4
         assertEquals("http://foo.com", filter.getNamespaces().get("foo"));
 93  4
     }
 94  
 
 95  
     // @Override
 96  
     public void testEndpointConfig()
 97  
     {
 98  4
         super.testEndpointConfig();
 99  
 
 100  4
         String endpointString = MuleManager.getInstance().lookupEndpointIdentifier("Test Queue", null);
 101  4
         assertEquals(endpointString, "test://test.queue");
 102  
         // test that endpoints have been resolved on endpoints
 103  4
         UMOEndpoint endpoint = MuleManager.getInstance().lookupEndpoint("waterMelonEndpoint");
 104  4
         assertNotNull(endpoint);
 105  4
         assertEquals("test.queue", endpoint.getEndpointURI().getAddress());
 106  
 
 107  4
         UMODescriptor descriptor = MuleManager.getInstance().lookupModel("main").getDescriptor("appleComponent2");
 108  4
         assertNotNull(descriptor);
 109  4
     }
 110  
 
 111  
     // @Override
 112  
     public void testInterceptorStacks()
 113  
     {
 114  4
         super.testInterceptorStacks();
 115  
 
 116  4
         UMOInterceptorStack stack = MuleManager.getInstance().lookupInterceptorStack("default");
 117  4
         assertNotNull(stack);
 118  4
         assertEquals(2, stack.getInterceptors().size());
 119  4
         assertTrue(stack.getInterceptors().get(0) instanceof LoggingInterceptor);
 120  4
         assertTrue(stack.getInterceptors().get(1) instanceof TimerInterceptor);
 121  4
     }
 122  
 
 123  
     public void testExceptionStrategy2()
 124  
     {
 125  4
         UMODescriptor descriptor = MuleManager.getInstance().lookupModel("main").getDescriptor("appleComponent");
 126  4
         assertNotNull(descriptor.getExceptionListener());
 127  8
         assertEquals(DefaultExceptionStrategy.class, descriptor.getExceptionListener().getClass());
 128  4
     }
 129  
 
 130  
     // @Override
 131  
     public void testTransformerConfig()
 132  
     {
 133  4
         super.testTransformerConfig();
 134  
 
 135  4
         UMOTransformer t = MuleManager.getInstance().lookupTransformer("TestCompressionTransformer");
 136  4
         assertNotNull(t);
 137  4
         assertTrue(t instanceof TestCompressionTransformer);
 138  4
         assertEquals(t.getReturnClass(), java.lang.String.class);
 139  4
         assertNotNull(((TestCompressionTransformer)t).getContainerProperty());
 140  4
     }
 141  
 
 142  
     // @Override
 143  
     public void testModelConfig() throws Exception
 144  
     {
 145  4
         super.testModelConfig();
 146  
 
 147  4
         UMOModel model = MuleManager.getInstance().lookupModel("main");
 148  4
         assertTrue(model.isComponentRegistered("appleComponent"));
 149  4
         assertTrue(model.isComponentRegistered("appleComponent2"));
 150  4
     }
 151  
 
 152  
     public void testOutboundRouterConfig2()
 153  
     {
 154  
         // test outbound message router
 155  4
         UMODescriptor descriptor = MuleManager.getInstance().lookupModel("main").getDescriptor("appleComponent");
 156  4
         assertNotNull(descriptor.getOutboundRouter());
 157  4
         UMOOutboundRouterCollection router = descriptor.getOutboundRouter();
 158  4
         assertNotNull(router.getCatchAllStrategy());
 159  4
         assertEquals(2, router.getRouters().size());
 160  
         // check first Router
 161  4
         UMOOutboundRouter route1 = (UMOOutboundRouter)router.getRouters().get(0);
 162  4
         assertTrue(route1 instanceof FilteringOutboundRouter);
 163  
         // todo don't currently support "transformer" property
 164  
         // assertNotNull(((FilteringOutboundRouter) route1).getTransformer());
 165  
 
 166  4
         UMOFilter filter = ((FilteringOutboundRouter)route1).getFilter();
 167  4
         assertNotNull(filter);
 168  4
         assertTrue(filter instanceof PayloadTypeFilter);
 169  4
         assertEquals(String.class, ((PayloadTypeFilter)filter).getExpectedType());
 170  
 
 171  
         // check second Router
 172  4
         UMOOutboundRouter route2 = (UMOOutboundRouter)router.getRouters().get(1);
 173  4
         assertTrue(route2 instanceof FilteringOutboundRouter);
 174  
 
 175  4
         UMOFilter filter2 = ((FilteringOutboundRouter)route2).getFilter();
 176  4
         assertNotNull(filter2);
 177  4
         assertTrue(filter2 instanceof AndFilter);
 178  4
         UMOFilter left = ((AndFilter)filter2).getLeftFilter();
 179  4
         UMOFilter right = ((AndFilter)filter2).getRightFilter();
 180  4
         assertNotNull(left);
 181  4
         assertTrue(left instanceof RegExFilter);
 182  4
         assertEquals("the quick brown (.*)", ((RegExFilter)left).getPattern());
 183  4
         assertNotNull(right);
 184  4
         assertTrue(right instanceof RegExFilter);
 185  4
         assertEquals("(.*) brown (.*)", ((RegExFilter)right).getPattern());
 186  
 
 187  4
         assertTrue(router.getCatchAllStrategy() instanceof TestCatchAllStrategy);
 188  4
     }
 189  
 
 190  
 
 191  
     public void testInboundRouterConfig2()
 192  
     {
 193  4
         UMODescriptor descriptor = MuleManager.getInstance().lookupModel("main").getDescriptor("appleComponent");
 194  4
         assertNotNull(descriptor.getInboundRouter());
 195  4
         UMOInboundRouterCollection messageRouter = descriptor.getInboundRouter();
 196  4
         assertNotNull(messageRouter.getCatchAllStrategy());
 197  4
         assertEquals(2, messageRouter.getRouters().size());
 198  4
         UMOInboundRouter router = (UMOInboundRouter)messageRouter.getRouters().get(0);
 199  4
         assertTrue(router instanceof SelectiveConsumer);
 200  4
         SelectiveConsumer sc = (SelectiveConsumer)router;
 201  
 
 202  4
         assertNotNull(sc.getFilter());
 203  4
         UMOFilter filter = sc.getFilter();
 204  
         // check first Router
 205  4
         assertTrue(filter instanceof PayloadTypeFilter);
 206  4
         assertEquals(String.class, ((PayloadTypeFilter)filter).getExpectedType());
 207  
 
 208  4
         UMOInboundRouter router2 = (UMOInboundRouter)messageRouter.getRouters().get(1);
 209  4
         assertTrue(router2 instanceof IdempotentReceiver);
 210  4
     }
 211  
 
 212  
     public void testThreadingConfig() throws MuleException
 213  
     {
 214  
         // expected default values from the configuration;
 215  
         // these should differ from the programmatic values!
 216  
         
 217  
         // globals
 218  4
         int defaultMaxBufferSize = 42;
 219  4
         int defaultMaxThreadsActive = 17;
 220  4
         int defaultMaxThreadsIdle = 3;
 221  4
         int defaultThreadPoolExhaustedAction = ThreadingProfile.WHEN_EXHAUSTED_WAIT;
 222  4
         int defaultThreadTTL = 60001;
 223  
         
 224  
         // for the connector
 225  4
         int connectorMaxBufferSize = 2;
 226  4
         int connectorThreadPoolExhaustedAction = ThreadingProfile.WHEN_EXHAUSTED_DISCARD_OLDEST;
 227  
 
 228  
         // for the component
 229  4
         int componentMaxBufferSize = 6;
 230  4
         int componentMaxThreadsActive = 12;
 231  4
         int componentMaxThreadsIdle = 6;
 232  4
         int componentThreadPoolExhaustedAction = ThreadingProfile.WHEN_EXHAUSTED_DISCARD;
 233  
 
 234  
         // test default config
 235  4
         ThreadingProfile tp = MuleManager.getConfiguration().getDefaultThreadingProfile();
 236  4
         assertEquals(defaultMaxBufferSize, tp.getMaxBufferSize());
 237  4
         assertEquals(defaultMaxThreadsActive, tp.getMaxThreadsActive());
 238  4
         assertEquals(defaultMaxThreadsIdle, tp.getMaxThreadsIdle());
 239  4
         assertEquals(defaultThreadPoolExhaustedAction, tp.getPoolExhaustedAction());
 240  4
         assertEquals(defaultThreadTTL, tp.getThreadTTL());
 241  
 
 242  
         // test component threading profile defaults
 243  4
         tp = MuleManager.getConfiguration().getComponentThreadingProfile();
 244  4
         assertEquals(defaultMaxBufferSize, tp.getMaxBufferSize());
 245  4
         assertEquals(defaultMaxThreadsActive, tp.getMaxThreadsActive());
 246  4
         assertEquals(defaultMaxThreadsIdle, tp.getMaxThreadsIdle());
 247  4
         assertEquals(defaultThreadPoolExhaustedAction, tp.getPoolExhaustedAction());
 248  4
         assertEquals(defaultThreadTTL, tp.getThreadTTL());
 249  
 
 250  
         // test that unset values retain a default value
 251  4
         AbstractConnector c = (AbstractConnector)MuleManager.getInstance().lookupConnector("dummyConnector");
 252  4
         tp = c.getDispatcherThreadingProfile();
 253  
         // this value is configured
 254  4
         assertEquals(connectorMaxBufferSize, tp.getMaxBufferSize());
 255  4
         assertEquals(connectorThreadPoolExhaustedAction, tp.getPoolExhaustedAction());
 256  
         // these values should be inherited if the current ConfigBuilder supports inheritance
 257  4
         assertEquals(defaultMaxThreadsActive, tp.getMaxThreadsActive());
 258  4
         assertEquals(defaultMaxThreadsIdle, tp.getMaxThreadsIdle());
 259  4
         assertEquals(defaultThreadTTL, tp.getThreadTTL());
 260  
 
 261  
         // test per-component values
 262  4
         MuleDescriptor descriptor = (MuleDescriptor)MuleManager.getInstance().lookupModel("main").getDescriptor(
 263  
             "appleComponent2");
 264  4
         tp = descriptor.getThreadingProfile();
 265  
         // these values are configured
 266  4
         assertEquals(componentMaxBufferSize, tp.getMaxBufferSize());
 267  4
         assertEquals(componentMaxThreadsActive, tp.getMaxThreadsActive());
 268  4
         assertEquals(componentMaxThreadsIdle, tp.getMaxThreadsIdle());
 269  4
         assertEquals(componentThreadPoolExhaustedAction, tp.getPoolExhaustedAction());
 270  
         // this value should be inherited when if current ConfigBuilder supports inheritance
 271  4
         assertEquals(defaultThreadTTL, tp.getThreadTTL());
 272  4
     }
 273  
 
 274  
     public void testPoolingConfig()
 275  
     {
 276  
         // test MuleManager config
 277  4
         PoolingProfile pp = MuleManager.getConfiguration().getPoolingProfile();
 278  4
         assertEquals(10, pp.getMaxActive());
 279  4
         assertEquals(5, pp.getMaxIdle());
 280  4
         assertEquals(10001, pp.getMaxWait());
 281  4
         assertEquals(ObjectPool.WHEN_EXHAUSTED_WAIT, pp.getExhaustedAction());
 282  4
         assertEquals(PoolingProfile.INITIALISE_ONE, pp.getInitialisationPolicy());
 283  4
         assertTrue(pp.getPoolFactory() instanceof CommonsPoolFactory);
 284  
 
 285  
         // test per-descriptor overrides
 286  4
         MuleDescriptor descriptor = (MuleDescriptor)MuleManager.getInstance().lookupModel("main").getDescriptor(
 287  
             "appleComponent2");
 288  4
         pp = descriptor.getPoolingProfile();
 289  
 
 290  4
         assertEquals(9, pp.getMaxActive());
 291  4
         assertEquals(6, pp.getMaxIdle());
 292  4
         assertEquals(4002, pp.getMaxWait());
 293  4
         assertEquals(ObjectPool.WHEN_EXHAUSTED_FAIL, pp.getExhaustedAction());
 294  4
         assertEquals(PoolingProfile.INITIALISE_ALL, pp.getInitialisationPolicy());
 295  4
     }
 296  
 
 297  
     public void testQueueProfileConfig()
 298  
     {
 299  
         // test config
 300  4
         QueueProfile qp = MuleManager.getConfiguration().getQueueProfile();
 301  4
         assertEquals(100, qp.getMaxOutstandingMessages());
 302  4
         assertTrue(qp.isPersistent());
 303  
 
 304  
         // test inherit
 305  4
         MuleDescriptor descriptor = (MuleDescriptor)MuleManager.getInstance().lookupModel("main").getDescriptor(
 306  
             "orangeComponent");
 307  4
         qp = descriptor.getQueueProfile();
 308  4
         assertEquals(100, qp.getMaxOutstandingMessages());
 309  4
         assertTrue(qp.isPersistent());
 310  
 
 311  
         // test override
 312  4
         descriptor = (MuleDescriptor)MuleManager.getInstance().lookupModel("main").getDescriptor("appleComponent2");
 313  4
         qp = descriptor.getQueueProfile();
 314  4
         assertEquals(102, qp.getMaxOutstandingMessages());
 315  4
         assertFalse(qp.isPersistent());
 316  4
     }
 317  
 
 318  
     public void testEndpointProperties() throws Exception
 319  
     {
 320  
         // test transaction config
 321  4
         UMODescriptor descriptor = MuleManager.getInstance().lookupModel("main").getDescriptor("appleComponent2");
 322  4
         MuleEndpoint inEndpoint = (MuleEndpoint)descriptor.getInboundRouter().getEndpoint(
 323  
             "transactedInboundEndpoint");
 324  4
         assertNotNull(inEndpoint);
 325  4
         assertEquals(TransportFactory.NEVER_CREATE_CONNECTOR, inEndpoint.getCreateConnector());
 326  4
         assertNotNull(inEndpoint.getProperties());
 327  4
         assertEquals("Prop1", inEndpoint.getProperties().get("testEndpointProperty"));
 328  4
     }
 329  
 
 330  
     public void testTransactionConfig() throws Exception
 331  
     {
 332  
         // test transaction config
 333  4
         UMODescriptor descriptor = MuleManager.getInstance().lookupModel("main").getDescriptor("appleComponent2");
 334  4
         UMOEndpoint inEndpoint = descriptor.getInboundRouter().getEndpoint("transactedInboundEndpoint");
 335  4
         assertNotNull(inEndpoint);
 336  4
         assertNull(descriptor.getOutboundEndpoint());
 337  4
         assertEquals(1, descriptor.getOutboundRouter().getRouters().size());
 338  
 
 339  4
         UMOEndpoint outEndpoint = (UMOEndpoint)((UMOOutboundRouter)descriptor.getOutboundRouter()
 340  
             .getRouters()
 341  
             .get(0)).getEndpoints().get(0);
 342  
 
 343  4
         assertNotNull(outEndpoint);
 344  4
         assertNotNull(inEndpoint.getTransactionConfig());
 345  4
         assertEquals(UMOTransactionConfig.ACTION_ALWAYS_BEGIN, inEndpoint.getTransactionConfig().getAction());
 346  4
         assertTrue(inEndpoint.getTransactionConfig().getFactory() instanceof TestTransactionFactory);
 347  4
         assertNull(inEndpoint.getTransactionConfig().getConstraint());
 348  4
     }
 349  
 
 350  
     public void testEnvironmentProperties()
 351  
     {
 352  4
         Map props = MuleManager.getInstance().getProperties();
 353  4
         assertNotNull(props);
 354  4
         assertNotNull(props.get("doCompression"));
 355  4
         assertEquals("true", props.get("doCompression"));
 356  4
         assertNotNull(props.get("beanProperty1"));
 357  4
         assertEquals("this was set from the manager properties!", props.get("beanProperty1"));
 358  4
         assertNotNull(props.get("OS Version"));
 359  4
     }
 360  
 }