public SnapshotDto insertSnapshot(ComponentDto componentDto, Consumer<SnapshotDto> consumer) { SnapshotDto snapshotDto = SnapshotTesting.newAnalysis(componentDto); consumer.accept(snapshotDto); SnapshotDto snapshot = dbClient.snapshotDao().insert(dbSession, snapshotDto); db.commit(); return snapshot; }
private SnapshotDto insertAnalysis(String projectUuid, boolean isLast) { return db.getDbClient().snapshotDao().insert(db.getSession(), SnapshotTesting.newSnapshot() .setUuid(Uuids.createFast()) .setComponentUuid(projectUuid) .setLast(isLast)); }
private SnapshotDto createProjectSnapshot(ComponentDto project) { SnapshotDto projectSnapshot = SnapshotTesting.newAnalysis(project); dbClient.snapshotDao().insert(dbSession, projectSnapshot); dbSession.commit(); return projectSnapshot; }
@Test public void fail_if_project_is_not_found() { userSession.logIn(); SnapshotDto analysis = dbClient.snapshotDao().insert(dbSession, newSnapshot().setUuid("A1")); db.commit(); expectedException.expect(IllegalStateException.class); expectedException.expectMessage("Project of analysis 'A1' is not found"); call(VERSION.name(), "5.6.3", analysis.getUuid()); }
private EventDto newEvent() { return EventTesting.newEvent(newAnalysis(ComponentTesting.newPrivateProjectDto(OrganizationTesting.newOrganizationDto()))); } }
@Test public void select_first_snapshots() { ComponentDto project = newPrivateProjectDto(db.getDefaultOrganization()); db.getDbClient().componentDao().insert(dbSession, project); db.getDbClient().snapshotDao().insert(dbSession, newAnalysis(project).setCreatedAt(5L), newAnalysis(project).setCreatedAt(2L), newAnalysis(project).setCreatedAt(1L)); dbSession.commit(); Optional<SnapshotDto> dto = underTest.selectOldestSnapshot(dbSession, project.uuid()); assertThat(dto).isNotEmpty(); assertThat(dto.get().getCreatedAt()).isEqualTo(1L); assertThat(underTest.selectOldestSnapshot(dbSession, "blabla")).isEmpty(); }
@Test public void return_only_processed_analyses() { ComponentDto project = db.components().insertComponent(ComponentTesting.newPrivateProjectDto(db.getDefaultOrganization()).setDbKey("P1")); userSession.addProjectPermission(UserRole.USER, project); db.components().insertSnapshot(newAnalysis(project).setUuid("A1")); db.components().insertSnapshot(newAnalysis(project).setUuid("A2").setStatus(SnapshotDto.STATUS_UNPROCESSED)); List<Analysis> result = call("P1").getAnalysesList(); assertThat(result).hasSize(1); assertThat(result.get(0).getKey()).isEqualTo("A1"); }
@Test public void insert_snapshots() { ComponentDto project = db.components().insertPrivateProject(); underTest.insert(db.getSession(), newAnalysis(project).setLast(false).setUuid("u5"), newAnalysis(project).setLast(false).setUuid("u6")); db.getSession().commit(); assertThat(db.countRowsOfTable("snapshots")).isEqualTo(2); }
@Test public void do_not_return_unprocessed_analyses() { dbClient.snapshotDao().insert(dbSession, newAnalysis(project).setStatus(STATUS_UNPROCESSED)); db.commit(); SearchHistoryResponse result = call(); // one analysis in setUp method assertThat(result.getPaging().getTotal()).isEqualTo(1); }
@Test public void test_selectByUuid() { ComponentDto project = db.components().insertPrivateProject(); db.components().insertSnapshot(newAnalysis(project) .setUuid("ABCD") .setStatus("P") .setLast(true) .setPurgeStatus(1) .setPeriodMode("days") .setPeriodParam("30") .setPeriodDate(1500000000001L) .setVersion("2.1-SNAPSHOT") .setBuildDate(1500000000006L) .setCreatedAt(1403042400000L)); SnapshotDto result = underTest.selectByUuid(db.getSession(), "ABCD").get(); assertThat(result.getId()).isNotNull(); assertThat(result.getUuid()).isEqualTo("ABCD"); assertThat(result.getComponentUuid()).isEqualTo(project.uuid()); assertThat(result.getStatus()).isEqualTo("P"); assertThat(result.getLast()).isTrue(); assertThat(result.getPurgeStatus()).isEqualTo(1); assertThat(result.getVersion()).isEqualTo("2.1-SNAPSHOT"); assertThat(result.getPeriodMode()).isEqualTo("days"); assertThat(result.getPeriodModeParameter()).isEqualTo("30"); assertThat(result.getPeriodDate()).isEqualTo(1500000000001L); assertThat(result.getBuildDate()).isEqualTo(1500000000006L); assertThat(result.getCreatedAt()).isEqualTo(1403042400000L); assertThat(result.getVersion()).isEqualTo("2.1-SNAPSHOT"); assertThat(underTest.selectByUuid(db.getSession(), "DOES_NOT_EXIST").isPresent()).isFalse(); }
@Test public void insert() { ComponentDto project = db.components().insertPrivateProject(); SnapshotDto dto = underTest.insert(db.getSession(), newAnalysis(project) .setStatus("P") .setLast(true) .setPurgeStatus(1) .setPeriodMode("days") .setPeriodParam("30") .setPeriodDate(1500000000001L) .setVersion("2.1-SNAPSHOT") .setBuildDate(1500000000006L) .setCreatedAt(1403042400000L)); assertThat(dto.getId()).isNotNull(); assertThat(dto.getUuid()).isNotNull(); assertThat(dto.getComponentUuid()).isEqualTo(project.uuid()); assertThat(dto.getStatus()).isEqualTo("P"); assertThat(dto.getLast()).isTrue(); assertThat(dto.getPurgeStatus()).isEqualTo(1); assertThat(dto.getPeriodMode()).isEqualTo("days"); assertThat(dto.getPeriodModeParameter()).isEqualTo("30"); assertThat(dto.getPeriodDate()).isEqualTo(1500000000001L); assertThat(dto.getBuildDate()).isEqualTo(1500000000006L); assertThat(dto.getCreatedAt()).isEqualTo(1403042400000L); assertThat(dto.getVersion()).isEqualTo("2.1-SNAPSHOT"); }
private SnapshotDto insertComponentAndSnapshot(ComponentDto component) { dbClient.componentDao().insert(dbSession, component); SnapshotDto snapshot = dbClient.snapshotDao().insert(dbSession, newAnalysis(component)); db.commit(); return snapshot; }
private SnapshotDto createAnalysisAndLogInAsProjectAdministrator(String version) { ComponentDto project = db.components().insertPrivateProject(); SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setVersion(version)); logInAsProjectAdministrator(project); return analysis; } }
@Test public void delete_by_uuid() { dbTester.events().insertEvent(newEvent(newAnalysis(ComponentTesting.newPrivateProjectDto(dbTester.getDefaultOrganization()))).setUuid("E1")); underTest.delete(dbTester.getSession(), "E1"); dbTester.commit(); assertThat(dbTester.countRowsOfTable("events")).isEqualTo(0); }
@Test public void return_undefined_status_if_specified_analysis_is_not_found() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPrivateProject(organization); SnapshotDto snapshot = dbClient.snapshotDao().insert(dbSession, newAnalysis(project)); dbSession.commit(); userSession.addProjectPermission(UserRole.USER, project); ProjectStatusResponse result = ws.newRequest() .setParam(PARAM_ANALYSIS_ID, snapshot.getUuid()) .executeProtobuf(ProjectStatusResponse.class); assertThat(result.getProjectStatus().getStatus()).isEqualTo(Status.NONE); assertThat(result.getProjectStatus().getConditionsCount()).isEqualTo(0); }
@Test public void selectSnapshotBefore() { ComponentDto project = db.components().insertPrivateProject(); SnapshotDto analysis1 = newAnalysis(project).setCreatedAt(50L).setPeriodDate(20L); SnapshotDto analysis2 = newAnalysis(project).setCreatedAt(20L).setPeriodDate(10L); SnapshotDto analysis3 = newAnalysis(project).setCreatedAt(10L).setPeriodDate(null); db.components().insertSnapshots(analysis1, analysis2, analysis3); assertThat(underTest.selectSnapshotBefore(project.uuid(), 50L, dbSession)) .extracting(ViewsSnapshotDto::getUuid, ViewsSnapshotDto::getCreatedAt, ViewsSnapshotDto::getLeakDate) .containsExactlyInAnyOrder(analysis2.getUuid(), analysis2.getCreatedAt(), analysis2.getPeriodDate()); assertThat(underTest.selectSnapshotBefore(project.uuid(), 20L, dbSession)) .extracting(ViewsSnapshotDto::getUuid, ViewsSnapshotDto::getLeakDate) .containsExactlyInAnyOrder(analysis3.getUuid(), null); assertThat(underTest.selectSnapshotBefore(project.uuid(), 5L, dbSession)).isNull(); }
private void insertAnalysis(ComponentDto project, String uuid, String status, boolean isLastFlag) { SnapshotDto snapshot = SnapshotTesting.newAnalysis(project) .setLast(isLastFlag) .setStatus(status) .setUuid(uuid); db.getDbClient().snapshotDao().insert(db.getSession(), snapshot); } }
private SnapshotDto insertAnalysis(String projectUuid, String uuid, String status, boolean isLastFlag) { SnapshotDto snapshot = newAnalysis(newPrivateProjectDto(OrganizationTesting.newOrganizationDto(), projectUuid)) .setLast(isLastFlag) .setStatus(status) .setUuid(uuid); underTest.insert(db.getSession(), snapshot); return snapshot; }
@Test public void return_project_without_analysis() { ComponentDto project = dbTester.components().insertComponent(ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert())); dbClient.snapshotDao().insert(dbSession, newAnalysis(project).setLast(false)); dbSession.commit(); Map<String, ProjectMeasures> docsById = createResultSetAndReturnDocsById(); assertThat(docsById).hasSize(1); ProjectMeasures doc = docsById.get(project.uuid()); assertThat(doc.getProject().getAnalysisDate()).isNull(); }
@Test public void selectLastSnapshotsByRootComponentUuids_returns_snapshots_flagged_as_last() { ComponentDto firstProject = db.components().insertComponent(newPrivateProjectDto(db.getDefaultOrganization(), "PROJECT_UUID_1")); dbClient.snapshotDao().insert(dbSession, newAnalysis(firstProject).setLast(false)); SnapshotDto lastSnapshotOfFirstProject = dbClient.snapshotDao().insert(dbSession, newAnalysis(firstProject).setLast(true)); ComponentDto secondProject = db.components().insertComponent(newPrivateProjectDto(db.getDefaultOrganization(), "PROJECT_UUID_2")); SnapshotDto lastSnapshotOfSecondProject = dbClient.snapshotDao().insert(dbSession, newAnalysis(secondProject).setLast(true)); db.components().insertProjectAndSnapshot(newPrivateProjectDto(db.getDefaultOrganization())); List<SnapshotDto> result = underTest.selectLastAnalysesByRootComponentUuids(dbSession, newArrayList(firstProject.uuid(), secondProject.uuid())); assertThat(result).extracting(SnapshotDto::getId).containsOnly(lastSnapshotOfFirstProject.getId(), lastSnapshotOfSecondProject.getId()); }