Enchance Expect:100-continue tests with async calls

Signed-off-by: Maxim Nesen <maxim.nesen@oracle.com>

Author: senivam

tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/nettyconnector/Expect100ContinueTest.java

@@ -22,14 +22,19 @@
 import org.glassfish.jersey.client.http.Expect100ContinueFeature;
 import org.glassfish.jersey.netty.connector.NettyClientProperties;
 import org.glassfish.jersey.netty.connector.NettyConnectorProvider;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import javax.net.ServerSocketFactory;
 import javax.ws.rs.ProcessingException;
+import javax.ws.rs.client.AsyncInvoker;
 import javax.ws.rs.client.Client;
 import javax.ws.rs.client.ClientBuilder;
 import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.client.InvocationCallback;
 import javax.ws.rs.client.WebTarget;
 import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.Response;
@@ -52,6 +57,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
 
 public class Expect100ContinueTest /*extends JerseyTest*/ {
 
@@ -74,13 +80,24 @@ public class Expect100ContinueTest /*extends JerseyTest*/ {
 
     private static Client client;
 
-    @BeforeEach
-    public void beforeEach() {
+    @BeforeAll
+    static void beforeAll() {
         final ClientConfig config = new ClientConfig();
-        this.configureClient(config);
+        config.connectorProvider(new NettyConnectorProvider());
         client = ClientBuilder.newClient(config);
     }
 
+    @BeforeEach
+    void beforeEach() throws IOException {
+        server = new TestSocketServer(portNumber);
+        server.runServer();
+    }
+
+    @AfterEach
+    void afterEach() {
+        server.stop();
+    }
+
     private Client client() {
         return client;
     }
@@ -94,147 +111,117 @@ protected void configureClient(ClientConfig config) {
     }
 
     @Test
-    public void testExpect100Continue() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
-            final Response response = target(RESOURCE_PATH).request().post(Entity.text(ENTITY_STRING));
-            assertEquals(200, response.getStatus(), "Expected 200"); //no Expect header sent - response OK
-        } finally {
-            server.stop();
-        }
+    public void testExpect100Continue() {
+        final Response response = target(RESOURCE_PATH).request().post(Entity.text(ENTITY_STRING));
+        assertEquals(200, response.getStatus(), "Expected 200"); //no Expect header sent - response OK
     }
 
     @Test
-    public void testExpect100ContinueChunked() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
+    public void testExpect100ContinueChunked() {
             final Response response = target(RESOURCE_PATH).register(Expect100ContinueFeature.basic())
                     .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
                             RequestEntityProcessing.CHUNKED)
                     .request().post(Entity.text(ENTITY_STRING));
             assertEquals(204, response.getStatus(), "Expected 204"); //Expect header sent - No Content response
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
-    public void testExpect100ContinueBuffered() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
+    public void testExpect100ContinueManyAsyncRequests() {
+
+        final Invocation.Builder requestBuilder = target(RESOURCE_PATH).register(Expect100ContinueFeature.basic())
+                .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
+                        RequestEntityProcessing.CHUNKED)
+                .request();
+        final AsyncInvoker invoker =
+                requestBuilder.async();
+
+        final InvocationCallback<Response> responseCallback = new InvocationCallback<Response>() {
+            @Override
+            public void completed(Response response) {
+                assertEquals(204, response.getStatus(), "Expected 204"); //Expect header sent - No Content response
+            }
 
+            @Override
+            public void failed(Throwable throwable) {
+                fail(throwable); // should not fail
+            }
+        };
+        invoker.post(Entity.text(ENTITY_STRING), responseCallback);
+        invoker.post(Entity.text(ENTITY_STRING), responseCallback);
+        invoker.post(Entity.text(ENTITY_STRING), responseCallback);
+        invoker.post(Entity.text(ENTITY_STRING), responseCallback);
+        invoker.post(Entity.text(ENTITY_STRING), responseCallback);
+        invoker.post(Entity.text(ENTITY_STRING), responseCallback);
+
+        final Response response = requestBuilder.post(Entity.text(ENTITY_STRING));
+        assertEquals(204, response.getStatus(), "Expected 204"); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueBuffered() {
             final Response response = target(RESOURCE_PATH).register(Expect100ContinueFeature.basic())
                     .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
                             RequestEntityProcessing.BUFFERED).request().header(HttpHeaders.CONTENT_LENGTH, 67000L)
                     .post(Entity.text(generateStringByContentLength(67000)));
             assertEquals(204, response.getStatus(), "Expected 204"); //Expect header sent - No Content response
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
-    public void testExpect100ContinueCustomLength() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
+    public void testExpect100ContinueCustomLength() {
             final Response response = target(RESOURCE_PATH).register(Expect100ContinueFeature.withCustomThreshold(100L))
                     .request().header(HttpHeaders.CONTENT_LENGTH, 200)
                     .post(Entity.text(generateStringByContentLength(200)));
             assertEquals(204, response.getStatus(), "Expected 204"); //Expect header sent - No Content response
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
-    public void testExpect100ContinueCustomLengthWrong() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
+    public void testExpect100ContinueCustomLengthWrong() {
             final Response response = target(RESOURCE_PATH).register(Expect100ContinueFeature.withCustomThreshold(100L))
                     .request().header(HttpHeaders.CONTENT_LENGTH, 99L)
                     .post(Entity.text(generateStringByContentLength(99)));
             assertEquals(200, response.getStatus(), "Expected 200"); //Expect header NOT sent - low request size
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
-    public void testExpect100ContinueCustomLengthProperty() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
+    public void testExpect100ContinueCustomLengthProperty() {
             final Response response = target(RESOURCE_PATH)
                     .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 555L)
                     .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
                     .register(Expect100ContinueFeature.withCustomThreshold(555L))
                     .request().header(HttpHeaders.CONTENT_LENGTH, 666L)
                     .post(Entity.text(generateStringByContentLength(666)));
             assertNotNull(response.getStatus()); //Expect header sent - No Content response
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
-    public void testExpect100ContinueRegisterViaCustomProperty() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
+    public void testExpect100ContinueRegisterViaCustomProperty() {
         final Response response = target(RESOURCE_PATH)
                 .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 43L)
                 .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
                 .request().header(HttpHeaders.CONTENT_LENGTH, 44L)
                 .post(Entity.text(generateStringByContentLength(44)));
         assertEquals(204, response.getStatus(), "Expected 204"); //Expect header sent - No Content response
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
-    public void testExpect100ContinueNotSupported() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
+    public void testExpect100ContinueNotSupported() {
             final Response response = target(RESOURCE_PATH_NOT_SUPPORTED)
                     .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 43L)
                     .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
                     .request().header(HttpHeaders.CONTENT_LENGTH, 44L)
                     .post(Entity.text(generateStringByContentLength(44)));
             assertEquals(204, response.getStatus(),
                     "This should re-send request without expect and obtain the 204 response code"); //Expectations not supported
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
-    public void testExpect100ContinueUnauthorized() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
+    public void testExpect100ContinueUnauthorized() {
             assertThrows(ProcessingException.class, () -> target(RESOURCE_PATH_UNAUTHORIZED)
                     .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 43L)
                     .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
                     .property(NettyClientProperties.EXPECT_100_CONTINUE_TIMEOUT, 10000)
                     .request().header(HttpHeaders.CONTENT_LENGTH, 44L)
                     .post(Entity.text(generateStringByContentLength(44))));
-        } finally {
-            server.stop();
-        }
     }
 
     @Test
@@ -248,21 +235,14 @@ public void testExpect100ContinuePayloadTooLarge() {
     }
 
     @Test
-    public void testExpect100ContinueMethodNotSupported() throws Exception {
-        final TestSocketServer server = new TestSocketServer(portNumber);
-        try {
-            server.runServer();
-
+    public void testExpect100ContinueMethodNotSupported() {
             assertThrows(ProcessingException.class, () ->  target(RESOURCE_PATH_METHOD_NOT_SUPPORTED)
                     .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 43L)
                     .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
                     .property(NettyClientProperties.EXPECT_100_CONTINUE_TIMEOUT, 10000)
                     .request().header(HttpHeaders.CONTENT_LENGTH, 44L)
                     .post(Entity.text(generateStringByContentLength(44))));
 
-        } finally {
-            server.stop();
-        }
     }
 
     private String generateStringByContentLength(int length) {
@@ -281,10 +261,12 @@ private static final class TestSocketServer {
         private static final String EXPECT_HEADER = "HTTP/1.1 100 Continue";
         private static final String UNAUTHORIZED_HEADER = "HTTP/1.1 401 Unauthorized";
         private static final String NOT_SUPPORTED_HEADER = "HTTP/1.1 405 Method Not Allowed";
+        private static final String TOO_LARGE_HEADER = "HTTP/1.1 413 Request Entity Too Large";
 
         private final ExecutorService executorService = Executors.newCachedThreadPool();
         private AtomicBoolean unauthorized = new AtomicBoolean(false);
         private AtomicBoolean not_supported = new AtomicBoolean(false);
+        private AtomicBoolean too_large = new AtomicBoolean(false);
 
         private AtomicBoolean expect_processed = new AtomicBoolean(false);
 
@@ -404,6 +386,12 @@ private boolean processExpect100Continue(Map<String, String> headers, BufferedWr
                     failed = true;
                 }
 
+                if (too_large.get()) {
+                    http_header = TOO_LARGE_HEADER;
+                    too_large.set(false);
+                    failed = true;
+                }
+
                 expect_processed.set(http_header.equals(EXPECT_HEADER));
 
 
@@ -438,6 +426,11 @@ private Map<String, String> mapHeaders(BufferedReader reader) throws IOException
                 if (line.contains(RESOURCE_PATH_METHOD_NOT_SUPPORTED)) {
                     not_supported.set(true);
                 }
+
+                if (line.contains(RESOURCE_PATH_PAYLOAD_TOO_LARGE)) {
+                    too_large.set(true);
+                }
+
                 int pos = line.indexOf(':');
                 if (pos > -1) {
                     headers.put(