Test clean up

Author: Stephane Landelle

api/src/test/java/org/asynchttpclient/async/AbstractBasicHttpsTest.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2010 Ning, Inc.
+ *
+ * Ning 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.
+ */
+package org.asynchttpclient.async;
+
+import java.io.File;
+import java.net.URL;
+
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ssl.SslSocketConnector;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testng.annotations.BeforeClass;
+
+public abstract class AbstractBasicHttpsTest extends AbstractBasicTest {
+    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractBasicHttpsTest.class);
+    protected Server server;
+    protected int port1;
+    protected int port2;
+
+    @BeforeClass(alwaysRun = true)
+    public void setUpGlobal() throws Exception {
+        server = new Server();
+        port1 = findFreePort();
+
+        ClassLoader cl = getClass().getClassLoader();
+
+        URL keystoreUrl = cl.getResource("ssltest-keystore.jks");
+        String keyStoreFile = new File(keystoreUrl.toURI()).getAbsolutePath();
+        LOGGER.info("SSL keystore path: {}", keyStoreFile);
+        SslContextFactory sslContextFactory = new SslContextFactory(keyStoreFile);
+        sslContextFactory.setKeyStorePassword("changeit");
+
+        String trustStoreFile = new File(cl.getResource("ssltest-cacerts.jks").toURI()).getAbsolutePath();
+        LOGGER.info("SSL certs path: {}", trustStoreFile);
+        sslContextFactory.setTrustStore(trustStoreFile);
+        sslContextFactory.setTrustStorePassword("changeit");
+
+        SslSocketConnector connector = new SslSocketConnector(sslContextFactory);
+        connector.setHost("127.0.0.1");
+        connector.setPort(port1);
+        server.addConnector(connector);
+
+        server.setHandler(configureHandler());
+        server.start();
+        LOGGER.info("Local HTTP server started successfully");
+    }
+}

api/src/test/java/org/asynchttpclient/async/AbstractBasicTest.java

@@ -15,6 +15,20 @@
  */
 package org.asynchttpclient.async;
 
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.nio.charset.Charset;
+import java.util.Enumeration;
+import java.util.UUID;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.io.FileUtils;
 import org.asynchttpclient.AsyncCompletionHandler;
 import org.asynchttpclient.AsyncHandler;
 import org.asynchttpclient.AsyncHttpClient;
@@ -34,28 +48,56 @@
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import java.io.IOException;
-import java.net.ServerSocket;
-import java.util.Enumeration;
-
 public abstract class AbstractBasicTest {
     protected final Logger log = LoggerFactory.getLogger(AbstractBasicTest.class);
     protected Server server;
     protected int port1;
     protected int port2;
 
     public final static int TIMEOUT = 30;
+    public static final File TMP = new File(System.getProperty("java.io.tmpdir"), "ahc-tests-" + UUID.randomUUID().toString().substring(0, 8));
+    public static final byte[] PATTERN_BYTES = "FooBarBazQixFooBarBazQixFooBarBazQixFooBarBazQixFooBarBazQixFooBarBazQix".getBytes(Charset.forName("UTF-16"));
+    public static final File LARGE_IMAGE_FILE;
+    public static byte[] LARGE_IMAGE_BYTES;
+    public static final File SIMPLE_TEXT_FILE;
+
+    static {
+        try {
+            TMP.mkdirs();
+            TMP.deleteOnExit();
+            LARGE_IMAGE_FILE = new File(AbstractBasicTest.class.getClassLoader().getResource("300k.png").toURI());
+            LARGE_IMAGE_BYTES = FileUtils.readFileToByteArray(LARGE_IMAGE_FILE);
+            SIMPLE_TEXT_FILE = new File(AbstractBasicTest.class.getClassLoader().getResource("SimpleTextFile.txt").toURI());
+        } catch (Exception e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    public static File createTempFile(byte[] pattern, int repeat) throws IOException {
+        File tmpFile = File.createTempFile("tmpfile-", ".data", TMP);
+        tmpFile.deleteOnExit();
+        FileOutputStream out = null;
+        try {
+            out = new FileOutputStream(tmpFile);
+            for (int i = 0; i < repeat; i++) {
+                out.write(pattern);
+            }
+            
+            long expectedFileSize = PATTERN_BYTES.length * repeat;
+            Assert.assertEquals(expectedFileSize, tmpFile.length(), "Invalid file length");
+            
+            return tmpFile;
+        } finally {
+            if (out != null) {
+                out.close();
+            }
+        }
+    }
 
     public static class EchoHandler extends AbstractHandler {
 
-        /* @Override */
-        public void handle(String pathInContext,
-                           Request request,
-                           HttpServletRequest httpRequest,
-                           HttpServletResponse httpResponse) throws IOException, ServletException {
+        @Override
+        public void handle(String pathInContext, Request request, HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws IOException, ServletException {
 
             if (httpRequest.getHeader("X-HEAD") != null) {
                 httpResponse.setContentLength(1);
@@ -68,8 +110,9 @@ public void handle(String pathInContext,
             }
 
             if (request.getMethod().equalsIgnoreCase("OPTIONS")) {
-                httpResponse.addHeader("Allow","GET,HEAD,POST,OPTIONS,TRACE");
-            };
+                httpResponse.addHeader("Allow", "GET,HEAD,POST,OPTIONS,TRACE");
+            }
+            ;
 
             Enumeration<?> e = httpRequest.getHeaderNames();
             String param;
@@ -110,9 +153,9 @@ public void handle(String pathInContext,
 
             httpResponse.addHeader("X-KEEP-ALIVE", httpRequest.getRemoteAddr() + ":" + httpRequest.getRemotePort());
 
-            javax.servlet.http.Cookie[] cs = httpRequest.getCookies();
+            Cookie[] cs = httpRequest.getCookies();
             if (cs != null) {
-                for (javax.servlet.http.Cookie c : cs) {
+                for (Cookie c : cs) {
                     httpResponse.addCookie(c);
                 }
             }
@@ -142,9 +185,35 @@ public void handle(String pathInContext,
         }
     }
 
+    @BeforeClass(alwaysRun = true)
+    public void setUpGlobal() throws Exception {
+        server = new Server();
+
+        port1 = findFreePort();
+        port2 = findFreePort();
+
+        Connector listener = new SelectChannelConnector();
+
+        listener.setHost("127.0.0.1");
+        listener.setPort(port1);
+
+        server.addConnector(listener);
+
+        listener = new SelectChannelConnector();
+        listener.setHost("127.0.0.1");
+        listener.setPort(port2);
+
+        server.addConnector(listener);
+
+        server.setHandler(configureHandler());
+        server.start();
+        log.info("Local HTTP server started successfully");
+    }
+
     @AfterClass(alwaysRun = true)
     public void tearDownGlobal() throws Exception {
-        server.stop();
+        if (server != null)
+            server.stop();
     }
 
     protected int findFreePort() throws IOException {
@@ -154,8 +223,7 @@ protected int findFreePort() throws IOException {
             socket = new ServerSocket(0);
 
             return socket.getLocalPort();
-        }
-        finally {
+        } finally {
             if (socket != null) {
                 socket.close();
             }
@@ -174,31 +242,6 @@ public AbstractHandler configureHandler() throws Exception {
         return new EchoHandler();
     }
 
-    @BeforeClass(alwaysRun = true)
-    public void setUpGlobal() throws Exception {
-        server = new Server();
-
-        port1 = findFreePort();
-        port2 = findFreePort();
-
-        Connector listener = new SelectChannelConnector();
-
-        listener.setHost("127.0.0.1");
-        listener.setPort(port1);
-
-        server.addConnector(listener);
-
-        listener = new SelectChannelConnector();
-        listener.setHost("127.0.0.1");
-        listener.setPort(port2);
-
-        server.addConnector(listener);
-
-        server.setHandler(configureHandler());
-        server.start();
-        log.info("Local HTTP server started successfully");
-    }
-
     public static class AsyncCompletionHandlerAdapter extends AsyncCompletionHandler<Response> {
         public Runnable runnable;
 
@@ -207,7 +250,7 @@ public Response onCompleted(Response response) throws Exception {
             return response;
         }
 
-        /* @Override */
+        @Override
         public void onThrowable(Throwable t) {
             t.printStackTrace();
             Assert.fail("Unexpected exception: " + t.getMessage(), t);
@@ -217,35 +260,32 @@ public void onThrowable(Throwable t) {
 
     public static class AsyncHandlerAdapter implements AsyncHandler<String> {
 
-
-        /* @Override */
+        @Override
         public void onThrowable(Throwable t) {
             t.printStackTrace();
             Assert.fail("Unexpected exception", t);
         }
 
-        /* @Override */
+        @Override
         public STATE onBodyPartReceived(final HttpResponseBodyPart content) throws Exception {
             return STATE.CONTINUE;
         }
 
-        /* @Override */
+        @Override
         public STATE onStatusReceived(final HttpResponseStatus responseStatus) throws Exception {
             return STATE.CONTINUE;
         }
 
-        /* @Override */
+        @Override
         public STATE onHeadersReceived(final HttpResponseHeaders headers) throws Exception {
             return STATE.CONTINUE;
         }
 
-        /* @Override */
+        @Override
         public String onCompleted() throws Exception {
             return "";
         }
-
     }
 
     public abstract AsyncHttpClient getAsyncHttpClient(AsyncHttpClientConfig config);
-
 }

api/src/test/java/org/asynchttpclient/async/AsyncProvidersBasicTest.java

@@ -62,6 +62,7 @@
 import org.asynchttpclient.StringPart;
 
 public abstract class AsyncProvidersBasicTest extends AbstractBasicTest {
+
     private static final String UTF_8 = "text/html;charset=UTF-8";
 
     @Test(groups = { "standalone", "default_provider", "async" })

api/src/test/java/org/asynchttpclient/async/AsyncStreamHandlerTest.java

@@ -38,8 +38,9 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public abstract class AsyncStreamHandlerTest extends AbstractBasicTest {
-    private final static String RESPONSE = "param_1_";
-    private final static String UTF8 = "text/html;charset=utf-8";
+    
+    private static final String RESPONSE = "param_1_";
+    private static final String UTF8 = "text/html;charset=utf-8";
 
     @Test(groups = { "standalone", "default_provider" })
     public void asyncStreamGETTest() throws Throwable {

api/src/test/java/org/asynchttpclient/async/AuthTimeoutTest.java

@@ -51,9 +51,9 @@
 
 public abstract class AuthTimeoutTest extends AbstractBasicTest {
 
-    private final static String user = "user";
+    private static final String USER = "user";
 
-    private final static String admin = "admin";
+    private static final String ADMIN = "admin";
 
     protected AsyncHttpClient client;
 
@@ -76,16 +76,16 @@ public void setUpServer(String auth) throws Exception {
 
         Constraint constraint = new Constraint();
         constraint.setName(auth);
-        constraint.setRoles(new String[] { user, admin });
+        constraint.setRoles(new String[] { USER, ADMIN });
         constraint.setAuthenticate(true);
 
         ConstraintMapping mapping = new ConstraintMapping();
         mapping.setConstraint(constraint);
         mapping.setPathSpec("/*");
 
         Set<String> knownRoles = new HashSet<String>();
-        knownRoles.add(user);
-        knownRoles.add(admin);
+        knownRoles.add(USER);
+        knownRoles.add(ADMIN);
 
         ConstraintSecurityHandler security = new ConstraintSecurityHandler();
 
@@ -258,7 +258,7 @@ protected Future<Response> execute(boolean preemptive) throws IOException {
     }
 
     private Realm realm(boolean preemptive) {
-        return (new Realm.RealmBuilder()).setPrincipal(user).setPassword(admin).setUsePreemptiveAuth(preemptive).build();
+        return (new Realm.RealmBuilder()).setPrincipal(USER).setPassword(ADMIN).setUsePreemptiveAuth(preemptive).build();
     }
 
     @Override