diff --git a/.gitea/workflows/demo.yaml b/.gitea/workflows/demo.yaml index 4c20a97..b1c4c8b 100644 --- a/.gitea/workflows/demo.yaml +++ b/.gitea/workflows/demo.yaml @@ -3,25 +3,6 @@ run-name: ${{ gitea.actor }} is testing out Gitea Actions 🚀 on: [push] jobs: - test: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v3 - - name: Set up JDK 17 - uses: actions/setup-java@v3 - with: - java-version: '17' - distribution: 'temurin' - cache: maven - - name: Set up Maven - uses: stCarolas/setup-maven@v4.5 - with: - maven-version: 3.8.2 - - name: Build with Maven - run: mvn -B package --file backend/pom.xml - build-and-push-frontend: runs-on: ubuntu-latest steps: diff --git a/backend/src/main/java/core/DemoApplication.java b/backend/src/main/java/core/DemoApplication.java index b24664d..70b701e 100644 --- a/backend/src/main/java/core/DemoApplication.java +++ b/backend/src/main/java/core/DemoApplication.java @@ -24,9 +24,12 @@ public class DemoApplication{ @Bean + @NotTest public CommandLineRunner init(TaskSchedulingService taskSchedulingService) { return args -> { taskSchedulingService.scheduleStartingTask("Finishing ConceptCreator"); }; } + + } diff --git a/backend/src/main/java/core/NotTest.java b/backend/src/main/java/core/NotTest.java new file mode 100644 index 0000000..871c773 --- /dev/null +++ b/backend/src/main/java/core/NotTest.java @@ -0,0 +1,16 @@ +package core; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Profile; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + + +@Target({ElementType.TYPE, ElementType.METHOD}) +@Retention(RetentionPolicy.RUNTIME) +@Profile("!test") +public @interface NotTest { +} diff --git a/backend/src/main/java/core/services/ntfy/TaskSchedulingService.java b/backend/src/main/java/core/services/ntfy/TaskSchedulingService.java index 8bab5ec..5067658 100644 --- a/backend/src/main/java/core/services/ntfy/TaskSchedulingService.java +++ b/backend/src/main/java/core/services/ntfy/TaskSchedulingService.java @@ -1,6 +1,7 @@ package core.services.ntfy; +import core.NotTest; import org.quartz.*; import org.quartz.impl.StdSchedulerFactory; import org.springframework.beans.factory.annotation.Value; @@ -11,6 +12,7 @@ import java.time.ZoneId; import java.util.Date; @Service +@NotTest public class TaskSchedulingService { @Value("${ntfy.host}") diff --git a/backend/src/test/java/core/DemoApplicationTests.java b/backend/src/test/java/core/DemoApplicationTests.java deleted file mode 100644 index 86d252a..0000000 --- a/backend/src/test/java/core/DemoApplicationTests.java +++ /dev/null @@ -1,13 +0,0 @@ -package core; - -import org.junit.jupiter.api.Test; -import org.springframework.boot.test.context.SpringBootTest; - -/*@SpringBootTest*/ -class DemoApplicationTests { - - /*@Test - void contextLoads() { - }*/ - -} diff --git a/backend/src/test/java/core/schedules/ScheduleRepositoryTest.java b/backend/src/test/java/core/schedules/ScheduleRepositoryTest.java deleted file mode 100644 index 5c7257f..0000000 --- a/backend/src/test/java/core/schedules/ScheduleRepositoryTest.java +++ /dev/null @@ -1,57 +0,0 @@ -package core.schedules; - -import core.entities.User; -import core.entities.timemanager.AbstractSchedule; -import core.repositories.timemanager.ScheduleRepository; -import core.services.ServiceResult; -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.autoconfigure.orm.jpa.DataJpaTest; -import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.jdbc.SqlGroup; -import org.springframework.test.context.junit.jupiter.SpringExtension; - -import java.util.Optional; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -@ExtendWith(SpringExtension.class) -@DataJpaTest -public class ScheduleRepositoryTest { - - @Autowired private ScheduleRepository scheduleRepository; - @Autowired private TestEntityManager entityManager; - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void getAllSchedulesOfUser() { - User referenceUser_1 = entityManager.find(User.class, 1L); - User referenceUser_2 = entityManager.find(User.class, 2L); - - assertEquals(0, scheduleRepository.findAllByUsername(referenceUser_2.getUsername()).size()); - assertEquals(5, scheduleRepository.findAllByUsername(referenceUser_1.getUsername()).size()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void getActiveScheduleOfUser() { - User referenceUser_1 = entityManager.find(User.class, 1L); - User referenceUser_2 = entityManager.find(User.class, 2L); - - Optional result_1 = scheduleRepository.getActiveScheduleOfUser(referenceUser_2.getUsername()); - assertTrue(result_1.isEmpty()); - - Optional result_2 = scheduleRepository.getActiveScheduleOfUser(referenceUser_1.getUsername()); - assertTrue(result_2.isPresent()); - } -} diff --git a/backend/src/test/java/core/schedules/ScheduleServiceTest.java b/backend/src/test/java/core/schedules/ScheduleServiceTest.java deleted file mode 100644 index 737de26..0000000 --- a/backend/src/test/java/core/schedules/ScheduleServiceTest.java +++ /dev/null @@ -1,321 +0,0 @@ -package core.schedules; - -import core.api.models.timemanager.taskSchedule.scheduleInfos.AdvancedScheduleFieldInfo; -import core.api.models.timemanager.taskSchedule.scheduleInfos.AdvancedScheduleInfo; -import core.api.models.timemanager.taskSchedule.scheduleInfos.BasicScheduleFieldInfo; -import core.api.models.timemanager.taskSchedule.ForgottenScheduleInfo; -import core.entities.timemanager.AbstractSchedule; -import core.entities.timemanager.AdvancedTaskSchedule; -import core.entities.timemanager.BasicTaskSchedule; -import core.entities.timemanager.Task; -import core.services.ServiceExitCode; -import core.services.ServiceResult; -import core.services.TaskScheduleService; -import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.jdbc.SqlGroup; - -import javax.persistence.EntityManager; -import javax.transaction.Transactional; - -import java.time.LocalDate; -import java.time.LocalDateTime; -import java.util.List; - -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.junit.jupiter.api.Assertions.*; - -@SpringBootTest -@Transactional -public class ScheduleServiceTest { - - - @Autowired - private EntityManager entityManager; - - @Autowired private TaskScheduleService taskScheduleService; - - private static final String username = "Testuser1"; - private static final String username2 = "Testuser2"; - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void getAllSchedulesOfUser() { - assertEquals(0, taskScheduleService.getAllSchedulesOfUser(username2).size()); - - List result_1 = taskScheduleService.getAllSchedulesOfUser(username); - assertEquals(5, result_1.size()); - assertTrue(result_1.contains(entityManager.find(AbstractSchedule.class, 1L))); - assertTrue(result_1.contains(entityManager.find(AbstractSchedule.class, 2L))); - assertTrue(result_1.contains(entityManager.find(AbstractSchedule.class, 3L))); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void scheduleBasic() { - //Situation 1: Schedule finished Task - ServiceResult result_1 = taskScheduleService.scheduleBasic(entityManager.find(Task.class, 2L), new BasicScheduleFieldInfo(LocalDate.now())); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode()); - - //Situation 2: Schedule before today - ServiceResult result_2 = taskScheduleService.scheduleBasic(entityManager.find(Task.class, 1L), new BasicScheduleFieldInfo(LocalDate.of(2010, 3, 14))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode()); - - //Situation 3: Valid schedule - ServiceResult result_3 = taskScheduleService.scheduleBasic(entityManager.find(Task.class, 1L), new BasicScheduleFieldInfo(LocalDate.now())); - assertEquals(ServiceExitCode.OK, result_3.getExitCode()); - assertThat(entityManager.find(BasicTaskSchedule.class, result_3.getResult().getScheduleID())).isNotNull(); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void editBasicSchedule() { - //Situation 1: Reschedule finished task - ServiceResult result_1 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 2L), new BasicScheduleFieldInfo(LocalDate.now())); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode()); - - //Situation 2: Reschedule unfinished task with invalid reschedule date - ServiceResult result_2 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 1L), new BasicScheduleFieldInfo(LocalDate.of(2011, 3, 4))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode()); - - //Situation 3: Reschedule unfinished task with valid reschedule date - LocalDate oldDate = entityManager.find(BasicTaskSchedule.class, 1L).getScheduleDate(); - ServiceResult result_3 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 1L), new BasicScheduleFieldInfo(LocalDate.now())); - assertEquals(ServiceExitCode.OK, result_3.getExitCode()); - assertNotEquals(((BasicTaskSchedule) result_3.getResult()).getScheduleDate(), oldDate); - - //Situation 4: Reschedule already running schedule - ServiceResult result_4 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 4L), - new BasicScheduleFieldInfo(LocalDate.now())); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_4.getExitCode()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void deleteSchedule() { - for(long i=1; i<=2; i++) { - taskScheduleService.deleteSchedule(entityManager.find(BasicTaskSchedule.class, i)); - assertThat(entityManager.find(BasicTaskSchedule.class, i)).isNull(); - } - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void getFilteredScheduledOfUser() { - //Invalid user - assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), false, "Quatsch").size()); - assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), true, "Quatsch").size()); - - //User with no tasks/schedules - assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), false, username2).size()); - assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), true, username2).size()); - - //user with tasks and schedules - List result_1 = taskScheduleService.getFilteredScheduledOfUser(LocalDate.of(2024,11,11), false, username); - assertEquals(3, result_1.size()); - assertTrue(result_1.contains(entityManager.find(BasicTaskSchedule.class, 3L))); - assertTrue(result_1.contains(entityManager.find(BasicTaskSchedule.class, 4L))); - assertTrue(result_1.contains(entityManager.find(BasicTaskSchedule.class, 5L))); - - List result_2 = taskScheduleService.getFilteredScheduledOfUser(LocalDate.of(2024,11,11), true, username); - assertEquals(1, result_2.size()); - } - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void scheduleNow() { - //Situation 1: Task has already an active schedule - ServiceResult result_1 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 3L)); - assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, result_1.getExitCode()); - - //Situation 2: Task is already finished - ServiceResult result_2 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 2L)); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode()); - - //Situation 3: Task can be scheduled and started - ServiceResult result_3 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 5L)); - assertEquals(ServiceExitCode.OK, result_3.getExitCode()); - assertThat(entityManager.find(BasicTaskSchedule.class, result_3.getResult().getScheduleID())).isNotNull(); - - //Situation 4: Running Advanced Schedule - ServiceResult result_4 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 17L)); - assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, result_4.getExitCode()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void activateSchedule() { - //Activate already running schedule - ServiceResult result_1 = taskScheduleService.activateSchedule(entityManager.find(BasicTaskSchedule.class, 4L)); - assertNotNull(result_1.getResult().getStartTime()); - assertNull(result_1.getResult().getStopTime()); - - entityManager.remove(entityManager.find(BasicTaskSchedule.class, 4L)); - assertThat(entityManager.find(BasicTaskSchedule.class, 4L)).isNull(); - - //Activate not running schedule - ServiceResult result_2 = taskScheduleService.activateSchedule(entityManager.find(BasicTaskSchedule.class, 5L)); - assertNotNull(result_2.getResult().getStartTime()); - assertNull(result_2.getResult().getStopTime()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void stopSchedule() { - //Stop schedule that is not running 4 - ServiceResult result_1 = taskScheduleService.stopSchedule(entityManager.find(BasicTaskSchedule.class, 5L), false); - assertNull(result_1.getResult().getStartTime()); - assertNull(result_1.getResult().getStopTime()); - - //Stop schedule (without finishing) - ServiceResult result_2 = taskScheduleService.stopSchedule(entityManager.find(BasicTaskSchedule.class, 4L), false); - assertNotNull(result_2.getResult().getStartTime()); - assertNotNull(result_2.getResult().getStopTime()); - - //Stop schedule with finishing - ServiceResult result_3 = taskScheduleService.stopSchedule(entityManager.find(BasicTaskSchedule.class, 7L), true); - assertNotNull(result_3.getResult().getStartTime()); - assertNotNull(result_3.getResult().getStopTime()); - assertTrue(result_3.getResult().getTask().isFinished()); - assertFalse(result_3.getResult().isStartable()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void registerForgottenSchedule() { - //Register task schedule for task that is already finished - LocalDateTime startTime = LocalDateTime.now().minusMinutes(10L); - LocalDateTime finishTime = LocalDateTime.now(); - - ServiceResult result_1 = taskScheduleService.registerForgottenSchedule(entityManager.find(Task.class, 2L), new ForgottenScheduleInfo(startTime, finishTime)); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode()); - - ServiceResult result_2 = taskScheduleService.registerForgottenSchedule(entityManager.find(Task.class, 5L), new ForgottenScheduleInfo(startTime, finishTime)); - assertEquals(ServiceExitCode.OK, result_2.getExitCode()); - assertEquals(startTime, result_2.getResult().getStartTime()); - assertEquals(finishTime, result_2.getResult().getStopTime()); - assertThat(entityManager.find(BasicTaskSchedule.class, result_2.getResult().getScheduleID())).isNotNull(); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void getAllMissedSchedulesOfUser() { - assertEquals(1, taskScheduleService.getAllMissedSchedulesOfUser(username).size()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void scheduleAdvanced() { - //Situation 1: Schedule finished Task - ServiceResult result_1 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 18L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(1L), LocalDateTime.now().plusHours(2L))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode()); - - //Situation 2: Schedule Start is before today - ServiceResult result_2 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(1L), LocalDateTime.now().plusHours(2L))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode()); - - //Situation 3: Schedule End is before today - ServiceResult result_3 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(2L), LocalDateTime.now().minusDays(1L))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_3.getExitCode()); - - //Situation 4: Start after stop - ServiceResult result_4 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(2L), LocalDateTime.now().plusHours(1L))); - assertEquals(ServiceExitCode.INVALID_PARAMETER, result_4.getExitCode()); - - //Situation 5: Valid schedule - ServiceResult result_5 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L), - new AdvancedScheduleFieldInfo(LocalDateTime.now(), LocalDateTime.now().plusHours(1L))); - assertEquals(ServiceExitCode.OK, result_5.getExitCode()); - assertThat(entityManager.find(AdvancedTaskSchedule.class, result_5.getResult().getScheduleID())).isNotNull(); - - - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void editscheduleAdvanced() { - //Situation 1: Schedule finished Task - ServiceResult result_1 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 12L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(1L), LocalDateTime.now().plusHours(2L))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode()); - - //Situation 2: Schedule Start is before today - ServiceResult result_2 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(1L), LocalDateTime.now().plusHours(2L))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode()); - - //Situation 3: Schedule End is before today - ServiceResult result_3 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(2L), LocalDateTime.now().minusDays(1L))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_3.getExitCode()); - - //Situation 4: Start after stop - ServiceResult result_4 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L), - new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(2L), LocalDateTime.now().plusHours(1L))); - assertEquals(ServiceExitCode.INVALID_PARAMETER, result_4.getExitCode()); - - //Situation 5: Valid schedule - ServiceResult result_5 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L), - new AdvancedScheduleFieldInfo(LocalDateTime.now(), LocalDateTime.now().plusHours(1L))); - assertEquals(ServiceExitCode.OK, result_5.getExitCode()); - assertThat(entityManager.find(AdvancedTaskSchedule.class, result_5.getResult().getScheduleID())).isNotNull(); - - //Situation 6: reschedule already running schedule - ServiceResult result_6 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 9L), - new AdvancedScheduleFieldInfo(LocalDateTime.now(), LocalDateTime.now().plusHours(1L))); - assertEquals(ServiceExitCode.INVALID_OPERATION, result_6.getExitCode()); - } -} diff --git a/backend/src/test/java/core/taskgroups/TaskgroupRepsitoryTest.java b/backend/src/test/java/core/taskgroups/TaskgroupRepsitoryTest.java deleted file mode 100644 index 9a80085..0000000 --- a/backend/src/test/java/core/taskgroups/TaskgroupRepsitoryTest.java +++ /dev/null @@ -1,93 +0,0 @@ -package core.taskgroups; - -import core.entities.User; -import core.entities.timemanager.Task; -import core.entities.timemanager.Taskgroup; -import core.repositories.timemanager.TaskgroupRepository; -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.autoconfigure.orm.jpa.DataJpaTest; -import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.junit.jupiter.SpringExtension; - -import java.util.List; - -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.junit.jupiter.api.Assertions.*; - -@ExtendWith(SpringExtension.class) -@DataJpaTest -public class TaskgroupRepsitoryTest { - - @Autowired private TaskgroupRepository taskgroupRepository; - @Autowired private TestEntityManager testEntityManager; - - @Test - @Sql("classpath:taskgroupRepositoryTestEntries.sql") - void findAllByUser() { - User testUser1 = testEntityManager.find(User.class, 1L); - User testUser2 = testEntityManager.find(User.class, 2L); - - List result_user2 = taskgroupRepository.findAllByUser(testUser2.getUsername()); - assertEquals(0, result_user2.size()); - - List result_user1 = taskgroupRepository.findAllByUser(testUser1.getUsername()); - assertEquals(8, result_user1.size()); - } - - @Test - @Sql("classpath:taskgroupRepositoryTestEntries.sql") - void findAllTopTaskgroupsByUser() { - User testUser1 = testEntityManager.find(User.class, 1L); - User testUser2 = testEntityManager.find(User.class, 2L); - - //Situation 1: Empty user, no taskgroups - assertEquals(0, taskgroupRepository.findAllTopTaskgroupsByUser(testUser2.getUsername()).size()); - - //Situation 2: Only top taskgroups are returned - List topgroups_user1 = taskgroupRepository.findAllTopTaskgroupsByUser(testUser1.getUsername()); - assertEquals(3, topgroups_user1.size()); - assertTrue(topgroups_user1.contains(testEntityManager.find(Taskgroup.class, 1L))); - assertTrue(topgroups_user1.contains(testEntityManager.find(Taskgroup.class, 2L))); - assertTrue(topgroups_user1.contains(testEntityManager.find(Taskgroup.class, 5L))); - - //Situation 3: User with username does not exist - assertEquals(0, taskgroupRepository.findAllTopTaskgroupsByUser("Rotzbakke").size()); - } - @Test - @Sql("classpath:taskgroupRepositoryTestEntries.sql") - void deleteAllByUser() { - User testUser1 = testEntityManager.find(User.class, 1L); - User testUser2 = testEntityManager.find(User.class, 2L); - - taskgroupRepository.deleteAllByUser(testUser2); - for(long i=1; i<=8; i++) { - assertThat(testEntityManager.find(Taskgroup.class, i)).isNotNull(); - } - - taskgroupRepository.deleteAllByUser(testUser1); - for(long i=1; i<=8; i++) { - assertThat(testEntityManager.find(Taskgroup.class, i)).isNull(); - } - } - - @Test - @Sql("classpath:taskgroupRepositoryTestEntries.sql") - void delete() { - Taskgroup no_children = testEntityManager.find(Taskgroup.class, 1L); - Taskgroup taskgroup_with_children = testEntityManager.find(Taskgroup.class, 5L); - - taskgroupRepository.delete(no_children); - assertThat(testEntityManager.find(Taskgroup.class, 1L)).isNull(); - for(long i=2; i<=8; i++) { - assertThat(testEntityManager.find(Taskgroup.class, i)).isNotNull(); - } - - taskgroupRepository.delete(taskgroup_with_children); - for(long i=5; i<=8; i++) { - assertThat(testEntityManager.find(Taskgroup.class, i)).isNull(); - } - } -} diff --git a/backend/src/test/java/core/taskgroups/TaskgroupServiceTest.java b/backend/src/test/java/core/taskgroups/TaskgroupServiceTest.java deleted file mode 100644 index eef487c..0000000 --- a/backend/src/test/java/core/taskgroups/TaskgroupServiceTest.java +++ /dev/null @@ -1,202 +0,0 @@ -package core.taskgroups; - -import core.api.models.timemanager.taskgroup.TaskgroupFieldInfo; -import core.entities.User; -import core.entities.timemanager.Task; -import core.entities.timemanager.Taskgroup; -import core.repositories.UserRepository; -import core.repositories.timemanager.TaskgroupRepository; -import core.services.PermissionResult; -import core.services.ServiceExitCode; -import core.services.ServiceResult; -import core.services.TaskgroupService; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; -import org.mockito.junit.jupiter.MockitoExtension; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; -import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.jdbc.SqlGroup; -import org.springframework.test.context.junit.jupiter.SpringExtension; -import org.springframework.test.context.junit4.SpringRunner; - -import javax.persistence.EntityManager; -import javax.transaction.Transactional; -import java.util.List; -import java.util.NoSuchElementException; -import java.util.Optional; - -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.junit.jupiter.api.Assertions.*; - -@SpringBootTest -@Transactional -public class TaskgroupServiceTest { - - @Autowired - private TaskgroupRepository taskgroupRepository; - @Autowired - private TaskgroupService taskgroupService; - @Autowired - private EntityManager entityManager; - - private static final String username = "Testuser1"; - private static final String username2 = "Testuser2"; - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void getTaskgroupByIDAndUsername() { - //Situation 1: correct taskgroup and username - assertFalse(taskgroupRepository.findById(1L).isEmpty()); - - PermissionResult permissionResult = taskgroupService.getTaskgroupByIDAndUsername(1L, username); - assertThat(permissionResult).isNotNull(); - assertTrue(permissionResult.isHasPermissions()); - assertEquals(ServiceExitCode.OK, permissionResult.getExitCode()); - assertEquals(taskgroupRepository.findById(1L).get(), permissionResult.getResult()); - - //Situation 2: invalid taskgroup - PermissionResult invalid_group = taskgroupService.getTaskgroupByIDAndUsername(-1L, username); - assertThat(invalid_group).isNotNull(); - assertEquals(ServiceExitCode.MISSING_ENTITY, invalid_group.getExitCode()); - assertFalse(invalid_group.isHasPermissions()); - - //Situation 3: invalid user - PermissionResult invalid_user = taskgroupService.getTaskgroupByIDAndUsername(1L, "Rotzbakke"); - assertThat(invalid_user).isNotNull(); - assertEquals(ServiceExitCode.OK, invalid_user.getExitCode()); - assertFalse(invalid_user.isHasPermissions()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void addTaskgroup() { - TaskgroupFieldInfo taskgroupFieldInfo = new TaskgroupFieldInfo("Taskgroup", -1); - //Situation 1: No such user - assertThrows(NoSuchElementException.class, () -> taskgroupService.addTaskgroup(taskgroupFieldInfo, "Rotzbakke")); - - //Situation 2: Taskgroup already exists - Taskgroup taskgroup = taskgroupRepository.findById(1L).get(); - ServiceResult creationResult = taskgroupService.addTaskgroup(new TaskgroupFieldInfo(taskgroup.getTaskgroupName(), -1), username); - assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, creationResult.getExitCode()); - assertThat(creationResult.getResult()).isNull(); - - //Situation 3: Taskgroup does not exist, no parent - ServiceResult creationResult_3 = taskgroupService.addTaskgroup(taskgroupFieldInfo, username); - assertEquals(ServiceExitCode.OK, creationResult_3.getExitCode()); - assertTrue(taskgroupRepository.existsById(creationResult_3.getResult().getTaskgroupID())); - - //Situation 4: Taskgroup does not exist, with parent; invalid parent (no existent) - ServiceResult creationResult_4 = taskgroupService.addTaskgroup(new TaskgroupFieldInfo("Situation 4", 100L), username); - assertEquals(ServiceExitCode.MISSING_ENTITY, creationResult_4.getExitCode()); - - //Situation 5: Taskgroup does not exist, parent exist - ServiceResult creationResult_5 = taskgroupService.addTaskgroup(new TaskgroupFieldInfo("Situation 5", 2L), username); - assertEquals(ServiceExitCode.OK, creationResult_5.getExitCode()); - assertTrue(taskgroupRepository.existsById(creationResult_5.getResult().getTaskgroupID())); - - //Situation 6: taskgroup exist on another user - ServiceResult creationResult_6 = taskgroupService.addTaskgroup(new TaskgroupFieldInfo(taskgroup.getTaskgroupName(), -1), username2); - assertEquals(ServiceExitCode.OK, creationResult_6.getExitCode()); - assertTrue(taskgroupRepository.existsById(creationResult_6.getResult().getTaskgroupID())); - - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void editTaskgroup() { - Taskgroup taskgroup = taskgroupRepository.findById(1L).get(); - //Situation 1: Nothing changed - ServiceExitCode exitCode_1 = taskgroupService.editTaskgroup(taskgroup, new TaskgroupFieldInfo(taskgroup.getTaskgroupName(),-1)); - assertEquals(ServiceExitCode.OK, exitCode_1); - - //Situation 2: Name is already taken - ServiceExitCode exitCode_2 = taskgroupService.editTaskgroup(taskgroup, new TaskgroupFieldInfo("Taskgroup 1", -1)); - assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, exitCode_2); - - //Situation 3: All fine - ServiceExitCode exitCode_3 = taskgroupService.editTaskgroup(taskgroup, new TaskgroupFieldInfo("Situation 3", -1)); - assertEquals(ServiceExitCode.OK, exitCode_3); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void deleteTaskgroup() { - taskgroupService.deleteTaskgroup(entityManager.find(Taskgroup.class, 1L)); - assertThat(entityManager.find(Taskgroup.class, 1L)).isNull(); - - taskgroupService.deleteTaskgroup(entityManager.find(Taskgroup.class, 2L)); - assertThat(entityManager.find(Taskgroup.class, 2L)).isNull(); - assertThat(entityManager.find(Taskgroup.class, 3L)).isNull(); - for(long i=1; i<=14; i++) { - assertThat(entityManager.find(Task.class, i)).isNull(); - } - - taskgroupService.deleteTaskgroup(entityManager.find(Taskgroup.class, 5L)); - assertThat(entityManager.find(Taskgroup.class, 5L)).isNull(); - assertThat(entityManager.find(Taskgroup.class, 6L)).isNull(); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void getTopTaskgroupsByUser() { - //Situation 1: User without taskgroups - List taskgroups_user2 = taskgroupService.getTopTaskgroupsByUser(username2); - assertEquals(0, taskgroups_user2.size()); - - - //Situation 2: user with taskgroups - List taskgroups_user1 = taskgroupService.getTopTaskgroupsByUser(username); - assertEquals(3, taskgroups_user1.size()); - assertTrue(taskgroups_user1.contains(entityManager.find(Taskgroup.class, 1L))); - assertTrue(taskgroups_user1.contains(entityManager.find(Taskgroup.class, 2L))); - assertTrue(taskgroups_user1.contains(entityManager.find(Taskgroup.class, 5L))); - - //Situation 3: No existent username - assertEquals(0, taskgroupService.getTopTaskgroupsByUser("Rotzbakke").size()); - } - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void deleteTaskgroupByUser() { - User referenceUser1 = entityManager.find(User.class, 1L); - User referenceUser2 = entityManager.find(User.class, 2L); - - taskgroupService.deleteTaskgroupByUser(referenceUser2); - for(long i=1; i<=8; i++) { - assertThat(entityManager.find(Taskgroup.class, i)).isNotNull(); - } - - taskgroupService.deleteTaskgroupByUser(referenceUser1); - for(long i=1; i<=8; i++) { - assertThat(entityManager.find(Taskgroup.class, i)).isNull(); - } - for(long i=1; i<=14; i++) { - assertThat(entityManager.find(Task.class, i)).isNull(); - } - } - -} diff --git a/backend/src/test/java/core/tasks/TaskRepositoryTest.java b/backend/src/test/java/core/tasks/TaskRepositoryTest.java deleted file mode 100644 index 99ea0ce..0000000 --- a/backend/src/test/java/core/tasks/TaskRepositoryTest.java +++ /dev/null @@ -1,160 +0,0 @@ -package core.tasks; - -import core.entities.User; -import core.entities.timemanager.Task; -import core.entities.timemanager.Taskgroup; -import core.repositories.timemanager.TaskRepository; -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.autoconfigure.orm.jpa.DataJpaTest; -import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.jdbc.SqlGroup; -import org.springframework.test.context.junit.jupiter.SpringExtension; - -import java.time.LocalDate; -import java.util.List; - -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - - -@ExtendWith(SpringExtension.class) -@DataJpaTest -public class TaskRepositoryTest { - - @Autowired private TaskRepository taskRepository; - @Autowired private TestEntityManager testEntityManager; - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void findAllByUser() { - User testUser1 = testEntityManager.find(User.class, 1L); - User testUser2 = testEntityManager.find(User.class, 2L); - - //Situation 1: Non existent user - assertEquals(0, taskRepository.findAllByUser("Rotzbakke", true).size()); - assertEquals(0, taskRepository.findAllByUser("Rotzbakke", false).size()); - - //Situation 2: User with no tasks at all - assertEquals(0, taskRepository.findAllByUser(testUser2.getUsername(), false).size()); - assertEquals(0, taskRepository.findAllByUser(testUser2.getUsername(), true).size()); - - //Situation 3: User with finished and unfinished tasks - List tasks_user1_false = taskRepository.findAllByUser(testUser1.getUsername(), false); - List tasks_user1_true = taskRepository.findAllByUser(testUser1.getUsername(), true); - assertEquals(7, tasks_user1_true.size()); - assertEquals(8, tasks_user1_false.size()); - - assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 1L))); - assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 3L))); - assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 5L))); - assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 7L))); - assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 9L))); - assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 11L))); - assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 12L))); - - assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 2L))); - assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 4L))); - assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 6L))); - assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 8L))); - assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 10L))); - assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 13L))); - assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 14L))); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void deleteAllByTaskgroup() { - Taskgroup taskgroup_no_tasks = testEntityManager.find(Taskgroup.class, 1L); - taskRepository.deleteAllByTaskgroup(taskgroup_no_tasks); - - for(long i=1; i<=14; i++) { - assertThat(testEntityManager.find(Task.class, i)).isNotNull(); - } - - Taskgroup taskgroup_with_task = testEntityManager.find(Taskgroup.class, 2L); - taskRepository.deleteAllByTaskgroup(taskgroup_with_task); - for(long i=1; i<=14; i++) { - Task task = testEntityManager.find(Task.class, i); - assertThat(task).isNull(); - } - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void deleteByTaskID() { - taskRepository.deleteByTaskID(-1); - for(long i=1; i<=14; i++) { - assertThat(testEntityManager.find(Task.class, i)).isNotNull(); - } - - taskRepository.deleteByTaskID(1); - assertThat(testEntityManager.find(Task.class, 1L)).isNull(); - for(long i=2; i<=14; i++) { - assertThat(testEntityManager.find(Task.class, i)).isNotNull(); - } - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void findAllOverdue() { - User testuser1 = testEntityManager.find(User.class, 1L); - LocalDate referenceDate = LocalDate.of(2023, 10, 11); - - List overdue = taskRepository.findAllOverdue(testuser1.getUsername(), referenceDate); - assertEquals(2, overdue.size()); - assertTrue(overdue.contains(testEntityManager.find(Task.class, 3L))); - assertTrue(overdue.contains(testEntityManager.find(Task.class, 5L))); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void findAllUpcoming() { - User testuser1 = testEntityManager.find(User.class, 1L); - LocalDate referenceDate = LocalDate.of(2023, 10, 11); - - List upcoming = taskRepository.findAllUpcoming(testuser1.getUsername(), referenceDate); - assertEquals(2, upcoming.size()); - assertTrue(upcoming.contains(testEntityManager.find(Task.class, 7L))); - assertTrue(upcoming.contains(testEntityManager.find(Task.class, 9L))); - - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql") - }) - void findAllActive() { - User testuser1 = testEntityManager.find(User.class, 1L); - LocalDate referenceDate = LocalDate.of(2023, 10, 11); - - List active = taskRepository.findAllActive(testuser1.getUsername(), referenceDate); - //1,3,5,11,12 - assertEquals(6, active.size()); - assertTrue(active.contains(testEntityManager.find(Task.class, 1L))); - assertTrue(active.contains(testEntityManager.find(Task.class, 3L))); - assertTrue(active.contains(testEntityManager.find(Task.class, 5L))); - assertTrue(active.contains(testEntityManager.find(Task.class, 11L))); - assertTrue(active.contains(testEntityManager.find(Task.class, 12L))); - } - -} diff --git a/backend/src/test/java/core/tasks/TaskServiceTest.java b/backend/src/test/java/core/tasks/TaskServiceTest.java deleted file mode 100644 index ede0e93..0000000 --- a/backend/src/test/java/core/tasks/TaskServiceTest.java +++ /dev/null @@ -1,287 +0,0 @@ -package core.tasks; - -import core.api.models.timemanager.tasks.TaskFieldInfo; -import core.api.models.timemanager.tasks.TaskScope; -import core.entities.timemanager.BasicTaskSchedule; -import core.entities.timemanager.Task; -import core.entities.timemanager.Taskgroup; -import core.repositories.timemanager.TaskRepository; -import core.repositories.timemanager.TaskgroupRepository; -import core.services.*; -import org.junit.jupiter.api.Test; -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.jdbc.Sql; -import org.springframework.test.context.jdbc.SqlGroup; - -import javax.persistence.EntityManager; -import javax.transaction.Transactional; - -import java.time.LocalDate; -import java.util.List; - -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.junit.jupiter.api.Assertions.*; - -@SpringBootTest -@Transactional -public class TaskServiceTest { - - - @Autowired - private TaskService taskService; - @Autowired - private EntityManager entityManager; - - private static final String username = "Testuser1"; - private static final String username2 = "Testuser2"; - @Autowired - private TaskRepository taskRepository; - @Autowired - private TaskgroupRepository taskgroupRepository; - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void createTask() { - //Situation 1: Task with that name already exists in a taskgroup - TaskFieldInfo taskFieldInfo_1 = new TaskFieldInfo(entityManager.find(Task.class, 1L).getTaskName(), 0, null, null); - ServiceResult situation_1 = taskService.createTask(entityManager.find(Taskgroup.class, 2L), taskFieldInfo_1); - assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, situation_1.getExitCode()); - - //Situation 2: Task with that name exists in another taskgroup - TaskFieldInfo taskFieldInfo_2 = new TaskFieldInfo(entityManager.find(Task.class, 1L).getTaskName(), 0, null, null); - ServiceResult result_2 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_2); - assertEquals(ServiceExitCode.OK, result_2.getExitCode()); - assertThat(entityManager.find(Task.class, result_2.getResult().getTaskID())).isNotNull(); - - //Situation 3: Normal, everything fine - TaskFieldInfo taskFieldInfo_3 = new TaskFieldInfo("Situation 3", 0, null, null); - ServiceResult result_3 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_3); - assertEquals(ServiceExitCode.OK, result_3.getExitCode()); - assertThat(entityManager.find(Task.class, result_3.getResult().getTaskID())).isNotNull(); - - //Robustness - Test for invalid dates - //Situation 4: Deadline, no start - TaskFieldInfo taskFieldInfo_4 = new TaskFieldInfo("Situation 4", 0, null, LocalDate.now()); - ServiceResult result_4 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_4); - assertEquals(ServiceExitCode.OK, result_4.getExitCode()); - assertThat(entityManager.find(Task.class, result_4.getResult().getTaskID())).isNotNull(); - - //Situation 5: Start but no deadline - TaskFieldInfo taskFieldInfo_5 = new TaskFieldInfo("Situation 5", 0, LocalDate.now(),null); - ServiceResult result_5 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_5); - assertEquals(ServiceExitCode.OK, result_5.getExitCode()); - assertThat(entityManager.find(Task.class, result_5.getResult().getTaskID())).isNotNull(); - - //Situation 6: Deadline before start (invalid) - TaskFieldInfo taskFieldInfo_6 = new TaskFieldInfo("Situation 6", 0, LocalDate.now(),LocalDate.of(2010, 3, 20)); - ServiceResult result_6= taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_6); - assertEquals(ServiceExitCode.INVALID_PARAMETER, result_6.getExitCode()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void getTaskPermissions() { - //Situation 1: correct task and username - PermissionResult permissionResult_1 = taskService.getTaskPermissions(1L, username); - assertEquals(ServiceExitCode.OK, permissionResult_1.getExitCode()); - assertTrue(permissionResult_1.isHasPermissions()); - assertEquals(entityManager.find(Task.class, 1L), permissionResult_1.getResult()); - - //Situation 2: invalid taskgroup - PermissionResult permissionResult_2 = taskService.getTaskPermissions(200L, username); - assertEquals(ServiceExitCode.MISSING_ENTITY, permissionResult_2.getExitCode()); - assertFalse(permissionResult_2.isHasPermissions()); - assertThat(permissionResult_2.getResult()).isNull(); - - //Situation 3: invalid user - PermissionResult permissionResult_3 = taskService.getTaskPermissions(1L, username2); - assertEquals(ServiceExitCode.OK, permissionResult_3.getExitCode()); - assertFalse(permissionResult_2.isHasPermissions()); - assertEquals(entityManager.find(Task.class, 1L), permissionResult_3.getResult()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void editTask() { - //Situation 1: Nothing is updated - Task task_1 = entityManager.find(Task.class, 1L); - TaskFieldInfo taskFieldInfo_1 = new TaskFieldInfo(entityManager.find(Task.class, 1L).getTaskName(), 0, null, null); - ServiceResult result_1 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_1); - assertEquals(ServiceExitCode.OK, result_1.getExitCode()); - assertEquals(task_1, result_1.getResult()); - - //Situation 2: Name is updated to name that already exists within the taskgroup - Task task_2 = entityManager.find(Task.class, 1L); - TaskFieldInfo taskFieldInfo_2 = new TaskFieldInfo(entityManager.find(Task.class, 2L).getTaskName(), 0, null, null); - ServiceResult result_2 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_2); - task_2.setTaskName(entityManager.find(Task.class, 2L).getTaskName()); - assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, result_2.getExitCode()); - assertNotEquals(task_2, result_2.getResult()); - - //Situation 3: Name is updated to nonexistend Name - Task task_3 = entityManager.find(Task.class, 1L); - TaskFieldInfo taskFieldInfo_3 = new TaskFieldInfo("Situation 3", 0, null, null); - ServiceResult result_3 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_3); - task_3.setTaskName("Situation 3"); - assertEquals(ServiceExitCode.OK, result_3.getExitCode()); - assertEquals(task_3, result_3.getResult()); - - //Situation 4: eta is updated - Task task_4 = entityManager.find(Task.class, 1L); - TaskFieldInfo taskFieldInfo_4 = new TaskFieldInfo(task_4.getTaskName(), 90, null, null); - ServiceResult result_4 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_4); - task_4.setEta(90); - assertEquals(ServiceExitCode.OK, result_4.getExitCode()); - assertEquals(task_4, result_4.getResult()); - - //Situation 5: deadline and start is updated in a valid way - Task task_5 = entityManager.find(Task.class, 1L); - TaskFieldInfo taskFieldInfo_5 = new TaskFieldInfo(task_5.getTaskName(), task_5.getEta(), LocalDate.of(2023, 4, 9), LocalDate.of(2023,5,9)); - ServiceResult result_5 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_5); - task_5.setStartDate(LocalDate.of(2023,4,9)); - task_5.setDeadline(LocalDate.of(2023,5,9)); - assertEquals(ServiceExitCode.OK, result_5.getExitCode()); - assertEquals(task_5, result_5.getResult()); - - //Situation 6: Deadline and start are updated in a not valid way - Task task_6 = entityManager.find(Task.class, 1L); - TaskFieldInfo taskFieldInfo_6 = new TaskFieldInfo(task_5.getTaskName(), task_5.getEta(), LocalDate.of(2023, 5, 9), LocalDate.of(2023,4,9)); - ServiceResult result_6 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_6); - task_6.setStartDate(LocalDate.of(2023,5,9)); - task_6.setDeadline(LocalDate.of(2023,4,9)); - assertEquals(ServiceExitCode.INVALID_PARAMETER, result_6.getExitCode()); - assertNotEquals(task_6, result_6.getResult()); - - //Situation 10 Startdate = null; - Task task_10 = entityManager.find(Task.class, 5L); - TaskFieldInfo taskFieldInfo_10 = new TaskFieldInfo(task_10.getTaskName(), task_10.getEta(),null, task_10.getDeadline()); - ServiceResult result_10 = taskService.editTask(entityManager.find(Task.class, 5L), taskFieldInfo_10); - task_10.setStartDate(null); - assertEquals(ServiceExitCode.OK, result_10.getExitCode()); - assertEquals(task_10, result_10.getResult()); - - //Situation 11 Deadline = null - Task task_11 = entityManager.find(Task.class, 5L); - TaskFieldInfo taskFieldInfo_11 = new TaskFieldInfo(task_11.getTaskName(), task_11.getEta(),task_11.getStartDate(), null); - ServiceResult result_11 = taskService.editTask(entityManager.find(Task.class, 5L), taskFieldInfo_11); - task_11.setDeadline(null); - assertEquals(ServiceExitCode.OK, result_11.getExitCode()); - assertEquals(task_11, result_11.getResult()); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void deleteTask() { - for(long i=1; i<=15; i++) { - taskService.deleteTask(entityManager.find(Task.class, i)); - assertThat(entityManager.find(Task.class, i)).isNull(); - } - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void clearTasks() { - //Situation 1: Delete from taskgroup with no tasks - taskService.clearTasks(entityManager.find(Taskgroup.class, 1L)); - for(long i=1; i<=15; i++) { - assertThat(entityManager.find(Task.class, i)).isNotNull(); - } - //Situation 2: Delete from taskgroup with tasks - taskService.clearTasks(entityManager.find(Taskgroup.class, 2L)); - for(long i=1; i<=15; i++) { - assertThat(entityManager.find(Task.class, i)).isNull(); - } - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void finishTask() { - taskService.finishTask(entityManager.find(Task.class, 1L)); - assertTrue(entityManager.find(Task.class, 1L).isFinished()); - - taskService.finishTask(entityManager.find(Task.class, 2L)); - assertTrue(entityManager.find(Task.class, 1L).isFinished()); - assertThat(entityManager.find(BasicTaskSchedule.class, 2L)).isNull(); - } - - @Test - @SqlGroup({ - @Sql("classpath:taskgroupRepositoryTestEntries.sql"), - @Sql("classpath:taskRepositoryEntries.sql"), - @Sql("classpath:basicScheduleEntries.sql") - }) - void loadAllTasks() { - //Situation 1: No tasks existing - List result_1 = taskService.loadAllTasks(username2, TaskScope.UNFINISHED); - assertEquals(0, result_1.size()); - - //Situation 2: Tasks existing, Unfinished# - List result_2 = taskService.loadAllTasks(username, TaskScope.UNFINISHED); - assertEquals(8, result_2.size()); - assertTrue(result_2.contains(entityManager.find(Task.class, 1L))); - assertTrue(result_2.contains(entityManager.find(Task.class, 3L))); - assertTrue(result_2.contains(entityManager.find(Task.class, 5L))); - assertTrue(result_2.contains(entityManager.find(Task.class, 7L))); - assertTrue(result_2.contains(entityManager.find(Task.class, 9L))); - assertTrue(result_2.contains(entityManager.find(Task.class, 11L))); - assertTrue(result_2.contains(entityManager.find(Task.class, 12L))); - - //Situation 3: Finished tasks - List result_3 = taskService.loadAllTasks(username, TaskScope.FINISHED); - assertEquals(7, result_3.size()); - assertTrue(result_3.contains(entityManager.find(Task.class, 2L))); - assertTrue(result_3.contains(entityManager.find(Task.class, 4L))); - assertTrue(result_3.contains(entityManager.find(Task.class, 6L))); - assertTrue(result_3.contains(entityManager.find(Task.class, 8L))); - assertTrue(result_3.contains(entityManager.find(Task.class, 10L))); - assertTrue(result_3.contains(entityManager.find(Task.class, 13L))); - assertTrue(result_3.contains(entityManager.find(Task.class, 14L))); - - //overdue - List result_4 = taskService.loadAllTasks(username, TaskScope.OVERDUE); - assertEquals(2, result_4.size()); - assertTrue(result_4.contains(entityManager.find(Task.class, 3L))); - assertTrue(result_4.contains(entityManager.find(Task.class, 5L))); - - //upcoming - List result_5 = taskService.loadAllTasks(username, TaskScope.UPCOMING); - assertEquals(2, result_5.size()); - assertTrue(result_5.contains(entityManager.find(Task.class, 7L))); - assertTrue(result_5.contains(entityManager.find(Task.class, 9L))); - //Active - List result_6 = taskService.loadAllTasks(username, TaskScope.ACTIVE); - assertEquals(6, result_6.size()); - assertTrue(result_6.contains(entityManager.find(Task.class, 1L))); - assertTrue(result_6.contains(entityManager.find(Task.class, 3L))); - assertTrue(result_6.contains(entityManager.find(Task.class, 5L))); - assertTrue(result_6.contains(entityManager.find(Task.class, 11L))); - assertTrue(result_6.contains(entityManager.find(Task.class, 12L))); - - } -} diff --git a/backend/src/test/java/core/users/UserRepositoryTests.java b/backend/src/test/java/core/users/UserRepositoryTests.java deleted file mode 100644 index 0b19155..0000000 --- a/backend/src/test/java/core/users/UserRepositoryTests.java +++ /dev/null @@ -1,87 +0,0 @@ -package core.users; - -import core.entities.User; -import core.repositories.UserRepository; -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.autoconfigure.orm.jpa.DataJpaTest; -import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; -import org.springframework.test.annotation.DirtiesContext; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.junit.jupiter.SpringExtension; - -import java.util.Optional; - -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.junit.jupiter.api.Assertions.*; - -@DataJpaTest -@ExtendWith(SpringExtension.class) -public class UserRepositoryTests { - - @Autowired - private UserRepository userRepository; - - @Autowired - private TestEntityManager testEntityManager; - - @Test - @Sql("classpath:userRepisotoryTestEntries.sql") - void test_findByUsername() { - //Situation 1: User with name "FawKes100" is present - User referenceUser = testEntityManager.find(User.class, 1L); - Optional findResult = userRepository.findByUsername(referenceUser.getUsername()); - assertTrue(findResult.isPresent()); - assertEquals(referenceUser,findResult.get()); - - //Situation 2: No user with the required name is present - findResult = userRepository.findByUsername("fawkes1001"); - assertFalse(findResult.isPresent()); - } - - @Test - @Sql("classpath:userRepisotoryTestEntries.sql") - void test_existsByMail() { - User referenceUser = testEntityManager.find(User.class, 1L); - //Situation 1: invalid email format should not matter - assertFalse(userRepository.existsByEmail("FawKes100")); - - //Situation 2: No user exists with such a mail - assertFalse(userRepository.existsByEmail("mail@fawkes100.de")); - - //Situation 3: User with this mail exists - assertTrue(userRepository.existsByEmail(referenceUser.getEmail())); - } - - @Test - @Sql("classpath:userRepisotoryTestEntries.sql") - void test_existsByUsername() { - User referenceUser = testEntityManager.find(User.class, 1L); - //Situation 1: No such user - assertFalse(userRepository.existsByUsername("FawKes100")); - - //Situation 3: User with this name exists - assertTrue(userRepository.existsByUsername(referenceUser.getUsername())); - } - - @Test - @Sql("classpath:userRepisotoryTestEntries.sql") - void test_deleteUserByName() { - User referenceUser1 = testEntityManager.find(User.class, 1L); - User referenceUser2 = testEntityManager.find(User.class, 2L); - - userRepository.deleteByUsername(referenceUser2.getUsername()); - - assertThat(testEntityManager.find(User.class, referenceUser2.getId())).isNull(); - assertThat(testEntityManager.find(User.class, referenceUser1.getId())).isNotNull(); - } - - - @Test - @Sql("classpath:userRepisotoryTestEntries.sql") - void test_countUsers() { - assertEquals(2, userRepository.countUsers()); - } - -}