/** * Equivalent to {@code async("async", callable)}. * @see #async(String, Callable) */ public static <T> Task<T> async(final Callable<Promise<? extends T>> callable) { return async("async: " + _taskDescriptor.getDescription(callable.getClass().getName()), callable); }
Task<Map<Long, Try<String>>> batchGet(Collection<Long> keys) { return Task.callable("batchGet", () -> keys.stream().collect(Collectors.toMap(Function.identity(), key -> Success.of(Long.toString(key))))); } }
@Test public void testPar15Dsc() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3), Task.value(4), Task.value(5), Task.value(6), Task.value(7), Task.value(8), Task.value(9), Task.value(10), Task.value(11), Task.value(12), Task.value(13), Task.value(14), Task.value(15)) .map("test", (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> a + b + c + d + e + f + g + h + i + j + k + l + m + n + o); runAndWait("TestTaskFactoryMethods.testPar15Dsc", task); assertEquals((int)task.get(), 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15); assertEquals(countTasks(task.getTrace()), 2 + 1 + 15); }
@Test public void testWithTimeoutTwiceSuccess() { Task<Integer> success = getSuccessTask().andThen(delayedValue(0, 30, TimeUnit.MILLISECONDS)) .withTimeout(100, TimeUnit.MILLISECONDS).withTimeout(5000, TimeUnit.MILLISECONDS); runAndWait("AbstractTaskTest.testWithTimeoutTwiceSuccess", success); assertEquals((int) success.get(), 0); assertEquals(countTasks(success.getTrace()), 7); }
@Test public void testGetRequestsWithError() { Task<String> task = Task.par(toMessage(greetingGet(1L)), toMessage(greetingGet(-1L)).recover(e -> "failed")) .map("combine", (x, y) -> x + y); runAndWait(getTestClassName() + ".testGetRequestsWithError", task); assertEquals(task.get(), "Good morning!failed"); if (expectBatching()) { assertTrue(hasTask("greetings batch_get(reqs: 2, ids: 2)", task.getTrace())); } else { assertFalse(hasTask("greetings batch_get(reqs: 2, ids: 2)", task.getTrace())); } }
@Test public void testTraceWithPredecessorTrace() throws InterruptedException { final Task<String> predecessor = value("predecessor", "predecessorValue"); final Task<String> successor = value("successor", "successorValue"); final Task<?> seq = predecessor.andThen(successor); runAndWait("TestTaskToTrace.testTraceWithPredecessorTrace", seq); verifyShallowTrace(successor); verifyShallowTrace(predecessor); assertEquals(predecessor.getTrace(), successor.getTrace()); //expected relationship: PARENT_OF and SUCCESSOR_OF assertEquals(2, getRelationships(successor.getTrace(), successor.getId()).size()); assertTrue(successor.getTrace().getRelationships() .contains(new TraceRelationship(successor.getShallowTraceBuilder(), predecessor.getShallowTraceBuilder(), Relationship.SUCCESSOR_OF))); }
public void testRecoverWithRecoverd(int expectedNumberOfTasks) { Task<String> recovered = getFailureTask().recoverWith(e -> Task.callable("recover success", () -> "recovered")); runAndWait("AbstractTaskTest.testRecoverWithRecoverd", recovered); assertEquals(recovered.get(), "recovered"); assertEquals(countTasks(recovered.getTrace()), expectedNumberOfTasks); }
public void testCancelledRecover(int expectedNumberOfTasks) { Task<Integer> cancelled = getCancelledTask().map("strlen", String::length).recover(e -> -1); try { runAndWait("AbstractTaskTest.testCancelledRecover", cancelled); fail("should have failed"); } catch (Exception ex) { assertTrue(cancelled.isFailed()); assertTrue(Exceptions.isCancellation(cancelled.getError())); } assertEquals(countTasks(cancelled.getTrace()), expectedNumberOfTasks); }
@Test public void testLastTaskAlreadyResolvedShareable() { final AtomicInteger counter = new AtomicInteger(); final Task<String> bob = Task.value("bob", "bob"); runAndWait("TestTaskReuse.testLastTaskAlreadyResolvedShareable-bob", bob); Task<String> task = Task.callable("increaser", () -> { counter.incrementAndGet(); return "hello"; } ); Task<String> test1 = task.andThen(bob.shareable()); runAndWait("TestTaskReuse.testLastTaskAlreadyResolvedShareable", test1); assertEquals(counter.get(), 1); }
@Test public void testWithTimeoutTwiceFailure() { Task<Integer> failure = getSuccessTask().andThen(delayedValue(0, 2000, TimeUnit.MILLISECONDS)) .withTimeout(5000, TimeUnit.MILLISECONDS).withTimeout(100, TimeUnit.MILLISECONDS); try { runAndWait("AbstractTaskTest.testWithTimeoutTwiceFailure", failure); fail("should have failed!"); } catch (Exception ex) { assertEquals(ex.getCause().getClass(), Exceptions.TIMEOUT_EXCEPTION.getClass()); } assertEquals(countTasks(failure.getTrace()), 7); }
public void testRecover(int expectedNumberOfTasks) { Task<Integer> success = getSuccessTask().map("strlen", String::length).recover(e -> -1); runAndWait("AbstractTaskTest.testRecoverSuccess", success); assertEquals((int) success.get(), TASK_VALUE.length()); assertEquals(countTasks(success.getTrace()), expectedNumberOfTasks); Task<Integer> failure = getFailureTask().map("strlen", String::length).recover(e -> -1); runAndWait("AbstractTaskTest.testRecoverFailure", failure); assertEquals((int) failure.get(), -1); assertEquals(countTasks(failure.getTrace()), expectedNumberOfTasks); }
public void testRecoverWithCancelled(int expectedNumberOfTasks) { Task<String> cancelled = getCancelledTask().recoverWith(e -> Task.callable("recover success", () -> "recovered")); try { runAndWait("AbstractTaskTest.testRecoverWithCancelled", cancelled); fail("should have failed"); } catch (Exception ex) { assertTrue(cancelled.isFailed()); assertTrue(Exceptions.isCancellation(cancelled.getError())); } assertEquals(countTasks(cancelled.getTrace()), expectedNumberOfTasks); }
public void testFlatMap(int expectedNumberOfTasks) { Task<String> task = getSuccessTask().flatMap(str -> Task.callable("strlenstr", () -> String.valueOf(str.length()))); runAndWait("AbstractTaskTest.testFlatMap", task); assertEquals(task.get(), String.valueOf(TASK_VALUE.length())); assertEquals(countTasks(task.getTrace()), expectedNumberOfTasks); }
@Test public void testWithTimeoutTaskType() { Task<?> taskWithTimeout = Task.value("test").withTimeout(50, TimeUnit.MILLISECONDS); runAndWait("taskWithTimeoutTaskType", taskWithTimeout); assertEquals(doesTaskTypeExistInTrace(taskWithTimeout.getTrace(), TaskType.TIMEOUT.getName()), true); Assert.assertEquals(taskWithTimeout.getShallowTrace().getTaskType(), TaskType.WITH_TIMEOUT.getName()); }
@Test public void testFlatMapTaskType() { Task<String> task = Task.value("Welcome"); Task<String> flatMap = task.flatMap("+earth", s -> Task.callable(() -> s + " on earth!")); runAndWait("flatMapTaskType", flatMap); assertEquals(flatMap.getShallowTrace().getTaskType(), TaskType.FLATTEN.getName()); }
@Test public void testAsyncWithContext() { final Task<String> t = Task.callable(() -> "done"); Task<String> task = Task.async(ctx -> { ctx.run(t); return t; }); String value = runAndWait("TestTaskFactoryMethods.testAsyncWithContext", task); assertEquals(value, "done"); assertEquals(countTasks(task.getTrace()), 2); }