private static Consumer<EventDto> checkVersionNameLength(UpdateEventRequest request) { String name = request.getName(); return candidateEvent -> { if (name != null && VERSION.getLabel().equals(candidateEvent.getCategory())) { checkArgument(name.length() <= MAX_NAME_LENGTH, "Version length (%s) is longer than the maximum authorized (%s). '%s' was provided.", name.length(), MAX_NAME_LENGTH, name); } }; }
static Consumer<EventDto> checkModifiable() { return event -> checkArgument(AUTHORIZED_CATEGORIES.contains(fromLabel(event.getCategory()).name()), "Event of category '%s' cannot be modified. Authorized categories: %s", EventCategory.fromLabel(event.getCategory()), AUTHORIZED_CATEGORIES_INLINED); } }
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 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 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; }
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 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 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(); }; }
@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 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()); }
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 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); }
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(); }; }
@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 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); }
assertThat(eventDto.getName()).isEqualTo("1.0"); assertThat(eventDto.getDescription()).isNull(); assertThat(eventDto.getCategory()).isEqualTo(CATEGORY_VERSION); assertThat(eventDto.getData()).isNull(); assertThat(eventDto.getDate()).isEqualTo(analysisMetadataHolder.getAnalysisDate());
@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())); }
static Consumer<EventDto> checkModifiable() { return event -> checkArgument(AUTHORIZED_CATEGORIES.contains(fromLabel(event.getCategory()).name()), "Event of category '%s' cannot be modified. Authorized categories: %s", EventCategory.fromLabel(event.getCategory()), AUTHORIZED_CATEGORIES_INLINED); } }
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 Event.Builder dbToWsEvent(EventDto dbEvent) { wsEvent.clear().setKey(dbEvent.getUuid()); setNullable(dbEvent.getName(), wsEvent::setName); setNullable(dbEvent.getDescription(), wsEvent::setDescription); setNullable(dbEvent.getCategory(), cat -> wsEvent.setCategory(fromLabel(cat).name())); return wsEvent; }