@Test public void test_getters_and_setters() { EventDto dto = new EventDto() .setId(1L) .setAnalysisUuid("uuid_1") .setComponentUuid("ABCD") .setName("1.0") .setCategory("Version") .setDescription("Version 1.0") .setData("some data") .setDate(1413407091086L) .setCreatedAt(1225630680000L); assertThat(dto.getId()).isEqualTo(1L); assertThat(dto.getAnalysisUuid()).isEqualTo("uuid_1"); assertThat(dto.getComponentUuid()).isEqualTo("ABCD"); assertThat(dto.getName()).isEqualTo("1.0"); assertThat(dto.getCategory()).isEqualTo("Version"); assertThat(dto.getDescription()).isEqualTo("Version 1.0"); assertThat(dto.getData()).isEqualTo("some data"); assertThat(dto.getCreatedAt()).isEqualTo(1225630680000L); }
private EventDto toDbEvent(CreateEventRequest request, SnapshotDto analysis) { checkArgument(isNotBlank(request.getName()), "A non empty name is required"); return new EventDto() .setUuid(uuidFactory.create()) .setAnalysisUuid(analysis.getUuid()) .setComponentUuid(analysis.getComponentUuid()) .setCategory(request.getCategory().getLabel()) .setName(request.getName()) .setCreatedAt(system.now()) .setDate(analysis.getCreatedAt()); }
private EventDto newBaseEvent(Component component, Long analysisDate) { return new EventDto() .setUuid(uuidFactory.create()) .setAnalysisUuid(analysisMetadataHolder.getUuid()) .setComponentUuid(component.getUuid()) .setCreatedAt(system2.now()) .setDate(analysisDate); }
private Consumer<EventDto> checkNonConflictingOtherEvents(DbSession dbSession) { return candidateEvent -> { List<EventDto> dbEvents = dbClient.eventDao().selectByAnalysisUuid(dbSession, candidateEvent.getAnalysisUuid()); Predicate<EventDto> otherEventWithSameName = otherEvent -> !candidateEvent.getUuid().equals(otherEvent.getUuid()) && otherEvent.getName().equals(candidateEvent.getName()); dbEvents.stream() .filter(otherEventWithSameName) .findAny() .ifPresent(event -> { throw new IllegalArgumentException(format("An '%s' event with the same name already exists on analysis '%s'", candidateEvent.getCategory(), candidateEvent.getAnalysisUuid())); }); }; }
private Optional<Period> newPeriod(DbSession dbSession, String periodMode, EventDto previousVersion) { Optional<Period> period = dbClient.snapshotDao().selectByUuid(dbSession, previousVersion.getAnalysisUuid()) .map(dto -> newPeriod(periodMode, previousVersion.getName(), dto)); if (!period.isPresent()) { throw new IllegalStateException(format("Analysis '%s' for version event '%s' has been deleted", previousVersion.getAnalysisUuid(), previousVersion.getName())); } return period; }
private void processEvents(DbSession session, Component component, Long analysisDate) { Function<Event, EventDto> eventToEventDto = event -> newBaseEvent(component, analysisDate) .setName(event.getName()) .setCategory(convertCategory(event.getCategory())) .setDescription(event.getDescription()) .setData(event.getData()); // FIXME bulk insert for (EventDto batchEventDto : StreamSupport.stream(eventRepository.getEvents(component).spliterator(), false).map(eventToEventDto).collect(Collectors.toList())) { dbClient.eventDao().insert(session, batchEventDto); } }
@Test public void persist_profile_events_on_root() { when(system2.now()).thenReturn(NOW); treeRootHolder.setRoot(ROOT); Event profile = Event.createProfile("foo", null, "bar"); when(eventRepository.getEvents(ROOT)).thenReturn(ImmutableList.of(profile)); underTest.execute(new TestComputationStepContext()); assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "events")).isEqualTo(2); List<EventDto> eventDtos = dbTester.getDbClient().eventDao().selectByComponentUuid(dbTester.getSession(), ROOT.getUuid()); assertThat(eventDtos) .extracting(EventDto::getCategory) .containsOnly(CATEGORY_PROFILE, CATEGORY_VERSION); EventDto eventDto = eventDtos.stream().filter(t -> CATEGORY_PROFILE.equals(t.getCategory())).findAny().get(); assertThat(eventDto.getComponentUuid()).isEqualTo(ROOT.getUuid()); assertThat(eventDto.getName()).isEqualTo(profile.getName()); assertThat(eventDto.getDescription()).isEqualTo(profile.getDescription()); assertThat(eventDto.getCategory()).isEqualTo(EventDto.CATEGORY_PROFILE); assertThat(eventDto.getData()).isNull(); assertThat(eventDto.getDate()).isEqualTo(analysisMetadataHolder.getAnalysisDate()); assertThat(eventDto.getCreatedAt()).isEqualTo(NOW); }
@Test public void select_by_component_uuid() { dbTester.prepareDbUnit(getClass(), "shared.xml"); List<EventDto> dtos = underTest.selectByComponentUuid(dbTester.getSession(), "ABCD"); assertThat(dtos).hasSize(3); dtos = underTest.selectByComponentUuid(dbTester.getSession(), "BCDE"); assertThat(dtos).hasSize(1); EventDto dto = dtos.get(0); assertThat(dto.getId()).isEqualTo(4L); assertThat(dto.getUuid()).isEqualTo("E4"); assertThat(dto.getAnalysisUuid()).isEqualTo("uuid_1"); assertThat(dto.getComponentUuid()).isEqualTo("BCDE"); assertThat(dto.getName()).isEqualTo("1.0"); assertThat(dto.getCategory()).isEqualTo("Version"); assertThat(dto.getDescription()).isEqualTo("Version 1.0"); assertThat(dto.getData()).isEqualTo("some data"); assertThat(dto.getDate()).isEqualTo(1413407091086L); assertThat(dto.getCreatedAt()).isEqualTo(1225630680000L); }
@Test public void return_events() { OrganizationDto organizationDto = db.organizations().insert(); ComponentDto project = db.components().insertComponent(ComponentTesting.newPrivateProjectDto(organizationDto).setDbKey("P1")); userSession.addProjectPermission(UserRole.USER, project); SnapshotDto a1 = db.components().insertSnapshot(newAnalysis(project).setUuid("A1")); SnapshotDto a42 = db.components().insertSnapshot(newAnalysis(ComponentTesting.newPrivateProjectDto(organizationDto)).setUuid("A42")); EventDto e1 = db.events().insertEvent(newEvent(a1).setUuid("E1").setName("N1").setCategory(EventCategory.QUALITY_GATE.getLabel()).setDescription("D1")); EventDto e2 = db.events().insertEvent(newEvent(a1).setUuid("E2").setName("N2").setCategory(VERSION.getLabel()).setDescription("D2")); db.events().insertEvent(newEvent(a42)); List<Analysis> result = call("P1").getAnalysesList(); assertThat(result).hasSize(1); List<Event> events = result.get(0).getEventsList(); assertThat(events).hasSize(2); assertThat(events).extracting(Event::getKey, wsToDbCategory(), Event::getName, Event::getDescription).containsOnly( tuple(e1.getUuid(), e1.getCategory(), e1.getName(), e1.getDescription()), tuple(e2.getUuid(), e2.getCategory(), e2.getName(), e2.getDescription())); }
@Test public void update_name_in_db() { SnapshotDto analysis = createAnalysisAndLogInAsProjectAdministrator("5.6"); EventDto originalEvent = db.events().insertEvent(newEvent(analysis).setUuid("E1").setName("Original Name")); call("E1", "name"); EventDto newEvent = dbClient.eventDao().selectByUuid(dbSession, "E1").get(); assertThat(newEvent.getName()).isEqualTo("name"); assertThat(newEvent.getDescription()).isNull(); assertThat(newEvent.getCategory()).isEqualTo(originalEvent.getCategory()); assertThat(newEvent.getDate()).isEqualTo(originalEvent.getDate()); assertThat(newEvent.getCreatedAt()).isEqualTo(originalEvent.getCreatedAt()); }
@Test public void update_name_only_in_db() { SnapshotDto analysis = createAnalysisAndLogInAsProjectAdministrator("5.6"); EventDto originalEvent = db.events().insertEvent(newEvent(analysis).setUuid("E1").setName("Original Name").setDescription("Original Description")); call("E1", "name"); EventDto newEvent = dbClient.eventDao().selectByUuid(dbSession, "E1").get(); assertThat(newEvent.getName()).isEqualTo("name"); assertThat(newEvent.getDescription()).isEqualTo(originalEvent.getDescription()); }
@Test public void update_OTHER_event_does_not_update_analysis_version() { SnapshotDto analysis = createAnalysisAndLogInAsProjectAdministrator("5.6"); db.events().insertEvent(newEvent(analysis).setUuid("E1").setCategory(OTHER.getLabel())); call("E1", "6.3"); SnapshotDto updatedAnalysis = dbClient.snapshotDao().selectByUuid(dbSession, analysis.getUuid()).get(); assertThat(updatedAnalysis.getVersion()).isEqualTo("5.6"); }
private void saveVersionEvent(DbSession session, Component component, Long analysisDate) { String version = component.getProjectAttributes().getVersion(); deletePreviousEventsHavingSameVersion(session, version, component); dbClient.eventDao().insert(session, newBaseEvent(component, analysisDate) .setName(version) .setCategory(EventDto.CATEGORY_VERSION)); }
@Test public void ignore_unprocessed_snapshots() { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto project = dbTester.components().insertPrivateProject(organization); SnapshotDto analysis1 = dbTester.components() .insertSnapshot(project, snapshot -> snapshot.setStatus(STATUS_UNPROCESSED).setCreatedAt(1226379600000L).setLast(false));// 2008-11-11 SnapshotDto analysis2 = dbTester.components().insertSnapshot(project, snapshot -> snapshot.setStatus(STATUS_PROCESSED).setVersion("not provided").setCreatedAt(1226379600000L).setLast(false));// 2008-11-29 dbTester.events().insertEvent(newEvent(analysis1).setName("not provided").setCategory(CATEGORY_VERSION).setDate(analysis1.getCreatedAt())); dbTester.events().insertEvent(newEvent(analysis2).setName("not provided").setCategory(CATEGORY_VERSION).setDate(analysis2.getCreatedAt())); when(analysisMetadataHolder.getAnalysisDate()).thenReturn(november30th2008.getTime()); when(analysisMetadataHolder.isFirstAnalysis()).thenReturn(false); setupRoot(project); settings.setProperty("sonar.leak.period", "100"); underTest.execute(new TestComputationStepContext()); assertPeriod(LEAK_PERIOD_MODE_DAYS, "100", analysis2.getCreatedAt(), analysis2.getUuid()); verifyDebugLogs("Resolving new code period by 100 days: 2008-08-22"); }
@Test public void limit_version_name_length_to_100_for_analysis_events() { SnapshotDto analysis = createAnalysisAndLogInAsProjectAdministrator("5.6"); db.events().insertEvent(newEvent(analysis).setUuid("E1").setCategory(OTHER.getLabel()).setName("E1 name")); db.events().insertEvent(newEvent(analysis).setUuid("E2").setCategory(VERSION.getLabel()).setName("E2 name")); call("E1", repeat("a", 100)); call("E1", repeat("a", 101)); call("E2", repeat("a", 100)); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Version length (101) is longer than the maximum authorized (100). 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' was provided"); call("E2", repeat("a", 101)); }
private void deleteEvent(DbSession dbSession, EventDto dbEvent) { if (VERSION.getLabel().equals(dbEvent.getCategory())) { SnapshotDto analysis = dbClient.snapshotDao().selectByUuid(dbSession, dbEvent.getAnalysisUuid()) .orElseThrow(() -> new IllegalStateException(format("Analysis '%s' not found", dbEvent.getAnalysisUuid()))); checkArgument(!analysis.getLast(), "Cannot delete the version event of last analysis"); analysis.setVersion(null); dbClient.snapshotDao().update(dbSession, analysis); } dbClient.eventDao().delete(dbSession, dbEvent.getUuid()); dbSession.commit(); }
private void deletePreviousEventsHavingSameVersion(DbSession session, String version, Component component) { for (EventDto dto : dbClient.eventDao().selectByComponentUuid(session, component.getUuid())) { if (Objects.equals(dto.getCategory(), EventDto.CATEGORY_VERSION) && Objects.equals(dto.getName(), version)) { dbClient.eventDao().delete(session, dto.getId()); } } }
@Test public void ws_response_with_updated_name() { SnapshotDto analysis = createAnalysisAndLogInAsProjectAdministrator("5.6"); EventDto originalEvent = db.events().insertEvent(newEvent(analysis).setUuid("E1").setName("Original Name")); ProjectAnalyses.Event result = call("E1", "name").getEvent(); assertThat(result.getName()).isEqualTo("name"); assertThat(result.hasDescription()).isFalse(); assertThat(result.getCategory()).isEqualTo(OTHER.name()); assertThat(result.getAnalysis()).isEqualTo(originalEvent.getAnalysisUuid()); assertThat(result.getKey()).isEqualTo("E1"); }
@Test public void update_name_and_description() { SnapshotDto analysis = dbTester.components().insertProjectAndSnapshot(ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert())); dbTester.events().insertEvent(newEvent(analysis).setUuid("E1")); underTest.update(dbSession, "E1", "New Name", "New Description"); EventDto result = dbClient.eventDao().selectByUuid(dbSession, "E1").get(); assertThat(result.getName()).isEqualTo("New Name"); assertThat(result.getDescription()).isEqualTo("New Description"); }
private static Predicate<EventDto> filterSimilarEvents(CreateEventRequest request) { switch (request.getCategory()) { case VERSION: return dbEvent -> VERSION.getLabel().equals(dbEvent.getCategory()); case OTHER: return dbEvent -> OTHER.getLabel().equals(dbEvent.getCategory()) && request.getName().equals(dbEvent.getName()); default: throw new IllegalStateException("Event category not handled: " + request.getCategory()); } }