/** * Equivalent to {@code map("map", func)}. * @see #map(String, Function1) */ default <R> Task<R> map(final Function1<? super T, ? extends R> func) { return map("map: " + _taskDescriptor.getDescription(func.getClass().getName()), func); }
@Test public void testWithTimeoutAsLastOperation() { Task<String> task = delayedValue("value", 250, TimeUnit.MILLISECONDS).map(x -> x + 1).map(x -> TASK_VALUE) .withTimeout(5, TimeUnit.MILLISECONDS); try { runAndWait("TestFusionTask.testWithTimeoutAsLastOperation", task); fail("should have failed!"); } catch (Exception ex) { assertSame(ex.getCause().getClass(), Exceptions.TIMEOUT_EXCEPTION.getClass()); } }
@Test public void testWithTimeoutAsMiddleOperation() { Task<String> task = delayedValue("value", 250, TimeUnit.MILLISECONDS).map("first", x -> x + 3) .withTimeout(5, TimeUnit.MILLISECONDS).map("second", x -> TASK_VALUE); try { runAndWait("TestFusionTask.testWithTimeoutAsMiddleOperation", task); fail("should have failed!"); } catch (Exception ex) { assertSame(ex.getCause().getClass(), Exceptions.TIMEOUT_EXCEPTION.getClass()); } }
@Test public void testMap1() { Task<Integer> task = Task.value("value", 1).map("m1", x -> x); runAndWait("FusionTaskTraceTest.testMap1", task); }
public void testNoRecover(int expectedNumberOfTasks) { Task<Integer> task = getFailureTask().map("strlen", String::length); try { runAndWait("AbstractTaskTest.testNoRecover", task); fail("should have failed"); } catch (Exception ex) { assertEquals(ex.getCause().getMessage(), TASK_ERROR_MESSAGE); } assertEquals(countTasks(task.getTrace()), expectedNumberOfTasks); }
public void testFlattenTaskReturnNulll() { Function1<String, Task<String>> func = s -> null; Task<String> task = Task.flatten(getSuccessTask().map(func)); runAndWaitException("AbstractTaskTest.testFlattenTaskReturnNulll", task, RuntimeException.class); assertTrue(task.getError().getMessage().contains("returned null")); }
public void testMap(int expectedNumberOfTasks) { Task<Integer> task = getSuccessTask().map(String::length); runAndWait("AbstractTaskTest.testMap", task); assertTrue(task.isDone()); assertEquals((int) task.get(), TASK_VALUE.length()); assertEquals(countTasks(task.getTrace()), expectedNumberOfTasks); }
@Test public void testSingleGetRequestIsNotBatchedWithProjection() { Task<Boolean> task = greetingGetWithProjection(1L, Greeting.fields().tone()).map(Response::getEntity).map(Greeting::hasMessage); runAndWait(getTestClassName() + ".testSingleGetRequestIsNotBatchedWithProjection", task); assertFalse(hasTask("greetings batch_get(reqs: 1, ids: 1)", task.getTrace())); assertFalse(task.get()); }
@Test public void testAsyncMap1() { Task<Integer> task = Task.async("value", () -> { SettablePromise<Integer> p = Promises.settable(); p.done(1); return p; }).map("m1", x -> x); runAndWait("FusionTaskTraceTest.testAsyncMa1p", task); }
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 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); }
public void testToTry(int expectedNumberOfTasks) { Task<Try<Integer>> success = getSuccessTask().map("strlen", String::length).toTry(); runAndWait("AbstractTaskTest.testToTrySuccess", success); assertFalse(success.get().isFailed()); assertEquals((int) success.get().get(), TASK_VALUE.length()); assertEquals(countTasks(success.getTrace()), expectedNumberOfTasks); Task<Try<Integer>> failure = getFailureTask().map("strlen", String::length).toTry(); runAndWait("AbstractTaskTest.testToTryFailure", failure); assertTrue(failure.get().isFailed()); assertEquals(failure.get().getError().getMessage(), TASK_ERROR_MESSAGE); assertEquals(countTasks(failure.getTrace()), expectedNumberOfTasks); }