Proxy tests

Author: jonathanedey

pom.xml

@@ -493,5 +493,10 @@
             <version>2.2</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mock-server</groupId>
+            <artifactId>mockserver-junit-rule-no-dependencies</artifactId>
+            <version>5.14.0</version>
+        </dependency>
     </dependencies>
 </project>

src/main/java/com/google/firebase/internal/ApacheHttp2Transport.java

@@ -29,11 +29,14 @@
 import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
 import org.apache.hc.client5.http.impl.async.HttpAsyncClientBuilder;
 import org.apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManager;
+import org.apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManagerBuilder;
 import org.apache.hc.client5.http.impl.routing.SystemDefaultRoutePlanner;
+import org.apache.hc.client5.http.ssl.ClientTlsStrategyBuilder;
 import org.apache.hc.core5.http.config.Http1Config;
 import org.apache.hc.core5.http2.HttpVersionPolicy;
 import org.apache.hc.core5.http2.config.H2Config;
 import org.apache.hc.core5.io.CloseMode;
+import org.apache.hc.core5.ssl.SSLContexts;
 
 /**
  * HTTP/2 enabled async transport based on the Apache HTTP Client library
@@ -64,16 +67,20 @@ public static CloseableHttpAsyncClient newDefaultHttpAsyncClient() {
 
   public static HttpAsyncClientBuilder defaultHttpAsyncClientBuilder() {
     PoolingAsyncClientConnectionManager connectionManager = 
-        new PoolingAsyncClientConnectionManager();
-
-    // Set Max total connections and max per route to match google api client limits
-    // https://github.com/googleapis/google-http-java-client/blob/f9d4e15bd3c784b1fd3b0f3468000a91c6f79715/google-http-client-apache-v5/src/main/java/com/google/api/client/http/apache/v5/Apache5HttpTransport.java#L151
-    connectionManager.setMaxTotal(200);
-    connectionManager.setDefaultMaxPerRoute(20);
-    connectionManager.setDefaultConnectionConfig(
-        ConnectionConfig.custom().setTimeToLive(-1, TimeUnit.MILLISECONDS).build());
-    connectionManager.setDefaultTlsConfig(
-        TlsConfig.custom().setVersionPolicy(HttpVersionPolicy.NEGOTIATE).build());
+        PoolingAsyncClientConnectionManagerBuilder.create()
+          // Set Max total connections to match google api client limits
+          // https://github.com/googleapis/google-http-java-client/blob/f9d4e15bd3c784b1fd3b0f3468000a91c6f79715/google-http-client-apache-v5/src/main/java/com/google/api/client/http/apache/v5/Apache5HttpTransport.java#L151
+          .setMaxConnTotal(200)
+          // Set max connections per route to match the concurrent stream limit of the FCM backend.
+          .setMaxConnPerRoute(100)
+          .setDefaultConnectionConfig(
+            ConnectionConfig.custom().setTimeToLive(-1, TimeUnit.MILLISECONDS).build())
+          .setDefaultTlsConfig(
+            TlsConfig.custom().setVersionPolicy(HttpVersionPolicy.NEGOTIATE).build())
+          .setTlsStrategy(ClientTlsStrategyBuilder.create()
+            .setSslContext(SSLContexts.createSystemDefault())
+            .build())
+          .build();
 
     return HttpAsyncClientBuilder.create()
       // Set maxConcurrentStreams to 100 to match the concurrent stream limit of the FCM backend.

src/test/java/com/google/firebase/internal/ApacheHttp2TransportIT.java

@@ -21,9 +21,15 @@
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.mockserver.model.Header.header;
+import static org.mockserver.model.HttpForward.forward;
+import static org.mockserver.model.HttpRequest.request;
+import static org.mockserver.model.HttpResponse.response;
 
+import com.google.api.client.http.GenericUrl;
 import com.google.api.client.http.HttpRequestFactory;
 import com.google.api.client.http.HttpResponseException;
+import com.google.api.client.http.HttpTransport;
 import com.google.api.client.http.LowLevelHttpResponse;
 import com.google.api.client.json.JsonFactory;
 import com.google.api.client.util.GenericData;
@@ -53,13 +59,17 @@
 import org.junit.BeforeClass;
 import org.junit.Test;
 
+import org.mockserver.integration.ClientAndServer;
+import org.mockserver.model.HttpForward.Scheme;
+import org.mockserver.socket.PortFactory;
+
 public class ApacheHttp2TransportIT {
   private static FirebaseApp app;
   private static final GoogleCredentials MOCK_CREDENTIALS = new MockGoogleCredentials("test_token");
   private static final ImmutableMap<String, Object> payload = 
       ImmutableMap.<String, Object>of("foo", "bar");
 
-  // Sets a 5 second delay before server response to simulate a slow network that 
+  // Sets a 5 second delay before server response to simulate a slow network that
   // results in a read timeout.
   private static final String DELAY_URL = "https://nghttp2.org/httpbin/delay/5";
   private static final String GET_URL = "https://nghttp2.org/httpbin/get";
@@ -69,9 +79,13 @@ public class ApacheHttp2TransportIT {
   private static Socket fillerSocket;
   private static int port;
 
+  private static ClientAndServer mockProxy;
+  private static ClientAndServer mockServer;
+
   @BeforeClass
   public static void setUpClass() throws IOException {
-    // Start server socket with a backlog queue of 1 and a automatically assigned port
+    // Start server socket with a backlog queue of 1 and a automatically assigned
+    // port
     serverSocket = new ServerSocket(0, 1);
     port = serverSocket.getLocalPort();
     // Fill the backlog queue to force socket to ignore future connections
@@ -89,14 +103,26 @@ public static void cleanUpClass() throws IOException {
     }
   }
 
-
   @After
   public void cleanup() {
     if (app != null) {
       app.delete();
     }
+
+    if (mockProxy != null && mockProxy.isRunning()) {
+      mockProxy.close();
+    }
+
+    if (mockServer != null && mockServer.isRunning()) {
+      mockServer.close();
+    }
+
+    System.clearProperty("http.proxyHost");
+    System.clearProperty("http.proxyPort");
+    System.clearProperty("https.proxyHost");
+    System.clearProperty("https.proxyPort");
   }
-  
+
   @Test(timeout = 10_000L)
   public void testUnauthorizedGetRequest() throws FirebaseException {
     ErrorHandlingHttpClient<FirebaseException> httpClient = getHttpClient(false);
@@ -115,7 +141,7 @@ public void testUnauthorizedPostRequest() throws FirebaseException {
 
   @Test(timeout = 10_000L)
   public void testConnectTimeoutAuthorizedGet() throws FirebaseException {
-    app  = FirebaseApp.initializeApp(FirebaseOptions.builder()
+    app = FirebaseApp.initializeApp(FirebaseOptions.builder()
         .setCredentials(MOCK_CREDENTIALS)
         .setConnectTimeout(100)
         .build(), "test-app");
@@ -270,6 +296,77 @@ public void process(
     assertTrue("Expected to have called our test interceptor", interceptorCalled.get());
   }
 
+  @Test(timeout = 10_000L)
+  public void testVerifyProxyIsRespected() {
+    try {
+      System.setProperty("https.proxyHost", "localhost");
+      System.setProperty("https.proxyPort", "8080");
+
+      HttpTransport transport = new ApacheHttp2Transport();
+      transport.createRequestFactory().buildGetRequest(new GenericUrl(GET_URL)).execute();
+      fail("No exception thrown for HTTP error response");
+    } catch (IOException e) {
+      assertEquals("Connection exception in request", e.getMessage());
+      assertTrue(e.getCause().getMessage().contains("localhost:8080"));
+    }
+  }
+
+  @Test(timeout = 10_000L)
+  public void testProxyMockHttp() throws Exception {
+    // Start MockServer
+    mockProxy = ClientAndServer.startClientAndServer(PortFactory.findFreePort());
+    mockServer = ClientAndServer.startClientAndServer(PortFactory.findFreePort());
+
+    System.setProperty("http.proxyHost", "localhost");
+    System.setProperty("http.proxyPort", mockProxy.getPort().toString());
+
+    // Configure proxy to receieve requests and forward them to a mock destination
+    // server
+    mockProxy
+        .when(
+            request())
+        .forward(
+            forward()
+                .withHost("localhost")
+                .withPort(mockServer.getPort())
+                .withScheme(Scheme.HTTP));
+
+    // Configure server to listen and respond
+    mockServer
+        .when(
+            request())
+        .respond(
+            response()
+                .withStatusCode(200)
+                .withBody("Expected server response"));
+
+    // Send a request through the proxy
+    app = FirebaseApp.initializeApp(FirebaseOptions.builder()
+        .setCredentials(MOCK_CREDENTIALS)
+        .setWriteTimeout(100)
+        .build(), "test-app");
+    ErrorHandlingHttpClient<FirebaseException> httpClient = getHttpClient(true, app);
+    HttpRequestInfo request = HttpRequestInfo.buildGetRequest("http://www.google.com");
+    IncomingHttpResponse response = httpClient.send(request);
+
+    // Verify that the proxy received request with destination host
+    mockProxy.verify(
+        request()
+            .withMethod("GET")
+            .withPath("/")
+            .withHeader(header("Host", "www.google.com")));
+
+    // Verify the forwarded request is received by the server
+    mockServer.verify(
+        request()
+            .withMethod("GET")
+            .withPath("/"));
+
+    // Verify response
+    assertEquals(200, response.getStatusCode());
+    assertEquals(response.getContent(), "Expected server response");
+  }
+
   private static ErrorHandlingHttpClient<FirebaseException> getHttpClient(boolean authorized,
       FirebaseApp app) {
     HttpRequestFactory requestFactory;
@@ -285,12 +382,11 @@ private static ErrorHandlingHttpClient<FirebaseException> getHttpClient(boolean
 
   private static ErrorHandlingHttpClient<FirebaseException> getHttpClient(boolean authorized) {
     app = FirebaseApp.initializeApp(FirebaseOptions.builder()
-    .setCredentials(MOCK_CREDENTIALS)
-    .build(), "test-app");
+        .setCredentials(MOCK_CREDENTIALS)
+        .build(), "test-app");
     return getHttpClient(authorized, app);
   }
 
-
   private static class TestHttpErrorHandler implements HttpErrorHandler<FirebaseException> {
     @Override
     public FirebaseException handleIOException(IOException e) {