Signal/Signal-Server
1
0
Fork 0
mirror of https://github.com/signalapp/Signal-Server synced 2026-04-21 10:38:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

Record experiment outcomes with timers instead of counters.

Browse Source
This commit is contained in:
Jon Chambers
2020-08-18 18:14:57 -04:00
committed by Jon Chambers
parent 7e8974683c
commit 56b27ea785
2 changed files with 78 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
service/src/test/java/org/whispersystems/textsecuregcm/experiment/ExperimentTest.java
View File

@@ -1,13 +1,12 @@
package org.whispersystems.textsecuregcm.experiment;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.Timer;
import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
@@ -16,50 +15,51 @@ import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(JUnitParamsRunner.class)
public class ExperimentTest {
private Counter matchCounter;
private Counter errorCounter;
private Timer matchTimer;
private Timer errorTimer;
private Experiment experiment;
@Before
public void setUp() {
matchCounter = mock(Counter.class);
errorCounter = mock(Counter.class);
matchTimer = mock(Timer.class);
errorTimer = mock(Timer.class);
experiment = new Experiment("test", matchCounter, errorCounter, mock(Counter.class), mock(Counter.class), mock(Counter.class));
experiment = new Experiment("test", matchTimer, errorTimer, mock(Timer.class), mock(Timer.class), mock(Timer.class));
}
@Test
public void compareFutureResult() {
experiment.compareFutureResult(12, CompletableFuture.completedFuture(12));
verify(matchCounter).increment();
verify(matchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
}
@Test
public void compareFutureResultError() {
experiment.compareFutureResult(12, CompletableFuture.failedFuture(new RuntimeException("OH NO")));
verify(errorCounter).increment();
verify(errorTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
}
@Test
public void compareSupplierResultMatch() {
experiment.compareSupplierResult(12, () -> 12);
verify(matchCounter).increment();
verify(matchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
}
@Test
public void compareSupplierResultError() {
experiment.compareSupplierResult(12, () -> { throw new RuntimeException("OH NO"); });
verify(errorCounter).increment();
verify(errorTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
}
@Test
@@ -70,7 +70,7 @@ public class ExperimentTest {
experimentExecutor.shutdown();
experimentExecutor.awaitTermination(1, TimeUnit.SECONDS);
verify(matchCounter).increment();
verify(matchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
}
@Test
@@ -81,7 +81,7 @@ public class ExperimentTest {
experimentExecutor.shutdown();
experimentExecutor.awaitTermination(1, TimeUnit.SECONDS);
verify(errorCounter).increment();
verify(errorTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
}
@Test
@@ -90,38 +90,40 @@ public class ExperimentTest {
doThrow(new RejectedExecutionException()).when(executorService).execute(any(Runnable.class));
experiment.compareSupplierResultAsync(12, () -> 12, executorService);
verify(errorCounter).increment();
verify(errorTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
}
@Test
@Parameters(method = "argumentsForTestRecordResult")
public void testRecordResult(final Object expected, final Object actual, final Experiment experiment, final Counter expectedCounter) {
reset(expectedCounter);
public void testRecordResult(final Object expected, final Object actual, final Experiment experiment, final Timer expectedTimer) {
reset(expectedTimer);
experiment.recordResult(expected, actual);
verify(expectedCounter).increment();
final long durationNanos = 123;
experiment.recordResult(expected, actual, durationNanos);
verify(expectedTimer).record(durationNanos, TimeUnit.NANOSECONDS);
}
@SuppressWarnings("unused")
private Object argumentsForTestRecordResult() {
// Hack: parameters are set before the @Before method gets called
final Counter matchCounter = mock(Counter.class);
final Counter errorCounter = mock(Counter.class);
final Counter bothPresentMismatchCounter = mock(Counter.class);
final Counter controlNullMismatchCounter = mock(Counter.class);
final Counter experimentNullMismatchCounter = mock(Counter.class);
final Timer matchTimer = mock(Timer.class);
final Timer errorTimer = mock(Timer.class);
final Timer bothPresentMismatchTimer = mock(Timer.class);
final Timer controlNullMismatchTimer = mock(Timer.class);
final Timer experimentNullMismatchTimer = mock(Timer.class);
final Experiment experiment = new Experiment("test", matchCounter, errorCounter, bothPresentMismatchCounter, controlNullMismatchCounter, experimentNullMismatchCounter);
final Experiment experiment = new Experiment("test", matchTimer, errorTimer, bothPresentMismatchTimer, controlNullMismatchTimer, experimentNullMismatchTimer);
return new Object[] {
new Object[] { 12, 12, experiment, matchCounter },
new Object[] { null, 12, experiment, controlNullMismatchCounter },
new Object[] { 12, null, experiment, experimentNullMismatchCounter },
new Object[] { 12, 17, experiment, bothPresentMismatchCounter },
new Object[] { Optional.of(12), Optional.of(12), experiment, matchCounter },
new Object[] { Optional.empty(), Optional.of(12), experiment, controlNullMismatchCounter },
new Object[] { Optional.of(12), Optional.empty(), experiment, experimentNullMismatchCounter },
new Object[] { Optional.of(12), Optional.of(17), experiment, bothPresentMismatchCounter }
new Object[] { 12, 12, experiment, matchTimer },
new Object[] { null, 12, experiment, controlNullMismatchTimer },
new Object[] { 12, null, experiment, experimentNullMismatchTimer },
new Object[] { 12, 17, experiment, bothPresentMismatchTimer },
new Object[] { Optional.of(12), Optional.of(12), experiment, matchTimer },
new Object[] { Optional.empty(), Optional.of(12), experiment, controlNullMismatchTimer },
new Object[] { Optional.of(12), Optional.empty(), experiment, experimentNullMismatchTimer },
new Object[] { Optional.of(12), Optional.of(17), experiment, bothPresentMismatchTimer }
};
}
}