christoph/lecture-professional-software-development
1
Fork 0
Code Activity

muss ich neu machen

Browse Source
This commit is contained in:
Christoph
2020-04-14 17:26:37 +02:00
parent cd445f12e8
commit bb3f57b562
27 changed files with 67 additions and 1217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/main/java/mops/gruppen2/domain/event/AddMemberEvent.java
View File

@ -10,6 +10,8 @@ import mops.gruppen2.domain.exception.UserAlreadyExistsException;
import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.User;
import java.util.UUID;
/**
* Fügt einen einzelnen Nutzer einer Gruppe hinzu.
*/
@ -21,8 +23,8 @@ public class AddMemberEvent extends Event {
@JsonProperty("user")
User user;
public AddMemberEvent(Group group, String exec, String target, User user) throws IdMismatchException {
super(group.getId(), exec, target);
public AddMemberEvent(UUID groupId, String exec, String target, User user) throws IdMismatchException {
super(groupId, exec, target);
this.user = user;
if (!target.equals(user.getId())) {

6
src/main/java/mops/gruppen2/domain/event/DestroyGroupEvent.java
View File

@ -6,13 +6,15 @@ import lombok.extern.log4j.Log4j2;
import mops.gruppen2.domain.exception.NoAccessException;
import mops.gruppen2.domain.model.group.Group;
import java.util.UUID;
@Log4j2
@Value
@AllArgsConstructor
public class DestroyGroupEvent extends Event {
public DestroyGroupEvent(Group group, String exec) {
super(group.getId(), exec, null);
public DestroyGroupEvent(UUID groupId, String exec) {
super(groupId, exec, null);
}
@Override

6
src/main/java/mops/gruppen2/domain/event/KickMemberEvent.java
View File

@ -7,6 +7,8 @@ import mops.gruppen2.domain.exception.LastAdminException;
import mops.gruppen2.domain.exception.UserNotFoundException;
import mops.gruppen2.domain.model.group.Group;
import java.util.UUID;
/**
* Entfernt ein einzelnes Mitglied einer Gruppe.
*/
@ -15,8 +17,8 @@ import mops.gruppen2.domain.model.group.Group;
@AllArgsConstructor
public class KickMemberEvent extends Event {
public KickMemberEvent(Group group, String exec, String target) {
super(group.getId(), exec, target);
public KickMemberEvent(UUID groupId, String exec, String target) {
super(groupId, exec, target);
}
@Override

5
src/main/java/mops/gruppen2/domain/event/SetDescriptionEvent.java
View File

@ -9,6 +9,7 @@ import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.wrapper.Description;
import javax.validation.Valid;
import java.util.UUID;
/**
* Ändert nur die Gruppenbeschreibung.
@ -21,8 +22,8 @@ public class SetDescriptionEvent extends Event {
@JsonProperty("desc")
Description description;
public SetDescriptionEvent(Group group, String exec, @Valid Description description) {
super(group.getId(), exec, null);
public SetDescriptionEvent(UUID groupId, String exec, @Valid Description description) {
super(groupId, exec, null);
this.description = description;
}

5
src/main/java/mops/gruppen2/domain/event/SetInviteLinkEvent.java
View File

@ -9,6 +9,7 @@ import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.wrapper.Link;
import javax.validation.Valid;
import java.util.UUID;
@Log4j2
@Value
@ -18,8 +19,8 @@ public class SetInviteLinkEvent extends Event {
@JsonProperty("link")
Link link;
public SetInviteLinkEvent(Group group, String exec, @Valid Link link) {
super(group.getId(), exec, null);
public SetInviteLinkEvent(UUID groupId, String exec, @Valid Link link) {
super(groupId, exec, null);
this.link = link;
}

5
src/main/java/mops/gruppen2/domain/event/SetLimitEvent.java
View File

@ -10,6 +10,7 @@ import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.wrapper.Limit;
import javax.validation.Valid;
import java.util.UUID;
@Log4j2
@Value
@ -19,8 +20,8 @@ public class SetLimitEvent extends Event {
@JsonProperty("limit")
Limit limit;
public SetLimitEvent(Group group, String exec, @Valid Limit limit) {
super(group.getId(), exec, null);
public SetLimitEvent(UUID groupId, String exec, @Valid Limit limit) {
super(groupId, exec, null);
this.limit = limit;
}

5
src/main/java/mops/gruppen2/domain/event/SetParentEvent.java
View File

@ -9,6 +9,7 @@ import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.wrapper.Parent;
import javax.validation.Valid;
import java.util.UUID;
@Log4j2
@Value
@ -18,8 +19,8 @@ public class SetParentEvent extends Event {
@JsonProperty("parent")
Parent parent;
public SetParentEvent(Group group, String exec, @Valid Parent parent) {
super(group.getId(), exec, null);
public SetParentEvent(UUID groupId, String exec, @Valid Parent parent) {
super(groupId, exec, null);
this.parent = parent;
}

5
src/main/java/mops/gruppen2/domain/event/SetTitleEvent.java
View File

@ -9,6 +9,7 @@ import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.wrapper.Title;
import javax.validation.Valid;
import java.util.UUID;
/**
* Ändert nur den Gruppentitel.
@ -21,8 +22,8 @@ public class SetTitleEvent extends Event {
@JsonProperty("title")
Title title;
public SetTitleEvent(Group group, String exec, @Valid Title title) {
super(group.getId(), exec, null);
public SetTitleEvent(UUID groupId, String exec, @Valid Title title) {
super(groupId, exec, null);
this.title = title;
}

5
src/main/java/mops/gruppen2/domain/event/SetTypeEvent.java
View File

@ -9,6 +9,7 @@ import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.Type;
import javax.validation.Valid;
import java.util.UUID;
@Log4j2
@Value
@ -18,8 +19,8 @@ public class SetTypeEvent extends Event {
@JsonProperty("type")
Type type;
public SetTypeEvent(Group group, String exec, @Valid Type type) {
super(group.getId(), exec, null);
public SetTypeEvent(UUID groupId, String exec, @Valid Type type) {
super(groupId, exec, null);
this.type = type;
}

6
src/main/java/mops/gruppen2/domain/event/UpdateRoleEvent.java
View File

@ -9,6 +9,8 @@ import mops.gruppen2.domain.exception.UserNotFoundException;
import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.Role;
import java.util.UUID;
/**
* Aktualisiert die Gruppenrolle eines Teilnehmers.
*/
@ -20,8 +22,8 @@ public class UpdateRoleEvent extends Event {
@JsonProperty("role")
Role role;
public UpdateRoleEvent(Group group, String exec, String target, Role role) {
super(group.getId(), exec, target);
public UpdateRoleEvent(UUID groupId, String exec, String target, Role role) {
super(groupId, exec, target);
this.role = role;
}

20
src/main/java/mops/gruppen2/domain/service/GroupService.java
View File

@ -161,7 +161,7 @@ public class GroupService {
* Prüft, ob der Nutzer schon Mitglied ist und ob Gruppe voll ist.
*/
public void addMember(Group group, String exec, String target, User user) {
applyAndSave(group, new AddMemberEvent(group, exec, target, user));
applyAndSave(group, new AddMemberEvent(group.getId(), exec, target, user));
}
/**
@ -169,7 +169,7 @@ public class GroupService {
* Prüft, ob der Nutzer Mitglied ist und ob er der letzte Admin ist.
*/
public void kickMember(Group group, String exec, String target) {
applyAndSave(group, new KickMemberEvent(group, exec, target));
applyAndSave(group, new KickMemberEvent(group.getId(), exec, target));
if (ValidationHelper.checkIfGroupEmpty(group)) {
deleteGroup(group, exec);
@ -185,7 +185,7 @@ public class GroupService {
return;
}
applyAndSave(group, new DestroyGroupEvent(group, exec));
applyAndSave(group, new DestroyGroupEvent(group.getId(), exec));
}
/**
@ -198,7 +198,7 @@ public class GroupService {
return;
}
applyAndSave(group, new SetTitleEvent(group, exec, title));
applyAndSave(group, new SetTitleEvent(group.getId(), exec, title));
}
/**
@ -211,7 +211,7 @@ public class GroupService {
return;
}
applyAndSave(group, new SetDescriptionEvent(group, exec, description));
applyAndSave(group, new SetDescriptionEvent(group.getId(), exec, description));
}
/**
@ -224,7 +224,7 @@ public class GroupService {
return;
}
applyAndSave(group, new UpdateRoleEvent(group, exec, target, role));
applyAndSave(group, new UpdateRoleEvent(group.getId(), exec, target, role));
}
/**
@ -237,7 +237,7 @@ public class GroupService {
return;
}
applyAndSave(group, new SetLimitEvent(group, exec, userLimit));
applyAndSave(group, new SetLimitEvent(group.getId(), exec, userLimit));
}
public void setParent(Group group, String exec, Parent parent) {
@ -245,7 +245,7 @@ public class GroupService {
return;
}
applyAndSave(group, new SetParentEvent(group, exec, parent));
applyAndSave(group, new SetParentEvent(group.getId(), exec, parent));
}
public void setLink(Group group, String exec, Link link) {
@ -253,7 +253,7 @@ public class GroupService {
return;
}
applyAndSave(group, new SetInviteLinkEvent(group, exec, link));
applyAndSave(group, new SetInviteLinkEvent(group.getId(), exec, link));
}
private void setType(Group group, String exec, Type type) {
@ -261,7 +261,7 @@ public class GroupService {
return;
}
applyAndSave(group, new SetTypeEvent(group, exec, type));
applyAndSave(group, new SetTypeEvent(group.getId(), exec, type));
}
private void applyAndSave(Group group, Event event) throws EventException {

2
src/main/java/mops/gruppen2/domain/service/ProjectionService.java
View File

@ -62,7 +62,7 @@ public class ProjectionService {
*
* @throws EventException Projektionsfehler
*/
private static List<Group> projectGroupsByEvents(List<Event> events) throws EventException {
public static List<Group> projectGroupsByEvents(List<Event> events) throws EventException {
Map<UUID, Group> groupMap = new HashMap<>();
events.forEach(event -> event.apply(getOrCreateGroup(groupMap, event.getGroupid())));

66
src/test/java/mops/gruppen2/TestBuilder.java
View File

@ -1,30 +1,8 @@
package mops.gruppen2;
import com.github.javafaker.Faker;
import mops.gruppen2.domain.Account;
import mops.gruppen2.domain.event.AddMemberEvent;
import mops.gruppen2.domain.event.DestroyGroupEvent;
import mops.gruppen2.domain.event.Event;
import mops.gruppen2.domain.event.KickMemberEvent;
import mops.gruppen2.domain.event.SetDescriptionEvent;
import mops.gruppen2.domain.event.SetLimitEvent;
import mops.gruppen2.domain.event.SetTitleEvent;
import mops.gruppen2.domain.event.UpdateRoleEvent;
import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.Role;
import mops.gruppen2.domain.model.group.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class TestBuilder {
private static final Faker faker = new Faker();
/*private static final Faker faker = new Faker();
public static Account account(String name) {
return new Account(name,
@ -47,13 +25,13 @@ public class TestBuilder {
return apply(new Group(), events);
}
/**
*//**
* Baut eine UUID.
*
* @param id Integer id
*
* @return UUID
*/
*//*
public static UUID uuidMock(int id) {
String idString = String.valueOf(Math.abs(id + 1));
return UUID.fromString("00000000-0000-0000-0000-"
@ -61,14 +39,14 @@ public class TestBuilder {
+ idString);
}
/**
*//**
* Generiert ein EventLog mit mehreren Gruppen und Usern.
*
* @param count Gruppenanzahl
* @param membercount Mitgliederanzahl pro Gruppe
*
* @return Eventliste
*/
*//*
public static List<Event> completePublicGroups(int count, int membercount) {
return IntStream.range(0, count)
.parallel()
@ -92,7 +70,7 @@ public class TestBuilder {
eventList.add(createPublicGroupEvent(groupId));
eventList.add(updateGroupTitleEvent(groupId));
eventList.add(updateGroupDescriptionEvent(groupId));
eventList.add(new SetLimitEvent(groupId, "fgsadggas", Long.MAX_VALUE));
eventList.add(new SetLimitEvent(groupId, "fgsadggas", new Limit(Long.MAX_VALUE)));
eventList.addAll(addUserEvents(membercount, groupId));
return eventList;
@ -105,7 +83,7 @@ public class TestBuilder {
eventList.add(createPrivateGroupEvent(groupId));
eventList.add(updateGroupTitleEvent(groupId));
eventList.add(updateGroupDescriptionEvent(groupId));
eventList.add(new SetLimitEvent(groupId, "fgsadggas", Long.MAX_VALUE));
eventList.add(new SetLimitEvent(groupId, "fgsadggas", new Limit(Long.MAX_VALUE)));
eventList.addAll(addUserEvents(membercount, groupId));
return eventList;
@ -119,13 +97,13 @@ public class TestBuilder {
return completePrivateGroup(100);
}
/**
*//**
* Generiert mehrere CreateGroupEvents, 1 <= groupId <= count.
*
* @param count Anzahl der verschiedenen Gruppen
*
* @return Eventliste
*/
*//*
public static List<Event> createPublicGroupEvents(int count) {
return IntStream.range(0, count)
.parallel()
@ -149,8 +127,9 @@ public class TestBuilder {
.collect(Collectors.toList());
}
public static Event createPrivateGroupEvent(UUID groupId) {
return createGroupEvent(groupId, Type.PRIVATE);
public static List<Event> createPrivateGroupEvents(UUID groupId) {
return (new ArrayList<>()).addAll(createGroupEvent(groupId)),
new SetTypeEvent(groupId);
}
public static Event createPrivateGroupEvent() {
@ -165,13 +144,10 @@ public class TestBuilder {
return createPublicGroupEvent(UUID.randomUUID());
}
public static Event createGroupEvent(UUID groupId, Type type) {
return new CreateGroupEvent(
groupId,
faker.random().hex(),
null,
type
);
public static Event createGroupEvent(UUID groupId) {
return new CreateGroupEvent(groupId,
faker.random().hex(),
LocalDateTime.now());
}
public static Event createLectureEvent() {
@ -187,14 +163,14 @@ public class TestBuilder {
);
}
/**
*//**
* Generiert mehrere AddUserEvents für eine Gruppe, 1 <= user_id <= count.
*
* @param count Anzahl der Mitglieder
* @param groupId Gruppe, zu welcher geaddet wird
*
* @return Eventliste
*/
*//*
public static List<Event> addUserEvents(int count, UUID groupId) {
return IntStream.range(0, count)
.parallel()
@ -239,13 +215,13 @@ public class TestBuilder {
return removeEvents;
}
/**
*//**
* Erzeugt mehrere DeleteUserEvents, sodass eine Gruppe komplett geleert wird.
*
* @param group Gruppe welche geleert wird
*
* @return Eventliste
*/
*//*
public static List<Event> deleteUserEvents(Group group) {
return group.getMemberships().parallelStream()
.map(user -> deleteUserEvent(group.getGroupid(), user.getUserId()))
@ -317,5 +293,5 @@ public class TestBuilder {
private static String clean(String string) {
return string.replaceAll("['\";,]", "");
}
}*/
}

2
src/test/java/mops/gruppen2/architecture/DomainTest.java
View File

@ -27,7 +27,7 @@ class DomainTest {
@ArchTest
public static final ArchRule classesInEventPackageShouldHaveEventInName = classes()
.that().resideInAPackage("..domain.event..")
.should().haveSimpleNameEndingWith("Event");
.should().haveSimpleNameNotContaining("..Event..");
@ArchTest
public static final ArchRule exceptionClassesShouldBeInExceptionPackage = classes()

59
src/test/java/mops/gruppen2/domain/event/AddMemberEventTest.java
View File

@ -1,59 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.domain.exception.GroupFullException;
import mops.gruppen2.domain.exception.UserAlreadyExistsException;
import mops.gruppen2.domain.model.group.Group;
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.updateUserLimitMaxEvent;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.junit.jupiter.api.Assertions.assertThrows;
class AddMemberEventTest {
@Test
void applyEvent() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateLimitEvent = updateUserLimitMaxEvent(uuidMock(0));
Event addEvent = new AddMemberEvent(uuidMock(0), "A", "Thomas", "Tom", "tho@mail.de");
Group group = apply(createEvent, updateLimitEvent, addEvent);
assertThat(group.getMemberships()).hasSize(1);
assertThat(group.getMemberships().get(0).getGivenname()).isEqualTo("Thomas");
assertThat(group.getMemberships().get(0).getFamilyname()).isEqualTo("Tom");
assertThat(group.getMemberships().get(0).getEmail()).isEqualTo("tho@mail.de");
}
@Test
void applyEvent_userAlreadyExists() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateLimitEvent = updateUserLimitMaxEvent(uuidMock(0));
Event addEventA = addUserEvent(uuidMock(0), "A");
Event addEventB = addUserEvent(uuidMock(0), "B");
Event addEventC = addUserEvent(uuidMock(0), "A");
Group group = apply(createEvent, updateLimitEvent, addEventA, addEventB);
assertThrows(UserAlreadyExistsException.class, () -> addEventA.apply(group));
assertThrows(UserAlreadyExistsException.class, () -> addEventC.apply(group));
assertThat(group.getMemberships()).hasSize(2);
}
@Test
void applyEvent_groupFull() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event maxSizeEvent = new SetLimitEvent(uuidMock(0), "A", 2L);
Event addEventA = addUserEvent(uuidMock(0), "A");
Event addEventB = addUserEvent(uuidMock(0), "B");
Event addEventC = addUserEvent(uuidMock(0), "C");
Group group = apply(createEvent, maxSizeEvent, addEventA, addEventB);
assertThrows(GroupFullException.class, () -> addEventC.apply(group));
assertThat(group.getMemberships()).hasSize(2);
}
}

27
src/test/java/mops/gruppen2/domain/event/CreateGroupEventTest.java
View File

@ -1,27 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.TestBuilder;
import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.Type;
import org.junit.jupiter.api.Test;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.assertj.core.api.Assertions.assertThat;
class CreateGroupEventTest {
@Test
void applyEvent() {
Event createEvent = new CreateGroupEvent(uuidMock(0),
"A",
uuidMock(1),
Type.PUBLIC);
Group group = TestBuilder.apply(createEvent);
assertThat(group.getMemberships()).hasSize(0);
assertThat(group.getType()).isEqualTo(Type.PUBLIC);
assertThat(group.getGroupid()).isEqualTo(uuidMock(0));
assertThat(group.getParent()).isEqualTo(uuidMock(1));
}
}

29
src/test/java/mops/gruppen2/domain/event/DestroyGroupEventTest.java
View File

@ -1,29 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.TestBuilder;
import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.Type;
import org.junit.jupiter.api.Test;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.assertj.core.api.Assertions.assertThat;
class DestroyGroupEventTest {
@Test
void applyEvent() {
Event createEvent = new CreateGroupEvent(uuidMock(0),
"A",
uuidMock(1),
Type.PUBLIC);
Event deleteEvent = new DestroyGroupEvent(uuidMock(0), "A");
Group group = TestBuilder.apply(createEvent, deleteEvent);
assertThat(group.getMemberships()).isEmpty();
assertThat(group.getType()).isEqualTo(null);
assertThat(group.getLimit()).isEqualTo(0);
assertThat(group.getGroupid()).isEqualTo(uuidMock(0));
assertThat(group.getParent()).isEqualTo(null);
}
}

24
src/test/java/mops/gruppen2/domain/event/EventTest.java
View File

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

40
src/test/java/mops/gruppen2/domain/event/KickMemberEventTest.java
View File

@ -1,40 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.TestBuilder;
import mops.gruppen2.domain.exception.UserNotFoundException;
import mops.gruppen2.domain.model.group.Group;
import org.junit.jupiter.api.Test;
import static mops.gruppen2.TestBuilder.addUserEvent;
import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
import static mops.gruppen2.TestBuilder.updateUserLimitMaxEvent;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.junit.jupiter.api.Assertions.assertThrows;
class KickMemberEventTest {
@Test
void applyEvent() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateLimitEvent = updateUserLimitMaxEvent(uuidMock(0));
Event addEvent = addUserEvent(uuidMock(0), "A");
Event deleteEvent = new KickMemberEvent(uuidMock(0), "A");
Group group = TestBuilder.apply(createEvent, updateLimitEvent, addEvent, deleteEvent);
assertThat(group.getMemberships()).hasSize(0);
}
@Test
void applyEvent_userNotFound() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateLimitEvent = updateUserLimitMaxEvent(uuidMock(0));
Event addEvent = addUserEvent(uuidMock(0), "A");
Event deleteEvent = new KickMemberEvent(uuidMock(0), "B");
Group group = TestBuilder.apply(createEvent, updateLimitEvent, addEvent);
assertThrows(UserNotFoundException.class, () -> deleteEvent.apply(group));
assertThat(group.getMemberships()).hasSize(1);
}
}

33
src/test/java/mops/gruppen2/domain/event/SetDescriptionEventTest.java
View File

@ -1,33 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.TestBuilder;
import mops.gruppen2.domain.exception.BadArgumentException;
import mops.gruppen2.domain.model.group.Group;
import org.junit.jupiter.api.Test;
import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.junit.jupiter.api.Assertions.assertThrows;
class SetDescriptionEventTest {
@Test
void applyEvent() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateEvent = new SetDescriptionEvent(uuidMock(0), "A", "desc.");
Group group = TestBuilder.apply(createEvent, updateEvent);
assertThat(group.getDescription()).isEqualTo("desc.");
}
@Test
void applyEvent_badDescription() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateEventA = new SetDescriptionEvent(uuidMock(0), "A", "");
Group group = TestBuilder.apply(createEvent);
assertThrows(BadArgumentException.class, () -> updateEventA.apply(group));
}
}

48
src/test/java/mops/gruppen2/domain/event/SetLimitEventTest.java
View File

@ -1,48 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.domain.exception.BadArgumentException;
import mops.gruppen2.domain.model.group.Group;
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.uuidMock;
import static org.junit.jupiter.api.Assertions.assertThrows;
class SetLimitEventTest {
@Test
void applyEvent() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateEvent = new SetLimitEvent(uuidMock(0), "A", 5L);
Group group = apply(createEvent, updateEvent);
assertThat(group.getLimit()).isEqualTo(5);
}
@Test
void applyEvent_badParameter_negative() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateEvent = new SetLimitEvent(uuidMock(0), "A", -5L);
Group group = apply(createEvent);
assertThrows(BadArgumentException.class, () -> updateEvent.apply(group));
}
@Test
void applyEvent_badParameter_tooSmall() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateEventA = new SetLimitEvent(uuidMock(0), "A", 5L);
Event addEventA = addUserEvent(uuidMock(0));
Event addEventB = addUserEvent(uuidMock(0));
Event addEventC = addUserEvent(uuidMock(0));
Event updateEventB = new SetLimitEvent(uuidMock(0), "A", 2L);
Group group = apply(createEvent, updateEventA, addEventA, addEventB, addEventC);
assertThrows(BadArgumentException.class, () -> updateEventB.apply(group));
}
}

33
src/test/java/mops/gruppen2/domain/event/SetTitleEventTest.java
View File

@ -1,33 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.TestBuilder;
import mops.gruppen2.domain.exception.BadArgumentException;
import mops.gruppen2.domain.model.group.Group;
import org.junit.jupiter.api.Test;
import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.junit.jupiter.api.Assertions.assertThrows;
class SetTitleEventTest {
@Test
void applyEvent() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateEvent = new SetTitleEvent(uuidMock(0), "A", "title.");
Group group = TestBuilder.apply(createEvent, updateEvent);
assertThat(group.getTitle()).isEqualTo("title.");
}
@Test
void applyEvent_badDescription() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateEventA = new SetTitleEvent(uuidMock(0), "A", "");
Group group = TestBuilder.apply(createEvent);
assertThrows(BadArgumentException.class, () -> updateEventA.apply(group));
}
}

41
src/test/java/mops/gruppen2/domain/event/UpdateRoleEventTest.java
View File

@ -1,41 +0,0 @@
package mops.gruppen2.domain.event;
import mops.gruppen2.domain.exception.UserNotFoundException;
import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.Role;
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.updateUserLimitMaxEvent;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.junit.jupiter.api.Assertions.assertThrows;
class UpdateRoleEventTest {
@Test
void applyEvent() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateLimitEvent = updateUserLimitMaxEvent(uuidMock(0));
Event addEvent = addUserEvent(uuidMock(0), "A");
Event updateEvent = new UpdateRoleEvent(uuidMock(0), "A", Role.ADMIN);
Group group = apply(createEvent, updateLimitEvent, addEvent, updateEvent);
assertThat(group.getRoles().get("A")).isEqualTo(Role.ADMIN);
}
@Test
void applyEvent_userNotFound() {
Event createEvent = createPublicGroupEvent(uuidMock(0));
Event updateLimitEvent = updateUserLimitMaxEvent(uuidMock(0));
Event addEvent = addUserEvent(uuidMock(0), "A");
Event updateEvent = new UpdateRoleEvent(uuidMock(0), "B", Role.ADMIN);
Group group = apply(createEvent, updateLimitEvent, addEvent);
assertThrows(UserNotFoundException.class, () -> updateEvent.apply(group));
assertThat(group.getRoles().get("A")).isEqualTo(Role.MEMBER);
}
}

314
src/test/java/mops/gruppen2/domain/service/ControllerServiceTest.java
View File

@ -1,314 +0,0 @@
package mops.gruppen2.domain.service;
import mops.gruppen2.Gruppen2Application;
import mops.gruppen2.domain.Account;
import mops.gruppen2.domain.helper.ValidationHelper;
import mops.gruppen2.persistance.EventRepository;
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;
//TODO: Alles in die entsprechenden Klassen sortieren :((((
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = Gruppen2Application.class)
@Transactional
@Rollback
class ControllerServiceTest {
Account account;
Account account2;
Account account3;
GroupEmpty
@Autowired
EventStoreService eventStoreService;
@Autowired
ValidationHelper validationHelper;
@Autowired
EventRepository eventRepository;
@Autowired
GroupService groupService;
@Autowired
InviteService inviteService;
@Autowired
SearchService searchService;
@Autowired
ProjectionService projectionService;
/*
@BeforeEach
void setUp() {
Set<String> roles = new HashSet<>();
roles.add("l");
account = new Account("ich", "ich@hhu.de", "l", "ichdude", "jap", roles);
account2 = new Account("ich2", "ich2@hhu.de", "l", "ichdude2", "jap2", roles);
account3 = new Account("ich3", "ich3@hhu.de", "l", "ichdude3", "jap3", roles);
eventRepository.deleteAll();
}
@Test
void createPublicGroupWithNoParentAndLimitedNumberTest() {
groupService.createGroup(account, "test", "hi", null, null, null, 20L, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(20L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createPublicGroupWithNoParentAndUnlimitedNumberTest() {
groupService.createGroup(account, "test", "hi", null, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(100000L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createPrivateGroupWithNoParentAndUnlimitedNumberTest() {
groupService.createGroup(account, "test", "hi", true, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PRIVATE, groups.get(0).getVisibility());
assertEquals(100000L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createPrivateGroupWithNoParentAndLimitedNumberTest() {
groupService.createGroup(account, "test", "hi", true, null, null, 20L, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PRIVATE, groups.get(0).getVisibility());
assertEquals(20L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createPrivateGroupWithParentAndLimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account2, "test", "hi", false, true, true, 1L, null, null);
List<Group> groups1 = projectionService.projectUserGroups(account2.getName());
groupService.createGroup(account, "test", "hi", true, null, null, 20L, groups1.get(0).getId());
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PRIVATE, groups.get(0).getVisibility());
assertEquals(20L, groups.get(0).getUserMaximum());
assertEquals(groups1.get(0).getId(), groups.get(0).getParent());
}
@Test
void createPublicGroupWithParentAndLimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account2, "test", "hi", false, false, true, 1L, null, null);
List<Group> groups1 = projectionService.projectUserGroups(account2.getName());
groupService.createGroup(account, "test", "hi", null, null, null, 20L, groups1.get(0).getId());
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(20L, groups.get(0).getUserMaximum());
assertEquals(groups1.get(0).getId(), groups.get(0).getParent());
}
@Test
void createPublicGroupWithParentAndUnlimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account2, "test", "hi", false, false, true, 1L, null, null);
List<Group> groups1 = projectionService.projectUserGroups(account2.getName());
groupService.createGroup(account, "test", "hi", null, true, true, null, groups1.get(0).getId());
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(100000L, groups.get(0).getUserMaximum());
assertEquals(groups1.get(0).getId(), groups.get(0).getParent());
}
@Test
void createPrivateGroupWithParentAndUnlimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account2, "test", "hi", false, false, true, 1L, null, null);
List<Group> groups1 = projectionService.projectUserGroups(account2.getName());
groupService.createGroup(account, "test", "hi", true, true, true, null, groups1.get(0).getId());
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(Visibility.PRIVATE, groups.get(0).getVisibility());
assertEquals(100000L, groups.get(0).getUserMaximum());
assertEquals(groups1.get(0).getId(), groups.get(0).getParent());
}
@Test
void createPublicOrgaGroupWithNoParentAndLimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account, "test", "hi", false, false, false, 20L, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(GroupType.SIMPLE, groups.get(0).getType());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(20L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createPublicOrgaGroupWithNoParentAndUnlimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account, "test", "hi", false, false, true, 1L, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(GroupType.SIMPLE, groups.get(0).getType());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(100000L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createPrivateOrgaGroupWithNoParentAndLimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account, "test", "hi", true, false, false, 20L, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(GroupType.SIMPLE, groups.get(0).getType());
assertEquals(Visibility.PRIVATE, groups.get(0).getVisibility());
assertEquals(20L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createPrivateOrgaGroupWithNoParentAndUnlimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account, "test", "hi", true, false, true, 1L, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(GroupType.SIMPLE, groups.get(0).getType());
assertEquals(Visibility.PRIVATE, groups.get(0).getVisibility());
assertEquals(100000L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createOrgaLectureGroupAndLimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account, "test", "hi", false, true, false, 20L, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(GroupType.LECTURE, groups.get(0).getType());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(20L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
@Test
void createOrgaLectureGroupAndUnlimitedNumberTest() throws IOException {
groupService.createGroupAsOrga(account, "test", "hi", false, true, true, 1L, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
testTitleAndDescription(groups.get(0).getTitle(), groups.get(0).getDescription());
assertEquals(GroupType.LECTURE, groups.get(0).getType());
assertEquals(Visibility.PUBLIC, groups.get(0).getVisibility());
assertEquals(100000L, groups.get(0).getUserMaximum());
assertNull(groups.get(0).getParent());
}
//TODO: GroupServiceTest
@Disabled
@Test
public void deleteUserTest() {
groupService.createGroup(account, "test", "hi", true, true, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
groupService.addUser(account2, groups.get(0).getId());
User user = new User(account.getName(), "", "", "");
groupService.deleteUser(account, user, groups.get(0));
assertTrue(projectionService.projectUserGroups(account.getName()).isEmpty());
}
//TODO: GroupServiceTest
@Disabled
@Test
public void updateRoleAdminTest() {
groupService.createGroup(account, "test", "hi", null, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
groupService.addUser(account2, groups.get(0).getId());
User user = new User(account.getName(), "", "", "");
groupService.updateRole(user, groups.get(0).getId());
groups = projectionService.projectUserGroups(account.getName());
assertEquals(Role.MEMBER, groups.get(0).getRoles().get(account.getName()));
}
//TODO: GroupServiceTest
@Disabled
@Test
public void updateRoleMemberTest() {
groupService.createGroup(account, "test", "hi", null, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
groupService.addUser(account2, groups.get(0).getId());
User user = new User(account2.getName(), "", "", "");
groupService.updateRole(user, groups.get(0).getId());
groups = projectionService.projectUserGroups(account.getName());
assertEquals(Role.ADMIN, groups.get(0).getRoles().get(account2.getName()));
}
//TODO: GroupServiceTest
@Test
public void updateRoleNonUserTest() {
groupService.createGroup(account, "test", "hi", null, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
User user = new User(account2.getName(), "", "", "");
Throwable exception = assertThrows(UserNotFoundException.class, () -> groupService.updateRole(user, groups.get(0).getId()));
assertEquals("404 NOT_FOUND \"Der User wurde nicht gefunden. (class mops.gruppen2.domain.service.ValidationService)\"", exception.getMessage());
}
//TODO: GroupServiceTest
@Test
public void deleteNonUserTest() {
groupService.createGroup(account, "test", "hi", true, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
User user = new User(account2.getName(), "", "", "");
Throwable exception = assertThrows(UserNotFoundException.class, () -> groupService.deleteUser(account, user, groups.get(0)));
assertEquals("404 NOT_FOUND \"Der User wurde nicht gefunden. (class mops.gruppen2.domain.service.ValidationService)\"", exception.getMessage());
}
void testTitleAndDescription(String title, String description) {
assertEquals("test", title);
assertEquals("hi", description);
}
//TODO: GroupServiceTest
@Disabled
@Test
void passIfLastAdminTest() {
groupService.createGroup(account, "test", "hi", null, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
groupService.addUser(account2, groups.get(0).getId());
User user = new User(account.getName(), "", "", "");
groups = projectionService.projectUserGroups(account2.getName());
groupService.deleteUser(account, user, groups.get(0));
groups = projectionService.projectUserGroups(account2.getName());
assertEquals(Role.ADMIN, groups.get(0).getRoles().get(account2.getName()));
}
//TODO: GroupServiceTest
@Disabled
@Test
void dontPassIfNotLastAdminTest() {
groupService.createGroup(account, "test", "hi", null, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
groupService.addUser(account2, groups.get(0).getId());
User user2 = new User(account2.getName(), "", "", "");
groupService.updateRole(user2, groups.get(0).getId());
groupService.addUser(account3, groups.get(0).getId());
groupService.changeRoleIfLastAdmin(account, groups.get(0));
User user = new User(account.getName(), "", "", "");
groupService.deleteUser(account, user, groups.get(0));
groups = projectionService.projectUserGroups(account2.getName());
assertEquals(Role.MEMBER, groups.get(0).getRoles().get(account3.getName()));
}
//TODO: GroupServiceTest
@Disabled
@Test
void getVeteranMemberTest() {
groupService.createGroup(account, "test", "hi", null, null, true, null, null);
List<Group> groups = projectionService.projectUserGroups(account.getName());
groupService.addUser(account2, groups.get(0).getId());
groupService.addUser(account3, groups.get(0).getId());
User user = new User(account.getName(), "", "", "");
groups = projectionService.projectUserGroups(account2.getName());
groupService.deleteUser(account, user, groups.get(0));
groups = projectionService.projectUserGroups(account2.getName());
assertEquals(Role.ADMIN, groups.get(0).getRoles().get(account2.getName()));
assertEquals(Role.MEMBER, groups.get(0).getRoles().get(account3.getName()));
}*/
}

101
src/test/java/mops/gruppen2/domain/service/EventStoreServiceTest.java
View File

@ -1,101 +0,0 @@
package mops.gruppen2.domain.service;
import mops.gruppen2.Gruppen2Application;
import mops.gruppen2.domain.event.Event;
import mops.gruppen2.domain.model.group.User;
import mops.gruppen2.persistance.EventRepository;
import mops.gruppen2.persistance.dto.EventDTO;
import org.junit.jupiter.api.BeforeEach;
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.jdbc.core.JdbcTemplate;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.transaction.annotation.Transactional;
import static mops.gruppen2.TestBuilder.addUserEvent;
import static mops.gruppen2.TestBuilder.addUserEvents;
import static mops.gruppen2.TestBuilder.createPrivateGroupEvents;
import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
import static mops.gruppen2.TestBuilder.createPublicGroupEvents;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = Gruppen2Application.class)
@Transactional
@Rollback
class EventStoreServiceTest {
@Autowired
private EventRepository eventRepository;
private EventStoreService eventStoreService;
@Autowired
private JdbcTemplate template;
@SuppressWarnings("SyntaxError")
@BeforeEach
void setUp() {
eventStoreService = new EventStoreService(eventRepository);
eventRepository.deleteAll();
//noinspection SqlResolve
template.execute("ALTER TABLE event ALTER COLUMN event_id RESTART WITH 1");
}
@Test
void saveEvent() {
eventStoreService.saveEvent(createPublicGroupEvent());
assertThat(eventRepository.findAll()).hasSize(1);
}
@Test
void saveAll() {
eventStoreService.saveAll(createPrivateGroupEvents(10));
assertThat(eventRepository.findAll()).hasSize(10);
}
@Test
void testSaveAll() {
eventStoreService.saveAll(createPublicGroupEvents(5),
createPrivateGroupEvents(5));
assertThat(eventRepository.findAll()).hasSize(10);
}
@Test
void getDTO() {
Event event = createPublicGroupEvent();
EventDTO dto = EventStoreService.getDTOFromEvent(event);
assertThat(dto.getGroup_id()).isEqualTo(event.getGroupid().toString());
assertThat(dto.getUser_id()).isEqualTo(event.getTarget());
assertThat(dto.getEvent_id()).isEqualTo(null);
assertThat(dto.getEvent_type()).isEqualTo("CreateGroupEvent");
}
@Test
void getEventsOfGroup() {
eventStoreService.saveAll(addUserEvents(10, uuidMock(0)),
addUserEvents(5, uuidMock(1)));
assertThat(eventStoreService.findGroupEvents(uuidMock(0))).hasSize(10);
assertThat(eventStoreService.findGroupEvents(uuidMock(1))).hasSize(5);
}
@Test
void findGroupIdsByUser() {
eventStoreService.saveAll(addUserEvent(uuidMock(0), "A"),
addUserEvent(uuidMock(1), "A"),
addUserEvent(uuidMock(2), "A"),
addUserEvent(uuidMock(3), "A"),
addUserEvent(uuidMock(3), "B"));
assertThat(eventStoreService.findExistingUserGroups(new User("A"))).hasSize(4);
assertThat(eventStoreService.findExistingUserGroups(new User("B"))).hasSize(1);
}
}

215
src/test/java/mops/gruppen2/domain/service/GroupServiceTest.java
View File

@ -1,215 +0,0 @@
package mops.gruppen2.domain.service;
import mops.gruppen2.Gruppen2Application;
import mops.gruppen2.TestBuilder;
import mops.gruppen2.domain.event.Event;
import mops.gruppen2.domain.model.group.Group;
import mops.gruppen2.domain.model.group.Type;
import mops.gruppen2.domain.model.group.User;
import mops.gruppen2.persistance.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.jdbc.core.JdbcTemplate;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
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.uuidMock;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = Gruppen2Application.class)
@Transactional
@Rollback
class GroupServiceTest {
@Autowired
private EventRepository eventRepository;
@Autowired
SearchService searchService;
private GroupService groupService;
@Autowired
private JdbcTemplate template;
@Autowired
ProjectionService projectionService;
@Autowired
private EventStoreService eventStoreService;
@Autowired
private InviteService inviteService;
@SuppressWarnings("SyntaxError")
@BeforeEach
void setUp() {
groupService = new GroupService(eventStoreService, inviteService);
eventRepository.deleteAll();
//noinspection SqlResolve
template.execute("ALTER TABLE event ALTER COLUMN event_id RESTART WITH 1");
}
//TODO: Wofür ist dieser Test?
//TODO: ProjectionServiceTest
@Test
void rightClassForSuccessfulGroup() {
List<Event> eventList = completePrivateGroup(1);
List<Group> groups = ProjectionService.projectGroupsByEvents(eventList);
assertThat(groups.get(0)).isInstanceOf(Group.class);
}
//TODO: ProjectionServiceTest
@Test
void projectEventList_SingleGroup() {
List<Event> eventList = completePrivateGroup(5);
List<Group> groups = ProjectionService.projectGroupsByEvents(eventList);
assertThat(groups).hasSize(1);
assertThat(groups.get(0).getMemberships()).hasSize(5);
assertThat(groups.get(0).getType()).isEqualTo(Type.PRIVATE);
}
//TODO: ProjectionServiceTest
@Test
void projectEventList_MultipleGroups() {
List<Event> eventList = completePrivateGroups(10, 2);
eventList.addAll(completePublicGroups(10, 5));
List<Group> groups = ProjectionService.projectGroupsByEvents(eventList);
assertThat(groups).hasSize(20);
assertThat(groups.stream().map(group -> group.getMemberships().size()).reduce(Integer::sum).get()).isEqualTo(70);
}
//TODO: EventStoreServiceTest
@Test
void getGroupEvents() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
createPublicGroupEvent(uuidMock(1)),
createPrivateGroupEvent(uuidMock(2)));
List<UUID> groupIds = Arrays.asList(uuidMock(0), uuidMock(1));
assertThat(eventStoreService.findGroupEvents(groupIds)).hasSize(2);
assertThat(eventStoreService.findGroupEvents(groupIds).get(0).getGroupid()).isEqualTo(uuidMock(0));
assertThat(eventStoreService.findGroupEvents(groupIds).get(1).getGroupid()).isEqualTo(uuidMock(1));
}
//TODO: ProjectionServiceTest
@Disabled
@Test
void getAllGroupWithVisibilityPublicTestCreateAndDeleteSameGroup() {
Event test1 = createPublicGroupEvent(uuidMock(0));
Event test2 = deleteGroupEvent(uuidMock(0));
//TODO: Hier projectEventlist()?
Group group = TestBuilder.apply(test1, test2);
assertThat(group.getType()).isEqualTo(null);
assertThat(projectionService.projectPublicGroups()).isEmpty();
}
//TODO: ProjectionServiceTest
@Disabled
@Test
void getAllGroupWithVisibilityPublicTestGroupPublic() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
deleteGroupEvent(uuidMock(0)),
createPublicGroupEvent());
assertThat(projectionService.projectPublicGroups().size()).isEqualTo(1);
}
//TODO: ProjectionServiceTest
@Disabled
@Test
void getAllGroupWithVisibilityPublicTestAddSomeEvents() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
deleteGroupEvent(uuidMock(0)),
createPublicGroupEvent(),
createPublicGroupEvent(),
createPublicGroupEvent(),
createPrivateGroupEvent());
assertThat(projectionService.projectPublicGroups().size()).isEqualTo(3);
}
//TODO: ProjectionServiceTest
@Disabled
@Test
void getAllGroupWithVisibilityPublic_UserInGroup() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
addUserEvent(uuidMock(0), "kobold"),
createPrivateGroupEvent(),
createPublicGroupEvent());
assertThat(projectionService.projectPublicGroups()).hasSize(1);
assertThat(projectionService.projectPublicGroups()).hasSize(2);
}
//TODO: ProjectionServiceTest
@Test
void getAllLecturesWithVisibilityPublic() {
eventStoreService.saveAll(createLectureEvent(),
createPublicGroupEvent(),
createLectureEvent(),
createLectureEvent(),
createLectureEvent());
assertThat(projectionService.projectLectures().size()).isEqualTo(4);
}
//TODO: SearchServiceTest
@Test
void findGroupWith_UserMember_AllGroups() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
addUserEvent(uuidMock(0), "jens"),
updateGroupTitleEvent(uuidMock(0)),
updateGroupDescriptionEvent(uuidMock(0)));
assertThat(searchService.searchPublicGroups("", new User("jens"))).isEmpty();
}
//TODO: SearchServiceTest
@Test
void findGroupWith_UserNoMember_AllGroups() {
eventStoreService.saveAll(completePublicGroups(10, 0),
completePrivateGroups(10, 0));
assertThat(searchService.searchPublicGroups("", new User("jens"))).hasSize(10);
}
//TODO: SearchServiceTest
@Test
void findGroupWith_FilterGroups() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
updateGroupTitleEvent(uuidMock(0), "KK"),
updateGroupDescriptionEvent(uuidMock(0), "ABCDE"),
createPublicGroupEvent(uuidMock(1)),
updateGroupTitleEvent(uuidMock(1), "ABCDEFG"),
updateGroupDescriptionEvent(uuidMock(1), "KK"),
createPrivateGroupEvent());
assertThat(searchService.searchPublicGroups("A", new User("jesus"))).hasSize(2);
assertThat(searchService.searchPublicGroups("F", new User("jesus"))).hasSize(1);
assertThat(searchService.searchPublicGroups("Z", new User("jesus"))).hasSize(0);
}
}

176
src/test/java/mops/gruppen2/web/APIControllerTest.java
View File

@ -1,176 +0,0 @@
package mops.gruppen2.web;
import mops.gruppen2.Gruppen2Application;
import mops.gruppen2.domain.exception.GroupNotFoundException;
import mops.gruppen2.domain.service.EventStoreService;
import mops.gruppen2.persistance.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.jdbc.core.JdbcTemplate;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.transaction.annotation.Transactional;
import static mops.gruppen2.TestBuilder.addUserEvent;
import static mops.gruppen2.TestBuilder.createPrivateGroupEvent;
import static mops.gruppen2.TestBuilder.createPublicGroupEvent;
import static mops.gruppen2.TestBuilder.deleteGroupEvent;
import static mops.gruppen2.TestBuilder.deleteUserEvent;
import static mops.gruppen2.TestBuilder.updateGroupTitleEvent;
import static mops.gruppen2.TestBuilder.updateUserLimitMaxEvent;
import static mops.gruppen2.TestBuilder.uuidMock;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = Gruppen2Application.class)
@Transactional
@Rollback
class APIControllerTest {
@Autowired
private EventRepository eventRepository;
@Autowired
private APIController apiController;
@Autowired
private EventStoreService eventStoreService;
@Autowired
private JdbcTemplate template;
@SuppressWarnings("SyntaxError")
@BeforeEach
void setUp() {
eventRepository.deleteAll();
//noinspection SqlResolve
template.execute("ALTER TABLE event ALTER COLUMN event_id RESTART WITH 1");
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void updateGroup_noGroup() {
assertThat(apiController.getApiUpdate(0L).getGroupList()).hasSize(0);
assertThat(apiController.getApiUpdate(4L).getGroupList()).hasSize(0);
assertThat(apiController.getApiUpdate(10L).getGroupList()).hasSize(0);
assertThat(apiController.getApiUpdate(0L).getStatus()).isEqualTo(0);
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void updateGroup_singleGroup() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
updateUserLimitMaxEvent(uuidMock(0)),
addUserEvent(uuidMock(0)),
addUserEvent(uuidMock(0)),
addUserEvent(uuidMock(0)),
addUserEvent(uuidMock(0)));
assertThat(apiController.getApiUpdate(0L).getGroupList()).hasSize(1);
assertThat(apiController.getApiUpdate(4L).getGroupList()).hasSize(1);
assertThat(apiController.getApiUpdate(10L).getGroupList()).hasSize(0);
assertThat(apiController.getApiUpdate(0L).getStatus()).isEqualTo(6);
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void updateGroup_multipleGroups() {
eventStoreService.saveAll(createPublicGroupEvent(uuidMock(0)),
updateUserLimitMaxEvent(uuidMock(0)),
addUserEvent(uuidMock(0)),
addUserEvent(uuidMock(0)),
createPrivateGroupEvent(uuidMock(1)),
updateUserLimitMaxEvent(uuidMock(1)),
addUserEvent(uuidMock(1)),
addUserEvent(uuidMock(1)),
addUserEvent(uuidMock(1)));
assertThat(apiController.getApiUpdate(0L).getGroupList()).hasSize(2);
assertThat(apiController.getApiUpdate(4L).getGroupList()).hasSize(1);
assertThat(apiController.getApiUpdate(6L).getGroupList()).hasSize(1);
assertThat(apiController.getApiUpdate(7L).getGroupList()).hasSize(1);
assertThat(apiController.getApiUpdate(0L).getStatus()).isEqualTo(9);
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupsOfUser_noGroup() {
assertThat(apiController.getApiUserGroups("A")).isEmpty();
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupsOfUser_singleGroup() {
eventStoreService.saveAll(createPrivateGroupEvent(uuidMock(0)),
createPrivateGroupEvent(uuidMock(1)),
createPrivateGroupEvent(uuidMock(2)),
addUserEvent(uuidMock(0), "A"));
assertThat(apiController.getApiUserGroups("A")).hasSize(1);
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupsOfUser_singleGroupDeletedUser() {
eventStoreService.saveAll(createPrivateGroupEvent(uuidMock(0)),
addUserEvent(uuidMock(0), "A"),
deleteUserEvent(uuidMock(0), "A"));
assertThat(apiController.getApiUserGroups("A")).isEmpty();
}
@Disabled
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupsOfUser_singleDeletedGroup() {
eventStoreService.saveAll(createPrivateGroupEvent(uuidMock(0)),
addUserEvent(uuidMock(0), "A"),
deleteGroupEvent(uuidMock(0)));
assertThat(apiController.getApiUserGroups("A")).isEmpty();
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupsOfUser_multipleGroups() {
eventStoreService.saveAll(createPrivateGroupEvent(uuidMock(0)),
createPrivateGroupEvent(uuidMock(1)),
createPrivateGroupEvent(uuidMock(2)),
addUserEvent(uuidMock(0), "A"),
addUserEvent(uuidMock(0), "B"),
addUserEvent(uuidMock(1), "A"),
addUserEvent(uuidMock(2), "A"),
addUserEvent(uuidMock(2), "B"));
assertThat(apiController.getApiUserGroups("A")).hasSize(3);
assertThat(apiController.getApiUserGroups("B")).hasSize(2);
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupFromId_noGroup() {
assertThrows(GroupNotFoundException.class, () -> apiController.getApiGroup(uuidMock(0).toString()));
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupFromId_singleGroup() {
eventStoreService.saveAll(createPrivateGroupEvent(uuidMock(0)));
assertThat(apiController.getApiGroup(uuidMock(0).toString()).getGroupid()).isEqualTo(uuidMock(0));
}
@Test
@WithMockUser(username = "api_user", roles = "api_user")
void getGroupFromId_deletedGroup() {
eventStoreService.saveAll(createPrivateGroupEvent(uuidMock(0)),
updateGroupTitleEvent(uuidMock(0)),
deleteGroupEvent(uuidMock(0)));
assertThat(apiController.getApiGroup(uuidMock(0).toString()).getTitle()).isEqualTo(null);
}
}