brooklyn-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From s...@apache.org
Subject [1/3] incubator-brooklyn git commit: tidy of HttpAssertsTest
Date Fri, 06 Nov 2015 07:22:58 GMT
Repository: incubator-brooklyn
Updated Branches:
  refs/heads/master a8f8c57d2 -> ae30539af


tidy of HttpAssertsTest


Project: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/commit/734770bd
Tree: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/tree/734770bd
Diff: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/diff/734770bd

Branch: refs/heads/master
Commit: 734770bd570ccdb8bbe02c224b26ceb7cf625a9d
Parents: f52d9e0
Author: Alex Heneveld <alex.heneveld@cloudsoftcorp.com>
Authored: Thu Nov 5 09:23:12 2015 -0800
Committer: Alex Heneveld <alex.heneveld@cloudsoftcorp.com>
Committed: Thu Nov 5 09:23:38 2015 -0800

----------------------------------------------------------------------
 .../brooklyn/test/http/TestHttpServer.java      |   4 +
 .../apache/brooklyn/util/http/HttpAsserts.java  |  34 +---
 .../apache/brooklyn/util/HttpAssertsTest.java   | 182 +++++++++++--------
 3 files changed, 119 insertions(+), 101 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/734770bd/utils/common/src/main/java/org/apache/brooklyn/test/http/TestHttpServer.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/test/http/TestHttpServer.java
b/utils/common/src/main/java/org/apache/brooklyn/test/http/TestHttpServer.java
index 75f5e60..0ea35d9 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/test/http/TestHttpServer.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/test/http/TestHttpServer.java
@@ -137,6 +137,10 @@ public class TestHttpServer {
 
     public String getUrl() {
         try {
+            if (server==null) {
+                // guess the URL, in those cases where the server is not started yet
+                return new URL("http", getLocalAddress().getHostAddress(), basePort, "").toExternalForm();
+            }
             return new URL("http", server.getInetAddress().getHostAddress(), server.getLocalPort(),
"").toExternalForm();
         } catch (MalformedURLException e) {
             throw Exceptions.propagate(e);

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/734770bd/utils/common/src/main/java/org/apache/brooklyn/util/http/HttpAsserts.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/util/http/HttpAsserts.java b/utils/common/src/main/java/org/apache/brooklyn/util/http/HttpAsserts.java
index 0479b79..3a8c9ca 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/util/http/HttpAsserts.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/util/http/HttpAsserts.java
@@ -19,33 +19,15 @@
 package org.apache.brooklyn.util.http;
 
 import java.io.IOException;
-import java.io.InputStream;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.net.URLConnection;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.HttpsURLConnection;
-import javax.net.ssl.SSLSession;
 
 import org.apache.brooklyn.test.Asserts;
 import org.apache.brooklyn.util.collections.MutableMap;
-import org.apache.brooklyn.util.crypto.SslTrustUtils;
 import org.apache.brooklyn.util.exceptions.Exceptions;
-import org.apache.brooklyn.util.stream.Streams;
-import org.apache.brooklyn.util.time.Time;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.google.common.base.Throwables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -120,7 +102,7 @@ public class HttpAsserts {
      * @param url The URL
      */
     public static void assertUrlUnreachableEventually(final String url) {
-        assertUrlUnreachableEventually(Maps.newLinkedHashMap(), url);
+        assertUrlUnreachableEventually(Maps.<String,Object>newLinkedHashMap(), url);
     }
 
 
@@ -131,7 +113,7 @@ public class HttpAsserts {
      *              For details see {@link org.apache.brooklyn.test.Asserts#succeedsEventually(java.util.Map,
java.util.concurrent.Callable)}
      * @param url The URL
      */
-    public static void assertUrlUnreachableEventually(Map flags, final String url) {
+    public static void assertUrlUnreachableEventually(Map<String,?> flags, final String
url) {
         assertEventually(flags, new Runnable() {
             public void run() {
                 assertUrlUnreachable(url);
@@ -163,10 +145,10 @@ public class HttpAsserts {
     }
 
     public static void assertHttpStatusCodeEventuallyEquals(final String url, final int expectedCode)
{
-        assertHttpStatusCodeEventuallyEquals(Maps.newLinkedHashMap(),  url, expectedCode);
+        assertHttpStatusCodeEventuallyEquals(Maps.<String,Object>newLinkedHashMap(),
url, expectedCode);
     }
 
-    public static void assertHttpStatusCodeEventuallyEquals(Map flags, final String url,
final int expectedCode) {
+    public static void assertHttpStatusCodeEventuallyEquals(Map<String,?> flags, final
String url, final int expectedCode) {
         assertEventually(flags, new Runnable() {
             public void run() {
                 assertHttpStatusCodeEquals(url, expectedCode);
@@ -241,10 +223,10 @@ public class HttpAsserts {
     }
 
     public static void assertContentEventuallyContainsText(final String url, final String
phrase, final String ...additionalPhrases) {
-        assertContentEventuallyContainsText(MutableMap.of(), url, phrase, additionalPhrases);
+        assertContentEventuallyContainsText(MutableMap.<String,Object>of(), url, phrase,
additionalPhrases);
     }
     
-    public static void assertContentEventuallyContainsText(Map flags, final String url, final
String phrase, final String ...additionalPhrases) {
+    public static void assertContentEventuallyContainsText(Map<String,?> flags, final
String url, final String phrase, final String ...additionalPhrases) {
         assertEventually(flags, new Runnable() {
             public void run() {
                 assertContentContainsText(url, phrase, additionalPhrases);
@@ -252,7 +234,7 @@ public class HttpAsserts {
         });
     }
 
-    private static void assertEventually(Map flags, Runnable r) {
+    private static void assertEventually(Map<String,?> flags, Runnable r) {
         try {
             Asserts.succeedsEventually(flags, r);
         } catch (Exception e) {
@@ -304,7 +286,7 @@ public class HttpAsserts {
      * {@code
      * Future<?> future = assertAsyncHttpStatusCodeContinuallyEquals(executor, url,
200);
      * // do other stuff...
-     * if (future.isDone()) future.get(); // get exception if it's Asserts.failed
+     * if (future.isDone()) future.get(); // get exception if its Asserts.failed
      * }
      * </pre>
      *

http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/734770bd/utils/common/src/test/java/org/apache/brooklyn/util/HttpAssertsTest.java
----------------------------------------------------------------------
diff --git a/utils/common/src/test/java/org/apache/brooklyn/util/HttpAssertsTest.java b/utils/common/src/test/java/org/apache/brooklyn/util/HttpAssertsTest.java
index 8bfd6e2..0eb8f0b 100644
--- a/utils/common/src/test/java/org/apache/brooklyn/util/HttpAssertsTest.java
+++ b/utils/common/src/test/java/org/apache/brooklyn/util/HttpAssertsTest.java
@@ -18,16 +18,22 @@
  */
 package org.apache.brooklyn.util;
 
-import com.google.common.collect.ImmutableMap;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
+import java.net.URI;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
 import org.apache.brooklyn.test.http.TestHttpRequestHandler;
 import org.apache.brooklyn.test.http.TestHttpServer;
 import org.apache.brooklyn.util.exceptions.Exceptions;
 import org.apache.brooklyn.util.http.HttpAsserts;
 import org.apache.brooklyn.util.http.HttpTool;
 import org.apache.brooklyn.util.http.HttpToolResponse;
+import org.apache.brooklyn.util.javalang.JavaClassNames;
+import org.apache.brooklyn.util.net.Networking;
+import org.apache.brooklyn.util.time.Duration;
+import org.apache.brooklyn.util.time.Time;
 import org.apache.http.HttpStatus;
 import org.apache.http.client.HttpClient;
 import org.apache.http.localserver.RequestBasicAuth;
@@ -35,14 +41,14 @@ import org.apache.http.localserver.ResponseBasicUnauthorized;
 import org.apache.http.protocol.ResponseServer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.testng.Assert;
-import org.testng.annotations.*;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
 
-import java.net.URI;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
 
 /**
  * Tests on {@link HttpAsserts}.
@@ -54,26 +60,33 @@ import java.util.concurrent.TimeUnit;
 public class HttpAssertsTest {
 
     private static final Logger LOG = LoggerFactory.getLogger(HttpAssertsTest.class);
+    private static Duration DELAY_FOR_SERVER_TO_SETTLE = Duration.seconds(2);
+    
     HttpClient httpClient;
     URI baseUri;
     private TestHttpServer server;
     private String baseUrl;
+    private String simpleEndpoint;
     private ScheduledExecutorService executor;
 
-
     @BeforeMethod(alwaysRun = true)
     public void setUp() throws Exception {
         server = initializeServer();
+        initVars();
+        Time.sleep(DELAY_FOR_SERVER_TO_SETTLE);
+    }
+
+    private void initVars() {
         baseUrl = server.getUrl();
         httpClient = HttpTool.httpClientBuilder()
             .uri(baseUrl)
             .build();
         baseUri = URI.create(baseUrl);
+        simpleEndpoint = testUri("/simple");
         executor = Executors.newScheduledThreadPool(3);
-        TimeUnit.SECONDS.sleep(2);
     }
 
-    private TestHttpServer initializeServer() {
+    private TestHttpServer initializeServerUnstarted() {
         return new TestHttpServer()
             .interceptor(new ResponseServer())
             .interceptor(new ResponseBasicUnauthorized())
@@ -83,46 +96,52 @@ public class HttpAssertsTest {
             .handler("/missing", new TestHttpRequestHandler().code(HttpStatus.SC_NOT_FOUND).response("Missing"))
             .handler("/redirect", new TestHttpRequestHandler().code(HttpStatus.SC_MOVED_TEMPORARILY).response("Redirect").header("Location",
"/simple"))
             .handler("/cycle", new TestHttpRequestHandler().code(HttpStatus.SC_MOVED_TEMPORARILY).response("Redirect").header("Location",
"/cycle"))
-            .handler("/secure", new TestHttpRequestHandler().code(HttpStatus.SC_MOVED_TEMPORARILY).response("Redirect").header("Location",
"https://0.0.0.0/"))
-            .start();
+            .handler("/secure", new TestHttpRequestHandler().code(HttpStatus.SC_MOVED_TEMPORARILY).response("Redirect").header("Location",
"https://0.0.0.0/"));
+    }
+    private TestHttpServer initializeServer() {
+            return initializeServerUnstarted().start();
     }
-
 
     @AfterMethod(alwaysRun = true)
     public void tearDown() throws Exception {
         if (executor != null) executor.shutdownNow();
         server.stop();
-        TimeUnit.SECONDS.sleep(2);
+        Time.sleep(DELAY_FOR_SERVER_TO_SETTLE);
     }
 
     // schedule a stop of server after n seconds
-    private void stopAfter(int delay) {
+    private void stopAfter(final Duration time) {
+        final TestHttpServer serverCached = server;
         executor.schedule(new Runnable() {
             @Override
             public void run() {
-                server.stop();
+                LOG.info("stopping server ("+time+" elapsed)");
+                serverCached.stop();
             }
-        }, delay, TimeUnit.SECONDS);
+        }, time.toMilliseconds(), TimeUnit.MILLISECONDS);
     }
 
     // stop server and pause to wait for it to finish
     private void stopServer() {
         server.stop();
-        try {
-            TimeUnit.SECONDS.sleep(2);
-        } catch (InterruptedException e) {
-            throw Exceptions.propagate(e);
-        }
+        Time.sleep(DELAY_FOR_SERVER_TO_SETTLE);
     }
 
     // schedule a start of server after n seconds
-    private void startAfter(int delay) {
+    private void startAfter(final Duration time) {
+        // find the port before delay so that callers can get the right url
+        // (sometimes if stopped and started it can't bind to the same port;
+        // at least that is one suspicion for failures on hosted jenkins)
+        server = initializeServerUnstarted();
+        server.basePort(Networking.nextAvailablePort(50606));
+        initVars();
         executor.schedule(new Runnable() {
             @Override
             public void run() {
-                server = initializeServer();
+                LOG.info("starting server ("+time+" elapsed)");
+                server.start();
             }
-        }, delay, TimeUnit.SECONDS);
+        }, time.toMilliseconds(), TimeUnit.MILLISECONDS);
     }
 
     private HttpToolResponse doGet(String str) {
@@ -145,45 +164,52 @@ public class HttpAssertsTest {
     @Test
     public void shouldAssertUrlUnreachable() {
         stopServer();
-        HttpAsserts.assertUrlUnreachable(testUri("/simple"));
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
     }
 
     @Test
     public void shouldAssertUrlUnreachableEventually() {
         HttpAsserts.assertUrlReachable(baseUrl);
-        stopAfter(1);
+        stopAfter(Duration.seconds(1));
         HttpAsserts.assertUrlUnreachableEventually(baseUrl);
     }
 
     @Test
     public void shouldAssertUrlUnreachableEventuallyWithFlags() throws Exception {
-        stopAfter(5);
-        TimeUnit.SECONDS.sleep(3);
-        HttpAsserts.assertUrlReachable(baseUrl);
-        HttpAsserts.assertUrlUnreachableEventually(ImmutableMap.of("timeout", "10s"), baseUrl);
+        String baseUrlOrig = baseUrl;
+        LOG.info("testing "+JavaClassNames.niceClassAndMethod()+", server "+server.getUrl());
+        stopAfter(DELAY_FOR_SERVER_TO_SETTLE);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(DELAY_FOR_SERVER_TO_SETTLE).add(DELAY_FOR_SERVER_TO_SETTLE));
+        LOG.info(JavaClassNames.niceClassAndMethod()+" queued server changes");
+        HttpAsserts.assertUrlReachable(baseUrlOrig);
+        HttpAsserts.assertUrlUnreachableEventually(ImmutableMap.of("timeout", "10s"), baseUrlOrig);
     }
 
     @Test(expectedExceptions = AssertionError.class)
-    public void shouldAssertUrlUnreachableEventuallyWithTimeout() throws Exception {
+    public void shouldFailAssertUrlUnreachableEventuallyWithTimeout() throws Exception {
         HttpAsserts.assertUrlReachable(baseUrl);
         HttpAsserts.assertUrlUnreachableEventually(ImmutableMap.of("timeout", "3s"), baseUrl);
     }
 
-
     @Test
     public void shouldAssertHttpStatusCodeEquals() {
         HttpAsserts.assertHttpStatusCodeEquals(baseUrl, 500, 501);
-        HttpAsserts.assertHttpStatusCodeEquals(testUri("/simple"), 201, 200);
+        HttpAsserts.assertHttpStatusCodeEquals(simpleEndpoint, 201, 200);
         HttpAsserts.assertHttpStatusCodeEquals(testUri("/missing"), 400, 404);
     }
 
     @Test
     public void shouldAssertHttpStatusCodeEventuallyEquals() throws Exception {
         stopServer();
-        final String simple = testUri("/simple");
-        HttpAsserts.assertUrlUnreachable(simple);
-        startAfter(2);
-        HttpAsserts.assertHttpStatusCodeEventuallyEquals(simple, 200);
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE);
+        try {
+            HttpAsserts.assertHttpStatusCodeEventuallyEquals(simpleEndpoint, 200);
+        } catch (Throwable t) {
+            LOG.warn("Failed waiting for simple with start after: "+t, t);
+            LOG.warn("Detail: server at "+server.getUrl()+" ("+server+"), looking at "+simpleEndpoint);
+            throw Exceptions.propagate(t);
+        }
     }
 
     private String testUri(String str) {
@@ -192,12 +218,12 @@ public class HttpAssertsTest {
 
     @Test
     public void shouldAssertContentContainsText() {
-        HttpAsserts.assertContentContainsText(testUri("/simple"), "OK");
+        HttpAsserts.assertContentContainsText(simpleEndpoint, "OK");
     }
 
     @Test
     public void shouldAssertContentNotContainsText() {
-        HttpAsserts.assertContentNotContainsText(testUri("/simple"), "Bad");
+        HttpAsserts.assertContentNotContainsText(simpleEndpoint, "Bad");
     }
 
     @Test
@@ -213,71 +239,72 @@ public class HttpAssertsTest {
     @Test
     public void shouldAssertContentEventuallyContainsText() {
         stopServer();
-        final String simple = testUri("/simple");
-        HttpAsserts.assertUrlUnreachable(simple);
-        startAfter(2);
-        HttpAsserts.assertContentEventuallyContainsText(simple, "OK");
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE);
+        HttpAsserts.assertContentEventuallyContainsText(simpleEndpoint, "OK");
     }
 
     @Test
     public void shouldAssertContentEventuallyContainsTextWithFlags() {
         stopServer();
-        final String simple = testUri("/simple");
-        HttpAsserts.assertUrlUnreachable(simple);
-        startAfter(2);
-        HttpAsserts.assertContentEventuallyContainsText(ImmutableMap.of("timeout", "3s"),
simple, "OK");
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE);
+        HttpAsserts.assertContentEventuallyContainsText(ImmutableMap.of("timeout", 
+            DELAY_FOR_SERVER_TO_SETTLE.add(Duration.ONE_SECOND).toStringRounded()), 
+            simpleEndpoint, "OK");
     }
 
     @Test(expectedExceptions = AssertionError.class)
     public void shouldAssertContentEventuallyContainsTextWithTimeout() {
         stopServer();
-        final String simple = testUri("/simple");
-        HttpAsserts.assertUrlUnreachable(simple);
-        startAfter(4);
-        HttpAsserts.assertContentEventuallyContainsText(ImmutableMap.of("timeout", "3s"),
simple, "OK");
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(2)));
+        HttpAsserts.assertContentEventuallyContainsText(ImmutableMap.of("timeout", 
+            DELAY_FOR_SERVER_TO_SETTLE.add(Duration.ONE_SECOND).toStringRounded()), 
+            simpleEndpoint, "OK");
     }
 
 
     @Test
     public void shouldAssertContentMatches() {
-        HttpAsserts.assertContentMatches(testUri("/simple"), "[Oo][Kk]");
+        HttpAsserts.assertContentMatches(simpleEndpoint, "[Oo][Kk]");
     }
 
     @Test
     public void shouldAssertContentEventuallyMatches() throws Exception {
         stopServer();
-        TimeUnit.SECONDS.sleep(2);
-        final String simple = testUri("/simple");
-        HttpAsserts.assertUrlUnreachable(simple);
-        TimeUnit.SECONDS.sleep(2);
-        startAfter(2);
-        HttpAsserts.assertContentEventuallyMatches(testUri("/simple"), "[Oo][Kk]");
+        Time.sleep(DELAY_FOR_SERVER_TO_SETTLE);
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
+        Time.sleep(DELAY_FOR_SERVER_TO_SETTLE);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE);
+        HttpAsserts.assertContentEventuallyMatches(simpleEndpoint, "[Oo][Kk]");
     }
 
     @Test
     public void shouldAssertContentEventuallyMatchesWithFlags() {
         stopServer();
-        final String simple = testUri("/simple");
-        HttpAsserts.assertUrlUnreachable(simple);
-        startAfter(2);
-        HttpAsserts.assertContentEventuallyMatches(ImmutableMap.of("timeout", "3s"), testUri("/simple"),
"[Oo][Kk]");
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE);
+        HttpAsserts.assertContentEventuallyMatches(ImmutableMap.of("timeout", "3s"), simpleEndpoint,
"[Oo][Kk]");
     }
 
     @Test(expectedExceptions = AssertionError.class)
     public void shouldAssertContentEventuallyMatchesWithTimeout() {
         stopServer();
-        final String simple = testUri("/simple");
-        HttpAsserts.assertUrlUnreachable(simple);
-        startAfter(4);
-        HttpAsserts.assertContentEventuallyMatches(ImmutableMap.of("timeout", "3s"), testUri("/simple"),
"[Oo][Kk]");
+        HttpAsserts.assertUrlUnreachable(simpleEndpoint);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(2)));
+        HttpAsserts.assertContentEventuallyMatches(ImmutableMap.of("timeout", 
+            DELAY_FOR_SERVER_TO_SETTLE.add(Duration.ONE_SECOND).toStringRounded()), 
+            simpleEndpoint, "[Oo][Kk]");
     }
 
     @Test
     public void shouldAssertAsyncHttpStatusCodeContinuallyEquals() throws Exception {
+        stopServer();
         ListeningExecutorService listeningExecutor = MoreExecutors.listeningDecorator(executor);
         final ListenableFuture<?> future =
-            HttpAsserts.assertAsyncHttpStatusCodeContinuallyEquals(listeningExecutor, testUri("/simple"),
200);
-        TimeUnit.SECONDS.sleep(3);
+            HttpAsserts.assertAsyncHttpStatusCodeContinuallyEquals(listeningExecutor, simpleEndpoint,
200);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(1)));
         if (future.isDone()) {
             future.get(); // should not throw exception
         }
@@ -286,12 +313,17 @@ public class HttpAssertsTest {
 
     @Test(expectedExceptions = ExecutionException.class)
     public void shouldAssertAsyncHttpStatusCodeContinuallyEqualsFails() throws Exception
{
+        stopServer();
         ListeningExecutorService listeningExecutor = MoreExecutors.listeningDecorator(executor);
         final ListenableFuture<?> future =
             HttpAsserts.assertAsyncHttpStatusCodeContinuallyEquals(listeningExecutor, testUri("/missing"),
200);
-        TimeUnit.SECONDS.sleep(3);
+        startAfter(DELAY_FOR_SERVER_TO_SETTLE.add(Duration.seconds(1)));
+        Time.sleep(DELAY_FOR_SERVER_TO_SETTLE);
         if (future.isDone()) {
-            future.get(); // should throw exception
+            Object result = future.get(); // should throw exception
+            LOG.warn("Should have failed, instead gave "+result+" (accessing "+server+")");
+        } else {
+            LOG.warn("Future should have been done");
         }
         future.cancel(true);
     }


Mime
View raw message