emp

class EmployeeServiceImplUnitTest {

    private static final String USERNAME = "Test Username";
    private static final String SECOND_USERNAME = "Test Username 2";
    private static final String USERNAME_NOT_FOUND = "Username not found";
    private static final String NEW_SUMMARY = "New information";
    private static final String PROFICIENT = "Proficient";

    @Mock
    private EmployeeRepository employeeRepository;
    @Mock
    private ProjectHistoryMapper projectHistoryMapper;
    @Mock
    private ImageUploadProperties imageUploadProperties;
    @Mock
    private ImageValidator imageValidator;
    @Mock
    private ProjectHistoryRepository projectHistoryRepository;
    @Mock
    private ProjectHistoryService projectHistoryService;
    @Mock
    private EducationRepository educationRepository;
    @Mock
    private LearnedLanguageRepository learnedLanguageRepository;
    @Mock
    private LanguageRepository languageRepository;
    @Mock
    private PopulateEmployeeGroupAndSkillEntitiesService populateEmployeeGroupAndSkillEntitiesService;
    @Mock
    private SkillGroupService skillGroupService;
    @Mock
    private EmployeeGroupService employeeGroupService;
    @Mock
    private SkillService skillService;
    @Mock
    private GroupService groupService;

    private EmployeeService employeeService;

    private List<ProjectHistory> projectHistories;

    private Employee employee;

    private List<UsernameRoleDTO> usernameRoleDTOs;

    private List<LearnedLanguage> learnedLanguages;

    private LearnedLanguage learnedLanguage;

    private Language language;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.initMocks(this);

        employeeService = new EmployeeServiceImpl(
                projectHistoryService, employeeRepository, projectHistoryMapper,
                imageUploadProperties, imageValidator, projectHistoryRepository,
                educationRepository, learnedLanguageRepository, populateEmployeeGroupAndSkillEntitiesService,
                skillGroupService, employeeGroupService, languageRepository, skillService, groupService);

        Education education = Education.builder()
                .id(1L)
                .title(TEST_NAME)
                .info(TEST_INFO)
                .startYear(TEST_START_INT)
                .endYear(TEST_END_INT)
                .build();

        employee = createUser(1L, WfmRole.EMPLOYEE, USERNAME, WfmStatus.ACTIVE);
        employee.setEducation(List.of(education));

        language = Language.builder().id(ID).name(LANGUAGE_NAME).build();

        learnedLanguage = LearnedLanguage.builder().id(ID).employee(employee).language(language).level(LanguageLevel.A1).build();

        learnedLanguages = new ArrayList<>();

        learnedLanguages.add(learnedLanguage);
        employee.setLearnedLanguages(learnedLanguages);

        usernameRoleDTOs = new ArrayList<>();
        projectHistories = new ArrayList<>();

    }

    @Test
    void editEmployeeLearnedLanguage_shouldUpdateLearnedLanguage() {
        // arrange
        LearnedLanguage updatedLearnedLanguage = LearnedLanguage.builder().employee(employee).language(language).level(LanguageLevel.getValueOfStringOrDefault(PROFICIENT)).build();
        learnedLanguages.add(learnedLanguage);
        employee.setLearnedLanguages(learnedLanguages);
        when(employeeRepository.findByUsernameIgnoreCase(employee.getUsername())).thenReturn(Optional.ofNullable(employee));
        when(learnedLanguageRepository.save(updatedLearnedLanguage)).thenReturn(updatedLearnedLanguage);

        // act
        employeeService.updateEmployeeLanguageLevel(USERNAME, LANGUAGE_NAME, updatedLearnedLanguage.getLevel().getDescription());

        // assert
        verify(employeeRepository, times(1)).findByUsernameIgnoreCase(USERNAME);
        verify(learnedLanguageRepository, times(1)).save(learnedLanguage);

    }

    @Test
    void editEmployeeLearnedLanguage_shouldThrowUsernameNotFoundException() {

        when(employeeRepository.findByUsernameIgnoreCase(USERNAME)).thenReturn(Optional.ofNullable(employee));
        assertThrows(NotFoundException.class, () -> employeeService.updateEmployeeLanguageLevel(USERNAME, "TEST_DUMMY_NAME", PROFICIENT));
    }

    @Test
    void editEmployeeLearnedLanguage_shouldThrowUnknownLanguageLevel() {

        when(employeeRepository.findByUsernameIgnoreCase(USERNAME)).thenReturn(Optional.ofNullable(employee));
        assertThrows(IllegalArgumentException.class, () -> employeeService.updateEmployeeLanguageLevel(USERNAME, LANGUAGE_NAME, "DUMMY_LEVEL"));
    }

    @Test
    void updateEmployeeSummaryInfo_shouldUpdateEmployeeSummaryInformation() {
        employee.setSummary(NEW_SUMMARY);
        when(employeeRepository.findByUsernameIgnoreCase(USERNAME)).thenReturn(Optional.ofNullable(employee));

        employeeService.updateUserSummaryInformation(USERNAME, NEW_SUMMARY);
        verify(employeeRepository, times(1)).findByUsernameIgnoreCase(USERNAME);
        verify(employeeRepository, times(1)).save(employee);
    }

    @Test
    void updateEmployeeSummaryInfo_shouldThrowUsernameNotFoundException() {

        assertThrows(NotFoundException.class, () -> employeeService.findByUsernameIgnoreCase(USERNAME));
    }

    @Test
    void updateUserRolesAndStatus_shouldUpdateUserRoleAndStatus() {
        UsernameRoleDTO usernameRoleDTO = UsernameRoleDTO.builder()
                .username(USERNAME)
                .isActive(Boolean.FALSE)
                .role(WfmRole.PLANNER)
                .build();

        List<UsernameRoleDTO> usernameRoleDTOs = singletonList(usernameRoleDTO);

        Employee updatedEmployee = createUser(1L, WfmRole.PLANNER, USERNAME, WfmStatus.INACTIVE);

        when(employeeRepository.findAllByUsernameInIgnoreCase(singletonList(any()))).thenReturn(singletonList(employee));
        when(employeeRepository.saveAll(any())).thenReturn(singletonList(updatedEmployee));

        // act
        employeeService.updateUserRolesAndStatus(usernameRoleDTOs);

        // assert
        Assert.assertEquals(usernameRoleDTO.getRole(), updatedEmployee.getRole());
        Assert.assertEquals(usernameRoleDTO.getIsActive(), isNotTrue(WfmStatus.INACTIVE.equals(employee.getStatus())));
    }

    @Test
    void updateUserRolesAndStatus_shouldUpdateMultiuserStatusAndRole() {
        // arrange
        usernameRoleDTOs.addAll(asList(
                UsernameRoleDTO.builder()
                        .username(SECOND_USERNAME)
                        .isActive(Boolean.FALSE)
                        .role(WfmRole.PLANNER)
                        .build(),

                UsernameRoleDTO.builder()
                        .username(USERNAME)
                        .isActive(Boolean.FALSE)
                        .role(WfmRole.PLANNER)
                        .build()
        ));

        List<Employee> users = new ArrayList<>(asList(
                createUser(1L, WfmRole.EMPLOYEE, USERNAME, WfmStatus.ACTIVE),
                createUser(2L, WfmRole.EMPLOYEE, SECOND_USERNAME, WfmStatus.ACTIVE)
        ));

        List<Employee> updatedEmployees = new ArrayList<>(asList(
                createUser(1L, WfmRole.PLANNER, USERNAME, WfmStatus.INACTIVE),
                createUser(2L, WfmRole.PLANNER, SECOND_USERNAME, WfmStatus.INACTIVE)
        ));

        when(employeeRepository.findAllByUsernameInIgnoreCase(singletonList(any()))).thenReturn(users);
        when(employeeRepository.saveAll(any())).thenReturn(updatedEmployees);

        // act
        employeeService.updateUserRolesAndStatus(usernameRoleDTOs);

        // assert
        assertEquals(users, updatedEmployees);
    }

    @Test
    void updateUserRolesAndStatus_shouldUpdateUserRoles() {

        UsernameRoleDTO usernameRoleDTOChangedRole = new UsernameRoleDTO();
        usernameRoleDTOChangedRole.setUsername(USERNAME);
        usernameRoleDTOChangedRole.setIsActive(Boolean.TRUE);
        usernameRoleDTOChangedRole.setRole(WfmRole.PLANNER);

        Employee employeeWithChangedRole = createUser(1L, WfmRole.PLANNER, USERNAME, WfmStatus.ACTIVE);

        usernameRoleDTOs.add(usernameRoleDTOChangedRole);

        when(employeeRepository.findAllByUsernameInIgnoreCase(singletonList(any()))).thenReturn(singletonList(employee));
        when(employeeRepository.saveAll(any())).thenReturn(singletonList(employeeWithChangedRole));

        employeeService.updateUserRolesAndStatus(usernameRoleDTOs);

        assertEquals(employeeWithChangedRole.getRole(), usernameRoleDTOs.get(0).getRole());
    }

    @Test
    void updateUserRolesAndStatus_shouldUpdateUserStatus() {

        UsernameRoleDTO usernameRoleDTOWithChangedStatus = new UsernameRoleDTO();
        usernameRoleDTOWithChangedStatus.setUsername(USERNAME);
        usernameRoleDTOWithChangedStatus.setIsActive(Boolean.FALSE);
        usernameRoleDTOWithChangedStatus.setRole(WfmRole.EMPLOYEE);

        Employee employeeWithChangedStatus = createUser(1L, WfmRole.EMPLOYEE, USERNAME, WfmStatus.INACTIVE);

        usernameRoleDTOs.add(usernameRoleDTOWithChangedStatus);

        when(employeeRepository.findAllByUsernameInIgnoreCase(singletonList(any()))).thenReturn(singletonList(employee));
        when(employeeRepository.saveAll(any())).thenReturn(singletonList(employeeWithChangedStatus));

        employeeService.updateUserRolesAndStatus(usernameRoleDTOs);

        assertEquals(WfmStatus.INACTIVE, employeeWithChangedStatus.getStatus());
    }

    @Test
    void testFindOneByUsernameThrowsUsernameNotFoundException() {
        //arrange
        when(employeeRepository.findByUsernameIgnoreCase(USERNAME)).thenReturn(Optional.empty());

        //assert
        Exception exception = assertThrows(NotFoundException.class, () -> employeeService.findByUsernameIgnoreCase(USERNAME));
        assertEquals(USERNAME_NOT_FOUND, exception.getMessage());
    }

    @Test
    void deleteProjectHistory_shouldDeleteProjectHistory() {
        projectHistories.addAll(asList(
                ProjectHistory.builder().id(ID).projectName(PROJECT_NAME).build(),
                ProjectHistory.builder().id(2L).projectName("TEST_PROJECT_NAME").build()
        ));
        employee.setProjectHistory(projectHistories);
        employeeService.deleteProjectHistory(projectHistories, ID);
        verify(projectHistoryRepository, times(1)).delete(projectHistories.get(0));
    }


    @Test
    void editEducationForEmployeeShouldThrowNotFoundException() {
        Education education = Education.builder()
                .id(2L)
                .title(TEST_NAME)
                .info(TEST_INFO)
                .startYear(TEST_START_INT)
                .endYear(TEST_END_INT)
                .build();

        when(employeeRepository.findByUsernameIgnoreCase(TEST_USERNAME1)).thenReturn(Optional.of(employee));
        assertThrows(NotFoundException.class, () -> employeeService.editEducationForEmployee(TEST_USERNAME1, education));
    }


    private Employee createUser(Long id, WfmRole wfmRole, String username, WfmStatus wfmStatus) {
        Employee employee = new Employee();
        employee.setId(id);
        employee.setUsername(username);
        employee.setRole(wfmRole);
        employee.setStatus(wfmStatus);
        return employee;
    }

    @Test
    void deleteLanguage_shouldThrowNotFoundException() {
        assertThrows(NotFoundException.class, () -> employeeService.deleteLearnedLanguage(USERNAME, TEST_NAME));
    }
}