diff --git a/src/main/java/com/gepardec/mega/service/impl/StepEntrySyncServiceImpl.java b/src/main/java/com/gepardec/mega/service/impl/StepEntrySyncServiceImpl.java index 0e7f7de3e..1feeac31b 100644 --- a/src/main/java/com/gepardec/mega/service/impl/StepEntrySyncServiceImpl.java +++ b/src/main/java/com/gepardec/mega/service/impl/StepEntrySyncServiceImpl.java @@ -26,7 +26,6 @@ import java.util.Collection; import java.util.List; import java.util.Optional; -import java.util.stream.Collectors; @Dependent @Transactional(value = Transactional.TxType.REQUIRED, rollbackOn = Exception.class) diff --git a/src/main/java/com/gepardec/mega/service/impl/UserServiceImpl.java b/src/main/java/com/gepardec/mega/service/impl/UserServiceImpl.java index 75b6686f1..58e6071f5 100644 --- a/src/main/java/com/gepardec/mega/service/impl/UserServiceImpl.java +++ b/src/main/java/com/gepardec/mega/service/impl/UserServiceImpl.java @@ -11,7 +11,6 @@ import jakarta.transaction.Transactional; import java.util.List; -import java.util.stream.Collectors; @ApplicationScoped public class UserServiceImpl implements UserService { diff --git a/src/test/java/com/gepardec/mega/rest/SyncResourceTest.java b/src/test/java/com/gepardec/mega/rest/SyncResourceTest.java index c508e6875..73db9e77c 100644 --- a/src/test/java/com/gepardec/mega/rest/SyncResourceTest.java +++ b/src/test/java/com/gepardec/mega/rest/SyncResourceTest.java @@ -12,20 +12,30 @@ import com.gepardec.mega.rest.model.EmployeeDto; import com.gepardec.mega.service.api.EmployeeService; +import com.gepardec.mega.service.api.ProjectSyncService; import com.gepardec.mega.service.api.StepEntryService; +import com.gepardec.mega.service.impl.ProjectSyncServiceImpl; import com.gepardec.mega.zep.ZepService; import io.quarkus.test.junit.QuarkusTest; import io.quarkus.test.junit.mockito.InjectMock; import jakarta.inject.Inject; +import jakarta.ws.rs.core.Response; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; +import org.slf4j.Logger; import java.time.LocalDate; +import java.time.YearMonth; import java.util.ArrayList; import java.util.List; +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; @@ -37,7 +47,6 @@ public class SyncResourceTest { @InjectMock EmployeeService employeeService; - @InjectMock ZepService zepService; @@ -48,6 +57,8 @@ public class SyncResourceTest { @Inject SyncResource syncResource; + private ProjectSyncService projectSyncService; + @Test @@ -206,6 +217,32 @@ void testUpdateEmployeesWithoutTimeBookingsAndAbsentWholeMonth_whenEmployeeIsExt assertThat(actual).isEmpty(); } + private static Stream provideParams() { + return Stream.of( + Arguments.of( null, YearMonth.of(2023, 1)), + Arguments.of(YearMonth.of(2023, 1), null), + Arguments.of(YearMonth.of(2023, 1), YearMonth.of(2023, 3)), + Arguments.of(YearMonth.of(2023, 1), YearMonth.of(2024, 1)) + ); + } + + @ParameterizedTest + @MethodSource("provideParams") + void syncProjects(YearMonth from, YearMonth to) { + projectSyncService = mock(ProjectSyncService.class); + + when(projectSyncService.generateProjects()) + .thenReturn(true); + + when(projectSyncService.generateProjects(any(LocalDate.class))) + .thenReturn(true); + + + + Response actual = syncResource.syncProjects(from, to); + assertThat(actual.getStatus()).isEqualTo(Response.Status.OK.getStatusCode()); + } + //helpers private Employee createEmployeeForId(final String id, final String email, final String releaseDate){ return Employee.builder() diff --git a/src/test/java/com/gepardec/mega/service/impl/init/StepEntrySyncServiceImplTest.java b/src/test/java/com/gepardec/mega/service/impl/init/StepEntrySyncServiceImplTest.java index 19e8a6cb2..d84f0d746 100644 --- a/src/test/java/com/gepardec/mega/service/impl/init/StepEntrySyncServiceImplTest.java +++ b/src/test/java/com/gepardec/mega/service/impl/init/StepEntrySyncServiceImplTest.java @@ -23,7 +23,6 @@ import java.time.LocalDate; import java.util.List; import java.util.Set; -import java.util.stream.Collectors; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.*; diff --git a/src/test/java/com/gepardec/mega/service/impl/mapper/PrematureEmployeeCheckMapperTest.java b/src/test/java/com/gepardec/mega/service/impl/mapper/PrematureEmployeeCheckMapperTest.java index 57fa4cfea..9320c908e 100644 --- a/src/test/java/com/gepardec/mega/service/impl/mapper/PrematureEmployeeCheckMapperTest.java +++ b/src/test/java/com/gepardec/mega/service/impl/mapper/PrematureEmployeeCheckMapperTest.java @@ -1,6 +1,7 @@ package com.gepardec.mega.service.impl.mapper; import com.gepardec.mega.db.entity.employee.PrematureEmployeeCheckEntity; +import com.gepardec.mega.db.entity.employee.PrematureEmployeeCheckState; import com.gepardec.mega.domain.mapper.PrematureEmployeeCheckMapper; import com.gepardec.mega.domain.model.PrematureEmployeeCheck; import com.gepardec.mega.domain.model.Role; @@ -22,8 +23,9 @@ public class PrematureEmployeeCheckMapperTest { PrematureEmployeeCheckMapper prematureEmployeeCheckMapper; + @Test - public void mapToDomain_dbEntity_mappedCorrectly() { + void mapToDomain_dbEntity_mappedCorrectly() { // Given PrematureEmployeeCheckEntity dbPrematureEmployeeCheck = createDBPrematureEmployeeCheck(1L); @@ -43,7 +45,7 @@ public void mapToDomain_dbEntity_mappedCorrectly() { } @Test - public void mapListToDomain_dbEntityList_correctLength() { + void mapListToDomain_dbEntityList_correctLength() { // Given List prematureEmployeeCheckEntity = List.of(createDBPrematureEmployeeCheck(1L), createDBPrematureEmployeeCheck(1L)); @@ -54,6 +56,43 @@ public void mapListToDomain_dbEntityList_correctLength() { assertThat(prematureEmployeeChecks.size()).isEqualTo(2); } + @Test + void mapToEntity() { + PrematureEmployeeCheck domain = createPrematureEmployeeCheck(1L, User.builder().userId("001-maxmustermann").build(), "Test reason"); + PrematureEmployeeCheckEntity actual = prematureEmployeeCheckMapper + .mapToEntity(domain); + + assertThat(actual.getState()).isEqualTo(domain.getState()); + assertThat(actual.getReason()).isEqualTo(domain.getReason()); + assertThat(actual.getId()).isEqualTo(domain.getId()); + } + + @Test + void mapToEntityWithTwoParams_whenReasonNotNull() { + PrematureEmployeeCheck domain = createPrematureEmployeeCheck(1L, User.builder().userId("001-maxmustermann").build(), "Test reason"); + PrematureEmployeeCheckEntity entity = new PrematureEmployeeCheckEntity(); + entity.setId(domain.getId()); + + PrematureEmployeeCheckEntity actual = prematureEmployeeCheckMapper.mapToEntity(domain, entity); + + assertThat(actual.getState()).isEqualTo(domain.getState()); + assertThat(actual.getReason()).isEqualTo(domain.getReason()); + assertThat(actual.getForMonth()).isEqualTo(domain.getForMonth()); + } + + @Test + void mapToEntityWithTwoParams_whenReasonIsNull() { + PrematureEmployeeCheck domain = createPrematureEmployeeCheck(1L, User.builder().userId("001-maxmustermann").build(), null); + PrematureEmployeeCheckEntity entity = new PrematureEmployeeCheckEntity(); + entity.setId(domain.getId()); + + PrematureEmployeeCheckEntity actual = prematureEmployeeCheckMapper.mapToEntity(domain, entity); + + assertThat(actual.getState()).isEqualTo(domain.getState()); + assertThat(actual.getReason()).isEqualTo(domain.getReason()); + assertThat(actual.getForMonth()).isEqualTo(domain.getForMonth()); + } + private com.gepardec.mega.db.entity.employee.User createDBUserForRole(final Role role) { com.gepardec.mega.db.entity.employee.User user = new com.gepardec.mega.db.entity.employee.User(); @@ -72,4 +111,14 @@ private PrematureEmployeeCheckEntity createDBPrematureEmployeeCheck(Long id) { return prematureEmployeeCheckEntity; } + private PrematureEmployeeCheck createPrematureEmployeeCheck(Long id, User user, String reason) { + return PrematureEmployeeCheck.builder() + .id(id) + .user(user) + .forMonth(LocalDate.of(2024,6,1)) + .reason(reason) + .state(PrematureEmployeeCheckState.IN_PROGRESS) + .build(); + } + } diff --git a/src/test/java/com/gepardec/mega/service/impl/prematureemployeecheck/PrematureEmployeeCheckServiceImplTest.java b/src/test/java/com/gepardec/mega/service/impl/prematureemployeecheck/PrematureEmployeeCheckServiceImplTest.java new file mode 100644 index 000000000..e88ccff47 --- /dev/null +++ b/src/test/java/com/gepardec/mega/service/impl/prematureemployeecheck/PrematureEmployeeCheckServiceImplTest.java @@ -0,0 +1,127 @@ +package com.gepardec.mega.service.impl.prematureemployeecheck; + +import com.gepardec.mega.db.entity.employee.PrematureEmployeeCheckEntity; +import com.gepardec.mega.db.entity.employee.PrematureEmployeeCheckState; +import com.gepardec.mega.db.repository.PrematureEmployeeCheckRepository; +import com.gepardec.mega.domain.mapper.PrematureEmployeeCheckMapper; +import com.gepardec.mega.domain.model.PrematureEmployeeCheck; +import com.gepardec.mega.service.api.PrematureEmployeeCheckService; +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.mockito.InjectMock; +import jakarta.inject.Inject; +import org.junit.jupiter.api.Test; + +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.when; + +@QuarkusTest +public class PrematureEmployeeCheckServiceImplTest { + @Inject + PrematureEmployeeCheckService prematureEmployeeCheckService; + + @InjectMock + PrematureEmployeeCheckRepository checkRepository; + + @InjectMock + PrematureEmployeeCheckMapper prematureEmployeeCheckMapper; + + @Test + void findAllForMonth_whenSuccessful_thenReturnTrue() { + List entityList = new ArrayList<>(); + entityList.add( + new PrematureEmployeeCheckEntity() + ); + + when(checkRepository.findAllForMonth(any(LocalDate.class))) + .thenReturn(entityList); + + when(prematureEmployeeCheckMapper.mapListToDomain(any())) + .thenReturn(List.of(PrematureEmployeeCheck.builder().id(1L).build())); + + List actual = prematureEmployeeCheckService.findAllForMonth(any(LocalDate.class)); + + assertThat(actual.size()).isOne(); + } + + @Test + void deleteById_whenSuccessful_thenReturnTrue() { + when(checkRepository.delete(anyLong())) + .thenReturn(true); + + assertThat(prematureEmployeeCheckService.deleteById(anyLong())).isTrue(); + } + + @Test + void deleteAllForMonthWithState_whenSuccessful_thenReturnId() { + when(checkRepository.deleteByMonthAndStates(any(LocalDate.class), any())) + .thenReturn(1L); + + assertThat(prematureEmployeeCheckService.deleteAllForMonthWithState(LocalDate.of(2024,3,1), List.of(PrematureEmployeeCheckState.IN_PROGRESS, PrematureEmployeeCheckState.DONE))).isEqualTo(1L); + } + + @Test + void update_whenSuccessful_thenReturnTrue() { + PrematureEmployeeCheck prematureEmployeeCheck = PrematureEmployeeCheck.builder().id(1L) + .forMonth(LocalDate.of(2024,6,1)) + .reason("Test reason") + .build(); + + when(checkRepository.findById(anyLong())) + .thenReturn(createEntity()); + + when(prematureEmployeeCheckMapper.mapToEntity(any(PrematureEmployeeCheck.class), any(PrematureEmployeeCheckEntity.class))) + .thenReturn(createEntity()); + + when(checkRepository.update(any(PrematureEmployeeCheckEntity.class))) + .thenReturn(createEntity()); + + boolean actual = prematureEmployeeCheckService.update(prematureEmployeeCheck); + + assertThat(actual).isTrue(); + } + + @Test + void update_whenNotSuccessful_thenReturnFalse() { + PrematureEmployeeCheck prematureEmployeeCheck = PrematureEmployeeCheck.builder().id(1L) + .forMonth(LocalDate.of(2024,6,1)) + .reason("Test reason") + .build(); + + when(checkRepository.findById(anyLong())) + .thenReturn(createEntity()); + + when(prematureEmployeeCheckMapper.mapToEntity(any(PrematureEmployeeCheck.class), any(PrematureEmployeeCheckEntity.class))) + .thenReturn(createEntity()); + + when(checkRepository.update(any(PrematureEmployeeCheckEntity.class))) + .thenReturn(createEntityWithIdNull()); + + boolean actual = prematureEmployeeCheckService.update(prematureEmployeeCheck); + + assertThat(actual).isFalse(); + } + + private PrematureEmployeeCheckEntity createEntity() { + PrematureEmployeeCheckEntity entity = new PrematureEmployeeCheckEntity(); + entity.setId(1L); + entity.setForMonth(LocalDate.of(2024,6, 1)); + entity.setReason("Test reason"); + + return entity; + } + + private PrematureEmployeeCheckEntity createEntityWithIdNull() { + PrematureEmployeeCheckEntity entity = new PrematureEmployeeCheckEntity(); + entity.setId(null); + entity.setForMonth(LocalDate.of(2024,6, 1)); + entity.setReason("Test reason"); + + return entity; + } +} diff --git a/src/test/java/com/gepardec/mega/service/impl/stepentry/StepEntryServiceImplTest.java b/src/test/java/com/gepardec/mega/service/impl/stepentry/StepEntryServiceImplTest.java index c2c59f0cb..83f8e5b95 100644 --- a/src/test/java/com/gepardec/mega/service/impl/stepentry/StepEntryServiceImplTest.java +++ b/src/test/java/com/gepardec/mega/service/impl/stepentry/StepEntryServiceImplTest.java @@ -5,14 +5,18 @@ import com.gepardec.mega.db.entity.employee.User; import com.gepardec.mega.db.repository.StepEntryRepository; import com.gepardec.mega.domain.model.Employee; +import com.gepardec.mega.domain.model.Project; import com.gepardec.mega.domain.model.ProjectEmployees; +import com.gepardec.mega.domain.model.Step; import com.gepardec.mega.domain.utils.DateUtils; import com.gepardec.mega.service.api.StepEntryService; import io.quarkus.test.junit.QuarkusTest; import io.quarkus.test.junit.mockito.InjectMock; import jakarta.inject.Inject; import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; import org.mockito.ArgumentMatchers; +import org.slf4j.Logger; import java.time.LocalDate; import java.time.LocalDateTime; @@ -22,7 +26,9 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -36,6 +42,9 @@ class StepEntryServiceImplTest { @InjectMock StepEntryRepository stepEntryRepository; + @InjectMock + Logger logger; + @Test void findEmployeeCheckState_whenValidStepEntries_thenValidState() { StepEntry stepEntry = createStepEntry(1L); @@ -269,6 +278,101 @@ void getProjectEmployeesForPM_whenValid_thenReturnListOfEntries() { ); } + @Test + void addStepEntry_whenProjectIsNotNull_thenCreateStepEntry() { + com.gepardec.mega.domain.model.StepEntry stepEntry = com.gepardec.mega.domain.model.StepEntry.builder() + .owner(com.gepardec.mega.domain.model.User.builder().dbId(1L).build()) + .step(Step.builder().dbId(1L).build()) + .assignee(com.gepardec.mega.domain.model.User.builder().dbId(1L).build()) + .date(LocalDate.of(2024,5,12)) + .project(Project.builder().projectId("ABC").build()) + .build(); + + User ownerDb = new User(); + ownerDb.setId(stepEntry.getOwner().getDbId()); + + User assigneeDb = new User(); + assigneeDb.setId(stepEntry.getAssignee().getDbId()); + + com.gepardec.mega.db.entity.employee.Step step = new com.gepardec.mega.db.entity.employee.Step(); + step.setId(stepEntry.getStep().getDbId()); + + + StepEntry expectedStepEntry = new StepEntry(); + expectedStepEntry.setDate(stepEntry.getDate()); + expectedStepEntry.setProject(stepEntry.getProject().getProjectId()); + expectedStepEntry.setState(EmployeeState.OPEN); + expectedStepEntry.setOwner(ownerDb); + expectedStepEntry.setAssignee(assigneeDb); + expectedStepEntry.setStep(step); + + stepEntryService.addStepEntry(stepEntry); + + ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(Object.class); + verify(logger).debug(eq("inserting step entry {}"), argumentCaptor.capture()); + + StepEntry capturedStepEntry = (StepEntry) argumentCaptor.getValue(); + assertThat(capturedStepEntry.getProject()).isEqualTo(expectedStepEntry.getProject()); + } + + @Test + void addStepEntry_whenProjectIsNull_thenCreateStepEntry() { + com.gepardec.mega.domain.model.StepEntry stepEntry = com.gepardec.mega.domain.model.StepEntry.builder() + .owner(com.gepardec.mega.domain.model.User.builder().dbId(1L).build()) + .step(Step.builder().dbId(1L).build()) + .assignee(com.gepardec.mega.domain.model.User.builder().dbId(1L).build()) + .date(LocalDate.of(2024,5,12)) + .project(null) + .build(); + + User ownerDb = new User(); + ownerDb.setId(stepEntry.getOwner().getDbId()); + + User assigneeDb = new User(); + assigneeDb.setId(stepEntry.getAssignee().getDbId()); + + com.gepardec.mega.db.entity.employee.Step step = new com.gepardec.mega.db.entity.employee.Step(); + step.setId(stepEntry.getStep().getDbId()); + + + StepEntry expectedStepEntry = new StepEntry(); + expectedStepEntry.setDate(stepEntry.getDate()); + expectedStepEntry.setProject(null); + expectedStepEntry.setState(EmployeeState.OPEN); + expectedStepEntry.setOwner(ownerDb); + expectedStepEntry.setAssignee(assigneeDb); + expectedStepEntry.setStep(step); + + stepEntryService.addStepEntry(stepEntry); + + ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(Object.class); + verify(logger).debug(eq("inserting step entry {}"), argumentCaptor.capture()); + + StepEntry capturedStepEntry = (StepEntry) argumentCaptor.getValue(); + assertThat(capturedStepEntry.getProject()).isEqualTo(expectedStepEntry.getProject()); + } + + @Test + void findEmployeeCheckState_whenEmployeeIsNull_thenReturnOptionalEmpty() { + assertThat(stepEntryService.findEmployeeCheckState(null)).isEmpty(); + } + + @Test + void findStepEntryForEmployeeAndProjectAtStep_whenNoEntriesFound_thenThrowsException() { + when(stepEntryRepository.findStepEntryForEmployeeAndProjectAtStepInRange(any(LocalDate.class), + any(LocalDate.class), + anyString(), + anyLong(), + anyString(), + anyString() + ) + ).thenReturn(Optional.empty()); + + assertThatThrownBy(() -> stepEntryService.findStepEntryForEmployeeAndProjectAtStep(1L, "max.mustermann@gmail.com", "max.mustermann@gmail.com", "ABC", "2024-05-01")) + .isInstanceOf(IllegalStateException.class); + } + + private List createStepEntriesForPM() { return List.of( createStepEntry(1L, "no-reply@gepardec.com", "008"), diff --git a/src/test/java/com/gepardec/mega/service/impl/user/UserServiceImplTest.java b/src/test/java/com/gepardec/mega/service/impl/user/UserServiceImplTest.java new file mode 100644 index 000000000..f0aee1790 --- /dev/null +++ b/src/test/java/com/gepardec/mega/service/impl/user/UserServiceImplTest.java @@ -0,0 +1,168 @@ +package com.gepardec.mega.service.impl.user; + +import com.gepardec.mega.application.exception.ForbiddenException; +import com.gepardec.mega.db.entity.employee.User; +import com.gepardec.mega.db.repository.UserRepository; +import com.gepardec.mega.domain.mapper.UserMapper; +import com.gepardec.mega.domain.model.Role; +import com.gepardec.mega.service.api.UserService; +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.mockito.InjectMock; +import jakarta.inject.Inject; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; + +@QuarkusTest +public class UserServiceImplTest { + + @Inject + UserService userService; + + @InjectMock + UserRepository userRepository; + + @InjectMock + UserMapper userMapper; + + @Test + void findUserForEmail_whenNoUser_thenThrowException() { + when(userRepository.findActiveByEmail(anyString())) + .thenReturn(Optional.empty()); + + + assertThatThrownBy(() -> userService.findUserForEmail(anyString())) + .isInstanceOf(ForbiddenException.class); + + } + + @Test + void findUserForEmail_whenUser_thenReturnUser() { + com.gepardec.mega.db.entity.employee.User user = User.of("001.max.mustermann@gmail.com"); + + when(userRepository.findActiveByEmail(anyString())) + .thenReturn(Optional.of(user)); + + when(userMapper.mapToDomain(any(User.class))) + .thenReturn(com.gepardec.mega.domain.model.User.builder().userId("001-mmustermann").build()); + + com.gepardec.mega.domain.model.User actual = userService.findUserForEmail(anyString()); + + assertThat(actual.getUserId()).isEqualTo("001-mmustermann"); + } + + @Test + void findByName_whenNoUser_thenThrowException() { + when(userRepository.findActiveByName(anyString(), anyString())) + .thenReturn(Optional.empty()); + + + assertThatThrownBy(() -> userService.findByName(anyString(), anyString())) + .isInstanceOf(ForbiddenException.class); + } + + @Test + void findByName_whenUser_thenReturnUser() { + com.gepardec.mega.db.entity.employee.User user = User.of("001.max.mustermann@gmail.com"); + + when(userRepository.findActiveByName(anyString(), anyString())) + .thenReturn(Optional.of(user)); + + when(userMapper.mapToDomain(any(User.class))) + .thenReturn(com.gepardec.mega.domain.model.User.builder().userId("001-mmustermann").build()); + + com.gepardec.mega.domain.model.User actual = userService.findByName(anyString(), anyString()); + + assertThat(actual.getUserId()).isEqualTo("001-mmustermann"); + } + + @Test + void findByZepId_whenNoUser_thenThrowException() { + when(userRepository.findByZepId(anyString())) + .thenReturn(Optional.empty()); + + + assertThatThrownBy(() -> userService.findByZepId(anyString())) + .isInstanceOf(ForbiddenException.class); + } + + @Test + void findByZepId_whenUser_thenReturnUser() { + com.gepardec.mega.db.entity.employee.User user = User.of("001.max.mustermann@gmail.com"); + + when(userRepository.findByZepId(anyString())) + .thenReturn(Optional.of(user)); + + when(userMapper.mapToDomain(any(User.class))) + .thenReturn(com.gepardec.mega.domain.model.User.builder().userId("001-mmustermann").build()); + + com.gepardec.mega.domain.model.User actual = userService.findByZepId(anyString()); + + assertThat(actual.getUserId()).isEqualTo("001-mmustermann"); + } + + @Test + void findActiveUsers_whenUser_thenReturnUser() { + User user = User.of("001.max.mustermann@gmail.com"); + List userList = List.of( + user + ); + + com.gepardec.mega.domain.model.User resultUser = com.gepardec.mega.domain.model.User.builder().userId("001-mmustermann").build(); + List resultList = List.of( + resultUser + ); + + when(userRepository.findActive()) + .thenReturn(userList); + + when(userMapper.mapToDomain(any(User.class))) + .thenReturn(resultUser); + + List actual = userService.findActiveUsers(); + assertThat(actual).isEqualTo(resultList); + } + + + @Test + void findByRoles_whenRolesNull_thenThrowException() { + assertThatThrownBy(() -> userService.findByRoles(null)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void findByRoles_whenRolesAreEmpty_thenThrowException() { + assertThatThrownBy(() -> userService.findByRoles(List.of())) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void findByRoles_whenRoles_thenReturnUserList() { + User user = User.of("001.max.mustermann@gmail.com"); + List userList = List.of( + user + ); + + com.gepardec.mega.domain.model.User resultUser = com.gepardec.mega.domain.model.User.builder().userId("001-mmustermann").build(); + List resultList = List.of( + resultUser + ); + + when(userRepository.findByRoles(List.of(Role.EMPLOYEE))) + .thenReturn(userList); + + when(userMapper.mapToDomain(any(User.class))) + .thenReturn(resultUser); + + List actual = userService.findByRoles(List.of(Role.EMPLOYEE)); + assertThat(actual).isEqualTo(resultList); + } + +}