private Optional<Period> resolvePreviousVersion(DbSession dbSession, String currentVersion, List<EventDto> versions, String mostRecentVersion) { EventDto previousVersion = versions.get(currentVersion.equals(mostRecentVersion) ? 1 : 0); LOG.debug("Resolving new code period by previous version: {}", previousVersion.getName()); return newPeriod(dbSession, LEAK_PERIOD_MODE_PREVIOUS_VERSION, previousVersion); }
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 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> resolveVersion(DbSession dbSession, List<EventDto> versions, String propertyValue) { LOG.debug("Resolving new code period by version: {}", propertyValue); Optional<EventDto> version = versions.stream().filter(t -> propertyValue.equals(t.getName())).findFirst(); checkPeriodProperty(version.isPresent(), propertyValue, "version is none of the existing ones: %s", supplierToString(() -> toVersions(versions))); return newPeriod(dbSession, LEAK_PERIOD_MODE_VERSION, version.get()); }
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()); } }
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()); } } }
private Optional<Period> resolve(DbSession dbSession, String projectUuid, String analysisProjectVersion, String propertyValue) { Integer days = parseDaysQuietly(propertyValue); if (days != null) { return resolveByDays(dbSession, projectUuid, days, propertyValue); } Instant date = parseDate(propertyValue); if (date != null) { return resolveByDate(dbSession, projectUuid, date, propertyValue); } List<EventDto> versions = dbClient.eventDao().selectVersionsByMostRecentFirst(dbSession, projectUuid); if (versions.isEmpty()) { return resolveWhenNoExistingVersion(dbSession, projectUuid, analysisProjectVersion, propertyValue); } String mostRecentVersion = Optional.ofNullable(versions.iterator().next().getName()) .orElseThrow(() -> new IllegalStateException("selectVersionsByMostRecentFirst returned a DTO which didn't have a name")); boolean previousVersionPeriod = LEAK_PERIOD_MODE_PREVIOUS_VERSION.equals(propertyValue); if (previousVersionPeriod) { if (versions.size() == 1) { return resolvePreviousVersionWithOnlyOneExistingVersion(dbSession, projectUuid); } return resolvePreviousVersion(dbSession, analysisProjectVersion, versions, mostRecentVersion); } return resolveVersion(dbSession, versions, propertyValue); }
private Consumer<EventDto> updateInDb(DbSession dbSession) { return event -> { dbClient.eventDao().update(dbSession, event.getUuid(), event.getName(), event.getDescription()); if (VERSION.getLabel().equals(event.getCategory())) { SnapshotDto analysis = getAnalysis(dbSession, event); analysis.setVersion(event.getName()); dbClient.snapshotDao().update(dbSession, analysis); } dbSession.commit(); }; }
private static Function<EventDto, UpdateEventResponse> toWsResponse() { return dbEvent -> { Event.Builder wsEvent = Event.newBuilder() .setKey(dbEvent.getUuid()) .setCategory(fromLabel(dbEvent.getCategory()).name()) .setAnalysis(dbEvent.getAnalysisUuid()); ofNullable(dbEvent.getName()).ifPresent(wsEvent::setName); ofNullable(dbEvent.getDescription()).ifPresent(wsEvent::setDescription); return UpdateEventResponse.newBuilder().setEvent(wsEvent).build(); }; }
private Event.Builder dbToWsEvent(EventDto dbEvent) { wsEvent.clear().setKey(dbEvent.getUuid()); ofNullable(dbEvent.getName()).ifPresent(wsEvent::setName); ofNullable(dbEvent.getDescription()).ifPresent(wsEvent::setDescription); ofNullable(dbEvent.getCategory()).ifPresent(cat -> wsEvent.setCategory(fromLabel(cat).name())); if (dbEvent.getCategory() != null) { switch (EventCategory.fromLabel(dbEvent.getCategory())) { case DEFINITION_CHANGE: addDefinitionChange(dbEvent); break; case QUALITY_GATE: addQualityGateInformation(dbEvent); break; case VERSION: case OTHER: case QUALITY_PROFILE: default: break; } } return wsEvent; }
@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); }
private static CreateEventResponse toCreateEventResponse(EventDto dbEvent) { Event.Builder wsEvent = Event.newBuilder() .setKey(dbEvent.getUuid()) .setCategory(fromLabel(dbEvent.getCategory()).name()) .setAnalysis(dbEvent.getAnalysisUuid()) .setName(dbEvent.getName()); ofNullable(dbEvent.getDescription()).ifPresent(wsEvent::setDescription); return CreateEventResponse.newBuilder().setEvent(wsEvent).build(); }
@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 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); }
@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 persist_alert_events_on_root() { when(system2.now()).thenReturn(NOW); treeRootHolder.setRoot(ROOT); Event alert = Event.createAlert("Red (was Orange)", null, "Open issues > 0"); when(eventRepository.getEvents(ROOT)).thenReturn(ImmutableList.of(alert)); 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_ALERT, CATEGORY_VERSION); EventDto eventDto = eventDtos.stream().filter(t -> CATEGORY_ALERT.equals(t.getCategory())).findAny().get(); assertThat(eventDto.getComponentUuid()).isEqualTo(ROOT.getUuid()); assertThat(eventDto.getName()).isEqualTo(alert.getName()); assertThat(eventDto.getDescription()).isEqualTo(alert.getDescription()); assertThat(eventDto.getCategory()).isEqualTo(CATEGORY_ALERT); assertThat(eventDto.getData()).isNull(); assertThat(eventDto.getDate()).isEqualTo(analysisMetadataHolder.getAnalysisDate()); assertThat(eventDto.getCreatedAt()).isEqualTo(NOW); }
@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_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"); }
EventDto eventDto = eventDtos.iterator().next(); assertThat(eventDto.getComponentUuid()).isEqualTo(ROOT.getUuid()); assertThat(eventDto.getName()).isEqualTo("1.0"); assertThat(eventDto.getDescription()).isNull(); assertThat(eventDto.getCategory()).isEqualTo(CATEGORY_VERSION);
@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())); }