Merge branch 'dev' into TEST-api-tests

src/test/java/mops/gruppen2/domain/event/AddUserEventTest.java

@@ -1,13 +1,57 @@
 package mops.gruppen2.domain.event;
 
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.exception.GroupFullException;
+import mops.gruppen2.domain.exception.UserAlreadyExistsException;
 import org.junit.jupiter.api.Test;
 
+import static mops.gruppen2.TestBuilder.addUserEvent;
+import static mops.gruppen2.TestBuilder.apply;
+import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 class AddUserEventTest {
 
     @Test
     void applyEvent() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event addEvent = new AddUserEvent(uuidFromInt(0), "A", "Thomas", "Tom", "tho@mail.de");
 
+        Group group = apply(createEvent, addEvent);
+
+        assertThat(group.getMembers()).hasSize(1);
+        assertThat(group.getMembers().get(0).getGivenname()).isEqualTo("Thomas");
+        assertThat(group.getMembers().get(0).getFamilyname()).isEqualTo("Tom");
+        assertThat(group.getMembers().get(0).getEmail()).isEqualTo("tho@mail.de");
     }
 
+    @Test
+    void applyEvent_userAlreadyExists() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event addEventA = addUserEvent(uuidFromInt(0), "A");
+        Event addEventB = addUserEvent(uuidFromInt(0), "B");
+        Event addEventC = addUserEvent(uuidFromInt(0), "A");
 
+        Group group = apply(createEvent, addEventA, addEventB);
+
+        assertThrows(UserAlreadyExistsException.class, () -> addEventA.apply(group));
+        assertThrows(UserAlreadyExistsException.class, () -> addEventC.apply(group));
+        assertThat(group.getMembers()).hasSize(2);
+    }
+
+    @Test
+    void applyEvent_groupFull() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event maxSizeEvent = new UpdateUserMaxEvent(uuidFromInt(0), "A", 2L);
+        Event addEventA = addUserEvent(uuidFromInt(0), "A");
+        Event addEventB = addUserEvent(uuidFromInt(0), "B");
+        Event addEventC = addUserEvent(uuidFromInt(0), "C");
+
+        Group group = apply(createEvent, maxSizeEvent, addEventA, addEventB);
+
+        assertThrows(GroupFullException.class, () -> addEventC.apply(group));
+        assertThat(group.getMembers()).hasSize(2);
+    }
 }

src/test/java/mops/gruppen2/domain/event/CreateGroupEventTest.java

@@ -0,0 +1,32 @@
+package mops.gruppen2.domain.event;
+
+import mops.gruppen2.TestBuilder;
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.GroupType;
+import mops.gruppen2.domain.Visibility;
+import org.junit.jupiter.api.Test;
+
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class CreateGroupEventTest {
+
+    @Test
+    void applyEvent() {
+        Event createEvent = new CreateGroupEvent(uuidFromInt(0),
+                                                 "A",
+                                                 uuidFromInt(1),
+                                                 GroupType.SIMPLE,
+                                                 Visibility.PUBLIC,
+                                                 100L);
+
+        Group group = TestBuilder.apply(createEvent);
+
+        assertThat(group.getMembers()).hasSize(0);
+        assertThat(group.getType()).isEqualTo(GroupType.SIMPLE);
+        assertThat(group.getVisibility()).isEqualTo(Visibility.PUBLIC);
+        assertThat(group.getUserMaximum()).isEqualTo(100);
+        assertThat(group.getId()).isEqualTo(uuidFromInt(0));
+        assertThat(group.getParent()).isEqualTo(uuidFromInt(1));
+    }
+}

src/test/java/mops/gruppen2/domain/event/DeleteGroupEventTest.java

@@ -0,0 +1,33 @@
+package mops.gruppen2.domain.event;
+
+import mops.gruppen2.TestBuilder;
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.GroupType;
+import mops.gruppen2.domain.Visibility;
+import org.junit.jupiter.api.Test;
+
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class DeleteGroupEventTest {
+
+    @Test
+    void applyEvent() {
+        Event createEvent = new CreateGroupEvent(uuidFromInt(0),
+                                                 "A",
+                                                 uuidFromInt(1),
+                                                 GroupType.SIMPLE,
+                                                 Visibility.PUBLIC,
+                                                 100L);
+        Event deleteEvent = new DeleteGroupEvent(uuidFromInt(0), "A");
+
+        Group group = TestBuilder.apply(createEvent, deleteEvent);
+
+        assertThat(group.getMembers()).isEmpty();
+        assertThat(group.getType()).isEqualTo(null);
+        assertThat(group.getVisibility()).isEqualTo(null);
+        assertThat(group.getUserMaximum()).isEqualTo(0);
+        assertThat(group.getId()).isEqualTo(uuidFromInt(0));
+        assertThat(group.getParent()).isEqualTo(null);
+    }
+}

src/test/java/mops/gruppen2/domain/event/DeleteUserEventTest.java

@@ -1,10 +1,38 @@
 package mops.gruppen2.domain.event;
 
+import mops.gruppen2.TestBuilder;
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.exception.UserNotFoundException;
 import org.junit.jupiter.api.Test;
 
+import static mops.gruppen2.TestBuilder.addUserEvent;
+import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 class DeleteUserEventTest {
 
     @Test
     void applyEvent() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event addEvent = addUserEvent(uuidFromInt(0), "A");
+        Event deleteEvent = new DeleteUserEvent(uuidFromInt(0), "A");
+
+        Group group = TestBuilder.apply(createEvent, addEvent, deleteEvent);
+
+        assertThat(group.getMembers()).hasSize(0);
+    }
+
+    @Test
+    void applyEvent_userNotFound() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event addEvent = addUserEvent(uuidFromInt(0), "A");
+        Event deleteEvent = new DeleteUserEvent(uuidFromInt(0), "B");
+
+        Group group = TestBuilder.apply(createEvent, addEvent);
+
+        assertThrows(UserNotFoundException.class, () -> deleteEvent.apply(group));
+        assertThat(group.getMembers()).hasSize(1);
     }
 }

src/test/java/mops/gruppen2/domain/event/EventTest.java

@@ -0,0 +1,24 @@
+package mops.gruppen2.domain.event;
+
+import mops.gruppen2.TestBuilder;
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.exception.GroupIdMismatchException;
+import org.junit.jupiter.api.Test;
+
+import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class EventTest {
+
+    @Test
+    void apply() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event addEvent = TestBuilder.addUserEvent(uuidFromInt(1));
+
+        Group group = TestBuilder.apply(createEvent);
+
+        assertThrows(GroupIdMismatchException.class, () -> addEvent.apply(group));
+    }
+
+}

src/test/java/mops/gruppen2/domain/event/UpdateGroupDescriptionEventTest.java

@@ -0,0 +1,36 @@
+package mops.gruppen2.domain.event;
+
+import mops.gruppen2.TestBuilder;
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.exception.BadParameterException;
+import org.junit.jupiter.api.Test;
+
+import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class UpdateGroupDescriptionEventTest {
+
+    @Test
+    void applyEvent() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event updateEvent = new UpdateGroupDescriptionEvent(uuidFromInt(0), "A", "desc.");
+
+        Group group = TestBuilder.apply(createEvent, updateEvent);
+
+        assertThat(group.getDescription()).isEqualTo("desc.");
+    }
+
+    @Test
+    void applyEvent_badDescription() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event updateEventA = new UpdateGroupDescriptionEvent(uuidFromInt(0), "A", "");
+        Event updateEventB = new UpdateGroupDescriptionEvent(uuidFromInt(0), "A", "  ");
+
+        Group group = TestBuilder.apply(createEvent);
+
+        assertThrows(BadParameterException.class, () -> updateEventA.apply(group));
+        assertThrows(BadParameterException.class, () -> updateEventB.apply(group));
+    }
+}

src/test/java/mops/gruppen2/domain/event/UpdateGroupTitleEventTest.java

@@ -0,0 +1,36 @@
+package mops.gruppen2.domain.event;
+
+import mops.gruppen2.TestBuilder;
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.exception.BadParameterException;
+import org.junit.jupiter.api.Test;
+
+import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class UpdateGroupTitleEventTest {
+
+    @Test
+    void applyEvent() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event updateEvent = new UpdateGroupTitleEvent(uuidFromInt(0), "A", "title.");
+
+        Group group = TestBuilder.apply(createEvent, updateEvent);
+
+        assertThat(group.getTitle()).isEqualTo("title.");
+    }
+
+    @Test
+    void applyEvent_badDescription() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event updateEventA = new UpdateGroupTitleEvent(uuidFromInt(0), "A", "");
+        Event updateEventB = new UpdateGroupTitleEvent(uuidFromInt(0), "A", "  ");
+
+        Group group = TestBuilder.apply(createEvent);
+
+        assertThrows(BadParameterException.class, () -> updateEventA.apply(group));
+        assertThrows(BadParameterException.class, () -> updateEventB.apply(group));
+    }
+}

src/test/java/mops/gruppen2/domain/event/UpdateRoleEventTest.java

@@ -0,0 +1,39 @@
+package mops.gruppen2.domain.event;
+
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.Role;
+import mops.gruppen2.domain.exception.UserNotFoundException;
+import org.junit.jupiter.api.Test;
+
+import static mops.gruppen2.TestBuilder.addUserEvent;
+import static mops.gruppen2.TestBuilder.apply;
+import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class UpdateRoleEventTest {
+
+    @Test
+    void applyEvent() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event addEvent = addUserEvent(uuidFromInt(0), "A");
+        Event updateEvent = new UpdateRoleEvent(uuidFromInt(0), "A", Role.ADMIN);
+
+        Group group = apply(createEvent, addEvent, updateEvent);
+
+        assertThat(group.getRoles().get("A")).isEqualTo(Role.ADMIN);
+    }
+
+    @Test
+    void applyEvent_userNotFound() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event addEvent = addUserEvent(uuidFromInt(0), "A");
+        Event updateEvent = new UpdateRoleEvent(uuidFromInt(0), "B", Role.ADMIN);
+
+        Group group = apply(createEvent, addEvent);
+
+        assertThrows(UserNotFoundException.class, () -> updateEvent.apply(group));
+        assertThat(group.getRoles().get("A")).isEqualTo(Role.MEMBER);
+    }
+}

src/test/java/mops/gruppen2/domain/event/UpdateUserMaxEventTest.java

@@ -0,0 +1,49 @@
+package mops.gruppen2.domain.event;
+
+import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.exception.BadParameterException;
+import org.junit.jupiter.api.Test;
+
+import static mops.gruppen2.TestBuilder.addUserEvent;
+import static mops.gruppen2.TestBuilder.apply;
+import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
+import static mops.gruppen2.TestBuilder.uuidFromInt;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class UpdateUserMaxEventTest {
+
+    @Test
+    void applyEvent() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event updateEvent = new UpdateUserMaxEvent(uuidFromInt(0), "A", 5L);
+
+        Group group = apply(createEvent, updateEvent);
+
+        assertThat(group.getUserMaximum()).isEqualTo(5);
+    }
+
+    @Test
+    void applyEvent_badParameter_negative() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event updateEvent = new UpdateUserMaxEvent(uuidFromInt(0), "A", -5L);
+
+        Group group = apply(createEvent);
+
+        assertThrows(BadParameterException.class, () -> updateEvent.apply(group));
+    }
+
+    @Test
+    void applyEvent_badParameter_tooSmall() {
+        Event createEvent = createPublicGroupEvent(uuidFromInt(0));
+        Event updateEventA = new UpdateUserMaxEvent(uuidFromInt(0), "A", 5L);
+        Event addEventA = addUserEvent(uuidFromInt(0));
+        Event addEventB = addUserEvent(uuidFromInt(0));
+        Event addEventC = addUserEvent(uuidFromInt(0));
+        Event updateEventB = new UpdateUserMaxEvent(uuidFromInt(0), "A", 2L);
+
+        Group group = apply(createEvent, updateEventA, addEventA, addEventB, addEventC);
+
+        assertThrows(BadParameterException.class, () -> updateEventB.apply(group));
+    }
+}

src/test/java/mops/gruppen2/service/GroupServiceTest.java

@@ -59,10 +59,6 @@ class GroupServiceTest {
     //TODO: Wofür ist dieser Test?
     @Test
     void rightClassForSuccessfulGroup() {
-        /*List<Event> 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<Event> eventList = completePrivateGroup(1);
 
         List<Group> groups = groupService.projectEventList(eventList);
@@ -93,9 +89,6 @@ class GroupServiceTest {
 
     @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(uuidMock(0)),
                              createPublicGroupEvent(uuidMock(1)),
                              createPrivateGroupEvent(uuidMock(2)));
@@ -109,15 +102,9 @@ class GroupServiceTest {
 
     @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(uuidMock(0));
         Event test2 = deleteGroupEvent(uuidMock(0));
 
-        //Group group = new Group();
-        //test1.apply(group);
-        //test2.apply(group);
-
         //TODO: Hier projectEventlist()?
         Group group = TestBuilder.apply(test1, test2);
 
@@ -127,11 +114,6 @@ class GroupServiceTest {
 
     @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(uuidMock(0)),
                              deleteGroupEvent(uuidMock(0)),
                              createPublicGroupEvent());
@@ -141,14 +123,6 @@ class GroupServiceTest {
 
     @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(uuidMock(0)),
                              deleteGroupEvent(uuidMock(0)),
                              createPublicGroupEvent(),
@@ -161,30 +135,17 @@ class GroupServiceTest {
 
     @Test
     void getAllGroupWithVisibilityPublic_UserInGroup() {
-        //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(uuidMock(0)),
                              addUserEvent(uuidMock(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(),
@@ -196,18 +157,11 @@ class GroupServiceTest {
 
     @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(uuidMock(0)),
                              addUserEvent(uuidMock(0), "jens"),
                              updateGroupTitleEvent(uuidMock(0)),
                              updateGroupDescriptionEvent(uuidMock(0)));
 
-        //assertThat(groupService.findGroupWith("T", new Account("jens", "a@A", "test", "peter", "mueller", null)).size()).isEqualTo(1);
         assertThat(groupService.findGroupWith("", account("jens"))).isEmpty();
     }