Add tests for connection events

This is groundwork for adding more events in AsyncHttpClient#732.

Sadly I couldn’t put these higher up in the test hierarchy, because the
Grizzly provider doesn’t seem to fire most events.

Author: barnardb

api/src/test/java/org/asynchttpclient/async/util/EventCollectingHandler.java

@@ -0,0 +1,88 @@
+package org.asynchttpclient.async.util;
+
+import org.asynchttpclient.AsyncCompletionHandlerBase;
+import org.asynchttpclient.AsyncHandlerExtensions;
+import org.asynchttpclient.HttpResponseHeaders;
+import org.asynchttpclient.HttpResponseStatus;
+import org.asynchttpclient.Response;
+import org.testng.Assert;
+
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class EventCollectingHandler extends AsyncCompletionHandlerBase implements AsyncHandlerExtensions {
+    public Queue<String> firedEvents = new ConcurrentLinkedQueue<String>();
+    private CountDownLatch completionLatch = new CountDownLatch(1);
+
+    public void waitForCompletion(int timeout, TimeUnit unit) throws InterruptedException {
+        if (!completionLatch.await(timeout, unit)) {
+            Assert.fail("Timeout out");
+        }
+    }
+
+    @Override
+    public Response onCompleted(Response response) throws Exception {
+        firedEvents.add("Completed");
+        try {
+            return super.onCompleted(response);
+        } finally {
+            completionLatch.countDown();
+        }
+    }
+
+    @Override
+    public STATE onStatusReceived(HttpResponseStatus status) throws Exception {
+        firedEvents.add("StatusReceived");
+        return super.onStatusReceived(status);
+    }
+
+    @Override
+    public STATE onHeadersReceived(HttpResponseHeaders headers) throws Exception {
+        firedEvents.add("HeadersReceived");
+        return super.onHeadersReceived(headers);
+    }
+
+    @Override
+    public STATE onHeaderWriteCompleted() {
+        firedEvents.add("HeaderWriteCompleted");
+        return super.onHeaderWriteCompleted();
+    }
+
+    @Override
+    public STATE onContentWriteCompleted() {
+        firedEvents.add("ContentWriteCompleted");
+        return super.onContentWriteCompleted();
+    }
+
+    @Override
+    public void onOpenConnection() {
+        firedEvents.add("OpenConnection");
+    }
+
+    @Override
+    public void onConnectionOpen() {
+        firedEvents.add("ConnectionOpen");
+    }
+
+    @Override
+    public void onPoolConnection() {
+        firedEvents.add("PoolConnection");
+    }
+
+    @Override
+    public void onConnectionPooled() {
+        firedEvents.add("ConnectionPooled");
+    }
+
+    @Override
+    public void onSendRequest(Object request) {
+        firedEvents.add("SendRequest");
+    }
+
+    @Override
+    public void onRetry() {
+        firedEvents.add("Retry");
+    }
+}

providers/netty/src/test/java/org/asynchttpclient/providers/netty/NettyAsyncProviderBasicTest.java

@@ -12,10 +12,20 @@
  */
 package org.asynchttpclient.providers.netty;
 
+import static org.testng.Assert.assertEquals;
+
 import org.asynchttpclient.AsyncHttpClient;
 import org.asynchttpclient.AsyncHttpClientConfig;
 import org.asynchttpclient.AsyncHttpProviderConfig;
+import org.asynchttpclient.Request;
+import org.asynchttpclient.RequestBuilder;
 import org.asynchttpclient.async.AsyncProvidersBasicTest;
+import org.asynchttpclient.async.util.EventCollectingHandler;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 import io.netty.channel.ChannelOption;
 
@@ -35,4 +45,28 @@ public AsyncHttpClient getAsyncHttpClient(AsyncHttpClientConfig config) {
     protected String acceptEncodingHeader() {
         return "gzip,deflate";
     }
+
+    @Test(groups = { "standalone", "default_provider", "async" })
+    public void testNewConnectionEventsFired() throws Exception {
+        Request request = new RequestBuilder("GET").setUrl("http://127.0.0.1:" + port1 + "/Test").build();
+
+        try (AsyncHttpClient client = getAsyncHttpClient(null)) {
+            EventCollectingHandler handler = new EventCollectingHandler();
+            client.executeRequest(request, handler).get(3, TimeUnit.SECONDS);
+            handler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            List<String> expectedEvents = Arrays.asList(
+                    "PoolConnection",
+                    "OpenConnection",
+                    "ConnectionOpen",
+                    "SendRequest",
+                    "HeaderWriteCompleted",
+                    "StatusReceived",
+                    "HeadersReceived",
+                    "Completed");
+
+            assertEquals(handler.firedEvents, expectedEvents, "Got " + Arrays.toString(handler.firedEvents.toArray()));
+        }
+
+    }
 }

providers/netty/src/test/java/org/asynchttpclient/providers/netty/NettyBasicHttpsTest.java

@@ -12,12 +12,46 @@
  */
 package org.asynchttpclient.providers.netty;
 
+import static org.asynchttpclient.async.util.TestUtils.createSSLContext;
+import static org.testng.Assert.assertEquals;
+
 import org.asynchttpclient.AsyncHttpClient;
 import org.asynchttpclient.AsyncHttpClientConfig;
 import org.asynchttpclient.async.BasicHttpsTest;
+import org.asynchttpclient.async.util.EventCollectingHandler;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 public class NettyBasicHttpsTest extends BasicHttpsTest {
 
+    @Test(groups = { "standalone", "default_provider" })
+    public void testNormalEventsFired() throws InterruptedException, TimeoutException, ExecutionException {
+        try (AsyncHttpClient client = getAsyncHttpClient(new AsyncHttpClientConfig.Builder().setSSLContext(createSSLContext(new AtomicBoolean(true))).build())) {
+            EventCollectingHandler handler = new EventCollectingHandler();
+            client.preparePost(getTargetUrl()).setBody("whatever").execute(handler).get(3, TimeUnit.SECONDS);
+            handler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            List<String> expectedEvents = Arrays.asList(
+                    "PoolConnection",
+                    "OpenConnection",
+                    "ConnectionOpen",
+                    "SendRequest",
+                    "HeaderWriteCompleted",
+                    "StatusReceived",
+                    "HeadersReceived",
+                    "Completed");
+
+            assertEquals(handler.firedEvents, expectedEvents, "Got " + Arrays.toString(handler.firedEvents.toArray()));
+        }
+
+    }
+
     @Override
     public AsyncHttpClient getAsyncHttpClient(AsyncHttpClientConfig config) {
         return NettyProviderUtil.nettyProvider(config);

providers/netty/src/test/java/org/asynchttpclient/providers/netty/NettyConnectionPoolTest.java

@@ -14,19 +14,25 @@
 import static org.testng.Assert.assertNull;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;
-import io.netty.channel.Channel;
-
-import java.net.ConnectException;
-import java.util.concurrent.TimeUnit;
 
 import org.asynchttpclient.AsyncHttpClient;
 import org.asynchttpclient.AsyncHttpClientConfig;
+import org.asynchttpclient.Request;
+import org.asynchttpclient.RequestBuilder;
 import org.asynchttpclient.Response;
 import org.asynchttpclient.async.ConnectionPoolTest;
+import org.asynchttpclient.async.util.EventCollectingHandler;
 import org.asynchttpclient.providers.netty.channel.pool.ChannelPool;
 import org.asynchttpclient.providers.netty.channel.pool.NoopChannelPool;
 import org.testng.annotations.Test;
 
+import java.net.ConnectException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import io.netty.channel.Channel;
+
 public class NettyConnectionPoolTest extends ConnectionPoolTest {
 
     @Override
@@ -125,4 +131,31 @@ public void testHostNotContactable() {
             client.close();
         }
     }
+
+    @Test(groups = { "standalone", "default_provider" })
+    public void testPooledEventsFired() throws Exception {
+        Request request = new RequestBuilder("GET").setUrl("http://127.0.0.1:" + port1 + "/Test").build();
+
+        try (AsyncHttpClient client = getAsyncHttpClient(null)) {
+            EventCollectingHandler firstHandler = new EventCollectingHandler();
+            client.executeRequest(request, firstHandler).get(3, TimeUnit.SECONDS);
+            firstHandler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            EventCollectingHandler secondHandler = new EventCollectingHandler();
+            client.executeRequest(request, secondHandler).get(3, TimeUnit.SECONDS);
+            secondHandler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            List<String> expectedEvents = Arrays.asList(
+                    "PoolConnection",
+                    "ConnectionPooled",
+                    "SendRequest",
+                    "HeaderWriteCompleted",
+                    "StatusReceived",
+                    "HeadersReceived",
+                    "Completed");
+
+            assertEquals(secondHandler.firedEvents, expectedEvents, "Got " + Arrays.toString(secondHandler.firedEvents.toArray()));
+        }
+    }
+
 }