Examples with COMPLETED com.netflix.conductor.common.metadata.tasks.Task.Status.COMPLETED used on opensource projects

Example 1 with COMPLETED

use of com.netflix.conductor.common.metadata.tasks.Task.Status.COMPLETED in project conductor by Netflix.

the class AbstractWorkflowServiceTest method testSimpleWorkflowWithResponseTimeout.

@Test
public void testSimpleWorkflowWithResponseTimeout() throws Exception {
    createWFWithResponseTimeout();
    String correlationId = "unit_test_1";
    Map<String, Object> workflowInput = new HashMap<>();
    String inputParam1 = "p1 value";
    workflowInput.put("param1", inputParam1);
    workflowInput.put("param2", "p2 value");
    String workflowId = startOrLoadWorkflowExecution("RTOWF", 1, correlationId, workflowInput, null, null);
    logger.debug("testSimpleWorkflowWithResponseTimeout.wfid=" + workflowId);
    assertNotNull(workflowId);
    Workflow workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(RUNNING, workflow.getStatus());
    // The very first task is the one that should be scheduled.
    assertEquals(1, workflow.getTasks().size());
    assertEquals(1, queueDAO.getSize("task_rt"));
    // Polling for the first task should return the first task
    Task task = workflowExecutionService.poll("task_rt", "task1.junit.worker.testTimeout");
    assertNotNull(task);
    assertEquals("task_rt", task.getTaskType());
    assertTrue(workflowExecutionService.ackTaskReceived(task.getTaskId()));
    assertEquals(workflowId, task.getWorkflowInstanceId());
    // As the task_rt is out of the queue, the next poll should not get it
    Task nullTask = workflowExecutionService.poll("task_rt", "task1.junit.worker.testTimeout");
    assertNull(nullTask);
    Thread.sleep(10000);
    workflowExecutor.decide(workflowId);
    assertEquals(1, queueDAO.getSize("task_rt"));
    // The first task would be timed_out and a new task will be scheduled
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(RUNNING, workflow.getStatus());
    assertEquals(2, workflow.getTasks().size());
    assertTrue(workflow.getTasks().stream().allMatch(t -> t.getReferenceTaskName().equals("task_rt_t1")));
    assertEquals(TIMED_OUT, workflow.getTasks().get(0).getStatus());
    assertEquals(SCHEDULED, workflow.getTasks().get(1).getStatus());
    // Polling now should get the same task back because it should have been put back in the queue
    Task taskAgain = workflowExecutionService.poll("task_rt", "task1.junit.worker");
    assertNotNull(taskAgain);
    // update task with callback after seconds greater than the response timeout
    taskAgain.setStatus(IN_PROGRESS);
    taskAgain.setCallbackAfterSeconds(2);
    workflowExecutionService.updateTask(taskAgain);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(WorkflowStatus.RUNNING, workflow.getStatus());
    assertEquals(2, workflow.getTasks().size());
    assertEquals(SCHEDULED, workflow.getTasks().get(1).getStatus());
    // wait for callback after seconds which is longer than response timeout seconds and then call decide
    Thread.sleep(2010);
    // Ensure unacks are processed.
    queueDAO.processUnacks(taskAgain.getTaskDefName());
    workflowExecutor.decide(workflowId);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    // Poll for task again
    taskAgain = workflowExecutionService.poll("task_rt", "task1.junit.worker");
    assertNotNull(taskAgain);
    taskAgain.getOutputData().put("op", "task1.Done");
    taskAgain.setStatus(COMPLETED);
    workflowExecutionService.updateTask(taskAgain);
    // poll for next task
    task = workflowExecutionService.poll("junit_task_2", "task2.junit.worker.testTimeout");
    assertNotNull(task);
    assertEquals("junit_task_2", task.getTaskType());
    assertTrue(workflowExecutionService.ackTaskReceived(task.getTaskId()));
    task.setStatus(COMPLETED);
    task.setReasonForIncompletion("unit test failure");
    workflowExecutionService.updateTask(task);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(WorkflowStatus.COMPLETED, workflow.getStatus());
}

Example 2 with COMPLETED

use of com.netflix.conductor.common.metadata.tasks.Task.Status.COMPLETED in project conductor by Netflix.

the class AbstractWorkflowServiceTest method testSubWorkflowTaskToDomainWildcard.

@Test
public void testSubWorkflowTaskToDomainWildcard() {
    Map<String, String> taskToDomain = new HashMap<>();
    taskToDomain.put("*", "unittest");
    createSubWorkflow(taskToDomain);
    metadataService.getWorkflowDef(WF_WITH_SUB_WF, 1);
    Map<String, Object> input = new HashMap<>();
    input.put("param1", "param 1 value");
    input.put("param3", "param 2 value");
    input.put("wfName", LINEAR_WORKFLOW_T1_T2);
    String workflowId = startOrLoadWorkflowExecution(WF_WITH_SUB_WF, 1, "test", input, null, null);
    assertNotNull(workflowId);
    Workflow workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    Task task = workflowExecutionService.poll("junit_task_5", "test");
    assertNotNull(task);
    task.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task);
    Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertNotNull(workflow.getTasks());
    // Simulating SystemTaskWorkerCoordinator to execute async system tasks
    String subWorkflowTaskId = workflow.getTaskByRefName("a2").getTaskId();
    workflowExecutor.executeSystemTask(dummySubWorkflowSystemTask, subWorkflowTaskId, 1);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    task = workflow.getTasks().stream().filter(t -> t.getTaskType().equals(SUB_WORKFLOW.name())).findAny().get();
    assertNotNull(task);
    assertNotNull(task.getOutputData());
    assertNotNull("Output: " + task.getOutputData().toString() + ", status: " + task.getStatus(), task.getSubWorkflowId());
    assertNotNull(task.getInputData());
    assertTrue(task.getInputData().containsKey("workflowInput"));
    assertEquals(42, ((Map<String, Object>) task.getInputData().get("workflowInput")).get("param2"));
    String subWorkflowId = task.getSubWorkflowId();
    Workflow subWorkflow = workflowExecutionService.getExecutionStatus(subWorkflowId, true);
    assertNotNull(subWorkflow);
    assertNotNull(subWorkflow.getTasks());
    assertEquals(workflowId, subWorkflow.getParentWorkflowId());
    assertEquals(RUNNING, subWorkflow.getStatus());
    task = workflowExecutionService.poll("junit_task_1", "test", "unittest");
    task.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task);
    task = workflowExecutionService.poll("junit_task_2", "test", "unittest");
    assertEquals(subWorkflowId, task.getWorkflowInstanceId());
    String uuid = UUID.randomUUID().toString();
    task.getOutputData().put("uuid", uuid);
    task.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task);
    subWorkflow = workflowExecutionService.getExecutionStatus(subWorkflowId, true);
    assertNotNull(subWorkflow);
    assertEquals(WorkflowStatus.COMPLETED, subWorkflow.getStatus());
    assertNotNull(subWorkflow.getOutput());
    assertTrue(subWorkflow.getOutput().containsKey("o1"));
    assertTrue(subWorkflow.getOutput().containsKey("o2"));
    assertEquals("sub workflow input param1", subWorkflow.getOutput().get("o1"));
    assertEquals(uuid, subWorkflow.getOutput().get("o2"));
    assertEquals(taskToDomain, subWorkflow.getTaskToDomain());
    // Execute again to re-evaluate the Subworkflow task.
    workflowExecutor.executeSystemTask(dummySubWorkflowSystemTask, subWorkflowTaskId, 1);
    task = workflowExecutionService.poll("junit_task_6", "test");
    assertNotNull(task);
    task.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(WorkflowStatus.COMPLETED, workflow.getStatus());
}

Example 3 with COMPLETED

use of com.netflix.conductor.common.metadata.tasks.Task.Status.COMPLETED in project conductor by Netflix.

the class AbstractWorkflowServiceTest method testForkJoinNestedSchemaVersion1.

@Test
public void testForkJoinNestedSchemaVersion1() {
    createForkJoinNestedWorkflow(1);
    Map<String, Object> input = new HashMap<>();
    // This should execute t16 and t19
    input.put("case", "a");
    String wfid = startOrLoadWorkflowExecution("forkJoinNested", FORK_JOIN_NESTED_WF, 1, "fork_join_nested_test", input, null, null);
    System.out.println("testForkJoinNested.wfid=" + wfid);
    Workflow wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(RUNNING, wf.getStatus());
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t11")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t12")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t13")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("fork1")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("fork2")));
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t16")));
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t1")));
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t2")));
    Task t1 = workflowExecutionService.poll("junit_task_11", "test");
    assertTrue(workflowExecutionService.ackTaskReceived(t1.getTaskId()));
    Task t2 = workflowExecutionService.poll("junit_task_12", "test");
    assertTrue(workflowExecutionService.ackTaskReceived(t2.getTaskId()));
    Task t3 = workflowExecutionService.poll("junit_task_13", "test");
    assertTrue(workflowExecutionService.ackTaskReceived(t3.getTaskId()));
    assertNotNull(t1);
    assertNotNull(t2);
    assertNotNull(t3);
    t1.setStatus(COMPLETED);
    t2.setStatus(COMPLETED);
    t3.setStatus(COMPLETED);
    workflowExecutionService.updateTask(t1);
    workflowExecutionService.updateTask(t2);
    workflowExecutionService.updateTask(t3);
    Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t16")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t14")));
    String[] tasks = new String[] { "junit_task_14", "junit_task_16" };
    for (String tt : tasks) {
        Task polled = workflowExecutionService.poll(tt, "test");
        assertNotNull("poll resulted empty for task: " + tt, polled);
        polled.setStatus(COMPLETED);
        workflowExecutionService.updateTask(polled);
    }
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(RUNNING, wf.getStatus());
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t19")));
    // Not there yet
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t15")));
    // Not there yet
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t20")));
    Task task19 = workflowExecutionService.poll("junit_task_19", "test");
    assertNotNull(task19);
    task19.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task19);
    Task task20 = workflowExecutionService.poll("junit_task_20", "test");
    assertNotNull(task20);
    task20.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task20);
    Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(RUNNING, wf.getStatus());
    Set<String> pendingTasks = wf.getTasks().stream().filter(t -> !t.getStatus().isTerminal()).map(t -> t.getReferenceTaskName()).collect(Collectors.toSet());
    assertTrue("Found only this: " + pendingTasks, wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("join1")));
    pendingTasks = wf.getTasks().stream().filter(t -> !t.getStatus().isTerminal()).map(t -> t.getReferenceTaskName()).collect(Collectors.toSet());
    assertTrue("Found only this: " + pendingTasks, wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t15")));
    Task task15 = workflowExecutionService.poll("junit_task_15", "test");
    assertNotNull(task15);
    task15.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task15);
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(WorkflowStatus.COMPLETED, wf.getStatus());
}

Example 4 with COMPLETED

use of com.netflix.conductor.common.metadata.tasks.Task.Status.COMPLETED in project conductor by Netflix.

the class AbstractWorkflowServiceTest method testSimpleWorkflowWithTaskSpecificDomain.

@Test
public void testSimpleWorkflowWithTaskSpecificDomain() throws Exception {
    long startTimeTimestamp = System.currentTimeMillis();
    clearWorkflows();
    createWorkflowWithSubWorkflow();
    metadataService.getWorkflowDef(LINEAR_WORKFLOW_T1_T2_SW, 1);
    String correlationId = "unit_test_sw";
    Map<String, Object> input = new HashMap<>();
    String inputParam1 = "p1 value";
    input.put("param1", inputParam1);
    input.put("param2", "p2 value");
    Map<String, String> taskToDomain = new HashMap<>();
    taskToDomain.put("junit_task_3", "domain1");
    taskToDomain.put("junit_task_2", "domain1");
    // Poll before so that a polling for this task is "active"
    Task task = workflowExecutionService.poll("junit_task_3", "task1.junit.worker", "domain1");
    assertNull(task);
    task = workflowExecutionService.poll("junit_task_2", "task1.junit.worker", "domain1");
    assertNull(task);
    String workflowId = startOrLoadWorkflowExecution("simpleWorkflowWithTaskSpecificDomain", LINEAR_WORKFLOW_T1_T2_SW, 1, correlationId, input, null, taskToDomain);
    assertNotNull(workflowId);
    Workflow workflow = workflowExecutor.getWorkflow(workflowId, false);
    assertNotNull(workflow);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(workflow.getReasonForIncompletion(), RUNNING, workflow.getStatus());
    assertEquals(RUNNING, workflow.getStatus());
    // The very first task is the one that should be scheduled.
    assertEquals(1, workflow.getTasks().size());
    // Check Size
    Map<String, Integer> sizes = workflowExecutionService.getTaskQueueSizes(Arrays.asList("domain1:junit_task_3", "junit_task_3"));
    assertEquals(sizes.get("domain1:junit_task_3").intValue(), 1);
    assertEquals(sizes.get("junit_task_3").intValue(), 0);
    // Polling for the first task
    task = workflowExecutionService.poll("junit_task_3", "task1.junit.worker");
    assertNull(task);
    task = workflowExecutionService.poll("junit_task_3", "task1.junit.worker", "domain1");
    assertNotNull(task);
    assertEquals("junit_task_3", task.getTaskType());
    assertTrue(workflowExecutionService.ackTaskReceived(task.getTaskId()));
    assertEquals(workflowId, task.getWorkflowInstanceId());
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    List<Task> tasks = workflowExecutionService.getTasks(task.getTaskType(), null, 10);
    assertNotNull(tasks);
    assertEquals(1, tasks.size());
    task = tasks.get(0);
    assertEquals(workflowId, task.getWorkflowInstanceId());
    String task1Op = "task1.Done";
    task.getOutputData().put("op", task1Op);
    task.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(RUNNING, workflow.getStatus());
    // Simulating SystemTaskWorkerCoordinator to execute async system tasks
    String subWorkflowTaskId = workflow.getTaskByRefName("sw1").getTaskId();
    workflowExecutor.executeSystemTask(dummySubWorkflowSystemTask, subWorkflowTaskId, 1);
    task = workflowExecutionService.poll("junit_task_1", "task1.junit.worker");
    assertNotNull(task);
    assertEquals("junit_task_1", task.getTaskType());
    workflow = workflowExecutionService.getExecutionStatus(workflowId, false);
    assertTrue(workflowExecutionService.ackTaskReceived(task.getTaskId()));
    assertNotNull(workflow.getTaskToDomain());
    assertEquals(workflow.getTaskToDomain().size(), 2);
    task.setStatus(COMPLETED);
    task.setReasonForIncompletion("unit test failure");
    workflowExecutionService.updateTask(task);
    task = workflowExecutionService.poll("junit_task_2", "task2.junit.worker", "domain1");
    assertNotNull(task);
    assertEquals("junit_task_2", task.getTaskType());
    assertTrue(workflowExecutionService.ackTaskReceived(task.getTaskId()));
    task.setStatus(COMPLETED);
    task.setReasonForIncompletion("unit test failure");
    workflowExecutionService.updateTask(task);
    // Execute again to re-evaluate the Subworkflow task.
    workflowExecutor.executeSystemTask(dummySubWorkflowSystemTask, subWorkflowTaskId, 1);
    workflow = workflowExecutionService.getExecutionStatus(workflowId, true);
    assertNotNull(workflow);
    assertEquals(WorkflowStatus.COMPLETED, workflow.getStatus());
    tasks = workflow.getTasks();
    assertNotNull(tasks);
    assertEquals(2, tasks.size());
    assertTrue("Found " + workflow.getOutput().toString(), workflow.getOutput().containsKey("o3"));
    assertEquals("task1.Done", workflow.getOutput().get("o3"));
    Predicate<PollData> pollDataWithinTestTimes = pollData -> pollData.getLastPollTime() != 0 && pollData.getLastPollTime() > startTimeTimestamp;
    List<PollData> pollData = workflowExecutionService.getPollData("junit_task_3").stream().filter(pollDataWithinTestTimes).collect(Collectors.toList());
    assertEquals(2, pollData.size());
    for (PollData pd : pollData) {
        assertEquals(pd.getQueueName(), "junit_task_3");
        assertEquals(pd.getWorkerId(), "task1.junit.worker");
        assertTrue(pd.getLastPollTime() != 0);
        if (pd.getDomain() != null) {
            assertEquals(pd.getDomain(), "domain1");
        }
    }
    List<PollData> pdList = workflowExecutionService.getAllPollData().stream().filter(pollDataWithinTestTimes).collect(Collectors.toList());
    int count = 0;
    for (PollData pd : pdList) {
        if (pd.getQueueName().equals("junit_task_3")) {
            count++;
        }
    }
    assertEquals(2, count);
}

Example 5 with COMPLETED

use of com.netflix.conductor.common.metadata.tasks.Task.Status.COMPLETED in project conductor by Netflix.

the class AbstractWorkflowServiceTest method testForkJoinNestedSchemaVersion2.

@Test
public void testForkJoinNestedSchemaVersion2() {
    createForkJoinNestedWorkflow(2);
    Map<String, Object> input = new HashMap<>();
    // This should execute t16 and t19
    input.put("case", "a");
    String wfid = startOrLoadWorkflowExecution("forkJoinNested", FORK_JOIN_NESTED_WF, 1, "fork_join_nested_test", input, null, null);
    System.out.println("testForkJoinNested.wfid=" + wfid);
    Workflow wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(RUNNING, wf.getStatus());
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t11")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t12")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t13")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("fork1")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("fork2")));
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t16")));
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t1")));
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t2")));
    Task t1 = workflowExecutionService.poll("junit_task_11", "test");
    assertTrue(workflowExecutionService.ackTaskReceived(t1.getTaskId()));
    Task t2 = workflowExecutionService.poll("junit_task_12", "test");
    assertTrue(workflowExecutionService.ackTaskReceived(t2.getTaskId()));
    Task t3 = workflowExecutionService.poll("junit_task_13", "test");
    assertTrue(workflowExecutionService.ackTaskReceived(t3.getTaskId()));
    assertNotNull(t1);
    assertNotNull(t2);
    assertNotNull(t3);
    t1.setStatus(COMPLETED);
    t2.setStatus(COMPLETED);
    t3.setStatus(COMPLETED);
    workflowExecutionService.updateTask(t1);
    workflowExecutionService.updateTask(t2);
    workflowExecutionService.updateTask(t3);
    Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t16")));
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t14")));
    String[] tasks = new String[] { "junit_task_14", "junit_task_16" };
    for (String tt : tasks) {
        Task polled = workflowExecutionService.poll(tt, "test");
        assertNotNull("poll resulted empty for task: " + tt, polled);
        polled.setStatus(COMPLETED);
        workflowExecutionService.updateTask(polled);
    }
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(RUNNING, wf.getStatus());
    assertTrue(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t19")));
    // Not there yet
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t15")));
    // Not there yet
    assertFalse(wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t20")));
    Task task19 = workflowExecutionService.poll("junit_task_19", "test");
    assertNotNull(task19);
    task19.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task19);
    Task task20 = workflowExecutionService.poll("junit_task_20", "test");
    assertNotNull(task20);
    task20.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task20);
    Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(RUNNING, wf.getStatus());
    Set<String> pendingTasks = wf.getTasks().stream().filter(t -> !t.getStatus().isTerminal()).map(t -> t.getReferenceTaskName()).collect(Collectors.toSet());
    assertTrue("Found only this: " + pendingTasks, wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("join1")));
    pendingTasks = wf.getTasks().stream().filter(t -> !t.getStatus().isTerminal()).map(t -> t.getReferenceTaskName()).collect(Collectors.toSet());
    assertTrue("Found only this: " + pendingTasks, wf.getTasks().stream().anyMatch(t -> t.getReferenceTaskName().equals("t15")));
    Task task15 = workflowExecutionService.poll("junit_task_15", "test");
    assertNotNull(task15);
    task15.setStatus(COMPLETED);
    workflowExecutionService.updateTask(task15);
    wf = workflowExecutionService.getExecutionStatus(wfid, true);
    assertNotNull(wf);
    assertEquals(WorkflowStatus.COMPLETED, wf.getStatus());
}