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 createProjectSnapshot(ComponentDto project) { SnapshotDto projectSnapshot = SnapshotTesting.newAnalysis(project); dbClient.snapshotDao().insert(dbSession, projectSnapshot); dbSession.commit(); return projectSnapshot; }
@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 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); }
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); }
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 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()); }
@Test public void set_no_base_project_snapshot_when_no_last_snapshot() { setAnalysisMetadataHolder(); OrganizationDto organizationDto = dbTester.organizations().insert(); ComponentDto project = insertComponent(newPrivateProjectDto(organizationDto, "ABCD").setDbKey(REPORT_PROJECT_KEY)); insertSnapshot(newAnalysis(project).setLast(false)); reportReader.putComponent(component(ROOT_REF, PROJECT, REPORT_PROJECT_KEY)); underTest.execute(new TestComputationStepContext()); assertThat(analysisMetadataHolder.isFirstAnalysis()).isTrue(); }
@Test public void project_administrator_deletes_analysis() { ComponentDto project = db.components().insertPrivateProject(); db.components().insertSnapshot(newAnalysis(project).setUuid("A1").setLast(false).setStatus(STATUS_PROCESSED)); db.components().insertSnapshot(newAnalysis(project).setUuid("A2").setLast(true).setStatus(STATUS_PROCESSED)); logInAsProjectAdministrator(project); call("A1"); db.commit(); assertThat(dbClient.snapshotDao().selectByUuids(dbSession, newArrayList("A1", "A2"))).extracting(SnapshotDto::getUuid, SnapshotDto::getStatus).containsExactly( tuple("A1", STATUS_UNPROCESSED), tuple("A2", STATUS_PROCESSED)); }
@Test public void create_2_version_events_on_same_project() { ComponentDto project = ComponentTesting.newPrivateProjectDto(db.organizations().insert()); SnapshotDto firstAnalysis = db.components().insertProjectAndSnapshot(project); SnapshotDto secondAnalysis = dbClient.snapshotDao().insert(dbSession, newAnalysis(project)); db.commit(); logInAsProjectAdministrator(project); call(VERSION.name(), "5.6.3", firstAnalysis.getUuid()); call(VERSION.name(), "6.3", secondAnalysis.getUuid()); List<EventDto> events = dbClient.eventDao().selectByComponentUuid(dbSession, project.uuid()); assertThat(events).hasSize(2); }
@Test public void fail_when_not_enough_permission() { ComponentDto project = db.components().insertPrivateProject(); db.components().insertSnapshot(newAnalysis(project).setUuid("A1").setLast(false)); userSession.logIn(); expectedException.expect(ForbiddenException.class); call("A1"); }
@Test public void delete_version_event() { ComponentDto project = db.components().insertPrivateProject(); SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(project).setVersion("5.6.3").setLast(false)); db.events().insertEvent(newEvent(analysis).setUuid("E1").setCategory(VERSION.getLabel())); logInAsProjectAdministrator(project); call("E1"); SnapshotDto newAnalysis = dbClient.snapshotDao().selectByUuid(dbSession, analysis.getUuid()).get(); assertThat(newAnalysis.getVersion()).isNull(); }
@Test public void project_administrator_is_allowed_to_get_project_status() { OrganizationDto organization = db.organizations().insert(); ComponentDto project = db.components().insertPrivateProject(organization); SnapshotDto snapshot = dbClient.snapshotDao().insert(dbSession, newAnalysis(project)); dbSession.commit(); userSession.addProjectPermission(UserRole.ADMIN, project); ws.newRequest() .setParam(PARAM_ANALYSIS_ID, snapshot.getUuid()) .executeProtobuf(ProjectStatusResponse.class); }
@Test public void project_user_is_allowed_to_get_project_status() { 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); ws.newRequest() .setParam(PARAM_ANALYSIS_ID, snapshot.getUuid()) .executeProtobuf(ProjectStatusResponse.class); }
@Test public void fail_if_not_a_project_portfolio_or_application() { ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); db.components().insertSnapshot(newAnalysis(project)); userSession.registerComponents(project, file); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("A project, portfolio or application is required"); call(file.getDbKey()); }
@Test public void provisioned_projects() { userSession.logIn().addPermission(ADMINISTER, db.getDefaultOrganization()); ComponentDto provisionedProject = db.components().insertPrivateProject(); ComponentDto analyzedProject = db.components().insertPrivateProject(); db.components().insertSnapshot(newAnalysis(analyzedProject)); ws.newRequest().setParam(PARAM_ON_PROVISIONED_ONLY, "true").execute(); verifyDeleted(provisionedProject); verifyListenersOnProjectsDeleted(provisionedProject); }
@Test public void return_file_with_missing_duplication_data() { ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project).setDbKey("foo.js")); db.components().insertSnapshot(newAnalysis(project)); userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project); TestResponse result = newBaseRequest().setParam("key", file.getDbKey()).execute(); assertJson(result.getInput()).isSimilarTo("{\n" + " \"duplications\": [],\n" + " \"files\": {}\n" + "}"); }
@Test public void not_fail_if_analysis_date_is_after_last_analysis() { ComponentDto project = ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert(), "ABCD").setDbKey(PROJECT_KEY); dbClient.componentDao().insert(dbTester.getSession(), project); dbClient.snapshotDao().insert(dbTester.getSession(), SnapshotTesting.newAnalysis(project).setCreatedAt(1420088400000L)); // 2015-01-01 dbTester.getSession().commit(); treeRootHolder.setRoot(ReportComponent.builder(Component.Type.PROJECT, 1).setUuid("ABCD").setKey(PROJECT_KEY).build()); underTest.execute(new TestComputationStepContext()); }