issue-86 #102
@ -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:
|
||||
|
||||
@ -24,9 +24,12 @@ public class DemoApplication{
|
||||
|
||||
|
||||
@Bean
|
||||
@NotTest
|
||||
public CommandLineRunner init(TaskSchedulingService taskSchedulingService) {
|
||||
return args -> {
|
||||
taskSchedulingService.scheduleStartingTask("Finishing ConceptCreator");
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
16
backend/src/main/java/core/NotTest.java
Normal file
16
backend/src/main/java/core/NotTest.java
Normal file
@ -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 {
|
||||
}
|
||||
@ -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}")
|
||||
|
||||
@ -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() {
|
||||
}*/
|
||||
|
||||
}
|
||||
@ -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<AbstractSchedule> result_1 = scheduleRepository.getActiveScheduleOfUser(referenceUser_2.getUsername());
|
||||
assertTrue(result_1.isEmpty());
|
||||
|
||||
Optional<AbstractSchedule> result_2 = scheduleRepository.getActiveScheduleOfUser(referenceUser_1.getUsername());
|
||||
assertTrue(result_2.isPresent());
|
||||
}
|
||||
}
|
||||
@ -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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> result_1 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 3L));
|
||||
assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, result_1.getExitCode());
|
||||
|
||||
//Situation 2: Task is already finished
|
||||
ServiceResult<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> result_1 = taskScheduleService.registerForgottenSchedule(entityManager.find(Task.class, 2L), new ForgottenScheduleInfo(startTime, finishTime));
|
||||
assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode());
|
||||
|
||||
ServiceResult<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> 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<AbstractSchedule> result_6 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 9L),
|
||||
new AdvancedScheduleFieldInfo(LocalDateTime.now(), LocalDateTime.now().plusHours(1L)));
|
||||
assertEquals(ServiceExitCode.INVALID_OPERATION, result_6.getExitCode());
|
||||
}
|
||||
}
|
||||
@ -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<Taskgroup> result_user2 = taskgroupRepository.findAllByUser(testUser2.getUsername());
|
||||
assertEquals(0, result_user2.size());
|
||||
|
||||
List<Taskgroup> 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<Taskgroup> 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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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<Taskgroup> 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<Taskgroup> 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<Taskgroup> 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<Taskgroup> 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<Taskgroup> 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<Taskgroup> 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<Taskgroup> 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<Taskgroup> 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<Taskgroup> taskgroups_user2 = taskgroupService.getTopTaskgroupsByUser(username2);
|
||||
assertEquals(0, taskgroups_user2.size());
|
||||
|
||||
|
||||
//Situation 2: user with taskgroups
|
||||
List<Taskgroup> 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();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -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<Task> tasks_user1_false = taskRepository.findAllByUser(testUser1.getUsername(), false);
|
||||
List<Task> 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<Task> 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<Task> 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<Task> 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)));
|
||||
}
|
||||
|
||||
}
|
||||
@ -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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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<Task> result_1 = taskService.loadAllTasks(username2, TaskScope.UNFINISHED);
|
||||
assertEquals(0, result_1.size());
|
||||
|
||||
//Situation 2: Tasks existing, Unfinished#
|
||||
List<Task> 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<Task> 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<Task> 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<Task> 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<Task> 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)));
|
||||
|
||||
}
|
||||
}
|
||||
@ -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<User> 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());
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user