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 void addDefinitionChange(EventDto event) { wsDefinitionChange.clear(); List<EventComponentChangeDto> eventComponentChangeDtos = searchData.componentChangesByEventUuid.get(event.getUuid()); if (eventComponentChangeDtos.isEmpty()) { return; } ListMultimap<String, EventComponentChangeDto> componentChangeByKey = eventComponentChangeDtos.stream() .collect(index(EventComponentChangeDto::getComponentKey)); try { wsDefinitionChange.addAllProjects( componentChangeByKey.asMap().values().stream() .map(SearchResponseBuilder::addChange) .map(Project::toProject) .collect(toList()) ); wsEvent.setDefinitionChange(wsDefinitionChange.build()); } catch (IllegalStateException e) { LOGGER.error(e.getMessage(), e); } }
private void addQualityGateInformation(EventDto event) { wsQualityGate.clear(); List<EventComponentChangeDto> eventComponentChangeDtos = searchData.componentChangesByEventUuid.get(event.getUuid()); if (eventComponentChangeDtos.isEmpty()) { return; } if (event.getData() != null) { try { Gson gson = new Gson(); Data data = gson.fromJson(event.getData(), Data.class); wsQualityGate.setStillFailing(data.isStillFailing()); wsQualityGate.setStatus(data.getStatus()); } catch (JsonSyntaxException ex) { LOGGER.error("Unable to retrieve data from event uuid=" + event.getUuid(), ex); return; } } wsQualityGate.addAllFailing(eventComponentChangeDtos.stream() .map(SearchResponseBuilder::toFailing) .collect(toList())); wsEvent.setQualityGate(wsQualityGate.build()); }
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 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 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(); }
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 EventComponentChangeDto generateEventComponentChange(EventDto event, ChangeCategory category, String name, String key, @Nullable String branch, String componentUuid) { return new EventComponentChangeDto() .setCategory(category) .setUuid(uuidFactoryFast.create()) .setComponentName(name) .setComponentKey(key) .setComponentBranchKey(branch) .setComponentUuid(componentUuid) .setEventUuid(event.getUuid()); }
@Test public void select_by_uuid() { SnapshotDto analysis = dbTester.components().insertProjectAndSnapshot(ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert())); dbTester.events().insertEvent(newEvent(analysis).setUuid("A1")); dbTester.events().insertEvent(newEvent(analysis).setUuid("A2")); dbTester.events().insertEvent(newEvent(analysis).setUuid("A3")); Optional<EventDto> result = underTest.selectByUuid(dbSession, "A2"); assertThat(result).isPresent(); assertThat(result.get().getUuid()).isEqualTo("A2"); }
public EventComponentChangeDto insertEventComponentChanges(EventDto event, SnapshotDto analysis, ChangeCategory changeCategory, ComponentDto component, @Nullable BranchDto branch) { EventComponentChangeDto eventComponentChange = new EventComponentChangeDto() .setUuid(UuidFactoryFast.getInstance().create()) .setCategory(changeCategory) .setEventUuid(event.getUuid()) .setComponentUuid(component.uuid()) .setComponentKey(component.getKey()) .setComponentName(component.name()) .setComponentBranchKey(Optional.ofNullable(branch).map(BranchDto::getKey).orElse(null)); EventPurgeData eventPurgeData = new EventPurgeData(analysis.getComponentUuid(), analysis.getUuid()); dbClient.eventComponentChangeDao().insert(dbSession, eventComponentChange, eventPurgeData); db.commit(); return eventComponentChange; }
.isEqualTo(3); assertThat(uuidsIn("events")) .containsOnly(projectEvent1.getUuid(), projectEvent2.getUuid(), projectEvent3.getUuid()); .isEqualTo(1); assertThat(uuidsIn("events")) .containsOnly(projectEvent2.getUuid(), projectEvent3.getUuid()); .isEqualTo(1); assertThat(uuidsIn("events")) .containsOnly(projectEvent2.getUuid(), projectEvent3.getUuid()); .isEqualTo(1); assertThat(uuidsIn("events")) .containsOnly(projectEvent2.getUuid());
@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 pull_request() { ComponentDto project = db.components().insertPrivateProject(); userSession.addProjectPermission(UserRole.USER, project); ComponentDto branch = db.components().insertProjectBranch(project, b -> b.setKey("pr-123").setBranchType(PULL_REQUEST)); SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(branch)); EventDto event = db.events().insertEvent(newEvent(analysis).setCategory(EventCategory.QUALITY_GATE.getLabel())); List<Analysis> result = call(SearchRequest.builder() .setProject(project.getKey()) .setPullRequest("pr-123") .build()) .getAnalysesList(); assertThat(result).extracting(Analysis::getKey).containsExactlyInAnyOrder(analysis.getUuid()); assertThat(result.get(0).getEventsList()).extracting(Event::getKey).containsExactlyInAnyOrder(event.getUuid()); }
.isEqualTo(5); assertThat(uuidsIn("events")) .containsOnly(projectEvent1.getUuid(), projectEvent2.getUuid(), projectEvent3.getUuid(), anotherBranchEvent.getUuid(), anotherProjectEvent.getUuid()); .isEqualTo(2); assertThat(uuidsIn("events")) .containsOnly(anotherBranchEvent.getUuid(), anotherProjectEvent.getUuid());
@Test public void branch() { ComponentDto project = db.components().insertPrivateProject(); userSession.addProjectPermission(UserRole.USER, project); ComponentDto branch = db.components().insertProjectBranch(project, b -> b.setKey("my_branch")); SnapshotDto analysis = db.components().insertSnapshot(newAnalysis(branch)); EventDto event = db.events().insertEvent(newEvent(analysis).setCategory(EventCategory.QUALITY_GATE.getLabel())); List<Analysis> result = call(SearchRequest.builder() .setProject(project.getKey()) .setBranch("my_branch") .build()) .getAnalysesList(); assertThat(result).extracting(Analysis::getKey).containsExactlyInAnyOrder(analysis.getUuid()); assertThat(result.get(0).getEventsList()).extracting(Event::getKey).containsExactlyInAnyOrder(event.getUuid()); }
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 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; }
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()); setNullable(dbEvent.getDescription(), wsEvent::setDescription); return CreateEventResponse.newBuilder().setEvent(wsEvent).build(); }