private ShallowTrace findPossiblyFusedTrace(final Task<?> task) { final ShallowTrace main = task.getShallowTrace(); if (main.getName().equals("fused")) { final Trace trace = task.getTrace(); Optional<Long> child = trace.getRelationships().stream() .map(rel -> getChild(rel, main.getId())) .filter(id-> id != null) .findFirst(); if (child.isPresent()) { return trace.getTraceMap().get(child.get()); } } return main; }
@Test public void testUnfinishedTrace() throws InterruptedException { // Used to ensure that the task has started running final CountDownLatch cdl = new CountDownLatch(1); final SettablePromise<Void> promise = Promises.settable(); final Task<Void> task = new BaseTask<Void>() { @Override public Promise<Void> run(final Context context) throws Exception { cdl.countDown(); // Return a promise that won't be satisfied until after out test return promise; } }; getEngine().run(task); assertTrue(cdl.await(5, TimeUnit.SECONDS)); logTracingResults("TestTaskToTrace.testUnfinishedTrace", task); verifyShallowTrace(task); // Finish task promise.done(null); }
@SuppressWarnings("deprecation") @Test public void testTraceWithSuccessChild() throws InterruptedException { final Task<String> task = value("taskName", "value"); final Task<?> seq = Tasks.seq(Arrays.asList(task)); runAndWait("TestTaskToTrace.testTraceWithSuccessChild", seq); verifyShallowTrace(task); verifyShallowTrace(seq); assertEquals(1, getRelationships(seq.getTrace(), seq.getId()).size()); assertTrue(seq.getTrace().getRelationships() .contains(new TraceRelationship(seq.getShallowTraceBuilder(), task.getShallowTraceBuilder(), Relationship.PARENT_OF))); }
@Test public void testSuccessfulTrace() throws InterruptedException { final Task<String> task = value("taskName", "value"); runAndWait("TestTaskToTrace.testSuccessfulTrace", task); verifyShallowTrace(task); }
runAndWait("TestTaskToTrace.testTraceWithMultiplePotentialParentsPar", par); assertAndFindParent(par.getTrace(), tasksWithParent, tasksWithPotentialParent); assertEquals(2, tasksWithParent.size()); assertEquals((Integer) 2, tasksWithPotentialParent.get(innerTask.getId())); assertTrue(tasksWithParent.contains(task1.getId())); assertTrue(tasksWithParent.contains(task2.getId())); verifyShallowTrace(task1); verifyShallowTrace(task2); verifyShallowTrace(innerTask); assertEquals(ResultType.EARLY_FINISH, innerTask.getTrace().getTraceMap().get(innerTask.getId()).getResultType());
@Test public void testTraceWithEarlyFinish() throws InterruptedException { final Task<String> innerTask = value("xyz"); final Task<String> task = new BaseTask<String>() { @Override protected Promise<? extends String> run(final Context context) throws Exception { // We kick off a task that won't finish before the containing task // (this task) is finished. context.run(innerTask); return Promises.value("value"); } }; runAndWait("TestTaskToTrace.testTraceWithEarlyFinish", task); assertEquals(1, getRelationships(task.getTrace(), task.getId()).size()); assertTrue(task.getTrace().getRelationships() .contains(new TraceRelationship(task.getShallowTraceBuilder(), innerTask.getShallowTraceBuilder(), Relationship.POTENTIAL_PARENT_OF))); assertEquals(ResultType.EARLY_FINISH, task.getTrace().getTraceMap().get(innerTask.getId()).getResultType()); }
@Test public void testTraceIsAddedBeforeAwaitCompletes() throws InterruptedException { for (int i = 0; i < 100; i++) { final Task<String> innerTask = value("xyz"); final Task<String> task = new BaseTask<String>() { @Override protected Promise<? extends String> run(final Context context) throws Exception { // We kick off a task that won't finish before the containing task // (this task) is finished. context.run(innerTask); return Promises.value("value"); } }; runAndWait("TestTaskToTrace.testTraceIsAddedBeforeAwaitCompletes", task); assertTrue(task.getTrace().getRelationships().size() > 0); } }
@Test public void testUnstartedTrace() { final Task<?> task = value("taskName", "value"); // We don't run the task verifyShallowTrace(task); }
private void verifyShallowTrace(final Task<?> task) { final ShallowTrace trace = findPossiblyFusedTrace(task); assertEquals(task.getName(), trace.getName()); assertEquals(ResultType.fromTask(task), trace.getResultType());
runAndWait("TestTaskToTrace.testTraceWithMultiplePotentialParentsSeq", seq); assertAndFindParent(seq.getTrace(), tasksWithParent, tasksWithPotentialParent); assertTrue(tasksWithParent.contains(task2.getId())); assertTrue(tasksWithParent.contains(task3.getId())); verifyShallowTrace(task1); verifyShallowTrace(task2); verifyShallowTrace(task3); verifyShallowTrace(innerTask); assertEquals(ResultType.EARLY_FINISH, innerTask.getTrace().getTraceMap().get(innerTask.getId()).getResultType());
@Test public void testSuccessfulTraceWithNullValue() throws InterruptedException { final Task<String> task = value("taskName", null); runAndWait("TestTaskToTrace.testSuccessfulTraceWithNullValue", task); verifyShallowTrace(task); }
@Test public void testNotHiddenTrace() throws InterruptedException { final Task<String> task1 = new BaseTask<String>() { @Override protected Promise<? extends String> run(Context context) throws Exception { return Promises.value("task1"); } }; final Task<String> task2 = new BaseTask<String>() { @Override protected Promise<? extends String> run(Context context) throws Exception { return Promises.value("task2"); } }; final Task<?> par1 = Task.par(task1, task2); runAndWait("TestTaskToTrace.testNotHiddenTrace", par1); assertFalse(par1.getShallowTrace().getHidden()); assertFalse(task1.getShallowTrace().getHidden()); assertFalse(task1.getShallowTrace().getHidden()); }
@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))); }
@Test public void testErrorTrace() throws InterruptedException { final Exception exception = new Exception("error message"); final Task<?> task = Task.failure("taskName", exception); try { runAndWait("TestTaskToTrace.testErrorTrace", task); fail("task should finish with Exception"); } catch (Throwable t) { assertEquals(exception, task.getError()); } verifyShallowTrace(task); }
@Test public void testUserHiddenTrace() throws InterruptedException { final Task<String> task1 = new BaseTask<String>() { @Override protected Promise<? extends String> run(Context context) throws Exception { return Promises.value("task1"); } @Override public ShallowTrace getShallowTrace() { _shallowTraceBuilder.setHidden(true); return super.getShallowTrace(); } }; final Task<String> task2 = new BaseTask<String>() { @Override protected Promise<? extends String> run(Context context) throws Exception { return Promises.value("task2"); } @Override public ShallowTrace getShallowTrace() { _shallowTraceBuilder.setHidden(true); return super.getShallowTrace(); } }; final Task<?> par1 = Task.par(task1, task2); runAndWait("TestTaskToTrace.testUserHiddenTrace", par1); assertFalse(par1.getShallowTrace().getHidden()); assertTrue(task1.getShallowTrace().getHidden()); assertTrue(task1.getShallowTrace().getHidden()); }
@Test public void testSideEffectsPredecessorTrace() throws InterruptedException, IOException { final Task<String> baseTask = value("base", "baseValue"); final Task<String> sideEffect = value("sideEffect", "sideEffectValue"); final Task<String> withSideEffect = baseTask.withSideEffect(x -> sideEffect); runAndWait("TestTaskToTrace.testSideEffectsPredecessorTrace", withSideEffect); assertTrue(sideEffect.await(5, TimeUnit.SECONDS)); assertEquals(2, getRelationships(withSideEffect.getTrace(), withSideEffect.getId()).size()); verifyShallowTrace(sideEffect); verifyShallowTrace(baseTask); assertTrue(withSideEffect.getTrace().getRelationships().toString(), withSideEffect.getTrace().getRelationships() .contains(new TraceRelationship(withSideEffect.getShallowTraceBuilder(), baseTask.getShallowTraceBuilder(), Relationship.PARENT_OF))); }
runAndWait("TestTaskToTrace.testTraceWithDiamond", parent); verifyShallowTrace(parent); verifyShallowTrace(a); verifyShallowTrace(b); verifyShallowTrace(c); verifyShallowTrace(d);