Author: pferraro Date: 2008-09-05 10:47:50 -0400 (Fri, 05 Sep 2008) New Revision: 1781 Added: trunk/mod_cluster/src/test/java/org/jboss/modcluster/DefaultJBossWebEventHandlerTestCase.java Log: Unit test for DefaultJBossWebEventHandler Added: trunk/mod_cluster/src/test/java/org/jboss/modcluster/DefaultJBossWebEventHandlerTestCase.java =================================================================== --- trunk/mod_cluster/src/test/java/org/jboss/modcluster/DefaultJBossWebEventHandlerTestCase.java (rev 0) +++ trunk/mod_cluster/src/test/java/org/jboss/modcluster/DefaultJBossWebEventHandlerTestCase.java 2008-09-05 14:47:50 UTC (rev 1781) @@ -0,0 +1,805 @@ +/* + * JBoss, Home of Professional Open Source. + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * as indicated by the @author tags. See the copyright.txt file in the + * distribution for a full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.modcluster; + +import java.io.IOException; +import java.net.InetAddress; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import junit.framework.TestCase; + +import org.apache.catalina.Container; +import org.apache.catalina.Context; +import org.apache.catalina.Engine; +import org.apache.catalina.Host; +import org.apache.catalina.Server; +import org.apache.catalina.Service; +import org.apache.catalina.connector.Connector; +import org.easymock.Capture; +import org.easymock.EasyMock; +import org.jboss.modcluster.advertise.AdvertiseListener; +import org.jboss.modcluster.advertise.AdvertiseListenerFactory; +import org.jboss.modcluster.config.BalancerConfiguration; +import org.jboss.modcluster.config.MCMPHandlerConfiguration; +import org.jboss.modcluster.config.NodeConfiguration; +import org.jboss.modcluster.load.LoadBalanceFactorProvider; +import org.jboss.modcluster.mcmp.AddressPort; +import org.jboss.modcluster.mcmp.MCMPHandler; +import org.jboss.modcluster.mcmp.MCMPRequest; +import org.jboss.modcluster.mcmp.MCMPRequestType; +import org.jboss.modcluster.mcmp.MCMPServerState; + +/** + * @author Paul Ferraro + * + */ +public class DefaultJBossWebEventHandlerTestCase extends TestCase +{ + private final NodeConfiguration nodeConfig = EasyMock.createStrictMock(NodeConfiguration.class); + private final BalancerConfiguration balancerConfig = EasyMock.createStrictMock(BalancerConfiguration.class); + private final MCMPHandler mcmpHandler = EasyMock.createStrictMock(MCMPHandler.class); + private final LoadBalanceFactorProvider provider = EasyMock.createStrictMock(LoadBalanceFactorProvider.class); + private final AdvertiseListenerFactory listenerFactory = EasyMock.createStrictMock(AdvertiseListenerFactory.class); + + private JBossWebEventHandler handler; + + /** + * @{inheritDoc} + * @see junit.framework.TestCase#setUp() + */ + @Override + protected void setUp() throws Exception + { + this.handler = new DefaultJBossWebEventHandler(this.nodeConfig, this.balancerConfig, this.mcmpHandler, this.provider, this.listenerFactory); + } + + public void testInit() throws IOException + { + InetAddress localAddress = InetAddress.getLocalHost(); + String localHostName = localAddress.getHostName(); + + MCMPHandlerConfiguration config = EasyMock.createStrictMock(MCMPHandlerConfiguration.class); + AdvertiseListener listener = EasyMock.createStrictMock(AdvertiseListener.class); + + // Test advertise = false + EasyMock.expect(this.mcmpHandler.getConfiguration()).andReturn(config); + EasyMock.expect(config.getProxyList()).andReturn(localHostName); + + this.mcmpHandler.init(Collections.singletonList(new AddressPort(localAddress, 8000))); + + EasyMock.expect(config.getAdvertise()).andReturn(Boolean.FALSE); + + EasyMock.replay(this.mcmpHandler, config, listener); + + this.handler.init(); + + EasyMock.verify(this.mcmpHandler, config, listener); + EasyMock.reset(this.mcmpHandler, config, listener); + + + // Test advertise = true + EasyMock.expect(this.mcmpHandler.getConfiguration()).andReturn(config); + EasyMock.expect(config.getProxyList()).andReturn(localHostName); + + this.mcmpHandler.init(Collections.singletonList(new AddressPort(localAddress, 8000))); + + EasyMock.expect(config.getAdvertise()).andReturn(Boolean.TRUE); + + EasyMock.expect(this.listenerFactory.createListener(this.mcmpHandler)).andReturn(listener); + + listener.start(); + + EasyMock.replay(this.mcmpHandler, this.listenerFactory, config, listener); + + this.handler.init(); + + EasyMock.verify(this.mcmpHandler, this.listenerFactory, config, listener); + EasyMock.reset(this.mcmpHandler, this.listenerFactory, config, listener); + + + // Test advertise = null, proxies configured + EasyMock.expect(this.mcmpHandler.getConfiguration()).andReturn(config); + EasyMock.expect(config.getProxyList()).andReturn(localHostName); + + this.mcmpHandler.init(Collections.singletonList(new AddressPort(localAddress, 8000))); + + EasyMock.expect(config.getAdvertise()).andReturn(null); + + EasyMock.replay(this.mcmpHandler, config, listener); + + this.handler.init(); + + EasyMock.verify(this.mcmpHandler, config, listener); + EasyMock.reset(this.mcmpHandler, config, listener); + + + // Test advertise = null, no proxies configured + EasyMock.expect(this.mcmpHandler.getConfiguration()).andReturn(config); + EasyMock.expect(config.getProxyList()).andReturn(null); + + List<AddressPort> emptyList = Collections.emptyList(); + + this.mcmpHandler.init(emptyList); + + EasyMock.expect(config.getAdvertise()).andReturn(null); + + EasyMock.expect(this.listenerFactory.createListener(this.mcmpHandler)).andReturn(listener); + + listener.start(); + + EasyMock.replay(this.mcmpHandler, this.listenerFactory, config, listener); + + this.handler.init(); + + EasyMock.verify(this.mcmpHandler, this.listenerFactory, config, listener); + EasyMock.reset(this.mcmpHandler, this.listenerFactory, config, listener); + } + + public void testShutdown() throws IOException + { + // Test w/out advertise listener + this.mcmpHandler.shutdown(); + + EasyMock.replay(this.mcmpHandler); + + this.handler.shutdown(); + + EasyMock.verify(this.mcmpHandler); + EasyMock.reset(this.mcmpHandler); + + + // Test w/advertise listener + // First init() to create listener + InetAddress localAddress = InetAddress.getLocalHost(); + String localHostName = localAddress.getHostName(); + + MCMPHandlerConfiguration config = EasyMock.createStrictMock(MCMPHandlerConfiguration.class); + AdvertiseListener listener = EasyMock.createStrictMock(AdvertiseListener.class); + + EasyMock.expect(this.mcmpHandler.getConfiguration()).andReturn(config); + EasyMock.expect(config.getProxyList()).andReturn(localHostName); + + this.mcmpHandler.init(Collections.singletonList(new AddressPort(localAddress, 8000))); + + EasyMock.expect(config.getAdvertise()).andReturn(Boolean.TRUE); + + EasyMock.expect(this.listenerFactory.createListener(this.mcmpHandler)).andReturn(listener); + + listener.start(); + + EasyMock.replay(this.mcmpHandler, this.listenerFactory, config, listener); + + this.handler.init(); + + EasyMock.verify(this.mcmpHandler, this.listenerFactory, config, listener); + EasyMock.reset(this.mcmpHandler, this.listenerFactory, config, listener); + + // Now test shutdown() + listener.destroy(); + + this.mcmpHandler.shutdown(); + + EasyMock.replay(this.mcmpHandler, listener); + + this.handler.shutdown(); + + EasyMock.verify(this.mcmpHandler, listener); + EasyMock.reset(this.mcmpHandler, listener); + } + + public void testAddContext() throws IOException + { + Context context = EasyMock.createStrictMock(Context.class); + + // Test not initialized + try + { + this.handler.addContext(context); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test context not started + Container container = EasyMock.createStrictMock(Container.class); + + recordAddContext(context, container); + + EasyMock.replay(context, container); + + this.handler.addContext(context); + + EasyMock.verify(context, container); + EasyMock.reset(context, container); + + // Test context started + Engine engine = EasyMock.createStrictMock(Engine.class); + Host host = EasyMock.createStrictMock(Host.class); + Capture<MCMPRequest> capturedRequest = new Capture<MCMPRequest>(); + + // Expect log message + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getName()).andReturn("parent-container"); + + EasyMock.expect(context.isStarted()).andReturn(true); + + // Building request + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getParent()).andReturn(engine); + EasyMock.expect(engine.getJvmRoute()).andReturn("host1"); + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(host); + EasyMock.expect(host.getName()).andReturn("host"); + EasyMock.expect(host.findAliases()).andReturn(new String[] { "alias1", "alias2" }); + + this.mcmpHandler.sendRequest(EasyMock.capture(capturedRequest)); + + EasyMock.replay(this.mcmpHandler, context, container, engine, host); + + this.handler.addContext(context); + + EasyMock.verify(this.mcmpHandler, context, container, engine, host); + + MCMPRequest request = capturedRequest.getValue(); + + assertSame(MCMPRequestType.ENABLE_APP, request.getRequestType()); + assertFalse(request.isWildcard()); + + Map<String, String> parameters = request.getParameters(); + + assertEquals(3, parameters.size()); + + assertEquals("host1", parameters.get("JVMRoute")); + assertEquals("/context", parameters.get("Context")); + assertEquals("host,alias1,alias2", parameters.get("Alias")); + + EasyMock.reset(this.mcmpHandler, context, container, engine, host); + } + + private void recordAddContext(Context context, Container container) + { + // Expect log message + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getName()).andReturn("parent-container"); + + EasyMock.expect(context.isStarted()).andReturn(false); + } + + public void testStartContext() throws IOException + { + Context context = EasyMock.createStrictMock(Context.class); + + // Test not initialized + try + { + this.handler.startContext(context); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test initialized + Container container = EasyMock.createStrictMock(Container.class); + Engine engine = EasyMock.createStrictMock(Engine.class); + Host host = EasyMock.createStrictMock(Host.class); + Capture<MCMPRequest> capturedRequest = new Capture<MCMPRequest>(); + + // Expect log message + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getName()).andReturn("parent-container"); + + // Building request + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getParent()).andReturn(engine); + EasyMock.expect(engine.getJvmRoute()).andReturn("host1"); + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(host); + EasyMock.expect(host.getName()).andReturn("host"); + EasyMock.expect(host.findAliases()).andReturn(new String[] { "alias1", "alias2" }); + + this.mcmpHandler.sendRequest(EasyMock.capture(capturedRequest)); + + EasyMock.replay(this.mcmpHandler, context, container, engine, host); + + this.handler.startContext(context); + + EasyMock.verify(this.mcmpHandler, context, container, engine, host); + + MCMPRequest request = capturedRequest.getValue(); + + assertSame(MCMPRequestType.ENABLE_APP, request.getRequestType()); + assertFalse(request.isWildcard()); + + Map<String, String> parameters = request.getParameters(); + + assertEquals(3, parameters.size()); + + assertEquals("host1", parameters.get("JVMRoute")); + assertEquals("/context", parameters.get("Context")); + assertEquals("host,alias1,alias2", parameters.get("Alias")); + + EasyMock.reset(this.mcmpHandler, context, container, engine, host); + } + + public void testStopContext() throws IOException + { + Context context = EasyMock.createStrictMock(Context.class); + + // Test not initialized + try + { + this.handler.stopContext(context); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test initialized + Container container = EasyMock.createStrictMock(Container.class); + Engine engine = EasyMock.createStrictMock(Engine.class); + Host host = EasyMock.createStrictMock(Host.class); + Capture<MCMPRequest> capturedRequest = new Capture<MCMPRequest>(); + + // Expect log message + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getName()).andReturn("parent-container"); + + // Building request + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getParent()).andReturn(engine); + EasyMock.expect(engine.getJvmRoute()).andReturn("host1"); + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(host); + EasyMock.expect(host.getName()).andReturn("host"); + EasyMock.expect(host.findAliases()).andReturn(new String[] { "alias1", "alias2" }); + + this.mcmpHandler.sendRequest(EasyMock.capture(capturedRequest)); + + EasyMock.replay(this.mcmpHandler, context, container, engine, host); + + this.handler.stopContext(context); + + EasyMock.verify(this.mcmpHandler, context, container, engine, host); + + MCMPRequest request = capturedRequest.getValue(); + + assertSame(MCMPRequestType.STOP_APP, request.getRequestType()); + assertFalse(request.isWildcard()); + + Map<String, String> parameters = request.getParameters(); + + assertEquals(3, parameters.size()); + + assertEquals("host1", parameters.get("JVMRoute")); + assertEquals("/context", parameters.get("Context")); + assertEquals("host,alias1,alias2", parameters.get("Alias")); + + EasyMock.reset(this.mcmpHandler, context, container, engine, host); + } + + public void testRemoveContext() throws IOException + { + Context context = EasyMock.createStrictMock(Context.class); + + // Test not initialized + try + { + this.handler.removeContext(context); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test initialized - no jvm route + Container container = EasyMock.createStrictMock(Container.class); + Engine engine = EasyMock.createStrictMock(Engine.class); + + this.recordRemoveContext(context, container, engine); + + EasyMock.replay(context, container, engine); + + this.handler.removeContext(context); + + EasyMock.verify(context, container, engine); + EasyMock.reset(context, container, engine); + + + // Test initialized - jvm route exists + Host host = EasyMock.createStrictMock(Host.class); + Capture<MCMPRequest> capturedRequest = new Capture<MCMPRequest>(); + + // Expect log message + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getName()).andReturn("parent-container"); + + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getParent()).andReturn(engine); + EasyMock.expect(engine.getJvmRoute()).andReturn("host1"); + + // Building request + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getParent()).andReturn(engine); + EasyMock.expect(engine.getJvmRoute()).andReturn("host1"); + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(host); + EasyMock.expect(host.getName()).andReturn("host"); + EasyMock.expect(host.findAliases()).andReturn(new String[] { "alias1", "alias2" }); + + this.mcmpHandler.sendRequest(EasyMock.capture(capturedRequest)); + + EasyMock.replay(this.mcmpHandler, context, container, engine, host); + + this.handler.removeContext(context); + + EasyMock.verify(this.mcmpHandler, context, container, engine, host); + + MCMPRequest request = capturedRequest.getValue(); + + assertSame(MCMPRequestType.REMOVE_APP, request.getRequestType()); + assertFalse(request.isWildcard()); + + Map<String, String> parameters = request.getParameters(); + + assertEquals(3, parameters.size()); + + assertEquals("host1", parameters.get("JVMRoute")); + assertEquals("/context", parameters.get("Context")); + assertEquals("host,alias1,alias2", parameters.get("Alias")); + + EasyMock.reset(this.mcmpHandler, context, container, engine, host); + } + + private void recordRemoveContext(Context context, Container container, Engine engine) + { + // Expect log message + EasyMock.expect(context.getPath()).andReturn("/context"); + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getName()).andReturn("parent-container"); + + EasyMock.expect(context.getParent()).andReturn(container); + EasyMock.expect(container.getParent()).andReturn(engine); + EasyMock.expect(engine.getJvmRoute()).andReturn(null); + } + + public void testConfig() throws Exception + { + Engine engine = EasyMock.createStrictMock(Engine.class); + Service service = EasyMock.createStrictMock(Service.class); + + Capture<MCMPRequest> capturedRequest = recordConfig(engine, service); + + EasyMock.replay(this.mcmpHandler, this.nodeConfig, this.balancerConfig, engine, service); + + this.handler.config(engine); + + EasyMock.verify(this.mcmpHandler, this.nodeConfig, this.balancerConfig, engine, service); + + MCMPRequest request = capturedRequest.getValue(); + + assertSame(MCMPRequestType.CONFIG, request.getRequestType()); + assertFalse(request.isWildcard()); + + Map<String, String> parameters = request.getParameters(); + + assertEquals(17, parameters.size()); + assertEquals("host1", parameters.get("JVMRoute")); + assertEquals("172.0.0.1", parameters.get("Host")); + assertEquals("0", parameters.get("Port")); + assertEquals("ajp", parameters.get("Type")); + assertEquals("domain", parameters.get("Domain")); + assertEquals("On", parameters.get("flushpackets")); + assertEquals("1", parameters.get("flushwait")); + assertEquals("2", parameters.get("ping")); + assertEquals("3", parameters.get("smax")); + assertEquals("4", parameters.get("ttl")); + assertEquals("5", parameters.get("Timeout")); + assertEquals("S", parameters.get("Balancer")); + assertEquals("No", parameters.get("StickySession")); + assertEquals("Yes", parameters.get("StickySessionRemove")); + assertEquals("No", parameters.get("StickySessionForce")); + assertEquals("6", parameters.get("WaitWorker")); + assertEquals("7", parameters.get("Maxattempts")); + + EasyMock.reset(this.mcmpHandler, this.nodeConfig, this.balancerConfig, engine, service); + } + + private Capture<MCMPRequest> recordConfig(Engine engine, Service service) throws Exception + { + Capture<MCMPRequest> capturedRequest = new Capture<MCMPRequest>(); + Connector connector = new Connector("AJP/1.3"); + + // Expect log message + EasyMock.expect(engine.getName()).andReturn("engine"); + + EasyMock.expect(engine.getService()).andReturn(service); + EasyMock.expect(service.findConnectors()).andReturn(new Connector[] { connector }); + EasyMock.expect(engine.getJvmRoute()).andReturn(null); + Set<MCMPServerState> states = Collections.emptySet(); + EasyMock.expect(this.mcmpHandler.getProxyStates()).andReturn(states); + + EasyMock.expect(engine.getService()).andReturn(service); + EasyMock.expect(service.findConnectors()).andReturn(new Connector[] { connector }); + EasyMock.expect(engine.getJvmRoute()).andReturn("host1"); + + EasyMock.expect(this.nodeConfig.getDomain()).andReturn("domain"); + EasyMock.expect(this.nodeConfig.getFlushPackets()).andReturn(Boolean.TRUE); + EasyMock.expect(this.nodeConfig.getFlushWait()).andReturn(1); + EasyMock.expect(this.nodeConfig.getPing()).andReturn(2); + EasyMock.expect(this.nodeConfig.getSmax()).andReturn(3); + EasyMock.expect(this.nodeConfig.getTtl()).andReturn(4); + EasyMock.expect(this.nodeConfig.getNodeTimeout()).andReturn(5); + EasyMock.expect(this.nodeConfig.getBalancer()).andReturn("S"); + + EasyMock.expect(this.balancerConfig.getStickySession()).andReturn(Boolean.FALSE); + EasyMock.expect(this.balancerConfig.getStickySessionRemove()).andReturn(Boolean.TRUE); + EasyMock.expect(this.balancerConfig.getStickySessionForce()).andReturn(Boolean.FALSE); + EasyMock.expect(this.balancerConfig.getWorkerTimeout()).andReturn(6); + EasyMock.expect(this.balancerConfig.getMaxAttempts()).andReturn(7); + + this.mcmpHandler.sendRequest(EasyMock.capture(capturedRequest)); + + return capturedRequest; + } + + public void testRemoveAll() throws IOException + { + Engine engine = EasyMock.createStrictMock(Engine.class); + + // Test not initialized + try + { + this.handler.removeAll(engine); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test initialized - no jvm route + // Expect log message + EasyMock.expect(engine.getName()).andReturn("engine"); + + EasyMock.expect(engine.getJvmRoute()).andReturn(null); + + EasyMock.replay(engine); + + this.handler.removeAll(engine); + + EasyMock.verify(engine); + EasyMock.reset(engine); + + + // Test initialized - jvm route exists + Capture<MCMPRequest> capturedRequest = this.recordRemoveAll(engine); + + EasyMock.replay(this.mcmpHandler, engine); + + this.handler.removeAll(engine); + + EasyMock.verify(this.mcmpHandler, engine); + + MCMPRequest request = capturedRequest.getValue(); + + assertSame(MCMPRequestType.REMOVE_APP, request.getRequestType()); + assertTrue(request.isWildcard()); + assertEquals(Collections.singletonMap("JVMRoute", "host1"), request.getParameters()); + + EasyMock.reset(this.mcmpHandler, engine); + } + + private Capture<MCMPRequest> recordRemoveAll(Engine engine) + { + Capture<MCMPRequest> capturedRequest = new Capture<MCMPRequest>(); + + // Expect log message + EasyMock.expect(engine.getName()).andReturn("engine"); + + EasyMock.expect(engine.getJvmRoute()).andReturn("host1").times(2); + + this.mcmpHandler.sendRequest(EasyMock.capture(capturedRequest)); + + return capturedRequest; + } + + public void testStatus() throws IOException + { + Engine engine = EasyMock.createStrictMock(Engine.class); + + // Test not initialized + try + { + this.handler.removeAll(engine); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test initialized + Capture<MCMPRequest> capturedRequest = new Capture<MCMPRequest>(); + + // Expect log message + EasyMock.expect(engine.getName()).andReturn("engine"); + + this.mcmpHandler.status(); + + EasyMock.expect(this.provider.getLoadBalanceFactor()).andReturn(10); + EasyMock.expect(engine.getJvmRoute()).andReturn("host1"); + + this.mcmpHandler.sendRequest(EasyMock.capture(capturedRequest)); + + EasyMock.replay(this.mcmpHandler, this.provider, engine); + + this.handler.status(engine); + + EasyMock.verify(this.mcmpHandler, this.provider, engine); + + MCMPRequest request = capturedRequest.getValue(); + + assertSame(MCMPRequestType.STATUS, request.getRequestType()); + assertFalse(request.isWildcard()); + + Map<String, String> parameters = request.getParameters(); + + assertEquals(2, parameters.size()); + assertEquals("host1", parameters.get("JVMRoute")); + assertEquals("10", parameters.get("Load")); + + EasyMock.reset(this.mcmpHandler, this.provider, engine); + } + + public void testStartServer() throws Exception + { + Server server = EasyMock.createStrictMock(Server.class); + + // Test not initialized + try + { + this.handler.startServer(server); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test initialized + Service service1 = EasyMock.createStrictMock(Service.class); + Service service2 = EasyMock.createStrictMock(Service.class); + Engine engine1 = EasyMock.createStrictMock(Engine.class); + Engine engine2 = EasyMock.createStrictMock(Engine.class); + Container container1 = EasyMock.createStrictMock(Container.class); + Container container2 = EasyMock.createStrictMock(Container.class); + Context context1 = EasyMock.createStrictMock(Context.class); + Context context2 = EasyMock.createStrictMock(Context.class); + + EasyMock.expect(server.findServices()).andReturn(new Service[] { service1, service2 }); + + EasyMock.expect(service1.getContainer()).andReturn(engine1); + this.recordConfig(engine1, service1); + EasyMock.expect(engine1.findChildren()).andReturn(new Container[] { container1 }); + EasyMock.expect(container1.findChildren()).andReturn(new Container[] { context1 }); + this.recordAddContext(context1, container1); + + EasyMock.expect(service2.getContainer()).andReturn(engine2); + this.recordConfig(engine2, service2); + EasyMock.expect(engine2.findChildren()).andReturn(new Container[] { container2 }); + EasyMock.expect(container2.findChildren()).andReturn(new Container[] { context2 }); + this.recordAddContext(context2, container2); + + EasyMock.replay(this.mcmpHandler, this.nodeConfig, this.balancerConfig, server, service1, service2, engine1, engine2, container1, container2, context1, context2); + + this.handler.startServer(server); + + EasyMock.verify(this.mcmpHandler, this.nodeConfig, this.balancerConfig, server, service1, service2, engine1, engine2, container1, container2, context1, context2); + EasyMock.reset(this.mcmpHandler, this.nodeConfig, this.balancerConfig, server, service1, service2, engine1, engine2, container1, container2, context1, context2); + } + + public void testStopServer() throws IOException + { + Server server = EasyMock.createStrictMock(Server.class); + + // Test not initialized + try + { + this.handler.stopServer(server); + + fail(); + } + catch (IllegalStateException e) + { + // Expected + } + + testInit(); + + // Test initialized + Service service1 = EasyMock.createStrictMock(Service.class); + Service service2 = EasyMock.createStrictMock(Service.class); + Engine engine1 = EasyMock.createStrictMock(Engine.class); + Engine engine2 = EasyMock.createStrictMock(Engine.class); + Container container1 = EasyMock.createStrictMock(Container.class); + Container container2 = EasyMock.createStrictMock(Container.class); + Context context1 = EasyMock.createStrictMock(Context.class); + Context context2 = EasyMock.createStrictMock(Context.class); + + EasyMock.expect(server.findServices()).andReturn(new Service[] { service1, service2 }); + + EasyMock.expect(service1.getContainer()).andReturn(engine1); + this.recordRemoveAll(engine1); + EasyMock.expect(engine1.findChildren()).andReturn(new Container[] { container1 }); + EasyMock.expect(container1.findChildren()).andReturn(new Container[] { context1 }); + this.recordRemoveContext(context1, container1, engine1); + + EasyMock.expect(service2.getContainer()).andReturn(engine2); + this.recordRemoveAll(engine2); + EasyMock.expect(engine2.findChildren()).andReturn(new Container[] { container2 }); + EasyMock.expect(container2.findChildren()).andReturn(new Container[] { context2 }); + this.recordRemoveContext(context2, container2, engine2); + + EasyMock.replay(this.mcmpHandler, this.nodeConfig, this.balancerConfig, server, service1, service2, engine1, engine2, container1, container2, context1, context2); + + this.handler.stopServer(server); + + EasyMock.verify(this.mcmpHandler, this.nodeConfig, this.balancerConfig, server, service1, service2, engine1, engine2, container1, container2, context1, context2); + EasyMock.reset(this.mcmpHandler, this.nodeConfig, this.balancerConfig, server, service1, service2, engine1, engine2, container1, container2, context1, context2); + } +} \ No newline at end of file