You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@brooklyn.apache.org by sv...@apache.org on 2015/11/06 08:22:58 UTC
[1/3] incubator-brooklyn git commit: tidy of HttpAssertsTest
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 <al...@cloudsoftcorp.com>
Authored: Thu Nov 5 09:23:12 2015 -0800
Committer: Alex Heneveld <al...@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);
}
[3/3] incubator-brooklyn git commit: This closes #1005
Posted by sv...@apache.org.
This closes #1005
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/ae30539a
Tree: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/tree/ae30539a
Diff: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/diff/ae30539a
Branch: refs/heads/master
Commit: ae30539afcd399e259d772a56393ae8994516135
Parents: a8f8c57 5f42507
Author: Svetoslav Neykov <sv...@cloudsoftcorp.com>
Authored: Fri Nov 6 09:22:44 2015 +0200
Committer: Svetoslav Neykov <sv...@cloudsoftcorp.com>
Committed: Fri Nov 6 09:22:44 2015 +0200
----------------------------------------------------------------------
.../brooklyn/core/entity/EntityAssertsTest.java | 37 ++--
.../brooklyn/test/http/TestHttpServer.java | 4 +
.../apache/brooklyn/util/http/HttpAsserts.java | 34 +---
.../apache/brooklyn/util/HttpAssertsTest.java | 182 +++++++++++--------
4 files changed, 137 insertions(+), 120 deletions(-)
----------------------------------------------------------------------
[2/3] incubator-brooklyn git commit: change slow entity asserts tests
to integration
Posted by sv...@apache.org.
change slow entity asserts tests to integration
Project: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/commit/5f42507d
Tree: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/tree/5f42507d
Diff: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/diff/5f42507d
Branch: refs/heads/master
Commit: 5f42507d86696eb3f0bbb5ca6489f5d9f65809d0
Parents: 734770b
Author: Alex Heneveld <al...@cloudsoftcorp.com>
Authored: Thu Nov 5 09:49:23 2015 -0800
Committer: Alex Heneveld <al...@cloudsoftcorp.com>
Committed: Thu Nov 5 09:49:40 2015 -0800
----------------------------------------------------------------------
.../brooklyn/core/entity/EntityAssertsTest.java | 37 ++++++++++----------
1 file changed, 18 insertions(+), 19 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/5f42507d/core/src/test/java/org/apache/brooklyn/core/entity/EntityAssertsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/core/entity/EntityAssertsTest.java b/core/src/test/java/org/apache/brooklyn/core/entity/EntityAssertsTest.java
index 8a9d480..8ea2fd0 100644
--- a/core/src/test/java/org/apache/brooklyn/core/entity/EntityAssertsTest.java
+++ b/core/src/test/java/org/apache/brooklyn/core/entity/EntityAssertsTest.java
@@ -18,10 +18,10 @@
*/
package org.apache.brooklyn.core.entity;
-import com.google.common.base.Predicate;
-import com.google.common.base.Predicates;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
import org.apache.brooklyn.api.entity.EntitySpec;
import org.apache.brooklyn.api.location.LocationSpec;
import org.apache.brooklyn.api.sensor.AttributeSensor;
@@ -34,16 +34,16 @@ import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
/**
* Tests on {@link EntityAsserts}.
*/
public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
- private static final int TIMEOUT_MS = 10*1000;
private static final String STOOGE = "stooge";
private SimulatedLocation loc;
@@ -99,7 +99,7 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
EntityAsserts.assertConfigEquals(entity, TestEntity.CONF_NAME, "bogus");
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertAttributeEqualsEventually() {
entity.sensors().set(TestEntity.NAME, "before");
final String after = "after";
@@ -107,8 +107,7 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
EntityAsserts.assertAttributeEqualsEventually(entity, TestEntity.NAME, after);
}
-
- @Test(expectedExceptions = AssertionError.class)
+ @Test(groups="Integration", expectedExceptions = AssertionError.class)
public void shouldFailToAssertAttributeEqualsEventually() {
entity.sensors().set(TestEntity.NAME, "before");
final String after = "after";
@@ -125,14 +124,14 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
}, delay.toUnit(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS);
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertAttributeEventuallyNonNull() {
EntityAsserts.assertAttributeEquals(entity, TestEntity.NAME, null);
setSensorValueLater(TestEntity.NAME, "something", Duration.seconds(1));
EntityAsserts.assertAttributeEventuallyNonNull(entity, TestEntity.NAME);
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertAttributeEventually() {
setSensorValueLater(TestEntity.NAME, "testing testing 123", Duration.seconds(1));
EntityAsserts.assertAttributeEventually(entity, TestEntity.NAME, new Predicate<String>() {
@@ -150,7 +149,7 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
EntityAsserts.assertAttribute(entity, TestEntity.NAME, Predicates.equalTo(before));
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertPredicateEventuallyTrue() {
final int testVal = 987654321;
executor.schedule(new Runnable() {
@@ -167,7 +166,7 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
});
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertAttributeEqualsContinually() {
final String myName = "myname";
entity.sensors().set(TestEntity.NAME, myName);
@@ -175,7 +174,7 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
ImmutableMap.of("timeout", "2s"), entity, TestEntity.NAME, myName);
}
- @Test(expectedExceptions = AssertionError.class)
+ @Test(groups="Integration", expectedExceptions = AssertionError.class)
public void shouldFailAssertAttributeEqualsContinually() {
final String myName = "myname";
entity.sensors().set(TestEntity.NAME, myName);
@@ -184,7 +183,7 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
ImmutableMap.of("timeout", "2s"), entity, TestEntity.NAME, myName);
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertGroupSizeEqualsEventually() {
setGroupFilterLater(STOOGE, 1);
EntityAsserts.assertGroupSizeEqualsEventually(ImmutableMap.of("timeout", "2s"), stooges, 3);
@@ -201,14 +200,14 @@ public class EntityAssertsTest extends BrooklynAppUnitTestSupport {
}, delaySeconds, TimeUnit.SECONDS);
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertAttributeChangesEventually () {
entity.sensors().set(TestEntity.NAME, "before");
setSensorValueLater(TestEntity.NAME, "after", Duration.seconds(2));
EntityAsserts.assertAttributeChangesEventually(entity, TestEntity.NAME);
}
- @Test
+ @Test(groups="Integration")
public void shouldAssertAttributeNever() {
entity.sensors().set(TestEntity.NAME, "ever");
EntityAsserts.assertAttributeContinuallyNotEqualTo(ImmutableMap.of("timeout", "5s"), entity, TestEntity.NAME, "after");