/** * Equivalent to {@code map("map", f)}. * @see #map(String, Function3) */ default <R> Task<R> map(final Function3<T1, T2, T3, R> f) { return map("map: " + _taskDescriptor.getDescription(f.getClass().getName()), tuple -> f.apply(tuple._1(), tuple._2(), tuple._3())); }
@Test public void testBatchAndSingleton() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> Success.of(String.valueOf(key)), key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testBatchAndSingleton", task); assertEquals(result, "012"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchAndSingleton() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<>((key, promise) -> promise.done(String.valueOf(key)), key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestBatchingSupport.testBatchAndSingleton", task); assertEquals(result, "012"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchWithTimeoutAndSingleton() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> Success.of(String.valueOf(key)), key -> key % 2) { @Override public Task<Map<Integer, Try<String>>> taskForBatch(Integer group, Set<Integer> keys) { return super.taskForBatch(group, keys).flatMap(map -> delayedValue(map, 250, TimeUnit.MILLISECONDS)); } }; _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).withTimeout(10, TimeUnit.MILLISECONDS).recover("toExceptionName", e -> e.getClass().getName()), strategy.batchable(1), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testBatchWithTimeoutAndSingleton", task); assertEquals(result, "java.util.concurrent.TimeoutException12"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testEntriesMissingInReturnedMap() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> Success.of(String.valueOf(key)), key -> key % 2) { @Override public Task<Map<Integer, Try<String>>> taskForBatch(Integer group, Set<Integer> keys) { return super.taskForBatch(group, keys).andThen(map -> map.remove(1)); } }; _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).recover(e -> "missing"), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testEntriesMissingInReturnedMap", task); assertEquals(result, "0missing2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testPar3Dsc() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3)).map("test", (a, b, c) -> a + b + c); runAndWait("TestTaskFactoryMethods.testPar3Dsc", task); assertEquals((int)task.get(), 1 + 2 + 3); assertEquals(countTasks(task.getTrace()), 2 + 1 + 3); }
@Test public void testFailureReturned() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> { if (key % 2 == 1) { return Failure.of(new Exception("failure message")); } else { return Success.of(String.valueOf(key)); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).recover(e -> e.getMessage()), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testFailureReturned", task); assertEquals(result, "0failure message2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchAndFailedSingleton() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> { if (key % 2 == 0) { return Success.of(String.valueOf(key)); } else { return Failure.of(new Exception()); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).recover(e -> "failed"), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testBatchAndFailedSingleton", task); assertEquals(result, "0failed2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchAndFailedSingleton() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<>((key, promise) -> { if (key % 2 == 0) { promise.done(String.valueOf(key)); } else { promise.fail(new Exception()); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).recover(e -> "failed"), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestBatchingSupport.testBatchAndFailedSingleton", task); assertEquals(result, "0failed2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchAndSingletonWithTimeout() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> Success.of(String.valueOf(key)), key -> key % 2) { @Override public Task<Map<Integer, Try<String>>> taskForBatch(Integer group, Set<Integer> keys) { return super.taskForBatch(group, keys).flatMap(map -> delayedValue(map, 250, TimeUnit.MILLISECONDS)); } }; _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).withTimeout(10, TimeUnit.MILLISECONDS).recover("toExceptionName", e -> e.getClass().getName()), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testBatchAndSingletonWithTimeout", task); assertEquals(result, "0java.util.concurrent.TimeoutException2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchWithTimeoutAndSingleton() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<Integer, Integer, String>((key, promise) -> promise.done(String.valueOf(key)), key -> key % 2) { @Override public void executeBatch(final Integer group, final Batch<Integer, String> batch) { getScheduler().schedule(() -> { super.executeBatch(group, batch); }, 250, TimeUnit.MILLISECONDS); } }; _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).withTimeout(10, TimeUnit.MILLISECONDS).recover("toExceptionName", e -> e.getClass().getName()), strategy.batchable(1), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestBatchingSupport.testBatchWithTimeoutAndSingleton", task); assertEquals(result, "java.util.concurrent.TimeoutException12"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testPar3() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3)).map((a, b, c) -> a + b + c); runAndWait("TestTaskFactoryMethods.testPar3", task); assertEquals((int)task.get(), 1 + 2 + 3); assertEquals(countTasks(task.getTrace()), 2 + 1 + 3); }
@Test public void testFailedBatchAndSingleton() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> { if (key % 2 == 1) { return Success.of(String.valueOf(key)); } else { return Failure.of(new Exception()); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).recover(e -> "failed"), strategy.batchable(1), strategy.batchable(2).recover(e -> "failed")) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testFailedBatchAndSingleton", task); assertEquals(result, "failed1failed"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testExecuteBatchFailure() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<Integer, Integer, String>((key, promise) -> promise.done(String.valueOf(key)), key -> key % 2) { @Override public void executeBatch(Integer group, Batch<Integer, String> batch) { throw new RuntimeException(); } }; _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).recover(e -> "failed"), strategy.batchable(1).recover(e -> "failed"), strategy.batchable(2).recover(e -> "failed")) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestBatchingSupport.testExecuteBatchFailure", task); assertEquals(result, "failedfailedfailed"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 0); assertEquals(strategy.getExecutedSingletons().size(), 0); }
@Test public void testExecuteBatchFailure() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> Success.of(String.valueOf(key)), key -> key % 2) { @Override public Task<Map<Integer, Try<String>>> taskForBatch(Integer group, Set<Integer> keys) { throw new RuntimeException(); }; }; _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).recover(e -> "failed"), strategy.batchable(1).recover(e -> "failed"), strategy.batchable(2).recover(e -> "failed")) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testExecuteBatchFailure", task); assertEquals(result, "failedfailedfailed"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 0); assertEquals(strategy.getExecutedSingletons().size(), 0); }
@Test public void testBatchAndSingletonWithTimeout() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<Integer, Integer, String>((key, promise) -> promise.done(String.valueOf(key)), key -> key % 2) { @Override public void executeBatch(final Integer group, final Batch<Integer, String> batch) { getScheduler().schedule(() -> { super.executeBatch(group, batch); }, 250, TimeUnit.MILLISECONDS); } }; _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1).withTimeout(10, TimeUnit.MILLISECONDS).recover("toExceptionName", e -> e.getClass().getName()), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestBatchingSupport.testBatchAndSingletonWithTimeout", task); assertEquals(result, "0java.util.concurrent.TimeoutException2"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testFailedBatchAndSingleton() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<>((key, promise) -> { if (key % 2 == 1) { promise.done(String.valueOf(key)); } else { promise.fail(new Exception()); } }, key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).recover(e -> "failed"), strategy.batchable(1), strategy.batchable(2).recover(e -> "failed")) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestBatchingSupport.testFailedBatchAndSingleton", task); assertEquals(result, "failed1failed"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testBatchGet404() { try { setInboundRequestContext(new InboundRequestContextBuilder() .setName("withBatching") .build()); Task<?> task = Task.par(greetingGet(1L).map(Response::getEntity).map(Greeting::getMessage), greetingGet(2L).map(Response::getEntity).map(Greeting::getMessage), greetingGet(400L).map(Response::getEntity).map(Greeting::getMessage).recover(t -> t.toString())) .map((a, b, c) -> a + b + c); runAndWait(getTestClassName() + ".testBatchGet404", task); assertTrue(task.get().toString().contains("Good morning!")); assertTrue(task.get().toString().contains("Guten Morgen!")); assertTrue(task.get().toString().contains("com.linkedin.restli.client.RestLiResponseException: Response status 404")); } finally { clearInboundRequestContext(); } }
@Test public void testBatchGet404() { try { setInboundRequestContext(new InboundRequestContextBuilder() .setName("withBatching") .build()); Task<?> task = Task.par(greetingGet(1L).map(Response::getEntity).map(Greeting::getMessage), greetingGet(2L).map(Response::getEntity).map(Greeting::getMessage), greetingGet(400L).map(Response::getEntity).map(Greeting::getMessage).recover(t -> t.toString())) .map((a, b, c) -> a + b + c); runAndWait(getTestClassName() + ".testBatchGet404", task); assertTrue(task.get().toString().contains("Good morning!")); assertTrue(task.get().toString().contains("Guten Morgen!")); assertTrue(task.get().toString().contains("com.linkedin.restli.client.RestLiResponseException: Response status 404")); } finally { clearInboundRequestContext(); } } }
@Override protected void doRunExample(final Engine engine) throws Exception { final Task<String> google = fetchBody("http://www.google.com"); final Task<String> yahoo = fetchBody("http://www.yahoo.com"); final Task<String> bing = fetchBody("http://www.bing.com"); // final Task<String> plan = Task.par(google, yahoo, bing) // .map((g, y, b) -> "Google Page: " + g +" \n" + // "Yahoo Page: " + y + "\n" + // "Bing Page: " + b + "\n") // .andThen(System.out::println); final Task<Integer> sumLengths = Task.par(google.map(String::length), yahoo.map(String::length), bing.map(String::length)) .map("sum", (g, y, b) -> g + y + b); engine.run(sumLengths); sumLengths.await(); ExampleUtil.printTracingResults(sumLengths); } }