Merge branch 'dev' into TEST-api-tests

.github/workflows/gradle.yml

@@ -4,13 +4,18 @@ on:
   push:
     branches: 
       - master
+      - dev
   pull_request:
     branches: 
       - master
+      - dev
     paths-ignore:
       - 'documentation/**'
+      - 'mysql/**'
       - 'README.adoc'
       - 'Dockerfile'
+      - 'docker-compose.yaml'
+      - '.gitignore'
 jobs:
   build:
     runs-on: ubuntu-latest

src/main/java/mops/gruppen2/controller/GroupCreationController.java

@@ -117,17 +117,4 @@ public class GroupCreationController {
 
         return "redirect:/gruppen2";
     }
-
-    @RolesAllowed({"ROLE_orga", "ROLE_actuator"})
-    @PostMapping("/details/members/addUsersFromCsv")
-    @CacheEvict(value = "groups", allEntries = true)
-    public String addUsersFromCsv(KeycloakAuthenticationToken token,
-                                  @RequestParam("group_id") String groupId,
-                                  @RequestParam(value = "file", required = false) MultipartFile file) {
-
-        Account account = KeyCloakService.createAccountFromPrincipal(token);
-        controllerService.addUsersFromCsv(account, file, groupId);
-
-        return "redirect:/gruppen2/details/members/" + groupId;
-    }
 }

src/main/java/mops/gruppen2/controller/GroupDetailsController.java

@@ -19,6 +19,7 @@ import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.context.annotation.SessionScope;
+import org.springframework.web.multipart.MultipartFile;
 
 import javax.annotation.security.RolesAllowed;
 import javax.servlet.http.HttpServletRequest;
@@ -259,4 +260,17 @@ public class GroupDetailsController {
 
         return "redirect:/gruppen2";
     }
+
+    @RolesAllowed({"ROLE_orga", "ROLE_actuator"})
+    @PostMapping("/details/members/addUsersFromCsv")
+    @CacheEvict(value = "groups", allEntries = true)
+    public String addUsersFromCsv(KeycloakAuthenticationToken token,
+                                  @RequestParam("group_id") String groupId,
+                                  @RequestParam(value = "file", required = false) MultipartFile file) {
+
+        Account account = KeyCloakService.createAccountFromPrincipal(token);
+        controllerService.addUsersFromCsv(account, file, groupId);
+
+        return "redirect:/gruppen2/details/members/" + groupId;
+    }
 }

src/main/java/mops/gruppen2/controller/GruppenfindungController.java

@@ -34,7 +34,6 @@ public class GruppenfindungController {
                         Model model) {
 
         Account account = KeyCloakService.createAccountFromPrincipal(token);
-        //TODO: new Contructor/method
         User user = new User(account);
 
         model.addAttribute("account", account);

src/main/java/mops/gruppen2/domain/event/AddUserEvent.java

@@ -1,6 +1,5 @@
 package mops.gruppen2.domain.event;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import mops.gruppen2.domain.Group;
@@ -16,7 +15,6 @@ import java.util.UUID;
  * Fügt einen einzelnen Nutzer einer Gruppe hinzu.
  */
 @Getter
-@AllArgsConstructor
 @NoArgsConstructor // For Jackson
 public class AddUserEvent extends Event {
 
@@ -33,14 +31,14 @@ public class AddUserEvent extends Event {
 
     @Override
     protected void applyEvent(Group group) throws EventException {
-        User user = new User(this.userId, this.givenname, this.familyname, this.email);
+        User user = new User(userId, givenname, familyname, email);
 
         if (group.getMembers().contains(user)) {
-            throw new UserAlreadyExistsException(this.getClass().toString());
+            throw new UserAlreadyExistsException(getClass().toString());
         }
 
         if (group.getMembers().size() >= group.getUserMaximum()) {
-            throw new GroupFullException(this.getClass().toString());
+            throw new GroupFullException(getClass().toString());
         }
 
         group.getMembers().add(user);

src/main/java/mops/gruppen2/domain/event/CreateGroupEvent.java

@@ -1,6 +1,5 @@
 package mops.gruppen2.domain.event;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import mops.gruppen2.domain.Group;
@@ -10,7 +9,6 @@ import mops.gruppen2.domain.Visibility;
 import java.util.UUID;
 
 @Getter
-@AllArgsConstructor
 @NoArgsConstructor // For Jackson
 public class CreateGroupEvent extends Event {
 
@@ -21,18 +19,18 @@ public class CreateGroupEvent extends Event {
 
     public CreateGroupEvent(UUID groupId, String userId, UUID parent, GroupType type, Visibility visibility, Long userMaximum) {
         super(groupId, userId);
-        this.groupParent = parent;
-        this.groupType = type;
-        this.groupVisibility = visibility;
-        this.groupUserMaximum = userMaximum;
+        groupParent = parent;
+        groupType = type;
+        groupVisibility = visibility;
+        groupUserMaximum = userMaximum;
     }
 
     @Override
     protected void applyEvent(Group group) {
-        group.setId(this.groupId);
-        group.setParent(this.groupParent);
-        group.setType(this.groupType);
-        group.setVisibility(this.groupVisibility);
-        group.setUserMaximum(this.groupUserMaximum);
+        group.setId(groupId);
+        group.setParent(groupParent);
+        group.setType(groupType);
+        group.setVisibility(groupVisibility);
+        group.setUserMaximum(groupUserMaximum);
     }
 }

src/main/java/mops/gruppen2/domain/event/DeleteGroupEvent.java

@@ -23,5 +23,6 @@ public class DeleteGroupEvent extends Event {
         group.setVisibility(null);
         group.setType(null);
         group.setParent(null);
+        group.setUserMaximum(0L);
     }
 }

src/main/java/mops/gruppen2/domain/event/UpdateGroupDescriptionEvent.java

@@ -1,10 +1,9 @@
 package mops.gruppen2.domain.event;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import mops.gruppen2.domain.Group;
-import mops.gruppen2.domain.exception.NoValueException;
+import mops.gruppen2.domain.exception.BadParameterException;
 
 import java.util.UUID;
 
@@ -12,7 +11,6 @@ import java.util.UUID;
  * Ändert nur die Gruppenbeschreibung.
  */
 @Getter
-@AllArgsConstructor
 @NoArgsConstructor // For Jackson
 public class UpdateGroupDescriptionEvent extends Event {
 
@@ -25,10 +23,10 @@ public class UpdateGroupDescriptionEvent extends Event {
 
     @Override
     protected void applyEvent(Group group) {
-        if (this.newGroupDescription.isEmpty()) {
-            throw new NoValueException(this.getClass().toString());
+        if (newGroupDescription.isEmpty()) {
+            throw new BadParameterException("Die Beschreibung ist leer.");
         }
 
-        group.setDescription(this.newGroupDescription);
+        group.setDescription(newGroupDescription);
     }
 }

src/main/java/mops/gruppen2/domain/event/UpdateGroupTitleEvent.java

@@ -1,10 +1,9 @@
 package mops.gruppen2.domain.event;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import mops.gruppen2.domain.Group;
-import mops.gruppen2.domain.exception.NoValueException;
+import mops.gruppen2.domain.exception.BadParameterException;
 
 import java.util.UUID;
 
@@ -12,7 +11,6 @@ import java.util.UUID;
  * Ändert nur den Gruppentitel.
  */
 @Getter
-@AllArgsConstructor
 @NoArgsConstructor // For Jackson
 public class UpdateGroupTitleEvent extends Event {
 
@@ -26,7 +24,7 @@ public class UpdateGroupTitleEvent extends Event {
     @Override
     protected void applyEvent(Group group) {
         if (newGroupTitle.isEmpty()) {
-            throw new NoValueException(getClass().toString());
+            throw new BadParameterException("Der Titel ist leer.");
         }
 
         group.setTitle(newGroupTitle);

src/main/java/mops/gruppen2/domain/event/UpdateRoleEvent.java

@@ -1,6 +1,5 @@
 package mops.gruppen2.domain.event;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import mops.gruppen2.domain.Group;
@@ -13,7 +12,6 @@ import java.util.UUID;
  * Aktualisiert die Gruppenrolle eines Teilnehmers.
  */
 @Getter
-@AllArgsConstructor
 @NoArgsConstructor // For Jackson
 public class UpdateRoleEvent extends Event {
 
@@ -26,12 +24,12 @@ public class UpdateRoleEvent extends Event {
 
     @Override
     protected void applyEvent(Group group) throws UserNotFoundException {
-        if (group.getRoles().containsKey(this.userId)) {
-            group.getRoles().put(this.userId, this.newRole);
+        if (group.getRoles().containsKey(userId)) {
+            group.getRoles().put(userId, newRole);
             return;
         }
 
-        throw new UserNotFoundException(this.getClass().toString());
+        throw new UserNotFoundException(getClass().toString());
     }
 
 }

src/main/java/mops/gruppen2/domain/event/UpdateUserMaxEvent.java

@@ -1,15 +1,14 @@
 package mops.gruppen2.domain.event;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import mops.gruppen2.domain.Group;
+import mops.gruppen2.domain.exception.BadParameterException;
 import mops.gruppen2.domain.exception.EventException;
 
 import java.util.UUID;
 
 @Getter
-@AllArgsConstructor
 @NoArgsConstructor
 public class UpdateUserMaxEvent extends Event {
 
@@ -22,6 +21,10 @@ public class UpdateUserMaxEvent extends Event {
 
     @Override
     protected void applyEvent(Group group) throws EventException {
+        if (userMaximum <= 0 || userMaximum < group.getMembers().size()) {
+            throw new BadParameterException("Usermaximum zu klein.");
+        }
+
         group.setUserMaximum(userMaximum);
     }
 }

src/main/java/mops/gruppen2/domain/exception/NoValueException.java

@@ -1,10 +0,0 @@
-package mops.gruppen2.domain.exception;
-
-import org.springframework.http.HttpStatus;
-
-public class NoValueException extends EventException {
-
-    public NoValueException(String info) {
-        super(HttpStatus.BAD_REQUEST, "Eine Information fehlt.", info);
-    }
-}

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();
     }