public static <T> void assertAttributeEqualsContinually(Map<?,?> flags, final Entity entity, final AttributeSensor<T> attribute, final T expected) { Asserts.succeedsContinually(flags, new Runnable() { @Override public void run() { assertAttributeEquals(entity, attribute, expected); }}); }
private void assertEventValuesEqualsContinually(final RecordingSensorEventListener<Object> listener, final List<?> expectedVals) { Asserts.succeedsContinually(new Runnable() { @Override public void run() { assertEventValuesEquals(listener, expectedVals); }}); }
private void assertFeedIsPollingContinuously() { Asserts.succeedsContinually(new Runnable() { @Override public void run() { assertFeedIsPolling(); } }); }
public static <T> void succeedsContinually(Map<?,?> flags, Runnable r) { succeedsContinually(flags, toCallable(r)); }
private void assertNoEventsContinually() { Asserts.succeedsContinually(new Runnable() { @Override public void run() { assertTrue(events.isEmpty(), "events="+events); }}); } }
protected void assertSizeContinually(final List<?> actual, final int expected, Duration duration) { Asserts.succeedsContinually(ImmutableMap.of("timeout", duration), new Runnable() { @Override public void run() { assertEquals(actual.size(), expected, "actual="+actual); }}); }
protected void assertSizeContinually(final int targetSize, final int quarantineSize, final int deletedSize) { Asserts.succeedsContinually(ImmutableMap.of("timeout", SHORT_WAIT_MS), new Runnable() { @Override public void run() { assertSize(targetSize, quarantineSize); assertEquals(entitiesRemoved.size(), deletedSize, "removed="+entitiesRemoved); }}); } }
private void assertNoEventsContinually(Duration duration) { Asserts.succeedsContinually(ImmutableMap.of("timeout", duration), new Runnable() { @Override public void run() { assertTrue(events.isEmpty(), "events="+events); }}); }
private void assertNotDoneContinually(final Task<?> t) { Asserts.succeedsContinually(ImmutableMap.of("timeout", SHORT_WAIT_MS), new Callable<Void>() { @Override public Void call() throws Exception { if (t.isDone()) { fail("task unexpectedly done: t="+t+"; result="+t.get()); } return null; } }); }
private void assertRecordsContinually(final RecordingMembershipTrackingPolicy policy, final Record... expected) { Asserts.succeedsContinually(ImmutableMap.of("timeout", 100), new Runnable() { @Override public void run() { assertEquals(policy.records, ImmutableList.copyOf(expected), "actual="+policy.records); }}); }
private void assertStateContinually(final Entity entity, final Lifecycle expectedState, final Lifecycle state, final Boolean isUp) { Asserts.succeedsContinually(ImmutableMap.of("timeout", Duration.millis(50)), new Runnable() { @Override public void run() { assertState(entity, expectedState, state, isUp); }}); }
protected void assertItemDistributionContinually(final Map<MockContainerEntity, Collection<MockItemEntity>> expected) { try { Asserts.succeedsContinually(MutableMap.of("timeout", SHORT_WAIT_MS), new Runnable() { @Override public void run() { assertItemDistribution(expected); }}); } catch (AssertionError e) { String errMsg = e.getMessage()+"; "+verboseDumpToString(); throw new RuntimeException(errMsg, e); } }
public void run() { int size1 = getCallHistoryCount(entity, effector); Asserts.succeedsContinually(ImmutableMap.of("timeout", Duration.millis(100)), new Runnable() { public void run() { int size2 = getCallHistoryCount(entity, effector); assertEquals(size1, size2); }}); }}); }
@Test(groups={"Integration"}) public void testIgnoresAddressWithoutGeography() throws Exception { System.setProperty(BrooklynSystemProperties.HOST_GEO_LOOKUP_IMPL.getPropertyName(), StubHostGeoLookup.class.getName()); geoDns.config().set(GeoscalingDnsService.INCLUDE_HOMELESS_ENTITIES, false); // false is default app.start(ImmutableList.of(locWithoutGeo)); target.sensors().set(Attributes.HOSTNAME, StubHostGeoLookup.HOMELESS_IP); LOG.info("geo-scaling test, using {}.{}; expect not to be wired to {}", new Object[] {subDomain, primaryDomain, addrWithoutGeo}); Asserts.succeedsContinually(MutableMap.of("timeout", 10*1000), new Runnable() { @Override public void run() { assertEquals(geoDns.getTargetHosts().size(), 0, "targets="+geoDns.getTargetHosts()); } }); }
@Test public void testSubscriptionNotReceivesInitialValueEventsByDefault() { observedEntity.sensors().set(TestEntity.SEQUENCE, 123); observedEntity.sensors().set(TestEntity.NAME, "myname"); entity.subscriptions().subscribe(observedEntity, TestEntity.SEQUENCE, listener); entity.subscriptions().subscribe(observedEntity, TestEntity.NAME, listener); Asserts.succeedsContinually(ImmutableMap.of("timeout", SHORT_WAIT_MS), new Runnable() { @Override public void run() { assertEquals(listener.getEvents(), ImmutableList.of()); }}); }
@Test public void testSubscriptionNotReceivesInitialValueEventsByDefault() { entity.sensors().set(TestEntity.SEQUENCE, 123); entity.sensors().set(TestEntity.NAME, "myname"); policy.subscriptions().subscribe(entity, TestEntity.SEQUENCE, listener); policy.subscriptions().subscribe(entity, TestEntity.NAME, listener); Asserts.succeedsContinually(ImmutableMap.of("timeout", SHORT_WAIT_MS), new Runnable() { @Override public void run() { assertEquals(listener.getEvents(), ImmutableList.of()); }}); }
@Test public void testUnmanagedGroupIgnoresComingAndGoingsOfEntities() { group.setEntityFilter(Predicates.instanceOf(TestEntity.class)); assertEqualsIgnoringOrder(group.getMembers(), ImmutableSet.of(e1, e2)); Entities.unmanage(group); @SuppressWarnings("unused") Entity e3 = app.addChild(EntitySpec.create(TestEntity.class)); Asserts.succeedsContinually(MutableMap.of("timeout", VERY_SHORT_WAIT_MS), new Runnable() { @Override public void run() { assertEqualsIgnoringOrder(ImmutableSet.copyOf(group.getMembers()), ImmutableSet.of(e1, e2)); }}); }
@Test public void testModifyAttributeReturningAbsentDoesNotEmit() throws Exception { AttributeSensor<Integer> sensor = Sensors.newIntegerSensor("a", ""); AttributeSensor<Integer> childSensor = Sensors.newIntegerSensor("a.b", ""); final RecordingSensorEventListener<Object> listener = new RecordingSensorEventListener<>(); entityImpl.subscriptions().subscribe(entityImpl, sensor, listener); map.modify(childSensor, Functions.constant(Maybe.<Integer>absent())); Asserts.succeedsContinually(new Runnable() { @Override public void run() { assertTrue(Iterables.isEmpty(listener.getEvents()), "events="+listener.getEvents()); }}); }
@Test public void testPostSuspendActions() { tc.resize(1); AutoScalerPolicy policy = tc.policies().add(AutoScalerPolicy.builder() .metric(MY_ATTRIBUTE) .metricLowerBound(50) .metricUpperBound(100) .buildSpec()); policy.suspend(); tc.sensors().set(MY_ATTRIBUTE, 100000); Asserts.succeedsContinually(ImmutableMap.of("timeout", SHORT_WAIT_MS), currentSizeAsserter(tc, 1)); }
@Test public void testDecrementsSizeIffLowerBoundExceeded() { tc.resize(2); tc.policies().add(AutoScalerPolicy.builder() .metric(MY_ATTRIBUTE) .metricLowerBound(50) .metricUpperBound(100) .buildSpec()); tc.sensors().set(MY_ATTRIBUTE, 50); Asserts.succeedsContinually(ImmutableMap.of("timeout", SHORT_WAIT_MS), currentSizeAsserter(tc, 2)); tc.sensors().set(MY_ATTRIBUTE, 49); Asserts.succeedsEventually(currentSizeAsserter(tc, 1)); }