@Test public void provision_project_if_does_not_exist() { OrganizationDto organization = db.organizations().insert(); userSession .addPermission(OrganizationPermission.SCAN, organization.getUuid()) .addPermission(PROVISION_PROJECTS, organization); mockSuccessfulPrepareSubmitCall(); ComponentDto createdProject = newPrivateProjectDto(organization, PROJECT_UUID).setDbKey(PROJECT_KEY); when(componentUpdater.createWithoutCommit(any(), any(), isNull())).thenReturn(createdProject); when( permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(organization.getUuid()), any(), eq(PROJECT_KEY), eq(Qualifiers.PROJECT))) .thenReturn(true); when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(), eq(organization.getUuid()), any())).thenReturn(true); underTest.submit(organization.getKey(), PROJECT_KEY, null, PROJECT_NAME, emptyMap(), IOUtils.toInputStream("{binary}")); verifyReportIsPersisted(TASK_UUID); verify(queue).submit(argThat(submit -> submit.getType().equals(CeTaskTypes.REPORT) && submit.getComponent().filter(cpt -> cpt.getUuid().equals(PROJECT_UUID) && cpt.getMainComponentUuid().equals(PROJECT_UUID)).isPresent() && submit.getUuid().equals(TASK_UUID))); verify(componentUpdater).commitAndIndex(any(DbSession.class), eq(createdProject)); }
public static Component fromDto(ComponentDto dto) { String uuid = dto.uuid(); return new Component(uuid, firstNonNull(dto.getMainBranchProjectUuid(), uuid)); }
.hasSize(2) .extracting(task -> task.getComponent().get().getUuid(),task -> task.getMainComponent().get().getUuid()) .containsOnly(tuple(componentForMainComponentUuid2.getUuid(), componentForMainComponentUuid2.getMainComponentUuid()), tuple(componentForMainComponentUuid4.getUuid(), componentForMainComponentUuid4.getMainComponentUuid())); assertThat(db.getDbClient().ceQueueDao().selectAllInAscOrder(db.getSession())) .extracting(CeQueueDto::getUuid)
assertThat(component.getName()).contains(componentDto.name()); } else if (taskSubmit.getComponent().isPresent()) { assertThat(task.getComponent()).contains(new CeTask.Component(taskSubmit.getComponent().get().getUuid(), null, null)); } else { assertThat(task.getComponent()).isEmpty(); assertThat(component.getName()).contains(mainComponentDto.name()); } else if (taskSubmit.getComponent().isPresent()) { assertThat(task.getMainComponent()).contains(new CeTask.Component(taskSubmit.getComponent().get().getMainComponentUuid(), null, null)); } else { assertThat(task.getMainComponent()).isEmpty();
private void verifyCeTask(CeTaskSubmit taskSubmit, CeTask task, @Nullable ComponentDto componentDto, @Nullable UserDto userDto) { if (componentDto == null) { assertThat(task.getOrganizationUuid()).isEqualTo(defaultOrganizationProvider.get().getUuid()); } else { assertThat(task.getOrganizationUuid()).isEqualTo(componentDto.getOrganizationUuid()); } assertThat(task.getUuid()).isEqualTo(taskSubmit.getUuid()); assertThat(task.getType()).isEqualTo(taskSubmit.getType()); if (componentDto != null) { CeTask.Component component = task.getComponent().get(); assertThat(component.getUuid()).isEqualTo(componentDto.uuid()); assertThat(component.getKey()).contains(componentDto.getDbKey()); assertThat(component.getName()).contains(componentDto.name()); } else if (taskSubmit.getComponent().isPresent()) { assertThat(task.getComponent()).contains(new CeTask.Component(taskSubmit.getComponent().get().getUuid(), null, null)); } else { assertThat(task.getComponent()).isEmpty(); } if (taskSubmit.getSubmitterUuid() != null) { if (userDto == null) { assertThat(task.getSubmitter().getUuid()).isEqualTo(taskSubmit.getSubmitterUuid()); assertThat(task.getSubmitter().getLogin()).isNull(); } else { assertThat(task.getSubmitter().getUuid()).isEqualTo(userDto.getUuid()).isEqualTo(taskSubmit.getSubmitterUuid()); assertThat(task.getSubmitter().getUuid()).isEqualTo(userDto.getLogin()); } } }
private CeQueueDto addToQueueInDb(DbSession dbSession, CeTaskSubmit submission) { for (Map.Entry<String, String> characteristic : submission.getCharacteristics().entrySet()) { CeTaskCharacteristicDto characteristicDto = new CeTaskCharacteristicDto(); characteristicDto.setUuid(uuidFactory.create()); characteristicDto.setTaskUuid(submission.getUuid()); characteristicDto.setKey(characteristic.getKey()); characteristicDto.setValue(characteristic.getValue()); dbClient.ceTaskCharacteristicsDao().insert(dbSession, characteristicDto); } CeQueueDto dto = new CeQueueDto(); dto.setUuid(submission.getUuid()); dto.setTaskType(submission.getType()); submission.getComponent().ifPresent(component -> dto .setComponentUuid(component.getUuid()) .setMainComponentUuid(component.getMainComponentUuid())); dto.setStatus(PENDING); dto.setSubmitterUuid(submission.getSubmitterUuid()); dbClient.ceQueueDao().insert(dbSession, dto); return dto; }
private Optional<CeTask> submit(CeTaskSubmit submission, EnumSet<SubmitOption> submitOptions) { try (DbSession dbSession = dbClient.openSession(false)) { if (submitOptions.contains(UNIQUE_QUEUE_PER_MAIN_COMPONENT) && submission.getComponent() .map(component -> dbClient.ceQueueDao().countByStatusAndMainComponentUuid(dbSession, PENDING, component.getMainComponentUuid()) > 0) .orElse(false)) { return Optional.empty(); } CeQueueDto taskDto = addToQueueInDb(dbSession, submission); dbSession.commit(); Map<String, ComponentDto> componentsByUuid = loadComponentDtos(dbSession, taskDto); if (componentsByUuid.isEmpty()) { return of(convertToTask(dbSession, taskDto, submission.getCharacteristics(), null, null)); } return of(convertToTask(dbSession, taskDto, submission.getCharacteristics(), ofNullable(taskDto.getComponentUuid()).map(componentsByUuid::get).orElse(null), ofNullable(taskDto.getMainComponentUuid()).map(componentsByUuid::get).orElse(null))); } }
@Test public void submit_a_report_on_existing_project() { ComponentDto project = db.components().insertPrivateProject(db.getDefaultOrganization()); UserDto user = db.users().insertUser(); userSession.logIn(user).addProjectPermission(SCAN_EXECUTION, project); mockSuccessfulPrepareSubmitCall(); underTest.submit(defaultOrganizationKey, project.getDbKey(), null, project.name(), emptyMap(), IOUtils.toInputStream("{binary}", StandardCharsets.UTF_8)); verifyReportIsPersisted(TASK_UUID); verifyZeroInteractions(permissionTemplateService); verifyZeroInteractions(favoriteUpdater); verify(queue).submit(argThat(submit -> submit.getType().equals(CeTaskTypes.REPORT) && submit.getComponent().filter(cpt -> cpt.getUuid().equals(project.uuid()) && cpt.getMainComponentUuid().equals(project.uuid())).isPresent() && submit.getSubmitterUuid().equals(user.getUuid()) && submit.getUuid().equals(TASK_UUID))); }
private void verifyCeQueueDtoForTaskSubmit(CeTaskSubmit taskSubmit) { Optional<CeQueueDto> queueDto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), taskSubmit.getUuid()); assertThat(queueDto.isPresent()).isTrue(); CeQueueDto dto = queueDto.get(); assertThat(dto.getTaskType()).isEqualTo(taskSubmit.getType()); Optional<CeTaskSubmit.Component> component = taskSubmit.getComponent(); if (component.isPresent()) { assertThat(dto.getMainComponentUuid()).isEqualTo(component.get().getMainComponentUuid()); assertThat(dto.getComponentUuid()).isEqualTo(component.get().getUuid()); } else { assertThat(dto.getMainComponentUuid()).isNull(); assertThat(dto.getComponentUuid()).isNull(); } assertThat(dto.getSubmitterUuid()).isEqualTo(taskSubmit.getSubmitterUuid()); assertThat(dto.getCreatedAt()).isEqualTo(dto.getUpdatedAt()).isNotNull(); }
private static Component newComponent(String mainComponentUuid) { return new Component("uuid_" + newComponentIdGenerator++, mainComponentUuid); } }
private CeQueueDto createTaskSubmit(@Nullable ComponentDto componentDto) { CeTaskSubmit.Builder submission = queue.prepareSubmit() .setType(CeTaskTypes.REPORT) .setSubmitterUuid(null) .setCharacteristics(emptyMap()); if (componentDto != null) { submission.setComponent(CeTaskSubmit.Component.fromDto(componentDto)); } CeTask task = queue.submit(submission.build()); return db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), task.getUuid()).get(); } }
private CeTaskSubmit createTaskSubmit(String type, @Nullable ComponentDto componentDto, @Nullable String submitterUuid) { CeTaskSubmit.Builder builder = underTest.prepareSubmit() .setType(type) .setSubmitterUuid(submitterUuid) .setCharacteristics(emptyMap()); if (componentDto != null) { builder.setComponent(CeTaskSubmit.Component.fromDto(componentDto)); } return builder.build(); }
@Test public void massSubmit_populates_component_name_and_key_of_CeTask_if_project_exists() { ComponentDto componentDto1 = insertComponent(ComponentTesting.newPrivateProjectDto(db.getDefaultOrganization(), "PROJECT_1")); CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, Component.fromDto(componentDto1), null); CeTaskSubmit taskSubmit2 = createTaskSubmit("something", newComponent(randomAlphabetic(12)), 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 submit_populates_component_name_and_key_of_CeTask_if_component_exists() { ComponentDto componentDto = insertComponent(ComponentTesting.newPrivateProjectDto(db.organizations().insert(), "PROJECT_1")); CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, Component.fromDto(componentDto), null); CeTask task = underTest.submit(taskSubmit); verifyCeTask(taskSubmit, task, componentDto, null); }
private CeQueueDto insertPendingInQueue(@Nullable Component component) { CeQueueDto dto = new CeQueueDto() .setUuid(UuidFactoryFast.getInstance().create()) .setTaskType("some type") .setStatus(CeQueueDto.Status.PENDING); if (component != null) { dto.setComponentUuid(component.getUuid()) .setMainComponentUuid(component.getMainComponentUuid()); } db.getDbClient().ceQueueDao().insert(db.getSession(), dto); db.commit(); return dto; }
private void verifyQueueSubmit(ComponentDto project, ComponentDto branch, UserDto user, Map<String, String> characteristics, String taskUuid) { verify(queue).submit(argThat(submit -> submit.getType().equals(CeTaskTypes.REPORT) && submit.getComponent().filter(cpt -> cpt.getUuid().equals(branch.uuid()) && cpt.getMainComponentUuid().equals(project.uuid())).isPresent() && submit.getSubmitterUuid().equals(user.getUuid()) && submit.getCharacteristics().equals(characteristics) && submit.getUuid().equals(taskUuid))); }
@Test public void submit_returns_task_populated_from_CeTaskSubmit_and_creates_CeQueue_row() { String componentUuid = randomAlphabetic(3); String mainComponentUuid = randomAlphabetic(4); CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, new Component(componentUuid, mainComponentUuid), "submitter uuid"); UserDto userDto = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit.getSubmitterUuid()); CeTask task = underTest.submit(taskSubmit); verifyCeTask(taskSubmit, task, null, userDto); verifyCeQueueDtoForTaskSubmit(taskSubmit); }
@Test public void massSubmit_populates_component_name_and_key_of_CeTask_if_project_and_branch_exists() { ComponentDto project = insertComponent(ComponentTesting.newPrivateProjectDto(db.getDefaultOrganization(), "PROJECT_1")); ComponentDto branch1 = db.components().insertProjectBranch(project); ComponentDto branch2 = db.components().insertProjectBranch(project); CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, Component.fromDto(branch1), null); CeTaskSubmit taskSubmit2 = createTaskSubmit("something", Component.fromDto(branch2), null); List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2)); assertThat(tasks).hasSize(2); verifyCeTask(taskSubmit1, tasks.get(0), branch1, project, null); verifyCeTask(taskSubmit2, tasks.get(1), branch2, project, null); }
private CeTask submitReport(DbSession dbSession, InputStream reportInput, ComponentDto project, Map<String, String> characteristics) { CeTaskSubmit.Builder submit = queue.prepareSubmit(); // the report file must be saved before submitting the task dbClient.ceTaskInputDao().insert(dbSession, submit.getUuid(), reportInput); dbSession.commit(); submit.setType(CeTaskTypes.REPORT); submit.setComponent(CeTaskSubmit.Component.fromDto(project)); submit.setSubmitterUuid(userSession.getUuid()); submit.setCharacteristics(characteristics); return queue.submit(submit.build()); }
@Override public boolean test(CeTaskSubmit ceTaskSubmit) { return ceTaskSubmit.getComponent() .map(component -> queuedItemsByMainComponentUuid.getOrDefault(component.getMainComponentUuid(), 0) == 0) .orElse(true); } }