You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@brooklyn.apache.org by al...@apache.org on 2016/08/09 19:44:40 UTC
[6/8] brooklyn-server git commit: TestSensor: support abortConditions
TestSensor: support abortConditions
Project: http://git-wip-us.apache.org/repos/asf/brooklyn-server/repo
Commit: http://git-wip-us.apache.org/repos/asf/brooklyn-server/commit/3e1171f7
Tree: http://git-wip-us.apache.org/repos/asf/brooklyn-server/tree/3e1171f7
Diff: http://git-wip-us.apache.org/repos/asf/brooklyn-server/diff/3e1171f7
Branch: refs/heads/master
Commit: 3e1171f7f8023da97d041d0f5dd5953182430a31
Parents: 967c2f0
Author: Aled Sage <al...@gmail.com>
Authored: Tue Jul 26 22:16:30 2016 +0100
Committer: Aled Sage <al...@gmail.com>
Committed: Mon Aug 8 14:48:25 2016 +0100
----------------------------------------------------------------------
.../brooklyn/test/framework/AbortError.java | 31 ++++
.../test/framework/TestFrameworkAssertions.java | 155 ++++++++++++++++---
...leShellCommandDeprecatedIntegrationTest.java | 13 +-
.../framework/TestFrameworkAssertionsTest.java | 54 ++++++-
.../brooklyn/test/framework/TestSensorTest.java | 128 +++++++++++++--
.../brooklyn/util/exceptions/Exceptions.java | 24 +++
.../apache/brooklyn/util/repeat/Repeater.java | 20 ++-
7 files changed, 368 insertions(+), 57 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/3e1171f7/test-framework/src/main/java/org/apache/brooklyn/test/framework/AbortError.java
----------------------------------------------------------------------
diff --git a/test-framework/src/main/java/org/apache/brooklyn/test/framework/AbortError.java b/test-framework/src/main/java/org/apache/brooklyn/test/framework/AbortError.java
new file mode 100644
index 0000000..dd82d01
--- /dev/null
+++ b/test-framework/src/main/java/org/apache/brooklyn/test/framework/AbortError.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF 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.apache.brooklyn.test.framework;
+
+public class AbortError extends Error {
+ private static final long serialVersionUID = -2922419711728467414L;
+
+ public AbortError(String msg) {
+ super(msg);
+ }
+
+ public AbortError(String msg, Throwable cause) {
+ super(msg, cause);
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/3e1171f7/test-framework/src/main/java/org/apache/brooklyn/test/framework/TestFrameworkAssertions.java
----------------------------------------------------------------------
diff --git a/test-framework/src/main/java/org/apache/brooklyn/test/framework/TestFrameworkAssertions.java b/test-framework/src/main/java/org/apache/brooklyn/test/framework/TestFrameworkAssertions.java
index 0227bf1..e1ed825 100644
--- a/test-framework/src/main/java/org/apache/brooklyn/test/framework/TestFrameworkAssertions.java
+++ b/test-framework/src/main/java/org/apache/brooklyn/test/framework/TestFrameworkAssertions.java
@@ -23,6 +23,7 @@ import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.concurrent.Callable;
import org.apache.brooklyn.api.entity.Entity;
import org.apache.brooklyn.config.ConfigKey;
@@ -32,14 +33,17 @@ import org.apache.brooklyn.util.core.flags.TypeCoercions;
import org.apache.brooklyn.util.exceptions.CompoundRuntimeException;
import org.apache.brooklyn.util.exceptions.Exceptions;
import org.apache.brooklyn.util.exceptions.FatalConfigurationRuntimeException;
+import org.apache.brooklyn.util.exceptions.RuntimeInterruptedException;
import org.apache.brooklyn.util.guava.Maybe;
+import org.apache.brooklyn.util.repeat.Repeater;
import org.apache.brooklyn.util.text.Strings;
import org.apache.brooklyn.util.time.Duration;
import com.google.common.base.Joiner;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
import com.google.common.reflect.TypeToken;
@@ -62,9 +66,9 @@ public class TestFrameworkAssertions {
public static final String UNKNOWN_CONDITION = "unknown condition";
public static class AssertionOptions {
- protected Map<String,?> flags;
- protected List<? extends Map<String, ?>> assertions;
- protected List<? extends Map<String, ?>> abortConditions;
+ protected Map<String,Object> flags = MutableMap.of();
+ protected List<? extends Map<String, ?>> assertions = ImmutableList.of();
+ protected List<? extends Map<String, ?>> abortConditions = ImmutableList.of();
protected String target;
protected Supplier<?> supplier;
@@ -73,18 +77,11 @@ public class TestFrameworkAssertions {
this.supplier = supplier;
}
public AssertionOptions flags(Map<String,?> val) {
- this.flags = val;
+ this.flags.putAll(val);
return this;
}
public AssertionOptions timeout(Duration val) {
- if (flags == null) {
- flags = ImmutableMap.of("timeout", val);
- } else {
- MutableMap.<String, Object>builder()
- .putAll(flags)
- .put("timeout", val)
- .build();
- }
+ this.flags.put("timeout", val);
return this;
}
public AssertionOptions assertions(Map<String, ?> val) {
@@ -216,20 +213,58 @@ public class TestFrameworkAssertions {
support.validate();
}
+ // TODO Copied from Asserts.toDuration
+ private static Duration toDuration(Object duration, Duration defaultVal) {
+ if (duration == null)
+ return defaultVal;
+ else
+ return Duration.of(duration);
+ }
+
protected static <T> void checkAssertionsEventually(AssertionSupport support, final AssertionOptions options) {
if (options.assertions == null || options.assertions.isEmpty()) {
return;
}
+ Map<String, ?> flags = options.flags;
+
+ // To speed up tests, default is for the period to start small and increase...
+ // TODO ignoring "period" and "maxAttempts"
+ Integer maxAttempts = (Integer) flags.get("maxAttempts");
+ Duration timeout = toDuration(flags.get("timeout"), (maxAttempts == null ? Asserts.DEFAULT_LONG_TIMEOUT : Duration.PRACTICALLY_FOREVER));
+ Duration fixedPeriod = toDuration(flags.get("period"), null);
+ Duration minPeriod = (fixedPeriod != null) ? fixedPeriod : toDuration(flags.get("minPeriod"), Duration.millis(1));
+ Duration maxPeriod = (fixedPeriod != null) ? fixedPeriod : toDuration(flags.get("maxPeriod"), Duration.millis(500));
+ Predicate<Throwable> rethrowImmediatelyPredicate = Predicates.or(ImmutableList.of(
+ Predicates.instanceOf(AbortError.class),
+ Predicates.instanceOf(InterruptedException.class),
+ Predicates.instanceOf(RuntimeInterruptedException.class)));
+
try {
- Asserts.succeedsEventually(options.flags, new Runnable() {
- @Override
- public void run() {
- Object actual = options.supplier.get();
- for (Map<String, ?> assertionMap : options.assertions) {
- checkActualAgainstAssertions(assertionMap, options.target, actual);
- }
- }
- });
+ Repeater.create()
+ .until(new Callable<Boolean>() {
+ public Boolean call() {
+ try {
+ Object actual = options.supplier.get();
+
+ for (Map<String, ?> abortMap : options.abortConditions) {
+ checkActualAgainstAbortConditions(abortMap, options.target, actual);
+ }
+ for (Map<String, ?> assertionMap : options.assertions) {
+ checkActualAgainstAssertions(assertionMap, options.target, actual);
+ }
+ return true;
+ } catch (AssertionError e) {
+ throw e;
+ } catch (Throwable t) {
+ throw t;
+ }
+ }})
+ .limitIterationsTo(maxAttempts != null ? maxAttempts : Integer.MAX_VALUE)
+ .limitTimeTo(timeout)
+ .backoff(minPeriod, 1.2, maxPeriod)
+ .rethrowExceptionImmediately(rethrowImmediatelyPredicate)
+ .runRequiringTrue();
+
} catch (AssertionError t) {
support.fail(t);
} catch (Throwable t) {
@@ -266,6 +301,8 @@ public class TestFrameworkAssertions {
if (Objects.equals(actual, expected)) {
failAssertion(target, condition, expected, actual);
}
+ break;
+
case IS_NULL :
if (isTrue(expected) != (null == actual)) {
failAssertion(target, condition, expected, actual);
@@ -314,6 +351,74 @@ public class TestFrameworkAssertions {
}
}
+ protected static <T> void checkActualAgainstAbortConditions(Map<String, ?> assertions, String target, T actual) {
+ for (Map.Entry<String, ?> assertion : assertions.entrySet()) {
+ String condition = assertion.getKey().toString();
+ Object expected = assertion.getValue();
+ switch (condition) {
+
+ case IS_EQUAL_TO :
+ case EQUAL_TO :
+ case EQUALS :
+ if (null != actual && actual.equals(expected)) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case NOT_EQUAL :
+ if (!Objects.equals(actual, expected)) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case IS_NULL :
+ if (isTrue(expected) == (null == actual)) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case NOT_NULL :
+ if (isTrue(expected) == (null != actual)) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case CONTAINS :
+ if (null != actual && actual.toString().contains(expected.toString())) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case IS_EMPTY :
+ if (isTrue(expected) == (null == actual || Strings.isEmpty(actual.toString()))) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case NOT_EMPTY :
+ if (isTrue(expected) == ((null != actual && Strings.isNonEmpty(actual.toString())))) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case MATCHES :
+ if (null != actual && actual.toString().matches(expected.toString())) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ case HAS_TRUTH_VALUE :
+ if (isTrue(expected) == isTrue(actual)) {
+ abort(target, condition, expected, actual);
+ }
+ break;
+
+ default:
+ abort(target, condition, expected, actual);
+ }
+ }
+ }
+
static void failAssertion(String target, String assertion, Object expected, Object actual) {
throw new AssertionError(Joiner.on(' ').join(
Objects.toString(target),
@@ -324,6 +429,12 @@ public class TestFrameworkAssertions {
Objects.toString(actual)));
}
+ static void abort(String target, String assertion, Object expected, Object actual) {
+ throw new AbortError(Objects.toString(target) + " matched abort criteria '"
+ + Objects.toString(assertion) + " " + Objects.toString(expected) + "', found "
+ + Objects.toString(actual));
+ }
+
private static boolean isTrue(Object object) {
return null != object && Boolean.valueOf(object.toString());
}
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/3e1171f7/test-framework/src/test/java/org/apache/brooklyn/test/framework/SimpleShellCommandDeprecatedIntegrationTest.java
----------------------------------------------------------------------
diff --git a/test-framework/src/test/java/org/apache/brooklyn/test/framework/SimpleShellCommandDeprecatedIntegrationTest.java b/test-framework/src/test/java/org/apache/brooklyn/test/framework/SimpleShellCommandDeprecatedIntegrationTest.java
index 34ffc6d..f8fdbde 100644
--- a/test-framework/src/test/java/org/apache/brooklyn/test/framework/SimpleShellCommandDeprecatedIntegrationTest.java
+++ b/test-framework/src/test/java/org/apache/brooklyn/test/framework/SimpleShellCommandDeprecatedIntegrationTest.java
@@ -102,16 +102,14 @@ public class SimpleShellCommandDeprecatedIntegrationTest extends BrooklynAppUnit
}
}
- private List<Map<String, Object>> makeAssertions(Map<String, Object> ...maps) {
- ArrayList<Map<String, Object>> assertions = new ArrayList<>();
- for (Map<String, Object> map : maps) {
+ private List<Map<String, ?>> makeAssertions(Map<String, ?> ...maps) {
+ ArrayList<Map<String, ?>> assertions = new ArrayList<>();
+ for (Map<String, ?> map : maps) {
assertions.add(map);
}
return assertions;
}
-
-
@Test(groups = "Integration")
public void shouldSucceedUsingSuccessfulExitAsDefaultCondition() {
TestEntity testEntity = app.createAndManageChild(EntitySpec.create(TestEntity.class).location(TestApplication.LOCALHOST_MACHINE_SPEC));
@@ -140,7 +138,7 @@ public class SimpleShellCommandDeprecatedIntegrationTest extends BrooklynAppUnit
try {
app.start(ImmutableList.<Location>of());
} catch (Throwable t) {
- Asserts.expectedFailureContains(t, "exit code equals 0");
+ Asserts.expectedFailureContains(t, "exit code expected equals 0 but found 1");
}
assertThat(uptime.sensors().get(SERVICE_UP)).isFalse()
@@ -193,8 +191,9 @@ public class SimpleShellCommandDeprecatedIntegrationTest extends BrooklynAppUnit
try {
app.start(ImmutableList.<Location>of());
+ Asserts.shouldHaveFailedPreviously();
} catch (Exception e) {
- Asserts.expectedFailureContains(e, "exit code equals 1", "exit code equals 255");
+ Asserts.expectedFailureContains(e, "exit code expected equals 1", "exit code expected equals 255");
}
assertThat(ServiceStateLogic.getExpectedState(uptime)).isEqualTo(Lifecycle.ON_FIRE)
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/3e1171f7/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestFrameworkAssertionsTest.java
----------------------------------------------------------------------
diff --git a/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestFrameworkAssertionsTest.java b/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestFrameworkAssertionsTest.java
index 0b660e3..9e79bfe 100644
--- a/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestFrameworkAssertionsTest.java
+++ b/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestFrameworkAssertionsTest.java
@@ -35,7 +35,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
-import java.util.concurrent.TimeUnit;
public class TestFrameworkAssertionsTest {
private static final Logger LOG = LoggerFactory.getLogger(TestFrameworkAssertionsTest.class);
@@ -71,7 +70,7 @@ public class TestFrameworkAssertionsTest {
}
@Test(dataProvider = "positiveTestsDP")
- public void positiveTest(final Object data, final List<Map<String, Object>> assertions) {
+ public void positiveTest(final Object data, final List<Map<String, ?>> assertions) {
final Supplier<Object> supplier = new Supplier<Object>() {
@Override
public Object get() {
@@ -79,7 +78,30 @@ public class TestFrameworkAssertionsTest {
return data;
}
};
- TestFrameworkAssertions.checkAssertionsEventually(new AssertionOptions(Objects.toString(data), supplier).timeout(Duration.seconds(2)).assertions(assertions));
+ TestFrameworkAssertions.checkAssertionsEventually(new AssertionOptions(Objects.toString(data), supplier)
+ .timeout(Asserts.DEFAULT_LONG_TIMEOUT).assertions(assertions));
+ }
+
+ @Test(dataProvider = "positiveTestsDP")
+ public void positiveAbortTest(final Object data, final List<Map<String, ?>> abortConditions) {
+ final Supplier<Object> supplier = new Supplier<Object>() {
+ @Override
+ public Object get() {
+ LOG.info("Supplier invoked for data [{}]", data);
+ return data;
+ }
+ };
+
+ for (Map<String, ?> map : abortConditions) {
+ try {
+ TestFrameworkAssertions.checkAssertionsEventually(new AssertionOptions(Objects.toString(data), supplier)
+ .timeout(Asserts.DEFAULT_LONG_TIMEOUT).abortConditions(map)
+ .assertions(ImmutableMap.of("equals", "wrong-value-never-equals")));
+ Asserts.shouldHaveFailedPreviously();
+ } catch (AbortError e) {
+ // success
+ }
+ }
}
@DataProvider
@@ -115,7 +137,7 @@ public class TestFrameworkAssertionsTest {
}
@Test(dataProvider = "negativeTestsDP")
- public void negativeTests(final Object data, String condition, Object expected, final List<Map<String, Object>> assertions) {
+ public void negativeTests(final Object data, String condition, Object expected, final List<Map<String, ?>> assertions) {
final Supplier<Object> supplier = new Supplier<Object>() {
@Override
public Object get() {
@@ -133,7 +155,31 @@ public class TestFrameworkAssertionsTest {
} catch (AssertionError e) {
Asserts.expectedFailureContains(e, Objects.toString(data), condition, expected.toString());
}
+ }
+ @Test(dataProvider = "negativeTestsDP")
+ public void negativeAbortTest(final Object data, String condition, Object expected, final List<Map<String, ?>> assertions) {
+ final Supplier<Object> supplier = new Supplier<Object>() {
+ @Override
+ public Object get() {
+ LOG.info("Supplier invoked for data [{}]", data);
+ return data;
+ }
+ };
+
+ // It should always try at least once, so we can use a very small timeout
+ Duration timeout = Duration.millis(1);
+
+ // The abort-condition should never hold, so it should always fail due to the timeout rather than
+ // aborting.
+ try {
+ TestFrameworkAssertions.checkAssertionsEventually(new AssertionOptions(Objects.toString(data), supplier)
+ .timeout(timeout).abortConditions(assertions)
+ .assertions(assertions));
+ Asserts.shouldHaveFailedPreviously();
+ } catch (AssertionError e) {
+ Asserts.expectedFailureContains(e, Objects.toString(data), condition, expected.toString());
+ }
}
@Test
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/3e1171f7/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestSensorTest.java
----------------------------------------------------------------------
diff --git a/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestSensorTest.java b/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestSensorTest.java
index 17435fe..d0a5ebc 100644
--- a/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestSensorTest.java
+++ b/test-framework/src/test/java/org/apache/brooklyn/test/framework/TestSensorTest.java
@@ -22,24 +22,31 @@ package org.apache.brooklyn.test.framework;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
import org.apache.brooklyn.api.entity.Entity;
import org.apache.brooklyn.api.entity.EntitySpec;
import org.apache.brooklyn.api.location.Location;
+import org.apache.brooklyn.api.sensor.AttributeSensor;
import org.apache.brooklyn.core.config.ConfigKeys;
import org.apache.brooklyn.core.entity.Attributes;
import org.apache.brooklyn.core.entity.Entities;
import org.apache.brooklyn.core.entity.EntityAsserts;
import org.apache.brooklyn.core.entity.lifecycle.Lifecycle;
import org.apache.brooklyn.core.sensor.AttributeSensorAndConfigKey;
+import org.apache.brooklyn.core.sensor.Sensors;
import org.apache.brooklyn.core.test.BrooklynAppUnitTestSupport;
import org.apache.brooklyn.core.test.entity.TestApplication;
+import org.apache.brooklyn.core.test.entity.TestEntity;
import org.apache.brooklyn.test.Asserts;
import org.apache.brooklyn.util.exceptions.Exceptions;
import org.apache.brooklyn.util.exceptions.PropagatedRuntimeException;
import org.apache.brooklyn.util.text.Identifiers;
import org.apache.brooklyn.util.time.Duration;
+import org.apache.brooklyn.util.time.Time;
import org.apache.commons.lang3.builder.ToStringBuilder;
+import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
@@ -57,47 +64,76 @@ public class TestSensorTest extends BrooklynAppUnitTestSupport {
private List<Location> locs = ImmutableList.of();
private String testId;
+ private ExecutorService executor;
@BeforeMethod(alwaysRun=true)
@Override
public void setUp() throws Exception {
super.setUp();
testId = Identifiers.makeRandomId(8);
+ executor = Executors.newCachedThreadPool();
}
+ @AfterMethod(alwaysRun=true)
+ @Override
+ public void tearDown() throws Exception {
+ if (executor != null) executor.shutdownNow();
+ super.tearDown();
+ }
+
@Test
public void testAssertEqual() throws Exception {
int testInteger = 100;
//Add Sensor Test for BOOLEAN sensor
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseBool = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, BOOLEAN_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newMapAssertion("equals", true)));
//Add Sensor Test for STRING sensor
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseStr = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, STRING_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newListAssertion("equals", testId)));
//Add Sensor Test for INTEGER sensor
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseInt = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, INTEGER_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newListAssertion("equals", testInteger)));
- //Set BOOLEAN Sensor to true
+ //Set sensors, so test-cases will immediately succeed
app.sensors().set(BOOLEAN_SENSOR, Boolean.TRUE);
-
- // Give a value to INTEGER sensor
app.sensors().set(INTEGER_SENSOR, testInteger);
-
- //Set STRING sensor to random string
app.sensors().set(STRING_SENSOR, testId);
app.start(locs);
+
+ assertTestSensorSucceeds(testCaseBool);
+ assertTestSensorSucceeds(testCaseStr);
+ assertTestSensorSucceeds(testCaseInt);
+ }
+ @Test
+ public void testAssertEqualsWhenSensorSetLater() throws Exception {
+ TestSensor testCase = app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ .configure(TestSensor.TIMEOUT, Asserts.DEFAULT_LONG_TIMEOUT)
+ .configure(TestSensor.TARGET_ENTITY, app)
+ .configure(TestSensor.SENSOR_NAME, STRING_SENSOR.getName())
+ .configure(TestSensor.ASSERTIONS, newListAssertion("equals", testId)));
+
+ // Wait long enough that we expect the assertion to have been attempted
+ executor.submit(new Runnable() {
+ public void run() {
+ Time.sleep(Duration.millis(250));
+ app.sensors().set(STRING_SENSOR, testId);
+ }});
+
+ app.start(locs);
+
+ assertTestSensorSucceeds(testCase);
}
+
@Test
public void testAssertEqualFailure() throws Exception {
//Add Sensor Test for BOOLEAN sensor
@@ -127,21 +163,23 @@ public class TestSensorTest extends BrooklynAppUnitTestSupport {
@Test
public void testAssertNull() throws Exception {
//Add Sensor Test for BOOLEAN sensor
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseBool = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, BOOLEAN_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newMapAssertion("isNull", true)));
//Add Sensor Test for STRING sensor
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseStr = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, STRING_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newListAssertion("notNull", true)));
- //Set STRING sensor to random string
+ //Set STRING sensor (to non-null); leave bool sensor as null
app.sensors().set(STRING_SENSOR, testId);
app.start(locs);
-
+
+ assertTestSensorSucceeds(testCaseBool);
+ assertTestSensorSucceeds(testCaseStr);
}
@@ -165,11 +203,11 @@ public class TestSensorTest extends BrooklynAppUnitTestSupport {
final String sensorValue = String.format("%s%s%s", Identifiers.makeRandomId(8), time, Identifiers.makeRandomId(8));
//Add Sensor Test for STRING sensor
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseStr = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, STRING_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newListAssertion("matches", String.format(".*%s.*", time))));
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseBool = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, BOOLEAN_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newMapAssertion("matches", "true")));
@@ -178,8 +216,10 @@ public class TestSensorTest extends BrooklynAppUnitTestSupport {
app.sensors().set(STRING_SENSOR, sensorValue);
app.sensors().set(BOOLEAN_SENSOR, true);
-
app.start(locs);
+
+ assertTestSensorSucceeds(testCaseStr);
+ assertTestSensorSucceeds(testCaseBool);
}
@Test
@@ -214,7 +254,7 @@ public class TestSensorTest extends BrooklynAppUnitTestSupport {
@Test
public void testAssertMatchesOnNonStringSensor() throws Exception {
//Add Sensor Test for OBJECT sensor
- app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ TestSensor testCaseObj = app.createAndManageChild(EntitySpec.create(TestSensor.class)
.configure(TestSensor.TARGET_ENTITY, app)
.configure(TestSensor.SENSOR_NAME, OBJECT_SENSOR.getName())
.configure(TestSensor.ASSERTIONS, newListAssertion("matches", ".*TestObject.*id=.*")));
@@ -222,7 +262,54 @@ public class TestSensorTest extends BrooklynAppUnitTestSupport {
app.sensors().set(OBJECT_SENSOR, new TestObject());
app.start(locs);
+
+ assertTestSensorSucceeds(testCaseObj);
+ }
+
+ @Test
+ public void testAbortsIfConditionSatisfied() throws Exception {
+ final AttributeSensor<Lifecycle> serviceStateSensor = Sensors.newSensor(Lifecycle.class,
+ "test.service.state", "Actual lifecycle state of the service (for testing)");
+
+ TestEntity entity = app.addChild(EntitySpec.create(TestEntity.class));
+
+ app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ .configure(TestSensor.TIMEOUT, Duration.ONE_MINUTE)
+ .configure(TestSensor.TARGET_ENTITY, entity)
+ .configure(TestSensor.SENSOR_NAME, serviceStateSensor.getName())
+ .configure(TestSensor.ASSERTIONS, newMapAssertion("equals", Lifecycle.RUNNING))
+ .configure(TestSensor.ABORT_CONDITIONS, newMapAssertion("equals", Lifecycle.ON_FIRE)));
+
+ entity.sensors().set(serviceStateSensor, Lifecycle.ON_FIRE);
+ assertStartFails(app, AbortError.class, Asserts.DEFAULT_LONG_TIMEOUT);
+ }
+ @Test
+ public void testDoesNotAbortIfConditionUnsatisfied() throws Exception {
+ final AttributeSensor<Lifecycle> serviceStateSensor = Sensors.newSensor(Lifecycle.class,
+ "test.service.state", "Actual lifecycle state of the service (for testing)");
+
+ final TestEntity entity = app.addChild(EntitySpec.create(TestEntity.class));
+
+ TestSensor testCase = app.createAndManageChild(EntitySpec.create(TestSensor.class)
+ .configure(TestSensor.TIMEOUT, Asserts.DEFAULT_LONG_TIMEOUT)
+ .configure(TestSensor.TARGET_ENTITY, entity)
+ .configure(TestSensor.SENSOR_NAME, serviceStateSensor.getName())
+ .configure(TestSensor.ASSERTIONS, newMapAssertion("equals", Lifecycle.RUNNING))
+ .configure(TestSensor.ABORT_CONDITIONS, newMapAssertion("equals", Lifecycle.ON_FIRE)));
+
+ // Set the state to running while we are starting (so that the abort-condition will have
+ // been checked).
+ entity.sensors().set(serviceStateSensor, Lifecycle.STARTING);
+ executor.submit(new Runnable() {
+ public void run() {
+ Time.sleep(Duration.millis(50));
+ entity.sensors().set(serviceStateSensor, Lifecycle.RUNNING);
+ }});
+
+ app.start(locs);
+
+ assertTestSensorSucceeds(testCase);
}
@Test
@@ -271,6 +358,15 @@ public class TestSensorTest extends BrooklynAppUnitTestSupport {
}
Entity entity = Iterables.find(Entities.descendantsWithoutSelf(app), Predicates.instanceOf(TestSensor.class));
+ assertTestSensorFails((TestSensor) entity);
+ }
+
+ protected void assertTestSensorSucceeds(TestSensor entity) {
+ EntityAsserts.assertAttributeEqualsEventually(entity, Attributes.SERVICE_STATE_ACTUAL, Lifecycle.RUNNING);
+ EntityAsserts.assertAttributeEqualsEventually(entity, Attributes.SERVICE_UP, true);
+ }
+
+ protected void assertTestSensorFails(TestSensor entity) {
EntityAsserts.assertAttributeEqualsEventually(entity, Attributes.SERVICE_STATE_ACTUAL, Lifecycle.ON_FIRE);
EntityAsserts.assertAttributeEqualsEventually(entity, Attributes.SERVICE_UP, false);
}
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/3e1171f7/utils/common/src/main/java/org/apache/brooklyn/util/exceptions/Exceptions.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/util/exceptions/Exceptions.java b/utils/common/src/main/java/org/apache/brooklyn/util/exceptions/Exceptions.java
index 2997f49..421cc15 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/util/exceptions/Exceptions.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/util/exceptions/Exceptions.java
@@ -182,6 +182,30 @@ public class Exceptions {
}
}
+ /**
+ * Indicates whether this exception is "fatal" - i.e. in normal programming, should not be
+ * caught but should instead be propagating so the call-stack fails. For example, an interrupt
+ * should cause the task to abort rather than catching and ignoring (or "handling" incorrectly).
+ */
+ public static boolean isFatal(Throwable throwable) {
+ return (throwable instanceof InterruptedException)
+ || (throwable instanceof RuntimeInterruptedException)
+ || (throwable instanceof Error);
+ }
+
+ public static Predicate<Throwable> isFatalPredicate() {
+ return IsFatalPredicate.INSTANCE;
+ }
+
+ private static class IsFatalPredicate implements Predicate<Throwable> {
+ private static final IsFatalPredicate INSTANCE = new IsFatalPredicate();
+
+ @Override
+ public boolean apply(Throwable input) {
+ return input != null && isFatal(input);
+ }
+ }
+
/** returns the first exception of the given type, or null */
@SuppressWarnings("unchecked")
public static <T extends Throwable> T getFirstThrowableOfType(Throwable from, Class<T> clazz) {
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/3e1171f7/utils/common/src/main/java/org/apache/brooklyn/util/repeat/Repeater.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/util/repeat/Repeater.java b/utils/common/src/main/java/org/apache/brooklyn/util/repeat/Repeater.java
index b1df990..9dfc9fb 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/util/repeat/Repeater.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/util/repeat/Repeater.java
@@ -28,11 +28,9 @@ import javax.annotation.Nullable;
import org.apache.brooklyn.util.exceptions.Exceptions;
import org.apache.brooklyn.util.exceptions.ReferenceWithError;
-import org.apache.brooklyn.util.repeat.Repeater;
import org.apache.brooklyn.util.time.CountdownTimer;
import org.apache.brooklyn.util.time.Duration;
import org.apache.brooklyn.util.time.Time;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -40,6 +38,7 @@ import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
import com.google.common.base.Stopwatch;
import com.google.common.util.concurrent.Callables;
@@ -83,7 +82,7 @@ public class Repeater implements Callable<Boolean> {
private Duration timeLimit = null;
private int iterationLimit = 0;
private boolean rethrowException = false;
- private boolean rethrowExceptionImmediately = false;
+ private Predicate<? super Throwable> rethrowImmediatelyCondition = Exceptions.isFatalPredicate();
private boolean warnOnUnRethrownException = true;
public Repeater() {
@@ -243,7 +242,12 @@ public class Repeater implements Callable<Boolean> {
* @return {@literal this} to aid coding in a fluent style.
*/
public Repeater rethrowExceptionImmediately() {
- this.rethrowExceptionImmediately = true;
+ this.rethrowImmediatelyCondition = Predicates.alwaysTrue();
+ return this;
+ }
+
+ public Repeater rethrowExceptionImmediately(Predicate<? super Throwable> val) {
+ this.rethrowImmediatelyCondition = checkNotNull(val, "rethrowExceptionImmediately predicate");
return this;
}
@@ -321,19 +325,19 @@ public class Repeater implements Callable<Boolean> {
try {
body.call();
- } catch (Exception e) {
+ } catch (Throwable e) {
log.warn(description, e);
- if (rethrowExceptionImmediately) throw Exceptions.propagate(e);
+ if (rethrowImmediatelyCondition.apply(e)) throw Exceptions.propagate(e);
}
boolean done = false;
try {
lastError = null;
done = exitCondition.call();
- } catch (Exception e) {
+ } catch (Throwable e) {
if (log.isDebugEnabled()) log.debug(description, e);
lastError = e;
- if (rethrowExceptionImmediately) throw Exceptions.propagate(e);
+ if (rethrowImmediatelyCondition.apply(e)) throw Exceptions.propagate(e);
}
if (done) {
if (log.isDebugEnabled()) log.debug("{}: condition satisfied", description);