@Test public void massSubmit_returns_tasks_for_each_CeTaskSubmit_populated_from_CeTaskSubmit_and_creates_CeQueue_row_for_each() { CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1"), "rob"); CeTaskSubmit taskSubmit2 = createTaskSubmit("some type"); List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2)); UserDto userDto1 = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit1.getSubmitterUuid()); assertThat(tasks).hasSize(2); verifyCeTask(taskSubmit1, tasks.get(0), null, userDto1); verifyCeTask(taskSubmit2, tasks.get(1), null, null); verifyCeQueueDtoForTaskSubmit(taskSubmit1); verifyCeQueueDtoForTaskSubmit(taskSubmit2); }
@Test public void resetTasksWithUnknownWorkerUUIDs_with_empty_set_will_reset_all_in_progress_tasks() { CeQueueDto u1 = insertCeQueueDto("u1"); CeQueueDto u2 = insertCeQueueDto("u2"); CeQueueDto u6 = insertInProgress("u6", "worker1"); CeQueueDto u7 = insertInProgress("u7", "worker2"); CeQueueDto u8 = insertInProgress("u8", "worker3"); underTest.resetTasksWithUnknownWorkerUUIDs(ImmutableSet.of()); // Pending tasks must not be modified even if a workerUUID is not present verifyUnmodified(u1); verifyUnmodified(u2); // Unknown worker : null, "worker1" verifyReset(u6); verifyReset(u7); verifyReset(u8); }
@Test public void massSubmit_populates_component_name_and_key_of_CeTask_if_component_exists() { ComponentDto componentDto1 = insertComponent(newProjectDto("PROJECT_1")); CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, componentDto1, null); CeTaskSubmit taskSubmit2 = createTaskSubmit("something", newProjectDto("non existing component uuid"), null); List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2)); assertThat(tasks).hasSize(2); verifyCeTask(taskSubmit1, tasks.get(0), componentDto1, null); verifyCeTask(taskSubmit2, tasks.get(1), null, null); }
@Test public void peek_resets_to_pending_any_task_in_progress_for_specified_worker_uuid_and_only_this_uuid() { insertPending("u0"); // add a pending one that will be picked so that u1 isn't peek and status reset is visible in DB CeQueueDto u1 = insertInProgress("u1", WORKER_UUID_1); CeQueueDto u2 = insertInProgress("u2", WORKER_UUID_2); CeQueueDto u3 = insertInProgress("u3", WORKER_UUID_1); CeQueueDto u4 = insertInProgress("u4", WORKER_UUID_2); assertThat(underTest.peek(WORKER_UUID_1).get().getUuid()).isEqualTo("u0"); verifyResetTask(u1); verifyUnmodifiedTask(u2); verifyResetTask(u3); verifyUnmodifiedTask(u4); }
@Test public void peek_nothing_if_application_status_stopping() { submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); when(computeEngineStatus.getStatus()).thenReturn(STOPPING); Optional<CeTask> peek = underTest.peek(WORKER_UUID_1); assertThat(peek.isPresent()).isFalse(); }
@Test public void remove_saves_error_message_and_stacktrace_when_exception_is_provided() { Throwable error = new NullPointerException("Fake NPE to test persistence to DB"); CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); Optional<CeTask> peek = underTest.peek(WORKER_UUID_1); underTest.remove(peek.get(), CeActivityDto.Status.FAILED, null, error); Optional<CeActivityDto> activityDto = db.getDbClient().ceActivityDao().selectByUuid(session, task.getUuid()); assertThat(activityDto).isPresent(); assertThat(activityDto.get().getErrorMessage()).isEqualTo(error.getMessage()); assertThat(activityDto.get().getErrorStacktrace()).isEqualToIgnoringWhitespace(stacktraceToString(error)); assertThat(activityDto.get().getErrorType()).isNull(); }
@Test public void remove_sets_analysisUuid_in_CeActivity_when_CeTaskResult_has_analysis_uuid() { CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); Optional<CeTask> peek = underTest.peek(WORKER_UUID_2); underTest.remove(peek.get(), CeActivityDto.Status.SUCCESS, newTaskResult(AN_ANALYSIS_UUID), null); // available in history Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); assertThat(history.isPresent()).isTrue(); assertThat(history.get().getAnalysisUuid()).isEqualTo("U1"); }
@Test public void submit_returns_task_without_component_info_when_submit_has_none() { CeTaskSubmit taskSubmit = createTaskSubmit("not cpt related"); CeTask task = underTest.submit(taskSubmit); verifyCeTask(taskSubmit, task, null, null); }
private CeQueueDto insertInProgress(String uuid, String workerUuid) { CeQueueDto dto = new CeQueueDto() .setUuid(uuid) .setTaskType("foo") .setStatus(CeQueueDto.Status.PENDING); db.getDbClient().ceQueueDao().insert(session, dto); makeInProgress(dto, workerUuid); db.commit(); return db.getDbClient().ceQueueDao().selectByUuid(session, uuid).get(); }
private CeTaskSubmit createTaskSubmit(String type) { return createTaskSubmit(type, null, null); }
@Test public void peek_populates_name_and_key_for_existing_component_and_main_component() { ComponentDto project = db.components().insertPrivateProject(); ComponentDto branch = db.components().insertProjectBranch(project); CeTask task = submit(CeTaskTypes.REPORT, branch); Optional<CeTask> peek = underTest.peek(WORKER_UUID_1); assertThat(peek.isPresent()).isTrue(); assertThat(peek.get().getUuid()).isEqualTo(task.getUuid()); assertThat(peek.get().getType()).isEqualTo(CeTaskTypes.REPORT); assertThat(peek.get().getComponent()).contains(new CeTask.Component(branch.uuid(), branch.getDbKey(), branch.name())); assertThat(peek.get().getMainComponent()).contains(new CeTask.Component(project.uuid(), project.getDbKey(), project.name())); // no more pending tasks peek = underTest.peek(WORKER_UUID_2); assertThat(peek.isPresent()).isFalse(); }
@Test public void test_peek() { CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); Optional<CeTask> peek = underTest.peek(WORKER_UUID_1); assertThat(peek.isPresent()).isTrue(); assertThat(peek.get().getUuid()).isEqualTo(task.getUuid()); assertThat(peek.get().getType()).isEqualTo(CeTaskTypes.REPORT); assertThat(peek.get().getComponent()).contains(new CeTask.Component("PROJECT_1", null, null)); assertThat(peek.get().getMainComponent()).contains(peek.get().getComponent().get()); // no more pending tasks peek = underTest.peek(WORKER_UUID_2); assertThat(peek.isPresent()).isFalse(); }
@Test public void peek_resets_to_pending_any_task_in_progress_for_specified_worker_uuid_and_updates_updatedAt() { insertPending("u0"); // add a pending one that will be picked so that u1 isn't peek and status reset is visible in DB CeQueueDto u1 = insertPending("u1");// will be picked-because older than any of the reset ones CeQueueDto u2 = insertInProgress("u2", WORKER_UUID_1);// will be reset assertThat(underTest.peek(WORKER_UUID_1).get().getUuid()).isEqualTo("u0"); verifyUnmodifiedTask(u1); verifyResetTask(u2); }
@Test public void remove_saves_error_when_TypedMessageException_is_provided() { Throwable error = new TypedExceptionImpl("aType", "aMessage"); CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); Optional<CeTask> peek = underTest.peek(WORKER_UUID_1); underTest.remove(peek.get(), CeActivityDto.Status.FAILED, null, error); CeActivityDto activityDto = db.getDbClient().ceActivityDao().selectByUuid(session, task.getUuid()).get(); assertThat(activityDto.getErrorType()).isEqualTo("aType"); assertThat(activityDto.getErrorMessage()).isEqualTo("aMessage"); assertThat(activityDto.getErrorStacktrace()).isEqualToIgnoringWhitespace(stacktraceToString(error)); }
@Test public void remove_does_not_set_analysisUuid_in_CeActivity_when_CeTaskResult_has_no_analysis_uuid() { CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); Optional<CeTask> peek = underTest.peek(WORKER_UUID_1); underTest.remove(peek.get(), CeActivityDto.Status.SUCCESS, newTaskResult(null), null); // available in history Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid()); assertThat(history.isPresent()).isTrue(); assertThat(history.get().getAnalysisUuid()).isNull(); }
@Test public void peek_ignores_in_progress_tasks() { CeQueueDto dto = db.getDbClient().ceQueueDao().insert(session, new CeQueueDto() .setUuid("uuid") .setTaskType("foo") .setStatus(CeQueueDto.Status.PENDING)); makeInProgress(dto, "foo"); db.commit(); assertThat(underTest.peek(WORKER_UUID_1)).isEmpty(); }
private CeTask submit(String reportType, ComponentDto componentDto) { return underTest.submit(createTaskSubmit(reportType, componentDto, null)); }
@Test public void resetTasksWithUnknownWorkerUUIDs_with_worker_without_tasks_will_reset_all_in_progress_tasks() { CeQueueDto u1 = insertCeQueueDto("u1"); CeQueueDto u2 = insertCeQueueDto("u2"); CeQueueDto u6 = insertInProgress("u6", "worker1"); CeQueueDto u7 = insertInProgress("u7", "worker2"); CeQueueDto u8 = insertInProgress("u8", "worker3"); underTest.resetTasksWithUnknownWorkerUUIDs(ImmutableSet.of("worker1000", "worker1001")); // Pending tasks must not be modified even if a workerUUID is not present verifyUnmodified(u1); verifyUnmodified(u2); // Unknown worker : null, "worker1" verifyReset(u6); verifyReset(u7); verifyReset(u8); }
@Test public void fail_to_remove_if_not_in_queue() { CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1")); underTest.remove(task, CeActivityDto.Status.SUCCESS, null, null); expectedException.expect(IllegalStateException.class); underTest.remove(task, CeActivityDto.Status.SUCCESS, null, null); }
@Test public void submit_returns_task_populated_from_CeTaskSubmit_and_creates_CeQueue_row() { CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1"), "rob"); CeTask task = underTest.submit(taskSubmit); UserDto userDto = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit.getSubmitterUuid()); verifyCeTask(taskSubmit, task, null, userDto); verifyCeQueueDtoForTaskSubmit(taskSubmit); }