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

Return to just using counters instead of timers for measuring experiment outcomes.

Browse Source
This commit is contained in:
Jon Chambers
2020-06-17 14:41:42 -04:00
committed by Jon Chambers
parent 4c1844e46a
commit 6adcebb247
2 changed files with 52 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,95 +1,92 @@
package org.whispersystems.textsecuregcm.experiment;
import io.micrometer.core.instrument.Timer;
import io.micrometer.core.instrument.Counter;
import org.junit.Before;
import org.junit.Test;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
public class ExperimentTest {
private Timer matchTimer;
private Timer errorTimer;
private Timer bothPresentMismatchTimer;
private Timer controlNullMismatchTimer;
private Timer experimentNullMismatchTimer;
private Counter matchCounter;
private Counter errorCounter;
private Counter bothPresentMismatchCounter;
private Counter controlNullMismatchCounter;
private Counter experimentNullMismatchCounter;
private Experiment experiment;
@Before
public void setUp() {
matchTimer = mock(Timer.class);
errorTimer = mock(Timer.class);
bothPresentMismatchTimer = mock(Timer.class);
controlNullMismatchTimer = mock(Timer.class);
experimentNullMismatchTimer = mock(Timer.class);
matchCounter = mock(Counter.class);
errorCounter = mock(Counter.class);
bothPresentMismatchCounter = mock(Counter.class);
controlNullMismatchCounter = mock(Counter.class);
experimentNullMismatchCounter = mock(Counter.class);
experiment = new Experiment(matchTimer, errorTimer, bothPresentMismatchTimer, controlNullMismatchTimer, experimentNullMismatchTimer);
experiment = new Experiment(matchCounter, errorCounter, bothPresentMismatchCounter, controlNullMismatchCounter, experimentNullMismatchCounter);
}
@Test
public void compareFutureResultMatch() {
experiment.compareFutureResult(12, CompletableFuture.completedFuture(12));
verify(matchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(matchCounter).increment();
}
@Test
public void compareFutureResultMismatchBothPresent() {
experiment.compareFutureResult(12, CompletableFuture.completedFuture(77));
verify(bothPresentMismatchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(bothPresentMismatchCounter).increment();
}
@Test
public void compareFutureResultMismatchControlNull() {
experiment.compareFutureResult(null, CompletableFuture.completedFuture(77));
verify(controlNullMismatchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(controlNullMismatchCounter).increment();
}
@Test
public void compareFutureResultMismatchExperimentNull() {
experiment.compareFutureResult(12, CompletableFuture.completedFuture(null));
verify(experimentNullMismatchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(experimentNullMismatchCounter).increment();
}
@Test
public void compareFutureResultError() {
experiment.compareFutureResult(12, CompletableFuture.failedFuture(new RuntimeException("OH NO")));
verify(errorTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(errorCounter).increment();
}
@Test
public void compareSupplierResultMatch() {
experiment.compareSupplierResult(12, () -> 12);
verify(matchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(matchCounter).increment();
}
@Test
public void compareSupplierResultMismatchBothPresent() {
experiment.compareSupplierResult(12, () -> 77);
verify(bothPresentMismatchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(bothPresentMismatchCounter).increment();
}
@Test
public void compareSupplierResultMismatchControlNull() {
experiment.compareSupplierResult(null, () -> 77);
verify(controlNullMismatchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(controlNullMismatchCounter).increment();
}
@Test
public void compareSupplierResultMismatchExperimentNull() {
experiment.compareSupplierResult(12, () -> null);
verify(experimentNullMismatchTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(experimentNullMismatchCounter).increment();
}
@Test
public void compareSupplierResultError() {
experiment.compareSupplierResult(12, () -> { throw new RuntimeException("OH NO"); });
verify(errorTimer).record(anyLong(), eq(TimeUnit.NANOSECONDS));
verify(errorCounter).increment();
}
}