diff --git a/server/src/main/java/de/uftos/services/TagService.java b/server/src/main/java/de/uftos/services/TagService.java index 787bd9ddc..041bee784 100644 --- a/server/src/main/java/de/uftos/services/TagService.java +++ b/server/src/main/java/de/uftos/services/TagService.java @@ -21,6 +21,7 @@ import de.uftos.repositories.database.TimeslotRepository; import de.uftos.utils.ConstraintInstanceDeleter; import de.uftos.utils.SpecificationBuilder; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Optional; diff --git a/server/src/test/java/de/uftos/e2e/CurriculumTest.java b/server/src/test/java/de/uftos/e2e/CurriculumTest.java index c337a8b93..b35a14bc2 100644 --- a/server/src/test/java/de/uftos/e2e/CurriculumTest.java +++ b/server/src/test/java/de/uftos/e2e/CurriculumTest.java @@ -1,6 +1,5 @@ package de.uftos.e2e; -import static de.uftos.utils.JsonGenerator.generateCurriculumJson; import static de.uftos.utils.JsonGenerator.generateGradeJson; import static de.uftos.utils.JsonGenerator.generateIdListJson; import static de.uftos.utils.JsonGenerator.generatePageJson; @@ -9,11 +8,9 @@ import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.notNullValue; -import de.uftos.dto.requestdtos.LessonsCountRequestDto; import io.restassured.filter.log.LogDetail; import io.restassured.http.ContentType; import java.util.Collections; -import java.util.List; import org.json.JSONException; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; @@ -38,7 +35,7 @@ class CurriculumTest { static void createTestCurricula() throws JSONException { subjectId = given().contentType(ContentType.JSON) - .body(generateSubjectJson(SUBJECT_NAME)) + .body(generateSubjectJson(SUBJECT_NAME, "ffffff")) .when() .post("/subjects") .then() diff --git a/server/src/test/java/de/uftos/e2e/StudentGroupsTest.java b/server/src/test/java/de/uftos/e2e/StudentGroupsTest.java index 44698f5f5..498fb6024 100644 --- a/server/src/test/java/de/uftos/e2e/StudentGroupsTest.java +++ b/server/src/test/java/de/uftos/e2e/StudentGroupsTest.java @@ -80,7 +80,7 @@ static void createTestStudentGroups() throws JSONException { .body().jsonPath().getString("id"); subjectId = given().contentType(ContentType.JSON) - .body(generateSubjectJson(SUBJECT_NAME)) + .body(generateSubjectJson(SUBJECT_NAME, "ffffff")) .when() .post("/subjects") .then() diff --git a/server/src/test/java/de/uftos/e2e/SubjectsTest.java b/server/src/test/java/de/uftos/e2e/SubjectsTest.java index a13ee3b40..d0471ea5c 100644 --- a/server/src/test/java/de/uftos/e2e/SubjectsTest.java +++ b/server/src/test/java/de/uftos/e2e/SubjectsTest.java @@ -24,7 +24,7 @@ class SubjectsTest { @BeforeAll static void createTestStudents() throws JSONException { subject1Id = given().contentType(ContentType.JSON) - .body(generateSubjectJson(SUBJECT1_NAME)) + .body(generateSubjectJson(SUBJECT1_NAME, "ffffff")) .when() .post("/subjects") .then() @@ -36,7 +36,7 @@ static void createTestStudents() throws JSONException { .body().jsonPath().getString("id"); subject2Id = given().contentType(ContentType.JSON) - .body(generateSubjectJson(SUBJECT2_NAME)) + .body(generateSubjectJson(SUBJECT2_NAME, "ffffff")) .when() .post("/subjects") .then() diff --git a/server/src/test/java/de/uftos/e2e/TeachersTest.java b/server/src/test/java/de/uftos/e2e/TeachersTest.java index 9209b34c2..9180f8d73 100644 --- a/server/src/test/java/de/uftos/e2e/TeachersTest.java +++ b/server/src/test/java/de/uftos/e2e/TeachersTest.java @@ -48,7 +48,7 @@ static void createTestTeachers() throws JSONException { .body().jsonPath().getString("id"); subjectId = given().contentType(ContentType.JSON) - .body(generateSubjectJson(SUBJECT_NAME)) + .body(generateSubjectJson(SUBJECT_NAME, "ffffff")) .when() .post("/subjects") .then() diff --git a/server/src/test/java/de/uftos/services/ConstraintInstanceServiceTest.java b/server/src/test/java/de/uftos/services/ConstraintInstanceServiceTest.java index 401be7665..b6f873b4c 100644 --- a/server/src/test/java/de/uftos/services/ConstraintInstanceServiceTest.java +++ b/server/src/test/java/de/uftos/services/ConstraintInstanceServiceTest.java @@ -5,6 +5,8 @@ import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -51,6 +53,10 @@ import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageImpl; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Pageable; import org.springframework.web.server.ResponseStatusException; @SuppressWarnings("checkstyle:MissingJavadocType") @@ -260,11 +266,19 @@ void setUp() { Optional.of(constraintInstanceInvalidArgs)); when(constraintSignatureRepository.findById(constraintSignature.getName())).thenReturn( Optional.of(constraintSignature)); + + Page instancePage = new PageImpl<>(List.of(constraintInstance)); + when(constraintInstanceRepository.findByArguments(eq("teacherArgId"), + any(Pageable.class))).thenReturn(instancePage); + when( constraintSignatureRepository.findById(constraintSignatureManyParams.getName())).thenReturn( Optional.of(constraintSignatureManyParams)); when(constraintSignatureRepository.findById(constraintSignatureInvalid.getName())).thenReturn( Optional.of(constraintSignatureInvalid)); + when(constraintSignatureRepository.findInstancesBySignatureId(eq("test constraint"), + any(Pageable.class))).thenReturn(instancePage); + Timeslot timeslot = new Timeslot("timeslotId1"); timeslot.setDay(Weekday.TUESDAY); @@ -331,6 +345,35 @@ void nonExistentParameter() { () -> constraintInstanceService.create("test constraint", constraintInstanceRequestDto)); } + @Test + void getConstraintInstancesNoArgs() { + ConstraintInstancesResponseDto result = + constraintInstanceService.get("test constraint", PageRequest.of(0, 10), Optional.empty()); + assertEquals(1, result.totalElements()); + List instances = result.constraintInstances(); + assertEquals("123", instances.getFirst().id()); + } + + @Test + void getConstraintInstancesWithArgs() { + ConstraintInstancesResponseDto result = + constraintInstanceService.get("test constraint", PageRequest.of(0, 10), + Optional.of("teacherArgId")); + assertEquals(1, result.totalElements()); + List instances = result.constraintInstances(); + assertEquals("123", instances.getFirst().id()); + } + + @Test + void getConstraintInstancesWithEmptyArg() { + ConstraintInstancesResponseDto result = + constraintInstanceService.get("test constraint", PageRequest.of(0, 10), + Optional.of("")); + assertEquals(1, result.totalElements()); + List instances = result.constraintInstances(); + assertEquals("123", instances.getFirst().id()); + } + @Test void tooManyParameter() { ConstraintArgumentRequestDto arg1 = @@ -355,6 +398,17 @@ void createConstraintInstance() { () -> constraintInstanceService.create("test constraint", constraintInstanceRequestDto)); } + @Test + void createConstraintInstanceInvalidSignatureId() { + ConstraintArgumentRequestDto arg = + new ConstraintArgumentRequestDto("teacher123", "teacherId1"); + ConstraintInstanceRequestDto constraintInstanceRequestDto = + new ConstraintInstanceRequestDto(List.of(arg), RewardPenalize.HARD_PENALIZE); + + assertThrows(ResponseStatusException.class, + () -> constraintInstanceService.create("nonExistentId", constraintInstanceRequestDto)); + } + @Test void createConstraintInstanceWrongParamName() { ConstraintArgumentRequestDto arg = diff --git a/server/src/test/java/de/uftos/services/CurriculumServiceTests.java b/server/src/test/java/de/uftos/services/CurriculumServiceTests.java index 8b37b2151..1baad34ee 100644 --- a/server/src/test/java/de/uftos/services/CurriculumServiceTests.java +++ b/server/src/test/java/de/uftos/services/CurriculumServiceTests.java @@ -78,6 +78,7 @@ void setUp() { newGrade.setId("newGrade"); LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Mathe", 4); + LessonsCountRequestDto otherLessonCount = new LessonsCountRequestDto("OtherSubject", 4); Curriculum curriculum1 = new Curriculum(testGrade, "EmptyCurriculum", List.of()); curriculum1.setId("123"); @@ -85,6 +86,9 @@ void setUp() { curriculum2.setId("456"); Curriculum curriculum3 = new Curriculum(newGrade, "UpdateCurriculum", List.of(lessonsCount)); curriculum3.setId("234"); + Curriculum curriculumMultipleLessonsCounts = + new Curriculum(newGrade, "UpdateCurriculum", List.of(lessonsCount, otherLessonCount)); + curriculumMultipleLessonsCounts.setId("multipleCounts"); Curriculum testCurriculum = new Curriculum(testGrade, "testName", List.of(lessonsCount)); @@ -100,6 +104,8 @@ void setUp() { when(curriculumRepository.findById("123")).thenReturn(Optional.of(curriculum1)); when(curriculumRepository.findById("456")).thenReturn(Optional.of(curriculum2)); when(curriculumRepository.findById("234")).thenReturn(Optional.of(curriculum3)); + when(curriculumRepository.findById("multipleCounts")).thenReturn( + Optional.of(curriculumMultipleLessonsCounts)); when(curriculumRepository.save(any(Curriculum.class))).thenReturn(testCurriculum); } @@ -142,6 +148,22 @@ void createCurriculum() { assertEquals(1, curriculum.getLessonsCounts().size()); } + @Test + void createEmptyName() { + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Englisch", 4); + CurriculumRequestDto requestDto = + new CurriculumRequestDto("testGrade", "", List.of(lessonsCount)); + assertThrows(ResponseStatusException.class, () -> curriculumService.create(requestDto)); + } + + @Test + void createNonExistentGrade() { + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Englisch", 4); + CurriculumRequestDto requestDto = + new CurriculumRequestDto("nonExistentGrade", "testName", List.of(lessonsCount)); + assertThrows(ResponseStatusException.class, () -> curriculumService.create(requestDto)); + } + @Test void updateCurriculum() { LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Mathe", 5); @@ -157,6 +179,56 @@ void updateCurriculum() { assertEquals(1, curriculum.getLessonsCounts().size()); } + @Test + void updateCurriculumMultipleLessonsCounts() { + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Mathe", 5); + LessonsCountRequestDto otherCount = new LessonsCountRequestDto("OtherSubject", 5); + CurriculumRequestDto requestDto = + new CurriculumRequestDto("newGrade", "newName", List.of(lessonsCount, otherCount)); + curriculumService.update("multipleCounts", requestDto); + + Curriculum curriculum = curriculumRepository.findById("multipleCounts").get(); + assertNotNull(curriculum); + + assertEquals(newGrade, curriculum.getGrade()); + + assertEquals(2, curriculum.getLessonsCounts().size()); + } + + @Test + void updateCurriculumInconsistentLessonCountAmounts() { + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Mathe", 5); + CurriculumRequestDto requestDto = + new CurriculumRequestDto("newGrade", "newName", List.of(lessonsCount)); + assertThrows(ResponseStatusException.class, () -> curriculumService.update("123", requestDto)); + } + + @Test + void updateCurriculumInconsistentLessonCountSubjects() { + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("OtherSubject", 5); + CurriculumRequestDto requestDto = + new CurriculumRequestDto("newGrade", "newName", List.of(lessonsCount)); + assertThrows(ResponseStatusException.class, () -> curriculumService.update("234", requestDto)); + } + + @Test + void updateCurriculumNonExistent() { + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Physik", 4); + CurriculumRequestDto requestDto = + new CurriculumRequestDto("newGrade", "newName", List.of(lessonsCount)); + assertThrows(ResponseStatusException.class, + () -> curriculumService.update("nonExistentId", requestDto)); + } + + @Test + void updateCurriculumNonExistentGrade() { + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("Physik", 4); + CurriculumRequestDto requestDto = + new CurriculumRequestDto("nonExistentGrade", "newName", List.of(lessonsCount)); + assertThrows(ResponseStatusException.class, + () -> curriculumService.update("234", requestDto)); + } + @Test void deleteExistentCurriculum() { assertDoesNotThrow(() -> curriculumService.delete("123")); diff --git a/server/src/test/java/de/uftos/services/GradeServiceTests.java b/server/src/test/java/de/uftos/services/GradeServiceTests.java index b32761e90..a45eb96f2 100644 --- a/server/src/test/java/de/uftos/services/GradeServiceTests.java +++ b/server/src/test/java/de/uftos/services/GradeServiceTests.java @@ -54,6 +54,9 @@ public class GradeServiceTests { private final GradeRequestDto requestDtoForCreateAndUpdate = new GradeRequestDto("testName", List.of(), List.of("tagId")); + private final GradeRequestDto requestDtoForCreateAndUpdateEmptyName = + new GradeRequestDto("", List.of(), List.of("tagId")); + @Mock private GradeRepository gradeRepository; @@ -81,6 +84,9 @@ public class GradeServiceTests { @Mock private Grade grade2Mock; + @Mock + private Grade grade3Mock; + @Mock private Grade gradeForCreateAndUpdateMock; @@ -162,23 +168,38 @@ void setUp() { List.of("T2", "T3")); grade2.setId("456"); + Grade grade3 = new Grade("7", List.of(), + List.of("T2", "T3")); + grade2.setId("567"); + studentGroup1.setGrades(List.of(grade1Mock)); studentGroup2.setGrades(List.of(grade1Mock)); + when(subjectRepository.findAll()).thenReturn(List.of(subject)); + Break[] breaks = {}; Server server = new Server(new TimetableMetadata(45, 8, "8:00", breaks), "2024", "test@uftos.de"); when(serverRepository.findAll()).thenReturn(List.of(server)); + when(studentGroupRepository.findByGrades(grade1Mock)).thenReturn( + List.of(studentGroup1, studentGroup2)); + when(studentGroupRepository.findAllByGrades(List.of("123"))).thenReturn( + List.of(studentGroup1, studentGroup2)); when(gradeRepository.findById("123")).thenReturn(Optional.of(grade1Mock)); - when(gradeRepository.findAllById(List.of("123"))).thenReturn(List.of(grade1Mock)); when(gradeRepository.findById("456")).thenReturn(Optional.of(grade2Mock)); + when(gradeRepository.findById("567")).thenReturn(Optional.of(grade3Mock)); when(gradeRepository.save(any(Grade.class))).thenReturn(gradeForCreateAndUpdateMock); + when(gradeRepository.findAllById(List.of("123"))).thenReturn(List.of(grade1Mock)); + when(gradeRepository.findAllById(List.of("567"))).thenReturn(List.of(grade3Mock)); + when(gradeRepository.findAllById(List.of("nonExistentId", "123"))).thenReturn( + List.of(grade1Mock)); when(grade1Mock.getStudentGroups()).thenReturn(List.of(studentGroup1, studentGroup2)); when(grade1Mock.getId()).thenReturn(grade1.getId()); when(grade1Mock.getName()).thenReturn(grade1.getName()); when(grade1Mock.getTags()).thenReturn(grade1.getTags()); when(grade2Mock.getStudentGroups()).thenReturn(List.of(studentGroup3, studentGroup4)); + when(grade3Mock.getId()).thenReturn("567"); Grade gradeForTests = requestDtoForCreateAndUpdate.map(); when(gradeForCreateAndUpdateMock.getStudentGroups()).thenReturn( @@ -224,7 +245,18 @@ void createGrade() { assertEquals(1, grade.getTags().size()); assertEquals("tagId", grade.getTags().getFirst().getId()); + } + @Test + void createGradeEmptyName() { + assertThrows(ResponseStatusException.class, + () -> gradeService.create(requestDtoForCreateAndUpdateEmptyName)); + } + + @Test + void updateGradeEmptyName() { + assertThrows(ResponseStatusException.class, + () -> gradeService.update("123", requestDtoForCreateAndUpdateEmptyName)); } @Test @@ -255,6 +287,11 @@ void lessonsById() { ); } + @Test + void lessonsByNonExistentId() { + assertThrows(ResponseStatusException.class, () -> gradeService.getLessonsById("nonExistentId")); + } + @Test void updateGrade() { gradeService.update("123", requestDtoForCreateAndUpdate); @@ -273,22 +310,46 @@ void updateGrade() { @Test void deleteExistentGrade() { - assertDoesNotThrow(() -> gradeService.deleteGrades(new String[] {"123"})); + SuccessResponse successResponse = gradeService.deleteGrades(new String[] {"567"}); + assertTrue(successResponse.success()); ArgumentCaptor> gradeCap = ArgumentCaptor.forClass(getClassType()); verify(gradeRepository, times(1)).deleteAll(gradeCap.capture()); List grade = gradeCap.getValue(); assertEquals(1, grade.size()); - assertEquals("123", grade.getFirst().getId()); + assertEquals("567", grade.getFirst().getId()); + } + + @Test + void deleteGradeAssociatedWithGroup() { + SuccessResponse response = gradeService.deleteGrades(new String[] {"123"}); + assertFalse(response.success()); } @Test void deleteNonExistentGrade() { - assertDoesNotThrow(() -> gradeService.deleteGrades(new String[] {"nonExistentId"})); SuccessResponse successResponse = gradeService.deleteGrades(new String[] {"nonExistentId"}); assertFalse(successResponse.success()); } + @Test + void deleteGradesSomeExistent() { + SuccessResponse successResponse = + gradeService.deleteGrades(new String[] {"nonExistentId", "123"}); + assertFalse(successResponse.success()); + } + + @Test + void deleteGradesAllExistent() { + SuccessResponse successResponse = gradeService.deleteGrades(new String[] {"567"}); + assertTrue(successResponse.success()); + ArgumentCaptor> gradeCap = ArgumentCaptor.forClass(getClassType()); + verify(gradeRepository, times(1)).deleteAll(gradeCap.capture()); + + List gradeList = gradeCap.getValue(); + assertEquals(1, gradeList.size()); + assertEquals("567", gradeList.getFirst().getId()); + } @Test void emptyLessons() { diff --git a/server/src/test/java/de/uftos/services/RoomServiceTests.java b/server/src/test/java/de/uftos/services/RoomServiceTests.java index e622133c7..edf745ff6 100644 --- a/server/src/test/java/de/uftos/services/RoomServiceTests.java +++ b/server/src/test/java/de/uftos/services/RoomServiceTests.java @@ -126,8 +126,10 @@ void setUp() { new Server(new TimetableMetadata(45, 8, "7:45", new Break[] {}), "2024", "test@uftos.de"); when(serverRepository.findAll()).thenReturn(List.of(server)); when(roomRepository.findById("123")).thenReturn(Optional.of(room1)); - when(roomRepository.findAllById(List.of("123"))).thenReturn(List.of(room1)); when(roomRepository.findById("456")).thenReturn(Optional.of(room2)); + when(roomRepository.findAllById(List.of("123"))).thenReturn(List.of(room1)); + when(roomRepository.findAllById(List.of("nonExistentId", "123"))).thenReturn(List.of(room1)); + } @Test @@ -157,6 +159,21 @@ void createRoom() { assertEquals("tagId", room.getTags().getFirst().getId()); } + @Test + void createRoomEmptyName() { + RoomRequestDto requestDto = + new RoomRequestDto("", "buildingName", 10, List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> roomService.create(requestDto)); + } + + @Test + void createRoomEmptyBuildingName() { + RoomRequestDto requestDto = + new RoomRequestDto("roomName", "", 10, List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> roomService.create(requestDto)); + } + + @Test void updateRoom() { RoomRequestDto requestDto = @@ -177,6 +194,20 @@ void updateRoom() { assertEquals(0, room.getTags().size()); } + @Test + void updateRoomEmptyName() { + RoomRequestDto requestDto = + new RoomRequestDto("", "buildingName", 10, List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> roomService.update("123", requestDto)); + } + + @Test + void updateRoomEmptyBuildingName() { + RoomRequestDto requestDto = + new RoomRequestDto("roomName", "", 10, List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> roomService.update("123", requestDto)); + } + @Test void deleteExistingRoom() { assertDoesNotThrow(() -> roomService.deleteRooms(new String[] {"123"})); @@ -194,6 +225,32 @@ void deleteNonExistingRoom() { () -> roomService.deleteRooms(new String[] {"nonExistentId"})); } + @Test + void deleteRoomsNonExistent() { + assertThrows(ResponseStatusException.class, + () -> roomService.deleteRooms(new String[] {"nonExistentId"})); + } + + @Test + void deleteRoomsSomeExistent() { + assertThrows(ResponseStatusException.class, + () -> roomService.deleteRooms(new String[] {"nonExistentId", "123"})); + } + + @Test + void deleteRoomsAllExistent() { + assertDoesNotThrow(() -> roomService.deleteRooms(new String[] {"123"})); + Class> listClass = + (Class>) (Class) List.class; + ArgumentCaptor> roomCap = ArgumentCaptor.forClass(listClass); + verify(roomRepository, times(1)).deleteAll(roomCap.capture()); + + List roomList = roomCap.getValue(); + assertEquals(1, roomList.size()); + assertEquals("123", roomList.getFirst().getId()); + + } + @Test void emptyLessons() { assertDoesNotThrow(() -> roomService.getLessonsById("456")); diff --git a/server/src/test/java/de/uftos/services/ServerServiceTests.java b/server/src/test/java/de/uftos/services/ServerServiceTests.java index 6f9ebc155..10cc5284b 100644 --- a/server/src/test/java/de/uftos/services/ServerServiceTests.java +++ b/server/src/test/java/de/uftos/services/ServerServiceTests.java @@ -7,11 +7,13 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import de.uftos.dto.Weekday; import de.uftos.dto.requestdtos.ServerEmailRequestDto; import de.uftos.dto.responsedtos.ServerEmailResponseDto; import de.uftos.dto.responsedtos.ServerStatisticsResponseDto; import de.uftos.entities.Break; import de.uftos.entities.Server; +import de.uftos.entities.Timeslot; import de.uftos.entities.TimetableMetadata; import de.uftos.repositories.database.ConstraintSignatureRepository; import de.uftos.repositories.database.GradeRepository; @@ -22,6 +24,7 @@ import de.uftos.repositories.database.TeacherRepository; import de.uftos.repositories.database.TimeslotRepository; import de.uftos.repositories.database.TimetableRepository; +import java.util.ArrayList; import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -73,13 +76,21 @@ public class ServerServiceTests { void setUp() { Server server = new Server(new TimetableMetadata(45, 8, "7:45", new Break[] {}), "2024", "test@uftos.de"); + + List timeslotList = new ArrayList<>(); + for (Weekday weekday : Weekday.values()) { + for (int i = 0; i < 8; i++) { + timeslotList.add(new Timeslot(weekday, i, List.of())); + } + } + when(serverRepository.findAll()).thenReturn(List.of(server)); when(studentRepository.count()).thenReturn(1L); when(teacherRepository.count()).thenReturn(2L); when(gradeRepository.count()).thenReturn(3L); when(roomRepository.count()).thenReturn(4L); when(constraintSignatureRepository.count()).thenReturn(0L); - when(timeslotRepository.findAll()).thenReturn(List.of()); + when(timeslotRepository.findAll()).thenReturn(timeslotList); } @Test @@ -106,7 +117,7 @@ void getMetadata() { } @Test - void setMetadata() { + void setMetadataFewerTimeslots() { Break testBreak = new Break(false, 0, 15); TimetableMetadata newMetadata = new TimetableMetadata(90, 5, "8:00", new Break[] {testBreak}); serverService.setTimetableMetadata(newMetadata); @@ -119,6 +130,34 @@ void setMetadata() { assertEquals(server.getCurrentYear(), "2024"); } + @Test + void setMetadataSameTimeslotAmount() { + Break testBreak = new Break(false, 0, 15); + TimetableMetadata newMetadata = new TimetableMetadata(90, 8, "8:00", new Break[] {testBreak}); + serverService.setTimetableMetadata(newMetadata); + + ArgumentCaptor serverCap = ArgumentCaptor.forClass(Server.class); + verify(serverRepository, times(1)).save(serverCap.capture()); + + Server server = serverCap.getValue(); + assertEquals(server.getTimetableMetadata(), newMetadata); + assertEquals(server.getCurrentYear(), "2024"); + } + + @Test + void setMetadataMoreTimeslots() { + Break testBreak = new Break(false, 0, 15); + TimetableMetadata newMetadata = new TimetableMetadata(90, 10, "8:00", new Break[] {testBreak}); + serverService.setTimetableMetadata(newMetadata); + + ArgumentCaptor serverCap = ArgumentCaptor.forClass(Server.class); + verify(serverRepository, times(1)).save(serverCap.capture()); + + Server server = serverCap.getValue(); + assertEquals(server.getTimetableMetadata(), newMetadata); + assertEquals(server.getCurrentYear(), "2024"); + } + @Test void getEmail() { assertDoesNotThrow(() -> serverService.getEmail()); diff --git a/server/src/test/java/de/uftos/services/StudentGroupServiceTests.java b/server/src/test/java/de/uftos/services/StudentGroupServiceTests.java index b083565be..f110019e9 100644 --- a/server/src/test/java/de/uftos/services/StudentGroupServiceTests.java +++ b/server/src/test/java/de/uftos/services/StudentGroupServiceTests.java @@ -54,9 +54,23 @@ @MockitoSettings(strictness = Strictness.LENIENT) public class StudentGroupServiceTests { private final StudentGroupRequestDto requestDto = - new StudentGroupRequestDto("testName", List.of("studentId1"), List.of("gradeId1"), - List.of("tagId1"), List.of("subjectId1")); + new StudentGroupRequestDto("testName", new ArrayList<>(List.of("studentId1")), + new ArrayList<>(List.of("gradeId1")), + new ArrayList<>(List.of("tagId1")), new ArrayList<>(List.of("subjectId1"))); + + private final StudentGroupRequestDto requestDtoEmptyName = + new StudentGroupRequestDto("", new ArrayList<>(List.of("studentId1")), + new ArrayList<>(List.of("gradeId1")), + new ArrayList<>(List.of("tagId1")), new ArrayList<>(List.of("subjectId1"))); + private final StudentGroupRequestDto requestDtoInvalidGrade = + new StudentGroupRequestDto("groupName", new ArrayList<>(List.of("studentId1")), + new ArrayList<>(List.of("nonExistentGrade")), + new ArrayList<>(List.of("tagId1")), new ArrayList<>(List.of("subjectId1"))); + @Mock + private Grade gradeNoGroupsMock; + @Mock + private Grade gradeForUpdateMock; @Mock private StudentGroupRepository studentGroupRepository; @@ -84,12 +98,107 @@ public class StudentGroupServiceTests { @InjectMocks private StudentGroupService studentGroupService; + + @BeforeEach + void setUp() { + StudentGroup studentGroup1 = + new StudentGroup("Ethics", new ArrayList<>(List.of("studentId0", "studentId1")), + Collections.emptyList(), + Collections.emptyList()); + studentGroup1.setId("123"); + + StudentGroup studentGroup2 = + new StudentGroup("Religion", + new ArrayList<>(List.of("studentId1", "studentId2", "studentId3")), + Collections.emptyList(), new ArrayList<>(List.of("T1", "T2"))); + studentGroup2.setId("456"); + studentGroup2.setLessons(Collections.emptyList()); + + StudentGroup studentGroup3 = + new StudentGroup("testName", new ArrayList<>(List.of("studentId1")), + new ArrayList<>(List.of("tagId1")), + new ArrayList<>(List.of("subjectId1"))); + + Grade grade1 = new Grade("gradeId1"); + grade1.setStudentGroups(new ArrayList<>(List.of(studentGroup1, studentGroup2, studentGroup3))); + + Grade gradeEmpty = new Grade("emptyGrade"); + gradeEmpty.setStudentGroups(new ArrayList<>(List.of(studentGroup1))); + + when(gradeRepository.findAllById(new ArrayList<>(List.of("gradeId1")))).thenReturn( + new ArrayList<>(List.of(grade1))); + when( + gradeRepository.findAllById(new ArrayList<>(List.of("gradeId1", "emptyGrade")))).thenReturn( + new ArrayList<>(List.of(gradeEmpty, grade1))); + when(gradeRepository.findAllById( + new ArrayList<>(List.of("noGroupsId", "gradeForUpdate", "emptyGrade")))).thenReturn( + new ArrayList<>(List.of(gradeEmpty, grade1))); + + + studentGroup1.setGrades(new ArrayList<>(List.of(grade1, gradeEmpty))); + studentGroup2.setGrades(new ArrayList<>(List.of(grade1))); + studentGroup3.setGrades(new ArrayList<>(List.of(grade1))); + + Subject subject = new Subject("789"); + + Room room1 = new Room("534"); + Room room2 = new Room("574"); + + Teacher teacher1 = new Teacher("T1"); + Teacher teacher2 = new Teacher("T2"); + + Timetable timetable = new Timetable("timetable"); + timetable.setId("timetableId"); + + Lesson lesson1 = createLesson(teacher1, room1, studentGroup1, "2024", subject, timetable); + Lesson lesson2 = createLesson(teacher2, room1, studentGroup1, "2022", subject, timetable); + Lesson lesson3 = createLesson(teacher1, room2, studentGroup2, "2024", subject, timetable); + + studentGroup1.setLessons(new ArrayList<>(List.of(lesson1, lesson2, lesson3))); + + Student student = new Student("Firstname", "Lastname", new ArrayList<>(List.of("tagId1"))); + student.setId("studentId1"); + + Student student1 = new Student("Firstname1", "Lastname1", new ArrayList<>(List.of("tagId1"))); + student1.setId("studentId2"); + when(studentRepository.findById(student.getId())).thenReturn(Optional.of(student)); + when(studentRepository.findById(student1.getId())).thenReturn(Optional.of(student1)); + when(studentRepository.findAll()).thenReturn(new ArrayList<>(List.of(student, student1))); + + Break[] breaks = {}; + Server server = + new Server(new TimetableMetadata(45, 8, "8:00", breaks), "2024", "test@uftos.de"); + when(serverRepository.findAll()).thenReturn(new ArrayList<>(List.of(server))); + when(studentGroupRepository.findById("123")).thenReturn(Optional.of(studentGroup1)); + when(studentGroupRepository.findById("456")).thenReturn(Optional.of(studentGroup2)); + + studentGroup3.setId("789"); + when(studentGroupRepository.save(any(StudentGroup.class))).thenReturn(studentGroup3); + when(studentGroupRepository.findById("789")).thenReturn(Optional.of(studentGroup3)); + + when(gradeRepository.findByStudentGroups(studentGroup1)).thenReturn( + new ArrayList<>(List.of(grade1, gradeEmpty))); + } + @Test - void getByNonExistingId() { + void getByNonExistentId() { assertThrows(ResponseStatusException.class, () -> studentGroupService.getById("nonExistingId")); } + @Test + void getByExistentId() { + StudentGroupResponseDto result = studentGroupService.getById("123"); + assertEquals("Ethics", result.name()); + assertEquals(2, result.students().size()); + assertEquals("studentId0", result.students().getFirst().getId()); + assertEquals("studentId1", result.students().get(1).getId()); + assertEquals(2, result.grades().size()); + assertEquals("gradeId1", result.grades().getFirst().id()); + assertEquals("emptyGrade", result.grades().get(1).id()); + assertEquals(0, result.tags().size()); + } + @Test void emptyLessons() { assertDoesNotThrow(() -> studentGroupService.getLessonsById("456")); @@ -100,7 +209,7 @@ void emptyLessons() { @Test void lessonsById() { LessonResponseDto result = studentGroupService.getLessonsById("123"); - assertResultArraySizes(result, 1, 2, 2, 1); + assertResultArraySizes(result, 1, 2, 2, 2); assertAll("Testing whether the sizes of the arrays are correct", () -> assertEquals(3, result.grades().getFirst().studentGroupIds().size()), () -> assertEquals(4, result.grades().getFirst().studentIds().size()) @@ -145,11 +254,24 @@ void createGroup() { assertEquals("subjectId1", studentGroup.subjects().getFirst().getId()); } + @Test + void createGroupEmptyName() { + assertThrows(ResponseStatusException.class, + () -> studentGroupService.create(requestDtoEmptyName)); + } + + @Test + void createGroupInvalidGrade() { + assertThrows(ResponseStatusException.class, + () -> studentGroupService.create(requestDtoInvalidGrade)); + } + @Test void updateGroup() { StudentGroupRequestDto requestDto = - new StudentGroupRequestDto("Ethics2", List.of("studentId0", "studentId1"), List.of(), - List.of(), List.of()); + new StudentGroupRequestDto("Ethics2", new ArrayList<>(List.of("studentId0", "studentId1")), + new ArrayList<>(List.of("noGroupsId", "gradeForUpdate", "emptyGrade")), + Collections.emptyList(), Collections.emptyList()); studentGroupService.update("123", requestDto); ArgumentCaptor studentGroupCap = ArgumentCaptor.forClass(StudentGroup.class); @@ -162,14 +284,21 @@ void updateGroup() { } @Test - void addNonExistingStudent() { + void updateGroupEmptyName() { assertThrows(ResponseStatusException.class, - () -> studentGroupService.addStudents("123", List.of("studentId3"))); + () -> studentGroupService.update("123", requestDtoEmptyName)); } @Test - void addExistingStudent() { - assertDoesNotThrow(() -> studentGroupService.addStudents("123", List.of("studentId1"))); + void addNonExistentStudent() { + assertThrows(ResponseStatusException.class, + () -> studentGroupService.addStudents("123", new ArrayList<>(List.of("studentId3")))); + } + + @Test + void addExistentStudent() { + assertDoesNotThrow( + () -> studentGroupService.addStudents("123", new ArrayList<>(List.of("studentId1")))); ArgumentCaptor studentGroupCap = ArgumentCaptor.forClass(StudentGroup.class); verify(studentGroupRepository, times(1)).save(studentGroupCap.capture()); @@ -180,7 +309,7 @@ void addExistingStudent() { @Test void removeStudent() { - studentGroupService.removeStudents("456", List.of("studentId2")); + studentGroupService.removeStudents("456", new ArrayList<>(List.of("studentId2"))); ArgumentCaptor studentGroupCap = ArgumentCaptor.forClass(StudentGroup.class); verify(studentGroupRepository, times(1)).save(studentGroupCap.capture()); @@ -190,7 +319,7 @@ void removeStudent() { } @Test - void deleteExistingGroup() { + void deleteExistentGroup() { assertDoesNotThrow(() -> studentGroupService.delete("123")); ArgumentCaptor studentGroupCap = ArgumentCaptor.forClass(StudentGroup.class); verify(studentGroupRepository, times(1)).delete(studentGroupCap.capture()); @@ -200,74 +329,10 @@ void deleteExistingGroup() { } @Test - void deleteNonExistingGroup() { + void deleteNonExistentGroup() { assertThrows(ResponseStatusException.class, () -> studentGroupService.delete("123456")); } - @BeforeEach - void setUp() { - StudentGroup studentGroup1 = - new StudentGroup("Ethics", List.of("studentId0", "studentId1"), List.of(), - List.of()); - studentGroup1.setId("123"); - - StudentGroup studentGroup2 = - new StudentGroup("Religion", List.of("studentId1", "studentId2", "studentId3"), - List.of(), - List.of("T1", "T2")); - studentGroup2.setId("456"); - studentGroup2.setLessons(Collections.emptyList()); - - StudentGroup studentGroup3 = - new StudentGroup("testName", List.of("studentId1"), List.of("tagId1"), - List.of("subjectId1")); - - Grade grade1 = new Grade("gradeId1"); - grade1.setStudentGroups(new ArrayList<>(List.of(studentGroup1, studentGroup2, studentGroup3))); - - when(gradeRepository.findAllById(List.of("gradeId1"))).thenReturn(List.of(grade1)); - - studentGroup1.setGrades(List.of(grade1)); - studentGroup2.setGrades(List.of(grade1)); - studentGroup3.setGrades(List.of(grade1)); - - Subject subject = new Subject("789"); - - Room room1 = new Room("534"); - Room room2 = new Room("574"); - - Teacher teacher1 = new Teacher("T1"); - Teacher teacher2 = new Teacher("T2"); - - Timetable timetable = new Timetable("timetable"); - timetable.setId("timetableId"); - - Lesson lesson1 = createLesson(teacher1, room1, studentGroup1, "2024", subject, timetable); - Lesson lesson2 = createLesson(teacher2, room1, studentGroup1, "2022", subject, timetable); - Lesson lesson3 = createLesson(teacher1, room2, studentGroup2, "2024", subject, timetable); - - studentGroup1.setLessons(List.of(lesson1, lesson2, lesson3)); - - Student student = new Student("Firstname", "Lastname", List.of("tagId1")); - student.setId("studentId1"); - - Student student1 = new Student("Firstname1", "Lastname1", List.of("tagId1")); - student1.setId("studentId2"); - when(studentRepository.findById(student.getId())).thenReturn(Optional.of(student)); - when(studentRepository.findById(student1.getId())).thenReturn(Optional.of(student1)); - when(studentRepository.findAll()).thenReturn(List.of(student, student1)); - - Break[] breaks = {}; - Server server = - new Server(new TimetableMetadata(45, 8, "8:00", breaks), "2024", "test@uftos.de"); - when(serverRepository.findAll()).thenReturn(List.of(server)); - when(studentGroupRepository.findById("123")).thenReturn(Optional.of(studentGroup1)); - when(studentGroupRepository.findById("456")).thenReturn(Optional.of(studentGroup2)); - - studentGroup3.setId("789"); - when(studentGroupRepository.save(any(StudentGroup.class))).thenReturn(studentGroup3); - when(studentGroupRepository.findById("789")).thenReturn(Optional.of(studentGroup3)); - } private Lesson createLesson(Teacher teacher, Room room, StudentGroup studentGroup, String number, Subject subject, Timetable timetable) { diff --git a/server/src/test/java/de/uftos/services/StudentServiceTest.java b/server/src/test/java/de/uftos/services/StudentServiceTest.java index 7ce6422f6..372324848 100644 --- a/server/src/test/java/de/uftos/services/StudentServiceTest.java +++ b/server/src/test/java/de/uftos/services/StudentServiceTest.java @@ -1,22 +1,30 @@ package de.uftos.services; import static de.uftos.utils.ClassCaster.getClassType; +import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import de.uftos.dto.requestdtos.StudentRequestDto; +import de.uftos.dto.responsedtos.LessonResponseDto; +import de.uftos.entities.Lesson; +import de.uftos.entities.Room; +import de.uftos.entities.Server; import de.uftos.entities.Student; import de.uftos.entities.StudentGroup; import de.uftos.entities.Tag; import de.uftos.repositories.database.ConstraintSignatureRepository; +import de.uftos.repositories.database.ServerRepository; import de.uftos.repositories.database.StudentGroupRepository; import de.uftos.repositories.database.StudentRepository; +import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Optional; @@ -36,9 +44,15 @@ @ExtendWith(MockitoExtension.class) @MockitoSettings(strictness = Strictness.LENIENT) public class StudentServiceTest { + @Mock + private StudentGroup groupMock; + @Mock StudentGroupRepository studentGroupRepository; + @Mock + private ServerRepository serverRepository; + @Mock private StudentRepository studentRepository; @@ -53,18 +67,43 @@ void setUp() { Tag tag = new Tag("", "tagName"); tag.setId("tagId"); - StudentGroup group = new StudentGroup("group", List.of("123"), List.of(), List.of()); + StudentGroup group = + new StudentGroup("group", new ArrayList<>(List.of("123")), Collections.emptyList(), + Collections.emptyList()); group.setId("groupId"); - Student student = new Student("123", "Max", "Mustermann", List.of(group), List.of(tag)); - - when(studentRepository.findAll()).thenReturn(List.of(student)); + Lesson lesson = + new Lesson(0, "teacherId", "groupId", "roomId", "timeslotId", "subjectId", "timetableId", + "2024"); + lesson.setStudentGroup(groupMock); + + Lesson lessonWrongYear = + new Lesson(0, "teacherId", "groupId", "roomId", "timeslotId", "subjectId", "timetableId", + "1865"); + lessonWrongYear.setStudentGroup(groupMock); + group.setLessons(new ArrayList<>(List.of(lesson, lessonWrongYear))); + + Student student = new Student("123", "Max", "Mustermann", new ArrayList<>(List.of(groupMock)), + new ArrayList<>(List.of(tag))); + + when(groupMock.getGrades()).thenReturn(Collections.emptyList()); + when(groupMock.getLessons()).thenReturn(new ArrayList<>(List.of(lesson, lessonWrongYear))); + when(groupMock.getStudents()).thenReturn(new ArrayList<>(List.of(student))); + when(groupMock.getId()).thenReturn("groupId"); + Server server = new Server(null, "2024", "email"); + when(serverRepository.findAll()).thenReturn(new ArrayList<>(List.of(server))); + when(studentRepository.findAll()).thenReturn(new ArrayList<>(List.of(student))); when(studentRepository.findById("123")).thenReturn(Optional.of(student)); - when(studentRepository.findAllById(List.of("123"))).thenReturn(List.of(student)); + when(studentRepository.findAllById(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(student))); + when(studentRepository.findAllById(List.of("nonExistentId", "123"))).thenReturn( + new ArrayList<>(List.of(student))); when(constraintSignatureRepository.findAll(any(Specification.class))).thenReturn( Collections.emptyList()); when(studentGroupRepository.findByStudents(any(Student.class))).thenReturn( Collections.emptyList()); + when(studentGroupRepository.findAll(any(Specification.class))).thenReturn( + new ArrayList<>(List.of(groupMock))); when(studentRepository.save(any(Student.class))).thenReturn(student); } @@ -90,7 +129,7 @@ void getByExistentId() { @Test void createStudent() { StudentRequestDto requestDto = - new StudentRequestDto("Max", "Mustermann", List.of("tagId")); + new StudentRequestDto("Max", "Mustermann", new ArrayList<>(List.of("tagId"))); studentService.create(requestDto); ArgumentCaptor studentCap = ArgumentCaptor.forClass(Student.class); @@ -109,7 +148,7 @@ void createStudent() { @Test void createEmptyFirstNameStudent() { StudentRequestDto requestDto = new StudentRequestDto("", "Mustermann", - List.of()); + Collections.emptyList()); assertThrows(ResponseStatusException.class, () -> studentService.create(requestDto)); } @@ -117,7 +156,7 @@ void createEmptyFirstNameStudent() { @Test void createEmptyLastNameStudent() { StudentRequestDto requestDto = new StudentRequestDto("Max", "", - List.of()); + Collections.emptyList()); assertThrows(ResponseStatusException.class, () -> studentService.create(requestDto)); } @@ -126,7 +165,7 @@ void createEmptyLastNameStudent() { void updateStudent() { StudentRequestDto requestDto = new StudentRequestDto("newFirstName", "newLastName", - List.of()); + Collections.emptyList()); studentService.update("123", requestDto); ArgumentCaptor studentCap = ArgumentCaptor.forClass(Student.class); @@ -144,7 +183,7 @@ void updateStudent() { @Test void updateEmptyFirstNameStudent() { StudentRequestDto requestDto = new StudentRequestDto("", "Mustermann", - List.of()); + Collections.emptyList()); assertThrows(ResponseStatusException.class, () -> studentService.update("123", requestDto)); } @@ -152,7 +191,7 @@ void updateEmptyFirstNameStudent() { @Test void updateEmptyLastNameStudent() { StudentRequestDto requestDto = new StudentRequestDto("Max", "", - List.of()); + Collections.emptyList()); assertThrows(ResponseStatusException.class, () -> studentService.update("123", requestDto)); } @@ -174,4 +213,38 @@ void deleteNonExistentStudent() { assertThrows(ResponseStatusException.class, () -> studentService.deleteStudents(new String[] {"nonExistentId"})); } + + @Test + void deleteStudentsSomeExistent() { + assertThrows(ResponseStatusException.class, + () -> studentService.deleteStudents(new String[] {"nonExistentId", "123"})); + } + + @Test + void lessonsById() { + LessonResponseDto result = studentService.getLessonsById("123"); + assertResultArraySizes(result, 1, 1, 1, 0); + assertAll("Testing whether the sizes of the arrays are correct", + () -> assertEquals(1, result.groups().size()), + () -> assertEquals(1, result.groups().getFirst().students().size()), + () -> assertEquals("groupId", result.groups().getFirst().id()) + ); + + List roomIds = result.rooms().stream().map(Room::getId).toList(); + assertAll("Testing whether all the rooms are there", + () -> assertEquals(1, roomIds.size()), + () -> assertTrue(roomIds.contains("roomId")) + ); + } + + private void assertResultArraySizes(LessonResponseDto result, int teachers, int lessons, + int rooms, int grades) { + assertAll("Testing whether the sizes of the arrays are correct", + () -> assertEquals(teachers, result.teachers().size()), + () -> assertEquals(lessons, result.lessons().size()), + () -> assertEquals(rooms, result.rooms().size()), + () -> assertEquals(grades, result.grades().size()) + ); + } + } diff --git a/server/src/test/java/de/uftos/services/SubjectServiceTests.java b/server/src/test/java/de/uftos/services/SubjectServiceTests.java index e9749d61c..5ea4a936e 100644 --- a/server/src/test/java/de/uftos/services/SubjectServiceTests.java +++ b/server/src/test/java/de/uftos/services/SubjectServiceTests.java @@ -11,9 +11,14 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import de.uftos.dto.requestdtos.LessonsCountRequestDto; import de.uftos.dto.requestdtos.SubjectRequestDto; +import de.uftos.entities.Curriculum; +import de.uftos.entities.Grade; +import de.uftos.entities.StudentGroup; import de.uftos.entities.Subject; import de.uftos.entities.Tag; +import de.uftos.entities.Teacher; import de.uftos.repositories.database.ConstraintInstanceRepository; import de.uftos.repositories.database.ConstraintSignatureRepository; import de.uftos.repositories.database.CurriculumRepository; @@ -26,6 +31,7 @@ import java.util.Collections; import java.util.List; import java.util.Optional; +import java.util.stream.Collectors; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -35,6 +41,7 @@ import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import org.springframework.data.jpa.domain.Specification; import org.springframework.web.server.ResponseStatusException; @SuppressWarnings("checkstyle:MissingJavadocType") @@ -83,13 +90,39 @@ void setUp() { Subject subject = new Subject(); subject.setId(SUBJECT_ID); subject.setName(SUBJECT_NAME); - subject.setTags(List.of(tag)); + subject.setTags(new ArrayList<>(List.of(tag))); - when(subjectRepository.findAll()).thenReturn(List.of(subject)); + when(subjectRepository.findAll()).thenReturn(new ArrayList<>(List.of(subject))); when(subjectRepository.findById(SUBJECT_ID)).thenReturn(Optional.of(subject)); - when(subjectRepository.findAllById(List.of(SUBJECT_ID))).thenReturn(List.of(subject)); - when(curriculumRepository.findAll()).thenReturn(new ArrayList<>()); + when(subjectRepository.findAllById(new ArrayList<>(List.of(SUBJECT_ID)))).thenReturn( + new ArrayList<>(List.of(subject))); + when(subjectRepository.findAllById( + new ArrayList<>(List.of("nonExistentId", SUBJECT_ID)))).thenReturn( + new ArrayList<>(List.of(subject))); + when(subjectRepository.save(any(Subject.class))).thenReturn(subject); + + LessonsCountRequestDto lessonsCount = new LessonsCountRequestDto("123", 1); + List lessonsCounts = List.of(lessonsCount); + Curriculum testCurriculum = + new Curriculum(new Grade("gradeId"), "name", Collections.emptyList()); + testCurriculum.setLessonsCounts( + lessonsCounts.stream().map(LessonsCountRequestDto::map).collect(Collectors.toList()) + ); + + when(curriculumRepository.findAll()).thenReturn(new ArrayList<>(List.of(testCurriculum))); + when(curriculumRepository.findAll(any(Specification.class))).thenReturn( + new ArrayList<>(List.of(testCurriculum))); + + Teacher teacherWithSubject = new Teacher("teacherId"); + teacherWithSubject.setSubjects(new ArrayList<>(List.of(subject))); + when(teacherRepository.findAll(any(Specification.class))).thenReturn( + new ArrayList<>(List.of(teacherWithSubject))); when(teacherRepository.findBySubjects(any(Subject.class))).thenReturn(Collections.emptyList()); + + StudentGroup groupWithSubject = new StudentGroup("groupId"); + groupWithSubject.setSubjects(new ArrayList<>(List.of(subject))); + when(studentGroupRepository.findAll(any(Specification.class))).thenReturn( + new ArrayList<>(List.of(groupWithSubject))); when(studentGroupRepository.findBySubjects(any(Subject.class))).thenReturn( Collections.emptyList()); } @@ -112,7 +145,7 @@ void getByExistentId() { @Test void createSubject() { SubjectRequestDto requestDto = - new SubjectRequestDto("Mathe", "blue", List.of("tagId")); + new SubjectRequestDto("Mathe", "blue", new ArrayList<>(List.of("tagId"))); subjectService.create(requestDto); ArgumentCaptor subjectCap = ArgumentCaptor.forClass(Subject.class); @@ -128,10 +161,17 @@ void createSubject() { assertEquals("tagId", subject.getTags().getFirst().getId()); } + @Test + void createSubjectEmptyName() { + SubjectRequestDto requestDto = + new SubjectRequestDto("", "blue", new ArrayList<>(List.of("tagId"))); + assertThrows(ResponseStatusException.class, () -> subjectService.create(requestDto)); + } + @Test void updateSubject() { SubjectRequestDto requestDto = - new SubjectRequestDto("Englisch", "red", List.of("otherTagId")); + new SubjectRequestDto("Englisch", "red", new ArrayList<>(List.of("otherTagId"))); subjectService.update(SUBJECT_ID, requestDto); ArgumentCaptor subjectCap = ArgumentCaptor.forClass(Subject.class); @@ -147,6 +187,13 @@ void updateSubject() { assertEquals("otherTagId", subject.getTags().getFirst().getId()); } + @Test + void updateSubjectEmptyName() { + SubjectRequestDto requestDto = + new SubjectRequestDto("", "blue", new ArrayList<>(List.of("tagId"))); + assertThrows(ResponseStatusException.class, () -> subjectService.update("123", requestDto)); + } + @Test void deleteExistentSubject() { assertDoesNotThrow(() -> subjectService.deleteSubjects(new String[] {SUBJECT_ID})); @@ -163,4 +210,10 @@ void deleteNonExistentSubject() { assertThrows(ResponseStatusException.class, () -> subjectService.deleteSubjects(new String[] {"nonExistentId"})); } + + @Test + void deleteSubjectsSomeExistent() { + assertThrows(ResponseStatusException.class, + () -> subjectService.deleteSubjects(new String[] {"nonExistentId", "123"})); + } } diff --git a/server/src/test/java/de/uftos/services/TagServiceTests.java b/server/src/test/java/de/uftos/services/TagServiceTests.java index 4744c1e09..999565e7d 100644 --- a/server/src/test/java/de/uftos/services/TagServiceTests.java +++ b/server/src/test/java/de/uftos/services/TagServiceTests.java @@ -12,8 +12,15 @@ import de.uftos.dto.requestdtos.TagRequestDto; import de.uftos.entities.Break; +import de.uftos.entities.Grade; +import de.uftos.entities.Room; import de.uftos.entities.Server; +import de.uftos.entities.Student; +import de.uftos.entities.StudentGroup; +import de.uftos.entities.Subject; import de.uftos.entities.Tag; +import de.uftos.entities.Teacher; +import de.uftos.entities.Timeslot; import de.uftos.entities.TimetableMetadata; import de.uftos.repositories.database.ConstraintInstanceRepository; import de.uftos.repositories.database.ConstraintSignatureRepository; @@ -26,6 +33,7 @@ import de.uftos.repositories.database.TagRepository; import de.uftos.repositories.database.TeacherRepository; import de.uftos.repositories.database.TimeslotRepository; +import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Optional; @@ -87,16 +95,45 @@ void setUp() { Server server = new Server(new TimetableMetadata(45, 8, "7:45", new Break[] {}), "2024", "test@uftos.de"); - when(serverRepository.findAll()).thenReturn(List.of(server)); + when(serverRepository.findAll()).thenReturn(new ArrayList<>(List.of(server))); when(tagRepository.findById("123")).thenReturn(Optional.of(tag)); - when(tagRepository.findAllById(List.of("123"))).thenReturn(List.of(tag)); - when(teacherRepository.findByTags(any(Tag.class))).thenReturn(Collections.emptyList()); - when(studentGroupRepository.findByTags(any(Tag.class))).thenReturn(Collections.emptyList()); - when(studentRepository.findByTags(any(Tag.class))).thenReturn(Collections.emptyList()); - when(roomRepository.findByTags(any(Tag.class))).thenReturn(Collections.emptyList()); - when(subjectRepository.findByTags(any(Tag.class))).thenReturn(Collections.emptyList()); - when(gradeRepository.findByTags(any(Tag.class))).thenReturn(Collections.emptyList()); - when(timeslotRepository.findByTags(any(Tag.class))).thenReturn(Collections.emptyList()); + when(tagRepository.findAllById(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(tag))); + + Teacher teacherWithTag = new Teacher("teacherId"); + teacherWithTag.setTags(new ArrayList<>(List.of(tag))); + when(teacherRepository.findAllByTags(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(teacherWithTag))); + + StudentGroup groupWithTag = new StudentGroup("groupId"); + groupWithTag.setTags(new ArrayList<>(List.of(tag))); + when(studentGroupRepository.findAllByTags(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(groupWithTag))); + + Student studentWithTag = new Student("studentId"); + studentWithTag.setTags(new ArrayList<>(List.of(tag))); + when(studentRepository.findAllByTags(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(studentWithTag))); + + Room roomWithTag = new Room("roomId"); + roomWithTag.setTags(new ArrayList<>(List.of(tag))); + when(roomRepository.findAllByTags(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(roomWithTag))); + + Subject subjectWithTag = new Subject("subjectId"); + subjectWithTag.setTags(new ArrayList<>(List.of(tag))); + when(subjectRepository.findAllByTags(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(subjectWithTag))); + + Grade gradeWithTag = new Grade("gradeId"); + gradeWithTag.setTags(new ArrayList<>(List.of(tag))); + when(gradeRepository.findAllByTags(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(gradeWithTag))); + + Timeslot timeslotWithTag = new Timeslot("timeslotId"); + timeslotWithTag.setTags(new ArrayList<>(List.of(tag))); + when(timeslotRepository.findAllByTags(new ArrayList<>(List.of("123")))).thenReturn( + new ArrayList<>(List.of(timeslotWithTag))); } @Test @@ -128,6 +165,20 @@ void createTag() { assertEquals("Wheelchair", tag.getName()); } + @Test + void createTagEmptyName() { + TagRequestDto requestDto = + new TagRequestDto(""); + assertThrows(ResponseStatusException.class, () -> tagService.create(requestDto)); + } + + @Test + void updateTagEmptyName() { + TagRequestDto requestDto = + new TagRequestDto(""); + assertThrows(ResponseStatusException.class, () -> tagService.update("123", requestDto)); + } + @Test void updateTag() { TagRequestDto requestDto = diff --git a/server/src/test/java/de/uftos/services/TeacherServiceTests.java b/server/src/test/java/de/uftos/services/TeacherServiceTests.java index ff04f72ef..68b298688 100644 --- a/server/src/test/java/de/uftos/services/TeacherServiceTests.java +++ b/server/src/test/java/de/uftos/services/TeacherServiceTests.java @@ -131,8 +131,10 @@ void setUp() { new Server(new TimetableMetadata(45, 8, "7:45", new Break[] {}), "2024", "test@uftos.de"); when(serverRepository.findAll()).thenReturn(List.of(server)); when(teacherRepository.findById("123")).thenReturn(Optional.of(teacher1)); - when(teacherRepository.findAllById(List.of("123"))).thenReturn(List.of(teacher1)); when(teacherRepository.findById("456")).thenReturn(Optional.of(teacher2)); + when(teacherRepository.findAllById(List.of("123"))).thenReturn(List.of(teacher1)); + when(teacherRepository.findAllById(List.of("nonExistentId", "123"))).thenReturn( + List.of(teacher1)); } @Test @@ -166,6 +168,31 @@ void createTeacher() { assertEquals("tagId", teacher.getTags().getFirst().getId()); } + @Test + void createTeacherEmptyFirstName() { + TeacherRequestDto requestDto = + new TeacherRequestDto("", "lastName", "FL", List.of("subjectId"), + List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> teacherService.create(requestDto)); + } + + @Test + void createTeacherEmptyLastName() { + TeacherRequestDto requestDto = + new TeacherRequestDto("firstName", "", "FL", List.of("subjectId"), + List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> teacherService.create(requestDto)); + } + + @Test + void createTeacherEmptyAcronym() { + TeacherRequestDto requestDto = + new TeacherRequestDto("firstName", "lastName", "", List.of("subjectId"), + List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> teacherService.create(requestDto)); + } + + @Test void updateTeacher() { TeacherRequestDto requestDto = @@ -190,7 +217,31 @@ void updateTeacher() { } @Test - void deleteExistingTeacher() { + void updateTeacherEmptyFirstName() { + TeacherRequestDto requestDto = + new TeacherRequestDto("", "lastName", "FL", List.of("subjectId"), + List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> teacherService.update("123", requestDto)); + } + + @Test + void updateTeacherEmptyLastName() { + TeacherRequestDto requestDto = + new TeacherRequestDto("firstName", "", "FL", List.of("subjectId"), + List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> teacherService.update("123", requestDto)); + } + + @Test + void updateTeacherEmptyAcronym() { + TeacherRequestDto requestDto = + new TeacherRequestDto("firstName", "lastName", "", List.of("subjectId"), + List.of("tagId")); + assertThrows(ResponseStatusException.class, () -> teacherService.update("123", requestDto)); + } + + @Test + void deleteExistentTeacher() { assertDoesNotThrow(() -> teacherService.deleteTeachers(new String[] {"123"})); ArgumentCaptor> teacherCap = ArgumentCaptor.forClass(getClassType()); verify(teacherRepository, times(1)).deleteAll(teacherCap.capture()); @@ -201,11 +252,37 @@ void deleteExistingTeacher() { } @Test - void deleteNonExistingTeacher() { + void deleteNonExistentTeacher() { + assertThrows(ResponseStatusException.class, + () -> teacherService.deleteTeachers(new String[] {"nonExistentId"})); + } + + @Test + void deleteTeachersNonExistent() { assertThrows(ResponseStatusException.class, () -> teacherService.deleteTeachers(new String[] {"nonExistentId"})); } + @Test + void deleteTeachersSomeExistent() { + assertThrows(ResponseStatusException.class, + () -> teacherService.deleteTeachers(new String[] {"nonExistentId", "123"})); + } + + @Test + void deleteTeachersAllExistent() { + assertDoesNotThrow(() -> teacherService.deleteTeachers(new String[] {"123"})); + Class> listClass = + (Class>) (Class) List.class; + ArgumentCaptor> teacherCap = ArgumentCaptor.forClass(listClass); + verify(teacherRepository, times(1)).deleteAll(teacherCap.capture()); + + List teacherList = teacherCap.getValue(); + assertEquals(1, teacherList.size()); + assertEquals("123", teacherList.getFirst().getId()); + + } + @Test void emptyLessons() { assertDoesNotThrow(() -> teacherService.getLessonsById("456")); diff --git a/server/src/test/java/de/uftos/utils/JsonGenerator.java b/server/src/test/java/de/uftos/utils/JsonGenerator.java index 4e156a5a5..69cbb1f6b 100644 --- a/server/src/test/java/de/uftos/utils/JsonGenerator.java +++ b/server/src/test/java/de/uftos/utils/JsonGenerator.java @@ -3,7 +3,6 @@ import de.uftos.dto.Weekday; import de.uftos.dto.requestdtos.LessonsCountRequestDto; import de.uftos.entities.Break; -import de.uftos.entities.TimetableMetadata; import java.util.List; import org.json.JSONArray; import org.json.JSONException; @@ -235,14 +234,16 @@ public static String generateStudentGroupJson(String name, List students /** * Generates the subject JSON. * - * @param name The name of the subject + * @param name The name of the subject + * @param color The color of the subject * @return The requested JSON * @throws JSONException If something is malformed. */ - public static String generateSubjectJson(String name) + public static String generateSubjectJson(String name, String color) throws JSONException { return new JSONObject() .put("name", name) + .put("color", color) .put("tagIds", new JSONArray()) .toString(); }