From fc8df4ef2a23b9960010446c95680b2cebc9b91b Mon Sep 17 00:00:00 2001 From: Oleg Kalnichevski Date: Wed, 31 Jul 2013 16:29:35 +0000 Subject: [PATCH] Improved test coverage for classes added in 4.3 git-svn-id: https://svn.apache.org/repos/asf/httpcomponents/httpclient/trunk@1508949 13f79535-47bb-0310-9956-ffa450edef68 --- .../http/client/config/RequestConfig.java | 2 +- .../http/impl/client/HttpClientBuilder.java | 0 .../http/client/config/TestRequestConfig.java | 102 ++++++++++++ .../TestBasicConnectionManager.java | 86 +++++++++++ .../TestBasicHttpClientConnectionManager.java | 137 +++++++++++++++- ...estPoolingHttpClientConnectionManager.java | 146 ++++++++++++++++-- 6 files changed, 456 insertions(+), 17 deletions(-) mode change 100755 => 100644 httpclient/src/main/java/org/apache/http/impl/client/HttpClientBuilder.java create mode 100644 httpclient/src/test/java/org/apache/http/client/config/TestRequestConfig.java create mode 100644 httpclient/src/test/java/org/apache/http/impl/client/integration/TestBasicConnectionManager.java diff --git a/httpclient/src/main/java/org/apache/http/client/config/RequestConfig.java b/httpclient/src/main/java/org/apache/http/client/config/RequestConfig.java index ba28aa6d5..417b1fb49 100644 --- a/httpclient/src/main/java/org/apache/http/client/config/RequestConfig.java +++ b/httpclient/src/main/java/org/apache/http/client/config/RequestConfig.java @@ -189,7 +189,7 @@ public class RequestConfig implements Cloneable { .setCircularRedirectsAllowed(config.isCircularRedirectsAllowed()) .setMaxRedirects(config.getMaxRedirects()) .setAuthenticationEnabled(config.isAuthenticationEnabled()) - .setTargetPreferredAuthSchemes(config.getProxyPreferredAuthSchemes()) + .setTargetPreferredAuthSchemes(config.getTargetPreferredAuthSchemes()) .setProxyPreferredAuthSchemes(config.getProxyPreferredAuthSchemes()) .setConnectionRequestTimeout(config.getConnectionRequestTimeout()) .setConnectTimeout(config.getConnectTimeout()) diff --git a/httpclient/src/main/java/org/apache/http/impl/client/HttpClientBuilder.java b/httpclient/src/main/java/org/apache/http/impl/client/HttpClientBuilder.java old mode 100755 new mode 100644 diff --git a/httpclient/src/test/java/org/apache/http/client/config/TestRequestConfig.java b/httpclient/src/test/java/org/apache/http/client/config/TestRequestConfig.java new file mode 100644 index 000000000..7eef14cdf --- /dev/null +++ b/httpclient/src/test/java/org/apache/http/client/config/TestRequestConfig.java @@ -0,0 +1,102 @@ +/* + * ==================================================================== + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + * + */ + +package org.apache.http.client.config; + +import junit.framework.Assert; +import org.apache.http.HttpHost; +import org.junit.Test; + +import java.net.InetAddress; +import java.util.Arrays; + +public class TestRequestConfig { + + @Test + public void testBasics() { + final RequestConfig config = RequestConfig.custom().build(); + config.toString(); + } + + @Test + public void testDefaults() { + final RequestConfig config = RequestConfig.DEFAULT; + Assert.assertEquals(-1, config.getSocketTimeout()); + Assert.assertEquals(-1, config.getConnectTimeout()); + Assert.assertEquals(-1, config.getConnectionRequestTimeout()); + Assert.assertEquals(false, config.isExpectContinueEnabled()); + Assert.assertEquals(true, config.isStaleConnectionCheckEnabled()); + Assert.assertEquals(true, config.isAuthenticationEnabled()); + Assert.assertEquals(true, config.isRedirectsEnabled()); + Assert.assertEquals(true, config.isRelativeRedirectsAllowed()); + Assert.assertEquals(false, config.isCircularRedirectsAllowed()); + Assert.assertEquals(50, config.getMaxRedirects()); + Assert.assertEquals(null, config.getCookieSpec()); + Assert.assertEquals(null, config.getLocalAddress()); + Assert.assertEquals(null, config.getProxy()); + Assert.assertEquals(null, config.getTargetPreferredAuthSchemes()); + Assert.assertEquals(null, config.getProxyPreferredAuthSchemes()); + } + + @Test + public void testBuildAndCopy() throws Exception { + final RequestConfig config0 = RequestConfig.custom() + .setSocketTimeout(22) + .setConnectTimeout(33) + .setConnectionRequestTimeout(44) + .setExpectContinueEnabled(true) + .setStaleConnectionCheckEnabled(false) + .setAuthenticationEnabled(false) + .setRedirectsEnabled(false) + .setRelativeRedirectsAllowed(false) + .setCircularRedirectsAllowed(true) + .setMaxRedirects(100) + .setCookieSpec(CookieSpecs.RFC_2965) + .setLocalAddress(InetAddress.getLocalHost()) + .setProxy(new HttpHost("someproxy")) + .setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM)) + .setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.DIGEST)) + .build(); + final RequestConfig config = RequestConfig.copy(config0).build(); + Assert.assertEquals(22, config.getSocketTimeout()); + Assert.assertEquals(33, config.getConnectTimeout()); + Assert.assertEquals(44, config.getConnectionRequestTimeout()); + Assert.assertEquals(true, config.isExpectContinueEnabled()); + Assert.assertEquals(false, config.isStaleConnectionCheckEnabled()); + Assert.assertEquals(false, config.isAuthenticationEnabled()); + Assert.assertEquals(false, config.isRedirectsEnabled()); + Assert.assertEquals(false, config.isRelativeRedirectsAllowed()); + Assert.assertEquals(true, config.isCircularRedirectsAllowed()); + Assert.assertEquals(100, config.getMaxRedirects()); + Assert.assertEquals(CookieSpecs.RFC_2965, config.getCookieSpec()); + Assert.assertEquals(InetAddress.getLocalHost(), config.getLocalAddress()); + Assert.assertEquals(new HttpHost("someproxy"), config.getProxy()); + Assert.assertEquals(Arrays.asList(AuthSchemes.NTLM), config.getTargetPreferredAuthSchemes()); + Assert.assertEquals(Arrays.asList(AuthSchemes.DIGEST), config.getProxyPreferredAuthSchemes()); + } + +} diff --git a/httpclient/src/test/java/org/apache/http/impl/client/integration/TestBasicConnectionManager.java b/httpclient/src/test/java/org/apache/http/impl/client/integration/TestBasicConnectionManager.java new file mode 100644 index 000000000..395b204db --- /dev/null +++ b/httpclient/src/test/java/org/apache/http/impl/client/integration/TestBasicConnectionManager.java @@ -0,0 +1,86 @@ +/* + * ==================================================================== + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + * + */ +package org.apache.http.impl.client.integration; + +import junit.framework.Assert; +import org.apache.http.HttpHost; +import org.apache.http.client.methods.CloseableHttpResponse; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.impl.client.HttpClients; +import org.apache.http.impl.conn.BasicHttpClientConnectionManager; +import org.apache.http.localserver.LocalTestServer; +import org.apache.http.util.EntityUtils; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.io.IOException; +import java.net.InetSocketAddress; + +public class TestBasicConnectionManager extends IntegrationTestBase { + + @Before + public void setUp() throws Exception { + this.localServer = new LocalTestServer(null, null); + this.localServer.registerDefaultHandlers(); + this.localServer.start(); + + this.httpclient = HttpClients.custom() + .setConnectionManager(new BasicHttpClientConnectionManager()) + .build(); + } + + @After + public void cleanup() throws IOException { + this.httpclient.close(); + } + + @Test + public void testBasics() throws Exception { + final InetSocketAddress address = localServer.getServiceAddress(); + final HttpHost target = new HttpHost(address.getHostName(), address.getPort()); + final HttpGet get = new HttpGet("/random/1024"); + final CloseableHttpResponse response = this.httpclient.execute(target, get); + try { + Assert.assertEquals(200, response.getStatusLine().getStatusCode()); + EntityUtils.consume(response.getEntity()); + } finally { + response.close(); + } + } + + @Test(expected=IllegalStateException.class) + public void testConnectionStillInUse() throws Exception { + final InetSocketAddress address = localServer.getServiceAddress(); + final HttpHost target = new HttpHost(address.getHostName(), address.getPort()); + final HttpGet get1 = new HttpGet("/random/1024"); + this.httpclient.execute(target, get1); + final HttpGet get2 = new HttpGet("/random/1024"); + this.httpclient.execute(target, get2); + } + +} diff --git a/httpclient/src/test/java/org/apache/http/impl/conn/TestBasicHttpClientConnectionManager.java b/httpclient/src/test/java/org/apache/http/impl/conn/TestBasicHttpClientConnectionManager.java index 0fdcfb401..01be679d7 100644 --- a/httpclient/src/test/java/org/apache/http/impl/conn/TestBasicHttpClientConnectionManager.java +++ b/httpclient/src/test/java/org/apache/http/impl/conn/TestBasicHttpClientConnectionManager.java @@ -27,36 +27,59 @@ package org.apache.http.impl.conn; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.net.Socket; import java.util.concurrent.TimeUnit; import org.apache.http.HttpClientConnection; import org.apache.http.HttpHost; +import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.config.ConnectionConfig; import org.apache.http.config.Lookup; +import org.apache.http.config.SocketConfig; import org.apache.http.conn.ConnectionRequest; +import org.apache.http.conn.DnsResolver; import org.apache.http.conn.HttpConnectionFactory; import org.apache.http.conn.ManagedHttpClientConnection; +import org.apache.http.conn.SchemePortResolver; import org.apache.http.conn.routing.HttpRoute; import org.apache.http.conn.socket.ConnectionSocketFactory; +import org.apache.http.conn.socket.LayeredConnectionSocketFactory; +import org.apache.http.protocol.HttpContext; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.mockito.Mock; import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; public class TestBasicHttpClientConnectionManager { + @Mock private ManagedHttpClientConnection conn; + @Mock private HttpConnectionFactory connFactory; + @Mock private Lookup socketFactoryRegistry; + @Mock + private ConnectionSocketFactory plainSocketFactory; + @Mock + private LayeredConnectionSocketFactory sslSocketFactory; + @Mock + private Socket socket; + @Mock + private SchemePortResolver schemePortResolver; + @Mock + private DnsResolver dnsResolver; + private BasicHttpClientConnectionManager mgr; - @SuppressWarnings("unchecked") @Before public void setup() throws Exception { - conn = Mockito.mock(ManagedHttpClientConnection.class); - connFactory = Mockito.mock(HttpConnectionFactory.class); - socketFactoryRegistry = Mockito.mock(Lookup.class); - mgr = new BasicHttpClientConnectionManager(socketFactoryRegistry, connFactory); + MockitoAnnotations.initMocks(this); + mgr = new BasicHttpClientConnectionManager( + socketFactoryRegistry, connFactory, schemePortResolver, dnsResolver); } @Test @@ -262,6 +285,13 @@ public class TestBasicHttpClientConnectionManager { Assert.fail("IllegalStateException expected"); } catch (final IllegalStateException ex) { } + + // Should have no effect + mgr.closeExpiredConnections(); + mgr.closeIdleConnections(0L, TimeUnit.MILLISECONDS); + mgr.shutdown(); + + Mockito.verify(conn, Mockito.times(1)).shutdown(); } @Test @@ -339,4 +369,101 @@ public class TestBasicHttpClientConnectionManager { mgr.getConnection(route, null); } + @Test + public void testTargetConnect() throws Exception { + final HttpHost target = new HttpHost("somehost", -1, "https"); + final InetAddress remote = InetAddress.getByAddress(new byte[] {10, 0, 0, 1}); + final InetAddress local = InetAddress.getByAddress(new byte[] {127, 0, 0, 1}); + final HttpRoute route = new HttpRoute(target, local, true); + + Mockito.when(connFactory.create( + Mockito.eq(route), Mockito.any())).thenReturn(conn); + + final ConnectionRequest connRequest1 = mgr.requestConnection(route, null); + final HttpClientConnection conn1 = connRequest1.get(0, TimeUnit.MILLISECONDS); + Assert.assertNotNull(conn1); + + final HttpClientContext context = HttpClientContext.create(); + final SocketConfig sconfig = SocketConfig.custom().build(); + + mgr.setSocketConfig(sconfig); + + Mockito.when(dnsResolver.resolve("somehost")).thenReturn(new InetAddress[] {remote}); + Mockito.when(schemePortResolver.resolve(target)).thenReturn(8443); + Mockito.when(socketFactoryRegistry.lookup("https")).thenReturn(plainSocketFactory); + Mockito.when(plainSocketFactory.createSocket(Mockito.any())).thenReturn(socket); + Mockito.when(plainSocketFactory.connectSocket( + Mockito.anyInt(), + Mockito.eq(socket), + Mockito.any(), + Mockito.any(), + Mockito.any(), + Mockito.any())).thenReturn(socket); + + mgr.connect(conn1, route, 123, context); + + Mockito.verify(dnsResolver, Mockito.times(1)).resolve("somehost"); + Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(target); + Mockito.verify(plainSocketFactory, Mockito.times(1)).createSocket(context); + Mockito.verify(plainSocketFactory, Mockito.times(1)).connectSocket(123, socket, target, + new InetSocketAddress(remote, 8443), + new InetSocketAddress(local, 0), context); + + mgr.routeComplete(conn1, route, context); + } + + @Test + public void testProxyConnectAndUpgrade() throws Exception { + final HttpHost target = new HttpHost("somehost", -1, "https"); + final HttpHost proxy = new HttpHost("someproxy", 8080); + final InetAddress remote = InetAddress.getByAddress(new byte[] {10, 0, 0, 1}); + final InetAddress local = InetAddress.getByAddress(new byte[] {127, 0, 0, 1}); + final HttpRoute route = new HttpRoute(target, local, proxy, true); + + Mockito.when(connFactory.create( + Mockito.eq(route), Mockito.any())).thenReturn(conn); + + final ConnectionRequest connRequest1 = mgr.requestConnection(route, null); + final HttpClientConnection conn1 = connRequest1.get(0, TimeUnit.MILLISECONDS); + Assert.assertNotNull(conn1); + + final HttpClientContext context = HttpClientContext.create(); + final SocketConfig sconfig = SocketConfig.custom().build(); + + mgr.setSocketConfig(sconfig); + + Mockito.when(dnsResolver.resolve("someproxy")).thenReturn(new InetAddress[] {remote}); + Mockito.when(schemePortResolver.resolve(proxy)).thenReturn(8080); + Mockito.when(schemePortResolver.resolve(target)).thenReturn(8443); + Mockito.when(socketFactoryRegistry.lookup("http")).thenReturn(plainSocketFactory); + Mockito.when(socketFactoryRegistry.lookup("https")).thenReturn(sslSocketFactory); + Mockito.when(plainSocketFactory.createSocket(Mockito.any())).thenReturn(socket); + Mockito.when(plainSocketFactory.connectSocket( + Mockito.anyInt(), + Mockito.eq(socket), + Mockito.any(), + Mockito.any(), + Mockito.any(), + Mockito.any())).thenReturn(socket); + + mgr.connect(conn1, route, 123, context); + + Mockito.verify(dnsResolver, Mockito.times(1)).resolve("someproxy"); + Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(proxy); + Mockito.verify(plainSocketFactory, Mockito.times(1)).createSocket(context); + Mockito.verify(plainSocketFactory, Mockito.times(1)).connectSocket(123, socket, proxy, + new InetSocketAddress(remote, 8080), + new InetSocketAddress(local, 0), context); + + Mockito.when(conn.getSocket()).thenReturn(socket); + + mgr.upgrade(conn1, route, context); + + Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(target); + Mockito.verify(sslSocketFactory, Mockito.times(1)).createLayeredSocket( + socket, "somehost", 8443, context); + + mgr.routeComplete(conn1, route, context); + } + } diff --git a/httpclient/src/test/java/org/apache/http/impl/conn/TestPoolingHttpClientConnectionManager.java b/httpclient/src/test/java/org/apache/http/impl/conn/TestPoolingHttpClientConnectionManager.java index ac93477ad..d8d876f1f 100644 --- a/httpclient/src/test/java/org/apache/http/impl/conn/TestPoolingHttpClientConnectionManager.java +++ b/httpclient/src/test/java/org/apache/http/impl/conn/TestPoolingHttpClientConnectionManager.java @@ -27,6 +27,8 @@ package org.apache.http.impl.conn; +import java.net.InetAddress; +import java.net.InetSocketAddress; import java.net.Socket; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; @@ -35,7 +37,10 @@ import java.util.concurrent.TimeoutException; import org.apache.commons.logging.LogFactory; import org.apache.http.HttpClientConnection; import org.apache.http.HttpHost; +import org.apache.http.client.protocol.HttpClientContext; +import org.apache.http.config.ConnectionConfig; import org.apache.http.config.Lookup; +import org.apache.http.config.SocketConfig; import org.apache.http.conn.ConnectionPoolTimeoutException; import org.apache.http.conn.ConnectionRequest; import org.apache.http.conn.DnsResolver; @@ -43,38 +48,43 @@ import org.apache.http.conn.SchemePortResolver; import org.apache.http.conn.ManagedHttpClientConnection; import org.apache.http.conn.routing.HttpRoute; import org.apache.http.conn.socket.ConnectionSocketFactory; +import org.apache.http.conn.socket.LayeredConnectionSocketFactory; import org.apache.http.protocol.HttpContext; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.mockito.Mock; import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; /** * {@link PoolingHttpClientConnectionManager} tests. */ public class TestPoolingHttpClientConnectionManager { + @Mock private ManagedHttpClientConnection conn; - private Socket socket; - private ConnectionSocketFactory plainSocketFactory; + @Mock private Lookup socketFactoryRegistry; + @Mock + private ConnectionSocketFactory plainSocketFactory; + @Mock + private ConnectionSocketFactory sslSocketFactory; + @Mock + private Socket socket; + @Mock private SchemePortResolver schemePortResolver; + @Mock private DnsResolver dnsResolver; + @Mock private Future future; + @Mock private CPool pool; private PoolingHttpClientConnectionManager mgr; - @SuppressWarnings("unchecked") @Before public void setup() throws Exception { - conn = Mockito.mock(ManagedHttpClientConnection.class); - socket = Mockito.mock(Socket.class); - plainSocketFactory = Mockito.mock(ConnectionSocketFactory.class); - socketFactoryRegistry = Mockito.mock(Lookup.class); - schemePortResolver = Mockito.mock(SchemePortResolver.class); - dnsResolver = Mockito.mock(DnsResolver.class); - pool = Mockito.mock(CPool.class); - future = Mockito.mock(Future.class); + MockitoAnnotations.initMocks(this); mgr = new PoolingHttpClientConnectionManager( pool, socketFactoryRegistry, schemePortResolver, dnsResolver); } @@ -218,4 +228,118 @@ public class TestPoolingHttpClientConnectionManager { Mockito.verify(entry, Mockito.never()).updateExpiry(Mockito.anyLong(), Mockito.eq(TimeUnit.MILLISECONDS)); } + @Test + public void testTargetConnect() throws Exception { + final HttpHost target = new HttpHost("somehost", -1, "https"); + final InetAddress remote = InetAddress.getByAddress(new byte[] {10, 0, 0, 1}); + final InetAddress local = InetAddress.getByAddress(new byte[]{127, 0, 0, 1}); + final HttpRoute route = new HttpRoute(target, local, true); + + final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, + -1, TimeUnit.MILLISECONDS); + entry.markRouteComplete(); + Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE); + Mockito.when(conn.isOpen()).thenReturn(true); + Mockito.when(future.isCancelled()).thenReturn(false); + Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry); + Mockito.when(pool.lease(route, null, null)).thenReturn(future); + + final ConnectionRequest connRequest1 = mgr.requestConnection(route, null); + final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS); + Assert.assertNotNull(conn1); + + final HttpClientContext context = HttpClientContext.create(); + final SocketConfig sconfig = SocketConfig.custom().build(); + + mgr.setDefaultSocketConfig(sconfig); + + Mockito.when(dnsResolver.resolve("somehost")).thenReturn(new InetAddress[]{remote}); + Mockito.when(schemePortResolver.resolve(target)).thenReturn(8443); + Mockito.when(socketFactoryRegistry.lookup("https")).thenReturn(plainSocketFactory); + Mockito.when(plainSocketFactory.createSocket(Mockito.any())).thenReturn(socket); + Mockito.when(plainSocketFactory.connectSocket( + Mockito.anyInt(), + Mockito.eq(socket), + Mockito.any(), + Mockito.any(), + Mockito.any(), + Mockito.any())).thenReturn(socket); + + mgr.connect(conn1, route, 123, context); + + Mockito.verify(dnsResolver, Mockito.times(1)).resolve("somehost"); + Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(target); + Mockito.verify(plainSocketFactory, Mockito.times(1)).createSocket(context); + Mockito.verify(plainSocketFactory, Mockito.times(1)).connectSocket(123, socket, target, + new InetSocketAddress(remote, 8443), + new InetSocketAddress(local, 0), context); + + mgr.routeComplete(conn1, route, context); + } + + @Test + public void testProxyConnectAndUpgrade() throws Exception { + final HttpHost target = new HttpHost("somehost", -1, "https"); + final HttpHost proxy = new HttpHost("someproxy", 8080); + final InetAddress remote = InetAddress.getByAddress(new byte[] {10, 0, 0, 1}); + final InetAddress local = InetAddress.getByAddress(new byte[] {127, 0, 0, 1}); + final HttpRoute route = new HttpRoute(target, local, proxy, true); + + final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, + -1, TimeUnit.MILLISECONDS); + entry.markRouteComplete(); + Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE); + Mockito.when(conn.isOpen()).thenReturn(true); + Mockito.when(future.isCancelled()).thenReturn(false); + Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry); + Mockito.when(pool.lease(route, null, null)).thenReturn(future); + + final ConnectionRequest connRequest1 = mgr.requestConnection(route, null); + final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS); + Assert.assertNotNull(conn1); + + final ConnectionSocketFactory plainsf = Mockito.mock(ConnectionSocketFactory.class); + final LayeredConnectionSocketFactory sslsf = Mockito.mock(LayeredConnectionSocketFactory.class); + final Socket socket = Mockito.mock(Socket.class); + final HttpClientContext context = HttpClientContext.create(); + final SocketConfig sconfig = SocketConfig.custom().build(); + final ConnectionConfig cconfig = ConnectionConfig.custom().build(); + + mgr.setDefaultSocketConfig(sconfig); + mgr.setDefaultConnectionConfig(cconfig); + + Mockito.when(dnsResolver.resolve("someproxy")).thenReturn(new InetAddress[] {remote}); + Mockito.when(schemePortResolver.resolve(proxy)).thenReturn(8080); + Mockito.when(schemePortResolver.resolve(target)).thenReturn(8443); + Mockito.when(socketFactoryRegistry.lookup("http")).thenReturn(plainsf); + Mockito.when(socketFactoryRegistry.lookup("https")).thenReturn(sslsf); + Mockito.when(plainsf.createSocket(Mockito.any())).thenReturn(socket); + Mockito.when(plainsf.connectSocket( + Mockito.anyInt(), + Mockito.eq(socket), + Mockito.any(), + Mockito.any(), + Mockito.any(), + Mockito.any())).thenReturn(socket); + + mgr.connect(conn1, route, 123, context); + + Mockito.verify(dnsResolver, Mockito.times(1)).resolve("someproxy"); + Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(proxy); + Mockito.verify(plainsf, Mockito.times(1)).createSocket(context); + Mockito.verify(plainsf, Mockito.times(1)).connectSocket(123, socket, proxy, + new InetSocketAddress(remote, 8080), + new InetSocketAddress(local, 0), context); + + Mockito.when(conn.getSocket()).thenReturn(socket); + + mgr.upgrade(conn1, route, context); + + Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(target); + Mockito.verify(sslsf, Mockito.times(1)).createLayeredSocket( + socket, "somehost", 8443, context); + + mgr.routeComplete(conn1, route, context); + } + }