Skip to content

Commit 04db8d2

Browse files
bbakermanbbakerman
authored
Merge pull request #171 from AlexandreCarlton/parameterise-value-cache-dataloader-test
Parameterise more tests across DataLoader implementations
2 parents 3a0f976 + 47411a9 commit 04db8d2

10 files changed

+259
-183
lines changed

‎src/test/java/org/dataloader/DataLoaderTest.java

+44-63
Large diffs are not rendered by default.

‎src/test/java/org/dataloader/DataLoaderValueCacheTest.java

+59-46
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,13 @@
44
import com.github.benmanes.caffeine.cache.Caffeine;
55
import org.dataloader.fixtures.CaffeineValueCache;
66
import org.dataloader.fixtures.CustomValueCache;
7+
import org.dataloader.fixtures.parameterized.TestDataLoaderFactory;
78
import org.dataloader.impl.DataLoaderAssertionException;
8-
import org.junit.jupiter.api.Test;
9+
import org.junit.jupiter.params.ParameterizedTest;
10+
import org.junit.jupiter.params.provider.MethodSource;
911

1012
import java.util.ArrayList;
13+
import java.util.Collection;
1114
import java.util.List;
1215
import java.util.concurrent.CompletableFuture;
1316
import java.util.concurrent.TimeUnit;
@@ -18,7 +21,6 @@
1821
import static java.util.Collections.singletonList;
1922
import static org.awaitility.Awaitility.await;
2023
import static org.dataloader.DataLoaderOptions.newOptions;
21-
import static org.dataloader.fixtures.TestKit.idLoader;
2224
import static org.dataloader.fixtures.TestKit.snooze;
2325
import static org.dataloader.fixtures.TestKit.sort;
2426
import static org.dataloader.impl.CompletableFutureKit.failedFuture;
@@ -30,11 +32,12 @@
3032

3133
public class DataLoaderValueCacheTest {
3234

33-
@Test
34-
public void test_by_default_we_have_no_value_caching() {
35-
List<List<String>> loadCalls = new ArrayList<>();
35+
@ParameterizedTest
36+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
37+
public void test_by_default_we_have_no_value_caching(TestDataLoaderFactory factory) {
38+
List<Collection<String>> loadCalls = new ArrayList<>();
3639
DataLoaderOptions options = newOptions();
37-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
40+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
3841

3942
CompletableFuture<String> fA = identityLoader.load("a");
4043
CompletableFuture<String> fB = identityLoader.load("b");
@@ -64,12 +67,13 @@ public void test_by_default_we_have_no_value_caching() {
6467
assertThat(loadCalls, equalTo(emptyList()));
6568
}
6669

67-
@Test
68-
public void should_accept_a_remote_value_store_for_caching() {
70+
@ParameterizedTest
71+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
72+
public void should_accept_a_remote_value_store_for_caching(TestDataLoaderFactory factory) {
6973
CustomValueCache customValueCache = new CustomValueCache();
70-
List<List<String>> loadCalls = new ArrayList<>();
74+
List<Collection<String>> loadCalls = new ArrayList<>();
7175
DataLoaderOptions options = newOptions().setValueCache(customValueCache);
72-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
76+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
7377

7478
// Fetches as expected
7579

@@ -108,8 +112,9 @@ public void should_accept_a_remote_value_store_for_caching() {
108112
assertArrayEquals(customValueCache.store.keySet().toArray(), emptyList().toArray());
109113
}
110114

111-
@Test
112-
public void can_use_caffeine_for_caching() {
115+
@ParameterizedTest
116+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
117+
public void can_use_caffeine_for_caching(TestDataLoaderFactory factory) {
113118
//
114119
// Mostly to prove that some other CACHE library could be used
115120
// as the backing value cache. Not really Caffeine specific.
@@ -121,9 +126,9 @@ public void can_use_caffeine_for_caching() {
121126

122127
ValueCache<String, Object> caffeineValueCache = new CaffeineValueCache(caffeineCache);
123128

124-
List<List<String>> loadCalls = new ArrayList<>();
129+
List<Collection<String>> loadCalls = new ArrayList<>();
125130
DataLoaderOptions options = newOptions().setValueCache(caffeineValueCache);
126-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
131+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
127132

128133
// Fetches as expected
129134

@@ -148,8 +153,9 @@ public void can_use_caffeine_for_caching() {
148153
assertArrayEquals(caffeineCache.asMap().keySet().toArray(), asList("a", "b", "c").toArray());
149154
}
150155

151-
@Test
152-
public void will_invoke_loader_if_CACHE_GET_call_throws_exception() {
156+
@ParameterizedTest
157+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
158+
public void will_invoke_loader_if_CACHE_GET_call_throws_exception(TestDataLoaderFactory factory) {
153159
CustomValueCache customValueCache = new CustomValueCache() {
154160

155161
@Override
@@ -163,9 +169,9 @@ public CompletableFuture<Object> get(String key) {
163169
customValueCache.set("a", "Not From Cache");
164170
customValueCache.set("b", "From Cache");
165171

166-
List<List<String>> loadCalls = new ArrayList<>();
172+
List<Collection<String>> loadCalls = new ArrayList<>();
167173
DataLoaderOptions options = newOptions().setValueCache(customValueCache);
168-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
174+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
169175

170176
CompletableFuture<String> fA = identityLoader.load("a");
171177
CompletableFuture<String> fB = identityLoader.load("b");
@@ -178,8 +184,9 @@ public CompletableFuture<Object> get(String key) {
178184
assertThat(loadCalls, equalTo(singletonList(singletonList("a"))));
179185
}
180186

181-
@Test
182-
public void will_still_work_if_CACHE_SET_call_throws_exception() {
187+
@ParameterizedTest
188+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
189+
public void will_still_work_if_CACHE_SET_call_throws_exception(TestDataLoaderFactory factory) {
183190
CustomValueCache customValueCache = new CustomValueCache() {
184191
@Override
185192
public CompletableFuture<Object> set(String key, Object value) {
@@ -190,9 +197,9 @@ public CompletableFuture<Object> set(String key, Object value) {
190197
}
191198
};
192199

193-
List<List<String>> loadCalls = new ArrayList<>();
200+
List<Collection<String>> loadCalls = new ArrayList<>();
194201
DataLoaderOptions options = newOptions().setValueCache(customValueCache);
195-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
202+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
196203

197204
CompletableFuture<String> fA = identityLoader.load("a");
198205
CompletableFuture<String> fB = identityLoader.load("b");
@@ -206,8 +213,9 @@ public CompletableFuture<Object> set(String key, Object value) {
206213
assertArrayEquals(customValueCache.store.keySet().toArray(), singletonList("b").toArray());
207214
}
208215

209-
@Test
210-
public void caching_can_take_some_time_complete() {
216+
@ParameterizedTest
217+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
218+
public void caching_can_take_some_time_complete(TestDataLoaderFactory factory) {
211219
CustomValueCache customValueCache = new CustomValueCache() {
212220

213221
@Override
@@ -228,9 +236,9 @@ public CompletableFuture<Object> get(String key) {
228236
};
229237

230238

231-
List<List<String>> loadCalls = new ArrayList<>();
239+
List<Collection<String>> loadCalls = new ArrayList<>();
232240
DataLoaderOptions options = newOptions().setValueCache(customValueCache);
233-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
241+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
234242

235243
CompletableFuture<String> fA = identityLoader.load("a");
236244
CompletableFuture<String> fB = identityLoader.load("b");
@@ -247,8 +255,9 @@ public CompletableFuture<Object> get(String key) {
247255
assertThat(loadCalls, equalTo(singletonList(asList("missC", "missD"))));
248256
}
249257

250-
@Test
251-
public void batch_caching_works_as_expected() {
258+
@ParameterizedTest
259+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
260+
public void batch_caching_works_as_expected(TestDataLoaderFactory factory) {
252261
CustomValueCache customValueCache = new CustomValueCache() {
253262

254263
@Override
@@ -269,9 +278,9 @@ public CompletableFuture<List<Try<Object>>> getValues(List<String> keys) {
269278
};
270279

271280

272-
List<List<String>> loadCalls = new ArrayList<>();
281+
List<Collection<String>> loadCalls = new ArrayList<>();
273282
DataLoaderOptions options = newOptions().setValueCache(customValueCache);
274-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
283+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
275284

276285
CompletableFuture<String> fA = identityLoader.load("a");
277286
CompletableFuture<String> fB = identityLoader.load("b");
@@ -293,8 +302,9 @@ public CompletableFuture<List<Try<Object>>> getValues(List<String> keys) {
293302
assertThat(values, equalTo(asList("missC", "missD")));
294303
}
295304

296-
@Test
297-
public void assertions_will_be_thrown_if_the_cache_does_not_follow_contract() {
305+
@ParameterizedTest
306+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
307+
public void assertions_will_be_thrown_if_the_cache_does_not_follow_contract(TestDataLoaderFactory factory) {
298308
CustomValueCache customValueCache = new CustomValueCache() {
299309

300310
@Override
@@ -312,9 +322,9 @@ public CompletableFuture<List<Try<Object>>> getValues(List<String> keys) {
312322
}
313323
};
314324

315-
List<List<String>> loadCalls = new ArrayList<>();
325+
List<Collection<String>> loadCalls = new ArrayList<>();
316326
DataLoaderOptions options = newOptions().setValueCache(customValueCache);
317-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
327+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
318328

319329
CompletableFuture<String> fA = identityLoader.load("a");
320330
CompletableFuture<String> fB = identityLoader.load("b");
@@ -335,8 +345,9 @@ private boolean isAssertionException(CompletableFuture<String> fA) {
335345
}
336346

337347

338-
@Test
339-
public void if_caching_is_off_its_never_hit() {
348+
@ParameterizedTest
349+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
350+
public void if_caching_is_off_its_never_hit(TestDataLoaderFactory factory) {
340351
AtomicInteger getCalls = new AtomicInteger();
341352
CustomValueCache customValueCache = new CustomValueCache() {
342353

@@ -347,9 +358,9 @@ public CompletableFuture<Object> get(String key) {
347358
}
348359
};
349360

350-
List<List<String>> loadCalls = new ArrayList<>();
361+
List<Collection<String>> loadCalls = new ArrayList<>();
351362
DataLoaderOptions options = newOptions().setValueCache(customValueCache).setCachingEnabled(false);
352-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
363+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
353364

354365
CompletableFuture<String> fA = identityLoader.load("a");
355366
CompletableFuture<String> fB = identityLoader.load("b");
@@ -368,8 +379,9 @@ public CompletableFuture<Object> get(String key) {
368379
assertTrue(customValueCache.asMap().isEmpty());
369380
}
370381

371-
@Test
372-
public void if_everything_is_cached_no_batching_happens() {
382+
@ParameterizedTest
383+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
384+
public void if_everything_is_cached_no_batching_happens(TestDataLoaderFactory factory) {
373385
AtomicInteger getCalls = new AtomicInteger();
374386
AtomicInteger setCalls = new AtomicInteger();
375387
CustomValueCache customValueCache = new CustomValueCache() {
@@ -390,9 +402,9 @@ public CompletableFuture<List<Object>> setValues(List<String> keys, List<Object>
390402
customValueCache.asMap().put("b", "cachedB");
391403
customValueCache.asMap().put("c", "cachedC");
392404

393-
List<List<String>> loadCalls = new ArrayList<>();
405+
List<Collection<String>> loadCalls = new ArrayList<>();
394406
DataLoaderOptions options = newOptions().setValueCache(customValueCache).setCachingEnabled(true);
395-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
407+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
396408

397409
CompletableFuture<String> fA = identityLoader.load("a");
398410
CompletableFuture<String> fB = identityLoader.load("b");
@@ -410,8 +422,9 @@ public CompletableFuture<List<Object>> setValues(List<String> keys, List<Object>
410422
}
411423

412424

413-
@Test
414-
public void if_batching_is_off_it_still_can_cache() {
425+
@ParameterizedTest
426+
@MethodSource("org.dataloader.fixtures.parameterized.TestDataLoaderFactories#getWithoutPublisher")
427+
public void if_batching_is_off_it_still_can_cache(TestDataLoaderFactory factory) {
415428
AtomicInteger getCalls = new AtomicInteger();
416429
AtomicInteger setCalls = new AtomicInteger();
417430
CustomValueCache customValueCache = new CustomValueCache() {
@@ -430,9 +443,9 @@ public CompletableFuture<List<Object>> setValues(List<String> keys, List<Object>
430443
};
431444
customValueCache.asMap().put("a", "cachedA");
432445

433-
List<List<String>> loadCalls = new ArrayList<>();
446+
List<Collection<String>> loadCalls = new ArrayList<>();
434447
DataLoaderOptions options = newOptions().setValueCache(customValueCache).setCachingEnabled(true).setBatchingEnabled(false);
435-
DataLoader<String, String> identityLoader = idLoader(options, loadCalls);
448+
DataLoader<String, String> identityLoader = factory.idLoader(options, loadCalls);
436449

437450
CompletableFuture<String> fA = identityLoader.load("a");
438451
CompletableFuture<String> fB = identityLoader.load("b");

‎src/test/java/org/dataloader/fixtures/TestKit.java

-30
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,6 @@
88
import org.dataloader.MappedBatchLoader;
99
import org.dataloader.MappedBatchLoaderWithContext;
1010

11-
import java.time.Duration;
1211
import java.util.ArrayList;
1312
import java.util.Arrays;
1413
import java.util.Collection;
@@ -61,43 +60,14 @@ public static <K, V> BatchLoader<K, V> keysAsValues(List<List<K>> loadCalls) {
6160
};
6261
}
6362

64-
public static <K, V> BatchLoader<K, V> keysAsValuesAsync(Duration delay) {
65-
return keysAsValuesAsync(new ArrayList<>(), delay);
66-
}
67-
68-
public static <K, V> BatchLoader<K, V> keysAsValuesAsync(List<List<K>> loadCalls, Duration delay) {
69-
return keys -> CompletableFuture.supplyAsync(() -> {
70-
snooze(delay.toMillis());
71-
List<K> ks = new ArrayList<>(keys);
72-
loadCalls.add(ks);
73-
@SuppressWarnings("unchecked")
74-
List<V> values = keys.stream()
75-
.map(k -> (V) k)
76-
.collect(toList());
77-
return values;
78-
});
79-
}
80-
8163
public static <K, V> DataLoader<K, V> idLoader() {
8264
return idLoader(null, new ArrayList<>());
8365
}
8466

85-
public static <K, V> DataLoader<K, V> idLoader(List<List<K>> loadCalls) {
86-
return idLoader(null, loadCalls);
87-
}
88-
8967
public static <K, V> DataLoader<K, V> idLoader(DataLoaderOptions options, List<List<K>> loadCalls) {
9068
return DataLoaderFactory.newDataLoader(keysAsValues(loadCalls), options);
9169
}
9270

93-
public static <K, V> DataLoader<K, V> idLoaderAsync(Duration delay) {
94-
return idLoaderAsync(null, new ArrayList<>(), delay);
95-
}
96-
97-
public static <K, V> DataLoader<K, V> idLoaderAsync(DataLoaderOptions options, List<List<K>> loadCalls, Duration delay) {
98-
return DataLoaderFactory.newDataLoader(keysAsValuesAsync(loadCalls, delay), options);
99-
}
100-
10171
public static Collection<Integer> listFrom(int i, int max) {
10272
List<Integer> ints = new ArrayList<>();
10373
for (int j = i; j < max; j++) {

‎src/test/java/org/dataloader/fixtures/parameterized/ListDataLoaderFactory.java

+11
Original file line numberDiff line numberDiff line change
@@ -4,9 +4,11 @@
44
import org.dataloader.DataLoaderOptions;
55
import org.dataloader.fixtures.TestKit;
66

7+
import java.time.Duration;
78
import java.util.ArrayList;
89
import java.util.Collection;
910
import java.util.List;
11+
import java.util.concurrent.CompletableFuture;
1012
import java.util.stream.Collectors;
1113

1214
import static java.util.concurrent.CompletableFuture.completedFuture;
@@ -21,6 +23,15 @@ public <K> DataLoader<K, K> idLoader(DataLoaderOptions options, List<Collection<
2123
}, options);
2224
}
2325

26+
@Override
27+
public <K> DataLoader<K, K> idLoaderDelayed(DataLoaderOptions options, List<Collection<K>> loadCalls, Duration delay) {
28+
return newDataLoader(keys -> CompletableFuture.supplyAsync(() -> {
29+
TestKit.snooze(delay.toMillis());
30+
loadCalls.add(new ArrayList<>(keys));
31+
return keys;
32+
}));
33+
}
34+
2435
@Override
2536
public <K> DataLoader<K, K> idLoaderBlowsUps(
2637
DataLoaderOptions options, List<Collection<K>> loadCalls) {

‎src/test/java/org/dataloader/fixtures/parameterized/MappedDataLoaderFactory.java

+16
Original file line numberDiff line numberDiff line change
@@ -2,15 +2,19 @@
22

33
import org.dataloader.DataLoader;
44
import org.dataloader.DataLoaderOptions;
5+
import org.dataloader.fixtures.TestKit;
56

7+
import java.time.Duration;
68
import java.util.ArrayList;
79
import java.util.Collection;
810
import java.util.HashMap;
911
import java.util.List;
1012
import java.util.Map;
13+
import java.util.concurrent.CompletableFuture;
1114
import java.util.stream.Collectors;
1215

1316
import static java.util.concurrent.CompletableFuture.completedFuture;
17+
import static org.dataloader.DataLoaderFactory.newDataLoader;
1418
import static org.dataloader.DataLoaderFactory.newMappedDataLoader;
1519
import static org.dataloader.fixtures.TestKit.futureError;
1620

@@ -27,6 +31,18 @@ public <K> DataLoader<K, K> idLoader(
2731
}, options);
2832
}
2933

34+
@Override
35+
public <K> DataLoader<K, K> idLoaderDelayed(
36+
DataLoaderOptions options, List<Collection<K>> loadCalls, Duration delay) {
37+
return newMappedDataLoader(keys -> CompletableFuture.supplyAsync(() -> {
38+
TestKit.snooze(delay.toMillis());
39+
loadCalls.add(new ArrayList<>(keys));
40+
Map<K, K> map = new HashMap<>();
41+
keys.forEach(k -> map.put(k, k));
42+
return map;
43+
}));
44+
}
45+
3046
@Override
3147
public <K> DataLoader<K, K> idLoaderBlowsUps(DataLoaderOptions options, List<Collection<K>> loadCalls) {
3248
return newMappedDataLoader((keys) -> {

0 commit comments

Comments
 (0)