Instrumentatin support for dataloader - better tests

Author: bbakerman

src/test/java/org/dataloader/fixtures/Stopwatch.java

@@ -0,0 +1,57 @@
+package org.dataloader.fixtures;
+
+import java.time.Duration;
+
+public class Stopwatch {
+
+    public static Stopwatch stopwatchStarted() {
+        return new Stopwatch().start();
+    }
+
+    public static Stopwatch stopwatchUnStarted() {
+        return new Stopwatch();
+    }
+
+    private long started = -1;
+    private long stopped = -1;
+
+    public Stopwatch start() {
+        synchronized (this) {
+            if (started != -1) {
+                throw new IllegalStateException("You have started it before");
+            }
+            started = System.currentTimeMillis();
+        }
+        return this;
+    }
+
+    private Stopwatch() {
+    }
+
+    public long elapsed() {
+        synchronized (this) {
+            if (started == -1) {
+                throw new IllegalStateException("You haven't started it");
+            }
+            if (stopped == -1) {
+                return System.currentTimeMillis() - started;
+            } else {
+                return stopped - started;
+            }
+        }
+    }
+
+    public Duration duration() {
+        return Duration.ofMillis(elapsed());
+    }
+
+    public Duration stop() {
+        synchronized (this) {
+            if (started != -1) {
+                throw new IllegalStateException("You have started it");
+            }
+            stopped = System.currentTimeMillis();
+            return duration();
+        }
+    }
+}

src/test/java/org/dataloader/instrumentation/DataLoaderInstrumentationTest.java

@@ -6,13 +6,14 @@
 import org.dataloader.DataLoaderFactory;
 import org.dataloader.DataLoaderOptions;
 import org.dataloader.DispatchResult;
+import org.dataloader.fixtures.Stopwatch;
 import org.dataloader.fixtures.TestKit;
 import org.junit.jupiter.api.Test;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
 import static org.awaitility.Awaitility.await;
@@ -30,20 +31,19 @@ class DataLoaderInstrumentationTest {
 
     @Test
     void canMonitorDispatching() {
-        AtomicLong timer = new AtomicLong();
+        Stopwatch stopwatch = Stopwatch.stopwatchUnStarted();
         AtomicReference<DataLoader<?, ?>> dlRef = new AtomicReference<>();
 
         DataLoaderInstrumentation instrumentation = new DataLoaderInstrumentation() {
 
             @Override
             public DataLoaderInstrumentationContext<DispatchResult<?>> beginDispatch(DataLoader<?, ?> dataLoader) {
                 dlRef.set(dataLoader);
-
-                long then = System.currentTimeMillis();
+                stopwatch.start();
                 return new DataLoaderInstrumentationContext<>() {
                     @Override
                     public void onCompleted(DispatchResult<?> result, Throwable t) {
-                        timer.set(System.currentTimeMillis() - then);
+                        stopwatch.stop();
                     }
                 };
             }
@@ -54,24 +54,32 @@ public DataLoaderInstrumentationContext<List<?>> beginBatchLoader(DataLoader<?,
             }
         };
 
-        DataLoaderOptions options = new DataLoaderOptions().setInstrumentation(instrumentation).setMaxBatchSize(5);
+        DataLoaderOptions options = new DataLoaderOptions()
+                .setInstrumentation(instrumentation)
+                .setMaxBatchSize(5);
 
         DataLoader<String, String> dl = DataLoaderFactory.newDataLoader(snoozingBatchLoader, options);
 
+        List<String> keys = new ArrayList<>();
         for (int i = 0; i < 20; i++) {
-             dl.load("X"+ i);
+            String key = "X" + i;
+            keys.add(key);
+            dl.load(key);
         }
 
         CompletableFuture<List<String>> dispatch = dl.dispatch();
 
         await().until(dispatch::isDone);
-        assertThat(timer.get(), greaterThan(150L)); // we must have called batch load 4 times
+        // we must have called batch load 4 times at 100ms snooze  per call
+        // but its in parallel via supplyAsync
+        assertThat(stopwatch.elapsed(), greaterThan(75L));
         assertThat(dlRef.get(), is(dl));
+        assertThat(dispatch.join(), equalTo(keys));
     }
 
     @Test
     void canMonitorBatchLoading() {
-        AtomicLong timer = new AtomicLong();
+        Stopwatch stopwatch = Stopwatch.stopwatchUnStarted();
         AtomicReference<BatchLoaderEnvironment> beRef = new AtomicReference<>();
         AtomicReference<DataLoader<?, ?>> dlRef = new AtomicReference<>();
 
@@ -82,11 +90,11 @@ public DataLoaderInstrumentationContext<List<?>> beginBatchLoader(DataLoader<?,
                 dlRef.set(dataLoader);
                 beRef.set(environment);
 
-                long then = System.currentTimeMillis();
+                stopwatch.start();
                 return new DataLoaderInstrumentationContext<>() {
                     @Override
                     public void onCompleted(List<?> result, Throwable t) {
-                        timer.set(System.currentTimeMillis() - then);
+                        stopwatch.stop();
                     }
                 };
             }
@@ -95,13 +103,13 @@ public void onCompleted(List<?> result, Throwable t) {
         DataLoaderOptions options = new DataLoaderOptions().setInstrumentation(instrumentation);
         DataLoader<String, String> dl = DataLoaderFactory.newDataLoader(snoozingBatchLoader, options);
 
-        dl.load("A");
-        dl.load("B");
+        dl.load("A", "kcA");
+        dl.load("B", "kcB");
 
         CompletableFuture<List<String>> dispatch = dl.dispatch();
 
         await().until(dispatch::isDone);
-        assertThat(timer.get(), greaterThan(50L));
+        assertThat(stopwatch.elapsed(), greaterThan(50L));
         assertThat(dlRef.get(), is(dl));
         assertThat(beRef.get().getKeyContexts().keySet(), equalTo(Set.of("A", "B")));
     }