X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Futils%2FTransactionRateLimiterTest.java;h=5c7cdc6789774a51997c4e09bbc724c50de61593;hp=2c89716487acf1d03bfe2bca3ff342a99a11d7c4;hb=24ee386f244cafa9bd3126ddbba1435969aa76c2;hpb=3b0499cd187bcdeda057465350d381c8bc28847c diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TransactionRateLimiterTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TransactionRateLimiterTest.java index 2c89716487..5c7cdc6789 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TransactionRateLimiterTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TransactionRateLimiterTest.java @@ -5,79 +5,73 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.controller.cluster.datastore.utils; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.greaterThan; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; + import com.codahale.metrics.Snapshot; import com.codahale.metrics.Timer; +import com.google.common.base.Stopwatch; +import java.time.Duration; import java.util.concurrent.TimeUnit; -import org.apache.commons.lang3.time.StopWatch; import org.hamcrest.BaseMatcher; import org.hamcrest.Description; import org.hamcrest.Matcher; import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.controller.cluster.datastore.DatastoreContext; +// FIXME: use Strict runner +@RunWith(MockitoJUnitRunner.Silent.class) public class TransactionRateLimiterTest { - @Mock - public ActorContext actorContext; - + public ActorUtils actorUtils; @Mock public DatastoreContext datastoreContext; - @Mock public Timer commitTimer; - @Mock private Timer.Context commitTimerContext; - @Mock private Snapshot commitSnapshot; @Before - public void setUp(){ - MockitoAnnotations.initMocks(this); - doReturn(datastoreContext).when(actorContext).getDatastoreContext(); + public void setUp() { + doReturn(datastoreContext).when(actorUtils).getDatastoreContext(); doReturn(30).when(datastoreContext).getShardTransactionCommitTimeoutInSeconds(); doReturn(100L).when(datastoreContext).getTransactionCreationInitialRateLimit(); - doReturn(commitTimer).when(actorContext).getOperationTimer("commit"); + doReturn(commitTimer).when(actorUtils).getOperationTimer("commit"); doReturn(commitTimerContext).when(commitTimer).time(); doReturn(commitSnapshot).when(commitTimer).getSnapshot(); } @Test - public void testAcquireRateLimitChanged(){ - for(int i=1;i<11;i++){ + public void testAcquireRateLimitChanged() { + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(i) * 1D).when(commitSnapshot).getValue(i * 0.1); } - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); rateLimiter.acquire(); assertThat(rateLimiter.getTxCreationLimit(), approximately(292)); - assertEquals(147, rateLimiter.getPollOnCount()); } - @Test - public void testAcquirePercentileValueZero(){ - - for(int i=1;i<11;i++){ + public void testAcquirePercentileValueZero() { + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(i) * 1D).when(commitSnapshot).getValue(i * 0.1); @@ -85,19 +79,16 @@ public class TransactionRateLimiterTest { doReturn(TimeUnit.MILLISECONDS.toNanos(0) * 1D).when(commitSnapshot).getValue(0.1); - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); rateLimiter.acquire(); assertThat(rateLimiter.getTxCreationLimit(), approximately(192)); - assertEquals(97, rateLimiter.getPollOnCount()); } @Test - public void testAcquireOnePercentileValueVeryHigh(){ - - for(int i=1;i<11;i++){ + public void testAcquireOnePercentileValueVeryHigh() { + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(i) * 1D).when(commitSnapshot).getValue(i * 0.1); @@ -106,38 +97,33 @@ public class TransactionRateLimiterTest { // ten seconds doReturn(TimeUnit.MILLISECONDS.toNanos(10000) * 1D).when(commitSnapshot).getValue(1.0); - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); rateLimiter.acquire(); assertThat(rateLimiter.getTxCreationLimit(), approximately(282)); - assertEquals(142, rateLimiter.getPollOnCount()); } @Test - public void testAcquireWithAllPercentileValueVeryHigh(){ + public void testAcquireWithAllPercentileValueVeryHigh() { - for(int i=1;i<11;i++){ + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(10000) * 1D).when(commitSnapshot).getValue(i * 0.1); } - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); rateLimiter.acquire(); // The initial rate limit will be retained here because the calculated rate limit was too small assertThat(rateLimiter.getTxCreationLimit(), approximately(100)); - assertEquals(1, rateLimiter.getPollOnCount()); } @Test - public void testAcquireWithRealPercentileValues(){ - - for(int i=1;i<11;i++){ + public void testAcquireWithRealPercentileValues() { + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(8) * 1D).when(commitSnapshot).getValue(i * 0.1); @@ -147,20 +133,16 @@ public class TransactionRateLimiterTest { doReturn(TimeUnit.MILLISECONDS.toNanos(100) * 1D).when(commitSnapshot).getValue(0.9); doReturn(TimeUnit.MILLISECONDS.toNanos(200) * 1D).when(commitSnapshot).getValue(1.0); - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); rateLimiter.acquire(); assertThat(rateLimiter.getTxCreationLimit(), approximately(101)); - assertEquals(51, rateLimiter.getPollOnCount()); } - - @Test - public void testAcquireGetRateLimitFromOtherDataStores(){ - for(int i=1;i<11;i++){ + public void testAcquireGetRateLimitFromOtherDataStores() { + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(0.0D).when(commitSnapshot).getValue(i * 0.1); @@ -170,41 +152,35 @@ public class TransactionRateLimiterTest { Timer.Context operationalCommitTimerContext = mock(Timer.Context.class); Snapshot operationalCommitSnapshot = mock(Snapshot.class); - doReturn(operationalCommitTimer).when(actorContext).getOperationTimer("operational", "commit"); + doReturn(operationalCommitTimer).when(actorUtils).getOperationTimer("operational", "commit"); doReturn(operationalCommitTimerContext).when(operationalCommitTimer).time(); doReturn(operationalCommitSnapshot).when(operationalCommitTimer).getSnapshot(); - for(int i=1;i<11;i++){ + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(i) * 1D).when(operationalCommitSnapshot).getValue(i * 0.1); } - DatastoreContext.getGlobalDatastoreTypes().add("config"); - DatastoreContext.getGlobalDatastoreTypes().add("operational"); - - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); + DatastoreContext.getGlobalDatastoreNames().add("config"); + DatastoreContext.getGlobalDatastoreNames().add("operational"); + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); rateLimiter.acquire(); assertThat(rateLimiter.getTxCreationLimit(), approximately(292)); - assertEquals(147, rateLimiter.getPollOnCount()); } @Test - public void testRateLimiting(){ - - for(int i=1;i<11;i++){ + public void testRateLimiting() { + for (int i = 1; i < 11; i++) { doReturn(TimeUnit.SECONDS.toNanos(1) * 1D).when(commitSnapshot).getValue(i * 0.1); } - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - - StopWatch watch = new StopWatch(); - - watch.start(); + final TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); + final Stopwatch watch = Stopwatch.createStarted(); rateLimiter.acquire(); rateLimiter.acquire(); @@ -212,14 +188,13 @@ public class TransactionRateLimiterTest { watch.stop(); - assertTrue("did not take as much time as expected rate limit : " + rateLimiter.getTxCreationLimit(), - watch.getTime() > 1000); + assertThat("did not take as much time as expected rate limit : " + rateLimiter.getTxCreationLimit(), + watch.elapsed(), greaterThan(Duration.ofSeconds(1))); } @Test - public void testRateLimitNotCalculatedUntilPollCountReached(){ - - for(int i=1;i<11;i++){ + public void testRateLimitNotCalculatedUntilPollCountReached() { + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(8) * 1D).when(commitSnapshot).getValue(i * 0.1); @@ -229,15 +204,13 @@ public class TransactionRateLimiterTest { doReturn(TimeUnit.MILLISECONDS.toNanos(100) * 1D).when(commitSnapshot).getValue(0.9); doReturn(TimeUnit.MILLISECONDS.toNanos(200) * 1D).when(commitSnapshot).getValue(1.0); - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); rateLimiter.acquire(); assertThat(rateLimiter.getTxCreationLimit(), approximately(101)); - assertEquals(51, rateLimiter.getPollOnCount()); - for(int i=0;i<49;i++){ + for (int i = 0; i < 49; i++) { rateLimiter.acquire(); } @@ -250,9 +223,8 @@ public class TransactionRateLimiterTest { } @Test - public void testAcquireNegativeAcquireAndPollOnCount(){ - - for(int i=1;i<11;i++){ + public void testAcquireNegativeAcquireAndPollOnCount() { + for (int i = 1; i < 11; i++) { // Keep on increasing the amount of time it takes to complete transaction for each tenth of a // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on. doReturn(TimeUnit.MILLISECONDS.toNanos(8) * 1D).when(commitSnapshot).getValue(i * 0.1); @@ -262,38 +234,33 @@ public class TransactionRateLimiterTest { doReturn(TimeUnit.MILLISECONDS.toNanos(100) * 1D).when(commitSnapshot).getValue(0.9); doReturn(TimeUnit.MILLISECONDS.toNanos(200) * 1D).when(commitSnapshot).getValue(1.0); - TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorContext); - rateLimiter.setAcquireCount(Long.MAX_VALUE-1); + TransactionRateLimiter rateLimiter = new TransactionRateLimiter(actorUtils); + rateLimiter.setAcquireCount(Long.MAX_VALUE - 1); rateLimiter.setPollOnCount(Long.MAX_VALUE); - rateLimiter.acquire(); assertThat(rateLimiter.getTxCreationLimit(), approximately(101)); - assertEquals(-9223372036854775759L, rateLimiter.getPollOnCount()); - for(int i=0;i<50;i++){ + for (int i = 0; i < 50; i++) { rateLimiter.acquire(); } verify(commitTimer, times(2)).getSnapshot(); - } - public Matcher approximately(final double val){ - return new BaseMatcher() { + public Matcher approximately(final double val) { + return new BaseMatcher<>() { @Override - public boolean matches(Object o) { - Double aDouble = (Double) o; - return aDouble >= val && aDouble <= val+1; + public boolean matches(final Object obj) { + Double value = (Double) obj; + return value >= val && value <= val + 1; } @Override - public void describeTo(Description description) { - description.appendText("> " + val +" < " + (val+1)); + public void describeTo(final Description description) { + description.appendText("> " + val + " < " + (val + 1)); } }; } - - -} \ No newline at end of file +}