[Gepardec/mega#753] add tests several services

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)

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 {

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<Arguments> 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()

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.*;

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> 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();
+    }
+
 }

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<PrematureEmployeeCheckEntity> 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<PrematureEmployeeCheck> 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;
+    }
+}