@Override public Engine next() { return TomcatServer.this.registry.getEngineFactory().createEngine(TomcatServer.this.registry, (org.apache.catalina.Engine) services.next().getContainer(), TomcatServer.this); }
@Override public Connector getProxyConnector() { return this.registry.getProxyConnectorProvider().createProxyConnector(this.registry.getConnectorFactory(), this.engine); }
@Override public Context next() { return TomcatHost.this.registry.getContextFactory().createContext((org.apache.catalina.Context) children.next(), TomcatHost.this); }
protected void verifyCatalinaFactoryTypes(TomcatFactoryRegistry registry) { assertSame(TomcatServerFactory.class, registry.getServerFactory().getClass()); assertSame(TomcatEngineFactory.class, registry.getEngineFactory().getClass()); assertSame(TomcatHostFactory.class, registry.getHostFactory().getClass()); assertSame(TomcatContextFactory.class, registry.getContextFactory().getClass()); assertSame(TomcatConnectorFactory.class, registry.getConnectorFactory().getClass()); assertSame(this.provider, registry.getProxyConnectorProvider()); } }
@Override public Host next() { return TomcatEngine.this.registry.getHostFactory().createHost(TomcatEngine.this.registry, (org.apache.catalina.Host) children.next(), TomcatEngine.this); }
@Override public Connector next() { return TomcatEngine.this.registry.getConnectorFactory().createConnector(connectors.next()); }
@Test public void testCatalinaFactoryRegistry() { TomcatFactoryRegistry registry = new ServiceLoaderTomcatFactory(this.serverFactory, this.engineFactory, this.hostFactory, this.contextFactory, this.connectorFactory, this.provider); assertSame(this.serverFactory, registry.getServerFactory()); assertSame(this.engineFactory, registry.getEngineFactory()); assertSame(this.hostFactory, registry.getHostFactory()); assertSame(this.contextFactory, registry.getContextFactory()); assertSame(this.connectorFactory, registry.getConnectorFactory()); assertSame(this.provider, registry.getProxyConnectorProvider()); }
@Override public Host findHost(String name) { org.apache.catalina.Host host = (org.apache.catalina.Host) this.engine.findChild(name); return (host != null) ? this.registry.getHostFactory().createHost(this.registry, host, this) : null; }
@Test public void getProxyConnector() throws Exception { ProxyConnectorProvider provider = mock(ProxyConnectorProvider.class); Connector expected = mock(Connector.class); ConnectorFactory factory = mock(ConnectorFactory.class); when(this.registry.getProxyConnectorProvider()).thenReturn(provider); when(this.registry.getConnectorFactory()).thenReturn(factory); when(provider.createProxyConnector(factory, this.engine)).thenReturn(expected); Connector result = this.catalinaEngine.getProxyConnector(); assertSame(expected, result); }
@Override public Engine next() { return TomcatServer.this.registry.getEngineFactory().createEngine(TomcatServer.this.registry, services.next().getContainer(), TomcatServer.this); }
@Override public Context findContext(String path) { org.apache.catalina.Context context = (org.apache.catalina.Context) this.host.findChild(path); return (context != null) ? TomcatHost.this.registry.getContextFactory().createContext(context, this) : null; }
@Test public void findHost() { org.apache.catalina.Host host = mock(org.apache.catalina.Host.class); HostFactory hostFactory = mock(HostFactory.class); Host expected = mock(Host.class); when(this.engine.findChild("host")).thenReturn(host); when(this.registry.getHostFactory()).thenReturn(hostFactory); when(hostFactory.createHost(same(this.registry), same(host), same(this.catalinaEngine))).thenReturn(expected); Host result = this.catalinaEngine.findHost("host"); assertSame(expected, result); }
@Test public void getEngines() { Service service = mock(Service.class); org.apache.catalina.Engine engine = mock(org.apache.catalina.Engine.class); EngineFactory engineFactory = mock(EngineFactory.class); Engine expected = mock(Engine.class); when(this.server.findServices()).thenReturn(new Service[] { service }); when(service.getContainer()).thenReturn(engine); when(this.registry.getEngineFactory()).thenReturn(engineFactory); when(engineFactory.createEngine(same(this.registry), same(engine), same(this.catalinaServer))).thenReturn(expected); Iterable<Engine> result = this.catalinaServer.getEngines(); Iterator<Engine> engines = result.iterator(); assertTrue(engines.hasNext()); assertSame(expected, engines.next()); assertFalse(engines.hasNext()); } }
@Test public void findContext() { org.apache.catalina.Context context = mock(org.apache.catalina.Context.class); Context expected = mock(Context.class); ContextFactory contextFactory = mock(ContextFactory.class); when(this.host.findChild("path")).thenReturn(context); when(this.registry.getContextFactory()).thenReturn(contextFactory); when(contextFactory.createContext(same(context), same(this.catalinaHost))).thenReturn(expected); Context result = this.catalinaHost.findContext("path"); assertSame(expected, result); }
@Test public void getHosts() { org.apache.catalina.Host host = mock(org.apache.catalina.Host.class); HostFactory hostFactory = mock(HostFactory.class); Host expected = mock(Host.class); when(this.engine.findChildren()).thenReturn(new Container[] { host }); when(this.registry.getHostFactory()).thenReturn(hostFactory); when(hostFactory.createHost(same(this.registry), same(host), same(this.catalinaEngine))).thenReturn(expected); Iterable<Host> result = this.catalinaEngine.getHosts(); Iterator<Host> hosts = result.iterator(); assertTrue(hosts.hasNext()); assertSame(expected, hosts.next()); assertFalse(hosts.hasNext()); }
@Test public void getContexts() { org.apache.catalina.Context context = mock(org.apache.catalina.Context.class); Context expected = mock(Context.class); ContextFactory contextFactory = mock(ContextFactory.class); when(this.host.findChildren()).thenReturn(new Container[] { context }); when(this.registry.getContextFactory()).thenReturn(contextFactory); when(contextFactory.createContext(same(context), same(this.catalinaHost))).thenReturn(expected); Iterable<Context> result = this.catalinaHost.getContexts(); Iterator<Context> contexts = result.iterator(); assertTrue(contexts.hasNext()); assertSame(expected, contexts.next()); assertFalse(contexts.hasNext()); }