diff --git a/build.gradle b/build.gradle index d3c5650..c401fe5 100644 --- a/build.gradle +++ b/build.gradle @@ -86,8 +86,6 @@ dependencies { } testImplementation 'org.springframework.security:spring-security-test' testImplementation 'com.tngtech.archunit:archunit-junit5:0.13.1' - implementation 'junit:junit:4.12' - implementation 'junit:junit:4.12' } test { diff --git a/src/main/java/mops/gruppen2/domain/event/AddUserEvent.java b/src/main/java/mops/gruppen2/domain/event/AddUserEvent.java index 0e297fa..9020b0c 100644 --- a/src/main/java/mops/gruppen2/domain/event/AddUserEvent.java +++ b/src/main/java/mops/gruppen2/domain/event/AddUserEvent.java @@ -39,7 +39,7 @@ public class AddUserEvent extends Event { throw new UserAlreadyExistsException(this.getClass().toString()); } - if (group.getMembers().size() == group.getUserMaximum()) { + if (group.getMembers().size() >= group.getUserMaximum()) { throw new GroupFullException(this.getClass().toString()); } diff --git a/src/main/java/mops/gruppen2/repository/EventRepository.java b/src/main/java/mops/gruppen2/repository/EventRepository.java index b306452..f2199e8 100644 --- a/src/main/java/mops/gruppen2/repository/EventRepository.java +++ b/src/main/java/mops/gruppen2/repository/EventRepository.java @@ -9,6 +9,7 @@ import org.springframework.stereotype.Repository; import java.util.List; @Repository +//TODO Rename Queries + Formatting public interface EventRepository extends CrudRepository { @Query("select distinct group_id from event where user_id =:id") diff --git a/src/main/java/mops/gruppen2/service/ControllerService.java b/src/main/java/mops/gruppen2/service/ControllerService.java index 57341f8..aa7fc2b 100644 --- a/src/main/java/mops/gruppen2/service/ControllerService.java +++ b/src/main/java/mops/gruppen2/service/ControllerService.java @@ -56,7 +56,7 @@ public class ControllerService { */ public void createGroup(Account account, String title, String description, Boolean visibility, Boolean maxInfiniteUsers, Long userMaximum, UUID parent) throws EventException { Visibility visibility1; - UUID groupId = eventService.checkGroup(); + UUID groupId = UUID.randomUUID(); maxInfiniteUsers = maxInfiniteUsers != null; @@ -91,8 +91,7 @@ public class ControllerService { visibility = visibility == null; lecture = lecture != null; Visibility visibility1; - UUID groupId = eventService.checkGroup(); - + UUID groupId = UUID.randomUUID(); if (visibility) { visibility1 = Visibility.PUBLIC; } else { diff --git a/src/main/java/mops/gruppen2/service/EventService.java b/src/main/java/mops/gruppen2/service/EventService.java index 4d52888..92a671f 100644 --- a/src/main/java/mops/gruppen2/service/EventService.java +++ b/src/main/java/mops/gruppen2/service/EventService.java @@ -12,6 +12,7 @@ import java.util.UUID; import java.util.stream.Collectors; @Service +//TODO: Evtl aufsplitten in EventRepoService und EventService? public class EventService { private final JsonService jsonService; @@ -28,8 +29,22 @@ public class EventService { * @param event Event, welches gespeichert wird */ public void saveEvent(Event event) { - EventDTO eventDTO = getDTO(event); - eventStore.save(eventDTO); + eventStore.save(getDTO(event)); + } + + public void saveAll(Event... events) { + for (Event event : events) { + eventStore.save(getDTO(event)); + } + } + + @SafeVarargs + public final void saveAll(List... events) { + for (List eventlist : events) { + for (Event event : eventlist) { + eventStore.save(getDTO(event)); + } + } } /** @@ -39,6 +54,7 @@ public class EventService { * @param event Event, welches in DTO übersetzt wird * @return EventDTO Neues DTO */ + //TODO Rename: getDTOFromEvent? public EventDTO getDTO(Event event) { String payload = ""; try { @@ -56,26 +72,9 @@ public class EventService { return event.getClass().getName().substring(lastDot + 1); } - /** - * Gibt die nächst höhere groupID zurück die belegt werden kann. - * Gibt 1 zurück, falls keine Gruppe vorhanden ist. - * - * @return Long GruppenId - */ - public UUID checkGroup() { - return UUID.randomUUID(); - - /*Long maxGroupID = eventStore.getMaxGroupID(); - - if (maxGroupID == null) { - return 1L; - } - - return maxGroupID + 1;*/ - } - /** * Findet alle Events welche ab dem neuen Status hinzugekommen sind. + * Sucht alle Events mit event_id > status * * @param status Die Id des zuletzt gespeicherten Events * @return Liste von neueren Events @@ -93,6 +92,7 @@ public class EventService { * @param eventDTOS Liste von DTOs * @return Liste von Events */ + //TODO Rename: getEventsFromDTO? public List translateEventDTOs(Iterable eventDTOS) { List events = new ArrayList<>(); @@ -106,17 +106,6 @@ public class EventService { return events; } - /** - * Sichert eine Liste von Event Objekten mithilfe der Methode saveEvent(Event event). - * - * @param eventList Liste von Event Objekten - */ - public void saveEventList(List eventList) { - for (Event event : eventList) { - saveEvent(event); - } - } - public Long getMaxEvent_id() { return eventStore.getHighesEvent_ID(); } @@ -126,6 +115,7 @@ public class EventService { return translateEventDTOs(eventDTOList); } + //TODO: Nur AddUserEvents betrachten public List findGroupIdsByUser(String userId) { return eventStore.findGroup_idsWhereUser_id(userId).stream() .map(UUID::fromString) diff --git a/src/main/java/mops/gruppen2/service/GroupService.java b/src/main/java/mops/gruppen2/service/GroupService.java index aa22132..35df9dd 100644 --- a/src/main/java/mops/gruppen2/service/GroupService.java +++ b/src/main/java/mops/gruppen2/service/GroupService.java @@ -35,6 +35,7 @@ public class GroupService { * @param groupIds Liste an IDs * @return Liste an Events */ + //TODO Das vielleicht in den EventRepoService? public List getGroupEvents(List groupIds) { List eventDTOS = new ArrayList<>(); for (UUID groupId : groupIds) { @@ -75,6 +76,7 @@ public class GroupService { * @return Liste von projizierten Gruppen * @throws EventException Projektionsfehler */ + //TODO Rename public List getAllGroupWithVisibilityPublic(String userId) throws EventException { List groupEvents = eventService.translateEventDTOs(eventRepository.findAllEventsByType("CreateGroupEvent")); groupEvents.addAll(eventService.translateEventDTOs(eventRepository.findAllEventsByType("UpdateGroupDescriptionEvent"))); @@ -91,21 +93,16 @@ public class GroupService { .collect(Collectors.toList()); } - /** - * Wird verwendet beim Gruppe erstellen bei der Parent-Auswahl: nur Titel benötigt. - * - * @return - * @throws EventException - */ + public List getAllLecturesWithVisibilityPublic() throws EventException { List createEvents = eventService.translateEventDTOs(eventRepository.findAllEventsByType("CreateGroupEvent")); createEvents.addAll(eventService.translateEventDTOs(eventRepository.findAllEventsByType("DeleteGroupEvent"))); createEvents.addAll(eventService.translateEventDTOs(eventRepository.findAllEventsByType("UpdateGroupTitleEvent"))); + createEvents.addAll(eventService.translateEventDTOs(eventRepository.findAllEventsByType("DeleteGroupEvent"))); List visibleGroups = projectEventList(createEvents); return visibleGroups.parallelStream() - .filter(group -> group.getType() != null) .filter(group -> group.getType() == GroupType.LECTURE) .filter(group -> group.getVisibility() == Visibility.PUBLIC) .collect(Collectors.toList()); @@ -120,6 +117,7 @@ public class GroupService { * @return Liste von projizierten Gruppen * @throws EventException Projektionsfehler */ + //Todo Rename public List findGroupWith(String search, Account account) throws EventException { if (search.isEmpty()) { return getAllGroupWithVisibilityPublic(account.getName()); @@ -127,9 +125,8 @@ public class GroupService { return getAllGroupWithVisibilityPublic(account.getName()) .parallelStream() - .filter(group -> - group.getTitle().toLowerCase().contains(search.toLowerCase()) || - group.getDescription().toLowerCase().contains(search.toLowerCase())) + .filter(group -> group.getTitle().toLowerCase().contains(search.toLowerCase()) + || group.getDescription().toLowerCase().contains(search.toLowerCase())) .collect(Collectors.toList()); } } diff --git a/src/test/java/mops/gruppen2/TestBuilder.java b/src/test/java/mops/gruppen2/TestBuilder.java index 0af9555..5ab59fa 100644 --- a/src/test/java/mops/gruppen2/TestBuilder.java +++ b/src/test/java/mops/gruppen2/TestBuilder.java @@ -7,11 +7,13 @@ import mops.gruppen2.domain.Role; import mops.gruppen2.domain.Visibility; import mops.gruppen2.domain.event.AddUserEvent; import mops.gruppen2.domain.event.CreateGroupEvent; +import mops.gruppen2.domain.event.DeleteGroupEvent; import mops.gruppen2.domain.event.DeleteUserEvent; import mops.gruppen2.domain.event.Event; import mops.gruppen2.domain.event.UpdateGroupDescriptionEvent; import mops.gruppen2.domain.event.UpdateGroupTitleEvent; import mops.gruppen2.domain.event.UpdateRoleEvent; +import mops.gruppen2.security.Account; import java.util.ArrayList; import java.util.Collection; @@ -25,28 +27,67 @@ public class TestBuilder { private static final Faker faker = new Faker(); + public static Account account(String name) { + return new Account(name, + "", + "", + "", + "", + null); + } + + public static Group apply(Group group, Event... events) { + for (Event event : events) { + event.apply(group); + } + + return group; + } + + public static Group apply(Event... events) { + return apply(new Group(), events); + } + + /** + * Baut eine UUID. + * + * @param id Integer id + * @return UUID + */ + public static UUID uuidFromInt(int id) { + return UUID.fromString("00000000-0000-0000-0000-" + + "0".repeat(11 - String.valueOf(id).length()) + + id); + } + /** * Generiert ein EventLog mit mehreren Gruppen und Usern. * * @param count Gruppenanzahl - * @param membercount Gesamte Mitgliederanzahl + * @param membercount Mitgliederanzahl pro Gruppe * @return Eventliste */ - public static List completeGroups(int count, int membercount) { - int memPerGroup = membercount / count; - - return IntStream.rangeClosed(0, count) + public static List completePublicGroups(int count, int membercount) { + return IntStream.range(0, count) .parallel() - .mapToObj(i -> completeGroup(memPerGroup)) + .mapToObj(i -> completePublicGroup(membercount)) .flatMap(Collection::stream) .collect(Collectors.toList()); } - public static List completeGroup(int membercount) { + public static List completePrivateGroups(int count, int membercount) { + return IntStream.range(0, count) + .parallel() + .mapToObj(i -> completePrivateGroup(membercount)) + .flatMap(Collection::stream) + .collect(Collectors.toList()); + } + + public static List completePublicGroup(int membercount) { List eventList = new ArrayList<>(); UUID groupId = UUID.randomUUID(); - eventList.add(createGroupEvent(groupId)); + eventList.add(createPublicGroupEvent(groupId)); eventList.add(updateGroupTitleEvent(groupId)); eventList.add(updateGroupDescriptionEvent(groupId)); eventList.addAll(addUserEvents(membercount, groupId)); @@ -54,8 +95,24 @@ public class TestBuilder { return eventList; } - public static List completeGroup() { - return completeGroup(100); + public static List completePrivateGroup(int membercount) { + List eventList = new ArrayList<>(); + UUID groupId = UUID.randomUUID(); + + eventList.add(createPrivateGroupEvent(groupId)); + eventList.add(updateGroupTitleEvent(groupId)); + eventList.add(updateGroupDescriptionEvent(groupId)); + eventList.addAll(addUserEvents(membercount, groupId)); + + return eventList; + } + + public static List completePublicGroup() { + return completePublicGroup(100); + } + + public static List completePrivateGroup() { + return completePrivateGroup(100); } /** @@ -64,26 +121,69 @@ public class TestBuilder { * @param count Anzahl der verschiedenen Gruppen * @return Eventliste */ - public static List createGroupEvents(int count) { - return IntStream.rangeClosed(0, count) + public static List createPublicGroupEvents(int count) { + return IntStream.range(0, count) .parallel() - .mapToObj(i -> createGroupEvent()) + .mapToObj(i -> createPublicGroupEvent()) .collect(Collectors.toList()); } - public static CreateGroupEvent createGroupEvent(UUID groupId) { + public static List createPrivateGroupEvents(int count) { + return IntStream.range(0, count) + .parallel() + .mapToObj(i -> createPublicGroupEvent()) + .collect(Collectors.toList()); + } + + public static List createMixedGroupEvents(int count) { + return IntStream.range(0, count) + .parallel() + .mapToObj(i -> faker.random().nextInt(0, 1) > 0.5 + ? createPublicGroupEvent() + : createPrivateGroupEvent()) + .collect(Collectors.toList()); + } + + public static Event createPrivateGroupEvent(UUID groupId) { + return createGroupEvent(groupId, Visibility.PRIVATE); + } + + public static Event createPrivateGroupEvent() { + return createPrivateGroupEvent(UUID.randomUUID()); + } + + public static Event createPublicGroupEvent(UUID groupId) { + return createGroupEvent(groupId, Visibility.PUBLIC); + } + + public static Event createPublicGroupEvent() { + return createPublicGroupEvent(UUID.randomUUID()); + } + + public static Event createGroupEvent(UUID groupId, Visibility visibility) { return new CreateGroupEvent( groupId, faker.random().hex(), null, GroupType.SIMPLE, - Visibility.PUBLIC, + visibility, 10000000L ); } - public static CreateGroupEvent createGroupEvent() { - return createGroupEvent(UUID.randomUUID()); + public static Event createLectureEvent() { + return createLectureEvent(UUID.randomUUID()); + } + + public static Event createLectureEvent(UUID groupId) { + return new CreateGroupEvent( + groupId, + faker.random().hex(), + null, + GroupType.LECTURE, + Visibility.PUBLIC, + 10000000L + ); } /** @@ -94,13 +194,13 @@ public class TestBuilder { * @return Eventliste */ public static List addUserEvents(int count, UUID groupId) { - return IntStream.rangeClosed(1, count) + return IntStream.range(0, count) .parallel() .mapToObj(i -> addUserEvent(groupId, String.valueOf(i))) .collect(Collectors.toList()); } - public static AddUserEvent addUserEvent(UUID groupId, String userId) { + public static Event addUserEvent(UUID groupId, String userId) { String firstname = firstname(); String lastname = lastname(); @@ -113,10 +213,11 @@ public class TestBuilder { ); } - public static AddUserEvent addUserEvent(UUID groupId) { + public static Event addUserEvent(UUID groupId) { return addUserEvent(groupId, faker.random().hex()); } + // Am besten einfach nicht benutzen public static List deleteUserEvents(int count, List eventList) { List removeEvents = new ArrayList<>(); List shuffle = eventList.parallelStream() @@ -142,36 +243,44 @@ public class TestBuilder { * @param group Gruppe welche geleert wird * @return Eventliste */ - public static List deleteUserEvents(Group group) { + public static List deleteUserEvents(Group group) { return group.getMembers().parallelStream() .map(user -> deleteUserEvent(group.getId(), user.getId())) .collect(Collectors.toList()); } - public static DeleteUserEvent deleteUserEvent(UUID groupId, String userId) { + public static Event deleteUserEvent(UUID groupId, String userId) { return new DeleteUserEvent( groupId, userId ); } - public static UpdateGroupDescriptionEvent updateGroupDescriptionEvent(UUID groupId) { + public static Event updateGroupDescriptionEvent(UUID groupId) { + return updateGroupDescriptionEvent(groupId, quote()); + } + + public static Event updateGroupDescriptionEvent(UUID groupId, String description) { return new UpdateGroupDescriptionEvent( groupId, faker.random().hex(), - quote() + description ); } - public static UpdateGroupTitleEvent updateGroupTitleEvent(UUID groupId) { + public static Event updateGroupTitleEvent(UUID groupId) { + return updateGroupTitleEvent(groupId, champion()); + } + + public static Event updateGroupTitleEvent(UUID groupId, String title) { return new UpdateGroupTitleEvent( groupId, faker.random().hex(), - champion() + title ); } - public static UpdateRoleEvent randomUpdateRoleEvent(UUID groupId, String userId, Role role) { + public static Event updateRoleEvent(UUID groupId, String userId, Role role) { return new UpdateRoleEvent( groupId, userId, @@ -179,6 +288,10 @@ public class TestBuilder { ); } + public static Event deleteGroupEvent(UUID groupId) { + return new DeleteGroupEvent(groupId, faker.random().hex()); + } + private static String firstname() { return clean(faker.name().firstName()); } diff --git a/src/test/java/mops/gruppen2/architecture/DomainTest.java b/src/test/java/mops/gruppen2/architecture/DomainTest.java index 279ba11..caaa242 100644 --- a/src/test/java/mops/gruppen2/architecture/DomainTest.java +++ b/src/test/java/mops/gruppen2/architecture/DomainTest.java @@ -4,6 +4,7 @@ import com.tngtech.archunit.core.importer.ImportOption; import com.tngtech.archunit.junit.AnalyzeClasses; import com.tngtech.archunit.junit.ArchTest; import com.tngtech.archunit.lang.ArchRule; +import mops.gruppen2.domain.exception.EventException; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses; @@ -44,6 +45,16 @@ public class DomainTest { @ArchTest public static final ArchRule classesThatHaveExceptionInNameShouldBeAssignableToExceptionClass = classes() .that().haveSimpleNameEndingWith("Exception") - .should().beAssignableTo(Exception.class); + .should().beAssignableTo(EventException.class); + + @ArchTest + public static final ArchRule classesInDtoPackageShouldHaveDtoInName = classes() + .that().resideInAPackage("..domain.dto..") + .should().haveSimpleNameEndingWith("DTO"); + + @ArchTest + public static final ArchRule dtoClassesShouldBeInDtoPackage = classes() + .that().haveSimpleNameEndingWith("DTO") + .should().resideInAPackage("..domain.dto.."); } diff --git a/src/test/java/mops/gruppen2/domain/GroupTest.java b/src/test/java/mops/gruppen2/domain/GroupTest.java deleted file mode 100644 index 2c7e475..0000000 --- a/src/test/java/mops/gruppen2/domain/GroupTest.java +++ /dev/null @@ -1,141 +0,0 @@ -package mops.gruppen2.domain; - -class GroupTest { -/* - @BeforeEach - public void setUp() { - } - - - @Test - void applyEvent() { - } - - @Test - void createSingleGroup() throws Exception { - CreateGroupEvent createGroupEvent = new CreateGroupEvent(1L, "Prof", null, GroupType.LECTURE, Visibility.PRIVATE); - - Group group = new Group(); - - group.applyEvent(createGroupEvent); - assertThat(group.getId()).isEqualTo(1L); - assertNull(group.getParent()); - assertEquals(GroupType.LECTURE, group.getType()); - assertEquals(Visibility.PRIVATE, group.getVisibility()); - } - - // Verwendet CreateGroupEvent - @Test - void addSingleUser() throws Exception { - CreateGroupEvent createGroupEvent = new CreateGroupEvent(1L, "pepee",null, GroupType.LECTURE , Visibility.PRIVATE); - Group group = new Group(); - group.applyEvent(createGroupEvent); - - User user = new User("prof", "jens", "bendi", "hi@gmail.com"); - AddUserEvent addUserEvent = new AddUserEvent(1L, 1L, user); - group.applyEvent(addUserEvent); - - assertThat(group.getMembers().get(0)).isEqualTo(user); - } - - @Test - void addExistingUser() throws Exception { - CreateGroupEvent createGroupEvent = new CreateGroupEvent(1L, "prof1", null, GroupType.LECTURE, Visibility.PRIVATE); - Group group = new Group(); - group.applyEvent(createGroupEvent); - - User user1 = new User("prof", "jens", "bendi", "hi@gmail.com"); - AddUserEvent addUserEvent1 = new AddUserEvent(2L, 1L, user1); - group.applyEvent(addUserEvent1); - - User user2 = new User("prof", "olga", "bendi", "hi@gmail.com"); - AddUserEvent addUserEvent2 = new AddUserEvent(3L, 1L, user2); - Assertions.assertThrows(UserAlreadyExistsException.class, () -> { - group.applyEvent(addUserEvent2); - }); - - - assertThat(group.getMembers().size()).isEqualTo(1); - } - - @Test - void deleteSingleUser() throws Exception { - CreateGroupEvent createGroupEvent = new CreateGroupEvent(1L, "Prof", null, GroupType.LECTURE, Visibility.PRIVATE); - User user = new User("Prof", "Pro", "fessor", "pro@fessor.de"); - AddUserEvent addUserEvent = new AddUserEvent(2L, 2L, user); - Group group = new Group(); - group.applyEvent(createGroupEvent); - group.applyEvent(addUserEvent); - - DeleteUserEvent deleteUserEvent = new DeleteUserEvent(3L, 2L, "Prof"); - group.applyEvent(deleteUserEvent); - - assertThat(group.getMembers().size()).isEqualTo(0); - } - - @Test - void deleteUserThatDoesNotExists() throws Exception { - CreateGroupEvent createGroupEvent = new CreateGroupEvent(1L, "Prof", null, GroupType.LECTURE, Visibility.PRIVATE); - Group group = new Group(); - group.applyEvent(createGroupEvent); - - DeleteUserEvent deleteUserEvent = new DeleteUserEvent(3L, 2L, "Prof"); - - Assertions.assertThrows(UserNotFoundException.class, () -> { - group.applyEvent(deleteUserEvent); - }); - } - - // Verwendet CreateGroupEvent und AddUserEvent - @Test - void updateRoleForExistingUser() throws Exception { - // Arrange - CreateGroupEvent createGroupEvent = new CreateGroupEvent(1L, "Prof", null, GroupType.LECTURE, Visibility.PRIVATE); - AddUserEvent addUserEvent = new AddUserEvent(1L, 1L, "5L", "Peter", "Pan", "123@mail.de"); - - Group group = new Group(); - group.applyEvent(createGroupEvent); - group.applyEvent(addUserEvent); - - UpdateRoleEvent updateRoleEvent = new UpdateRoleEvent(1L, 1L, "5L", Role.ADMIN); - - // Act - group.applyEvent(updateRoleEvent); - - // Assert - assertThat(group.getRoles()) - .containsOnlyKeys(group.getMembers().get(0).getUser_id()) - .containsValue(Role.ADMIN); - } - - @Test - void updateRoleForNonExistingUser() throws Exception { - CreateGroupEvent createGroupEvent = new CreateGroupEvent(1L, "Prof", null, GroupType.LECTURE, Visibility.PRIVATE); - UpdateRoleEvent updateRoleEvent = new UpdateRoleEvent(345L, 33L, "coolerUser", Role.ADMIN); - - Group group = new Group(); - group.applyEvent(createGroupEvent); - Assertions.assertThrows(UserNotFoundException.class, () -> { - group.applyEvent(updateRoleEvent); - }); - } - - @Test - void updateTitle() throws Exception { //bitte umschreiben - Group group = new Group(); - UpdateGroupTitleEvent updateGroupTitleEvent = new UpdateGroupTitleEvent(2L, 1L, "Klaus", "Toller Titel"); - group.applyEvent(updateGroupTitleEvent); - - assertThat("Toller Titel").isEqualTo("Toller Titel"); - } - - @Test - void updateBeschreibung() throws Exception { //bitte umschreiben - Group group = new Group(); - - UpdateGroupDescriptionEvent updateGroupDescriptionEvent = new UpdateGroupDescriptionEvent(2L, 1L, "Peter", "Tolle Beschreibung"); - group.applyEvent(updateGroupDescriptionEvent); - - assertThat("Tolle Beschreibung").isEqualTo("Tolle Beschreibung"); - }*/ -} diff --git a/src/test/java/mops/gruppen2/domain/event/AddUserEventTest.java b/src/test/java/mops/gruppen2/domain/event/AddUserEventTest.java index 68ad113..81472a6 100644 --- a/src/test/java/mops/gruppen2/domain/event/AddUserEventTest.java +++ b/src/test/java/mops/gruppen2/domain/event/AddUserEventTest.java @@ -1,23 +1,35 @@ package mops.gruppen2.domain.event; +import mops.gruppen2.domain.Group; +import mops.gruppen2.domain.User; +import mops.gruppen2.domain.exception.EventException; +import mops.gruppen2.domain.exception.UserAlreadyExistsException; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + class AddUserEventTest { - /*@Test + @Test void userAlreadyExistExeption() throws EventException { Group group = new Group(); User user = new User("user1", "Stein", "Speck", "@sdasd"); group.getMembers().add(user); group.setUserMaximum(10L); - Event event1 = new AddUserEvent(4L, "user2", "Rock", "Roll", "and"); + UUID id = UUID.randomUUID(); + Event event1 = new AddUserEvent(id, "user2", "Rock", "Roll", "and"); event1.apply(group); - Event event2 = new AddUserEvent(4L, "user1", "Rock", "Roll", "and"); + Event event2 = new AddUserEvent(id, "user1", "Rock", "Roll", "and"); assertThrows(UserAlreadyExistsException.class, () -> event2.apply(group) ); assertThat(group.getMembers().size()).isEqualTo(2); - }*/ + } } diff --git a/src/test/java/mops/gruppen2/domain/event/DeleteUserEventTest.java b/src/test/java/mops/gruppen2/domain/event/DeleteUserEventTest.java index a5aae0f..dad27f5 100644 --- a/src/test/java/mops/gruppen2/domain/event/DeleteUserEventTest.java +++ b/src/test/java/mops/gruppen2/domain/event/DeleteUserEventTest.java @@ -1,8 +1,20 @@ package mops.gruppen2.domain.event; +import mops.gruppen2.domain.Group; +import mops.gruppen2.domain.User; +import mops.gruppen2.domain.exception.EventException; +import mops.gruppen2.domain.exception.UserNotFoundException; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static mops.gruppen2.domain.Role.MEMBER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + class DeleteUserEventTest { - /*@Test + @Test void applyDeleteUser() throws EventException { Group group = new Group(); User user = new User("user1", "Stein", "Speck", "@sdasd"); @@ -12,7 +24,7 @@ class DeleteUserEventTest { group.getMembers().add(user2); group.getRoles().put("user2", MEMBER); - Event event = new DeleteUserEvent(1L, "user1"); + Event event = new DeleteUserEvent(UUID.randomUUID(), "user1"); event.apply(group); assertThat(group.getMembers().size()).isEqualTo(1); @@ -27,10 +39,10 @@ class DeleteUserEventTest { group.getMembers().add(user); group.getRoles().put("user1", MEMBER); - Event event = new DeleteUserEvent(17L, "user5"); + Event event = new DeleteUserEvent(UUID.randomUUID(), "user5"); assertThrows(UserNotFoundException.class, () -> event.apply(group) ); assertThat(group.getMembers().size()).isEqualTo(1); - }*/ + } } diff --git a/src/test/java/mops/gruppen2/service/ControllerServiceTest.java b/src/test/java/mops/gruppen2/service/ControllerServiceTest.java new file mode 100644 index 0000000..205edd9 --- /dev/null +++ b/src/test/java/mops/gruppen2/service/ControllerServiceTest.java @@ -0,0 +1,80 @@ +package mops.gruppen2.service; + +import com.github.javafaker.Faker; +import mops.gruppen2.repository.EventRepository; +import mops.gruppen2.security.Account; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.HashSet; +import java.util.Set; + +import static org.mockito.Mockito.mock; + +class ControllerServiceTest { + Faker faker; + Account account; + ControllerService controllerService; + EventService eventService; + UserService userService; + EventRepository eventRepository; + GroupService groupService; + JsonService jsonService; + + + + @BeforeEach + void setUp() { + jsonService = new JsonService(); + eventRepository = mock(EventRepository.class); + eventService = new EventService(jsonService, eventRepository); + groupService = new GroupService(eventService, eventRepository); + userService = new UserService(groupService, eventService); + controllerService = new ControllerService(eventService, userService); + Set roles = new HashSet<>(); + roles.add("l"); + account = new Account("ich", "ich@hhu.de", "l", "ichdude", "jap", roles); + } + + @Test + void createGroupTest() { + + } + + @Test + void createOrga() { + } + + @Test + void addUser() { + } + + @Test + void addUserList() { + } + + @Test + void updateTitle() { + } + + @Test + void updateDescription() { + } + + @Test + void updateRoleTest() { + + } + + @Test + void deleteUser() { + } + + @Test + void deleteGroupEvent() { + } + + @Test + void passIfLastAdmin() { + } +} diff --git a/src/test/java/mops/gruppen2/service/EventServiceTest.java b/src/test/java/mops/gruppen2/service/EventServiceTest.java index 653c6df..427a35e 100644 --- a/src/test/java/mops/gruppen2/service/EventServiceTest.java +++ b/src/test/java/mops/gruppen2/service/EventServiceTest.java @@ -1,55 +1,132 @@ package mops.gruppen2.service; +import mops.gruppen2.Gruppen2Application; +import mops.gruppen2.domain.dto.EventDTO; +import mops.gruppen2.domain.event.Event; import mops.gruppen2.repository.EventRepository; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.annotation.Rollback; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import org.springframework.transaction.annotation.Transactional; -@RunWith(MockitoJUnitRunner.class) +import static mops.gruppen2.TestBuilder.addUserEvent; +import static mops.gruppen2.TestBuilder.addUserEvents; +import static mops.gruppen2.TestBuilder.createPrivateGroupEvent; +import static mops.gruppen2.TestBuilder.createPrivateGroupEvents; +import static mops.gruppen2.TestBuilder.createPublicGroupEvent; +import static mops.gruppen2.TestBuilder.createPublicGroupEvents; +import static mops.gruppen2.TestBuilder.updateGroupDescriptionEvent; +import static mops.gruppen2.TestBuilder.uuidFromInt; +import static org.assertj.core.api.Assertions.assertThat; + +//TODO: Der ID autocounter wird nicht resettet -> Tests schlagen fehl beim nacheinanderausführen +@ExtendWith(SpringExtension.class) +@SpringBootTest(classes = Gruppen2Application.class) +@Transactional +@Rollback class EventServiceTest { + @Autowired private EventRepository eventRepository; + @Autowired + private JsonService jsonService; private EventService eventService; - /*@BeforeEach + @BeforeEach void setUp() { - eventRepository = mock(EventRepository.class); - eventService = new EventService(mock(JsonService.class), eventRepository); + eventService = new EventService(jsonService, eventRepository); + eventRepository.deleteAll(); } @Test - void getMaxID() { - when(eventRepository.getHighesEvent_ID()).thenReturn(42L); + void saveEvent() { + eventService.saveEvent(createPublicGroupEvent()); - assertEquals(eventService.getMaxEvent_id(), 42L); + assertThat(eventRepository.findAll()).hasSize(1); } @Test - void checkGroupReturnNextValue() { - when(eventRepository.getMaxGroupID()).thenReturn(2L); + void saveAll() { + eventService.saveAll(createPrivateGroupEvents(10)); - assertEquals(eventService.checkGroup(), 3L); + assertThat(eventRepository.findAll()).hasSize(10); } @Test - void checkGroupReturnOneIfDBIsEmpty() { - List eventDTOS = new ArrayList<>(); - when(eventRepository.findAll()).thenReturn(eventDTOS); + void testSaveAll() { + eventService.saveAll(createPublicGroupEvents(5), + createPrivateGroupEvents(5)); - assertEquals(eventService.checkGroup(), 1); - }*/ - - /*@Test - void getDTOOffentlichTest() { - CreateGroupEvent createGroupEvent = new CreateGroupEvent(eventService.checkGroup(), "test", null, GroupType.LECTURE, Visibility.PUBLIC, null); - EventDTO eventDTO = eventService.getDTO(createGroupEvent); - assertTrue(eventDTO.isVisibility()); + assertThat(eventRepository.findAll()).hasSize(10); } @Test - void getDTOPrivatTest() { - AddUserEvent addUserEvent = new AddUserEvent(eventService.checkGroup(), "test", "franz", "mueller", "a@a"); - EventDTO eventDTO = eventService.getDTO(addUserEvent); - assertFalse(eventDTO.isVisibility()); - }*/ + void getDTO() { + Event event = createPublicGroupEvent(); + EventDTO dto = eventService.getDTO(event); + + assertThat(dto.getGroup_id()).isEqualTo(event.getGroupId().toString()); + assertThat(dto.getUser_id()).isEqualTo(event.getUserId()); + assertThat(dto.getEvent_id()).isEqualTo(null); + assertThat(dto.getEvent_type()).isEqualTo("CreateGroupEvent"); + } + + @Disabled + @Test + void getNewEvents_createGroupEvents() { + eventService.saveAll(createPrivateGroupEvents(10)); + + assertThat(eventService.getNewEvents(0L)).hasSize(10); + assertThat(eventService.getNewEvents(5L)).hasSize(5); + assertThat(eventService.getNewEvents(10L)).isEmpty(); + } + + @Disabled + @Test + void getNewEvents_mixedEvents() { + eventService.saveAll(createPrivateGroupEvent(uuidFromInt(0)), + updateGroupDescriptionEvent(uuidFromInt(0)), + createPrivateGroupEvent(uuidFromInt(1)), + updateGroupDescriptionEvent(uuidFromInt(1))); + + assertThat(eventService.getNewEvents(0L)).hasSize(4); + assertThat(eventService.getNewEvents(1L)).hasSize(4); + assertThat(eventService.getNewEvents(2L)).hasSize(2); + assertThat(eventService.getNewEvents(3L)).hasSize(2); + } + + @Disabled + @Test + void getMaxEvent_id() { + eventService.saveAll(createPrivateGroupEvents(10)); + + assertThat(eventService.getMaxEvent_id()).isEqualTo(10); + } + + @Test + void getEventsOfGroup() { + eventService.saveAll(addUserEvents(10, uuidFromInt(0)), + addUserEvents(5, uuidFromInt(1))); + + assertThat(eventService.getEventsOfGroup(uuidFromInt(0))).hasSize(10); + assertThat(eventService.getEventsOfGroup(uuidFromInt(1))).hasSize(5); + } + + @Test + void findGroupIdsByUser() { + eventService.saveAll(addUserEvent(uuidFromInt(0), "A"), + addUserEvent(uuidFromInt(1), "A"), + addUserEvent(uuidFromInt(2), "A"), + addUserEvent(uuidFromInt(3), "A"), + addUserEvent(uuidFromInt(3), "B")); + + assertThat(eventService.findGroupIdsByUser("A")).hasSize(4); + assertThat(eventService.findGroupIdsByUser("B")).hasSize(1); + } } diff --git a/src/test/java/mops/gruppen2/service/GroupServiceTest.java b/src/test/java/mops/gruppen2/service/GroupServiceTest.java index 6743055..ecd6069 100644 --- a/src/test/java/mops/gruppen2/service/GroupServiceTest.java +++ b/src/test/java/mops/gruppen2/service/GroupServiceTest.java @@ -1,28 +1,234 @@ package mops.gruppen2.service; +import mops.gruppen2.Gruppen2Application; +import mops.gruppen2.TestBuilder; +import mops.gruppen2.domain.Group; +import mops.gruppen2.domain.Visibility; +import mops.gruppen2.domain.event.Event; import mops.gruppen2.repository.EventRepository; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.annotation.Rollback; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import org.springframework.transaction.annotation.Transactional; -import static org.mockito.Mockito.mock; +import java.util.Arrays; +import java.util.List; +import java.util.UUID; +import static mops.gruppen2.TestBuilder.account; +import static mops.gruppen2.TestBuilder.addUserEvent; +import static mops.gruppen2.TestBuilder.completePrivateGroup; +import static mops.gruppen2.TestBuilder.completePrivateGroups; +import static mops.gruppen2.TestBuilder.completePublicGroups; +import static mops.gruppen2.TestBuilder.createLectureEvent; +import static mops.gruppen2.TestBuilder.createPrivateGroupEvent; +import static mops.gruppen2.TestBuilder.createPublicGroupEvent; +import static mops.gruppen2.TestBuilder.deleteGroupEvent; +import static mops.gruppen2.TestBuilder.updateGroupDescriptionEvent; +import static mops.gruppen2.TestBuilder.updateGroupTitleEvent; +import static mops.gruppen2.TestBuilder.uuidFromInt; +import static org.assertj.core.api.Assertions.assertThat; + +@ExtendWith(SpringExtension.class) +@SpringBootTest(classes = Gruppen2Application.class) +@Transactional +@Rollback class GroupServiceTest { + @Autowired + private EventRepository eventRepository; + @Autowired + private EventService eventService; private GroupService groupService; @BeforeEach void setUp() { - groupService = new GroupService(mock(EventService.class), mock(EventRepository.class)); + groupService = new GroupService(eventService, eventRepository); + eventRepository.deleteAll(); } - - /* @Test + //TODO: Wofür ist dieser Test? + @Test void rightClassForSuccessfulGroup() { - List eventList = new ArrayList<>(); - eventList.add(new CreateGroupEvent(1L, "Prof", null, GroupType.LECTURE, Visibility.PRIVATE,1000L)); - eventList.add(new AddUserEvent(1L, "Ulli", "Ulli", "Honnis", "FC@B.de")); + /*List eventList = new ArrayList<>(); + UUID id = UUID.randomUUID(); + eventList.add(new CreateGroupEvent(id, "Prof", null, GroupType.LECTURE, Visibility.PRIVATE, 1000L)); + eventList.add(new AddUserEvent(id, "Ulli", "Ulli", "Honnis", "FC@B.de"));*/ + List eventList = completePrivateGroup(1); + + List groups = groupService.projectEventList(eventList); + assertThat(groups.get(0)).isInstanceOf(Group.class); + } + + @Test + void projectEventList_SingleGroup() { + List eventList = completePrivateGroup(5); List groups = groupService.projectEventList(eventList); - assertThat(groups.get(0)).isInstanceOf(Group.class); - }*/ + assertThat(groups).hasSize(1); + assertThat(groups.get(0).getMembers()).hasSize(5); + assertThat(groups.get(0).getVisibility()).isEqualTo(Visibility.PRIVATE); + } + + @Test + void projectEventList_MultipleGroups() { + List eventList = completePrivateGroups(10, 2); + eventList.addAll(completePublicGroups(10, 5)); + + List groups = groupService.projectEventList(eventList); + + assertThat(groups).hasSize(20); + assertThat(groups.stream().map(group -> group.getMembers().size()).reduce(Integer::sum).get()).isEqualTo(70); + } + + @Test + void getGroupEvents() { +// CreateGroupEvent test1 = new CreateGroupEvent(uuidFromInt(0), "test1", null, GroupType.SIMPLE, Visibility.PUBLIC, 20L); +// CreateGroupEvent test2 = new CreateGroupEvent(uuidFromInt(1), "test2", null, GroupType.SIMPLE, Visibility.PUBLIC, 10L); + + eventService.saveAll(createPublicGroupEvent(uuidFromInt(0)), + createPublicGroupEvent(uuidFromInt(1)), + createPrivateGroupEvent(uuidFromInt(2))); + + List groupIds = Arrays.asList(uuidFromInt(0), uuidFromInt(1)); + + assertThat(groupService.getGroupEvents(groupIds)).hasSize(2); + assertThat(groupService.getGroupEvents(groupIds).get(0).getGroupId()).isEqualTo(uuidFromInt(0)); + assertThat(groupService.getGroupEvents(groupIds).get(1).getGroupId()).isEqualTo(uuidFromInt(1)); + } + + @Test + void getAllGroupWithVisibilityPublicTestCreateAndDeleteSameGroup() { + //CreateGroupEvent test1 = new CreateGroupEvent(uuidFromInt(0), "test1", null, GroupType.SIMPLE, Visibility.PUBLIC, 20L); + //DeleteGroupEvent test2 = new DeleteGroupEvent(uuidFromInt(0), "test1"); + Event test1 = createPublicGroupEvent(uuidFromInt(0)); + Event test2 = deleteGroupEvent(uuidFromInt(0)); + + //Group group = new Group(); + //test1.apply(group); + //test2.apply(group); + + //TODO: Hier projectEventlist()? + Group group = TestBuilder.apply(test1, test2); + + assertThat(group.getType()).isEqualTo(null); + assertThat(groupService.getAllGroupWithVisibilityPublic("test1")).isEmpty(); + } + + @Test + void getAllGroupWithVisibilityPublicTestGroupPublic() { +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(0), "test1", null, GroupType.SIMPLE, Visibility.PUBLIC, 20L)); +// eventService.saveEvent(new DeleteGroupEvent(uuidFromInt(0), "test1")); +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(1), "test2", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); +// eventService.saveEvent(new UpdateRoleEvent(uuidFromInt(1), "test2", Role.MEMBER)); //Wofür ist das + + eventService.saveAll(createPublicGroupEvent(uuidFromInt(0)), + deleteGroupEvent(uuidFromInt(0)), + createPublicGroupEvent()); + + assertThat(groupService.getAllGroupWithVisibilityPublic("test1").size()).isEqualTo(1); + } + + @Test + void getAllGroupWithVisibilityPublicTestAddSomeEvents() { +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(0), "test1", null, GroupType.SIMPLE, Visibility.PUBLIC, 20L)); +// eventService.saveEvent(new DeleteGroupEvent(uuidFromInt(0), "test1")); +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(1), "test2", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); +// eventService.saveEvent(new UpdateRoleEvent(uuidFromInt(1), "test2", Role.MEMBER)); // Wofür? +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(2), "test3", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(3), "test4", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(4), "test5", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); + + eventService.saveAll(createPublicGroupEvent(uuidFromInt(0)), + deleteGroupEvent(uuidFromInt(0)), + createPublicGroupEvent(), + createPublicGroupEvent(), + createPublicGroupEvent(), + createPrivateGroupEvent()); + + assertThat(groupService.getAllGroupWithVisibilityPublic("test1").size()).isEqualTo(3); + } + + @Disabled + @Test + void getAllGroupWithVisibilityPublicTestIsUserInGroup() { +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(0), "test1", null, GroupType.SIMPLE, Visibility.PUBLIC, 20L)); +// eventService.saveEvent(new AddUserEvent(uuidFromInt(0), "test1", "test", "test", "test@test")); + + eventService.saveAll(createPublicGroupEvent(uuidFromInt(0)), + addUserEvent(uuidFromInt(0), "kobold"), + createPrivateGroupEvent(), + createPublicGroupEvent()); + + //Das kommt glaube ich eher in einen Test für die Projektion + //assertThat(groupService.getAllGroupWithVisibilityPublic("test2").get(0).getMembers().size()).isEqualTo(1); + + assertThat(groupService.getAllGroupWithVisibilityPublic("kobold")).hasSize(1); + assertThat(groupService.getAllGroupWithVisibilityPublic("peter")).hasSize(2); + } + + @Test + void getAllLecturesWithVisibilityPublic() { +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(0), "test1", null, GroupType.SIMPLE, Visibility.PUBLIC, 20L)); +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(1), "test2", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); +// eventService.saveEvent(new UpdateRoleEvent(uuidFromInt(1), "test2", Role.MEMBER)); // Hä +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(2), "test3", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(3), "test4", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(4), "test5", null, GroupType.LECTURE, Visibility.PUBLIC, 10L)); + + eventService.saveAll(createLectureEvent(), + createPublicGroupEvent(), + createLectureEvent(), + createLectureEvent(), + createLectureEvent()); + + assertThat(groupService.getAllLecturesWithVisibilityPublic().size()).isEqualTo(4); + } + + @Test + void findGroupWith_UserMember_AllGroups() { +// eventService.saveEvent(new CreateGroupEvent(uuidFromInt(0), "test1", null, GroupType.SIMPLE, Visibility.PUBLIC, 20L)); +// eventService.saveEvent(new AddUserEvent(uuidFromInt(0), "test1", "test", "test", "test@test")); +// eventService.saveEvent(new UpdateGroupTitleEvent(uuidFromInt(0), "test1", "TestGroup")); +// eventService.saveEvent(new UpdateGroupDescriptionEvent(uuidFromInt(0), "test1", "TestDescription")); +// eventService.saveEvent(new UpdateRoleEvent(uuidFromInt(0), "test1", Role.MEMBER)); + + eventService.saveAll(createPublicGroupEvent(uuidFromInt(0)), + addUserEvent(uuidFromInt(0), "jens"), + updateGroupTitleEvent(uuidFromInt(0)), + updateGroupDescriptionEvent(uuidFromInt(0))); + + //assertThat(groupService.findGroupWith("T", new Account("jens", "a@A", "test", "peter", "mueller", null)).size()).isEqualTo(1); + assertThat(groupService.findGroupWith("", account("jens"))).isEmpty(); + } + + @Test + void findGroupWith_UserNoMember_AllGroups() { + eventService.saveAll(completePublicGroups(10, 0), + completePrivateGroups(10, 0)); + + assertThat(groupService.findGroupWith("", account("jens"))).hasSize(10); + } + + @Test + void findGroupWith_FilterGroups() { + eventService.saveAll(createPublicGroupEvent(uuidFromInt(0)), + updateGroupTitleEvent(uuidFromInt(0), "KK"), + updateGroupDescriptionEvent(uuidFromInt(0), "ABCDE"), + createPublicGroupEvent(uuidFromInt(1)), + updateGroupTitleEvent(uuidFromInt(1), "ABCDEFG"), + updateGroupDescriptionEvent(uuidFromInt(1), "KK"), + createPrivateGroupEvent()); + + assertThat(groupService.findGroupWith("A", account("jesus"))).hasSize(2); + assertThat(groupService.findGroupWith("F", account("jesus"))).hasSize(1); + assertThat(groupService.findGroupWith("Z", account("jesus"))).hasSize(0); + } + }