gfsBackendService/src/test/java/org/eclipse/openk/gridfailureinformation/service/DistributionGroupServiceMemberTest.java

/*
 *******************************************************************************
 * Copyright (c) 2019 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *******************************************************************************
 */
package org.eclipse.openk.gridfailureinformation.service;

import org.eclipse.openk.gridfailureinformation.config.TestConfiguration;
import org.eclipse.openk.gridfailureinformation.exceptions.NotFoundException;
import org.eclipse.openk.gridfailureinformation.exceptions.OperationDeniedException;
import org.eclipse.openk.gridfailureinformation.model.TblDistributionGroup;
import org.eclipse.openk.gridfailureinformation.model.TblDistributionGroupMember;
import org.eclipse.openk.gridfailureinformation.repository.DistributionGroupMemberRepository;
import org.eclipse.openk.gridfailureinformation.repository.DistributionGroupRepository;
import org.eclipse.openk.gridfailureinformation.support.MockDataHelper;
import org.eclipse.openk.gridfailureinformation.viewmodel.DistributionGroupMemberDto;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.ContextConfiguration;

import java.util.List;
import java.util.Optional;
import java.util.UUID;

import static org.hibernate.validator.internal.util.Contracts.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;

@DataJpaTest
@ContextConfiguration(classes = {TestConfiguration.class})

public class DistributionGroupServiceMemberTest {
    @Qualifier("myDistributionGroupMemberService")
    @Autowired
    private DistributionGroupMemberService distributionGroupMemberService;

    @MockBean
    private DistributionGroupMemberRepository distributionGroupMemberRepository;

    @MockBean
    private DistributionGroupRepository distributionGroupRepository;

    @Test
    public void shouldGetAllDistributionGroupMembers() {
        List<TblDistributionGroupMember> groupMembers = MockDataHelper.mockDistributionGroupMemberList();
        when(distributionGroupMemberRepository.findAll()).thenReturn(groupMembers);
        List<DistributionGroupMemberDto> groupMemberDtoList = distributionGroupMemberService.getDistributionGroupMembers();

        assertEquals(groupMemberDtoList.size(), groupMembers.size());
        assertEquals(2, groupMemberDtoList.size());
        assertEquals(groupMemberDtoList.get(1).getUuid(), groupMembers.get(1).getUuid());
    }

    @Test
    @WithMockUser(username = "admin", authorities = { "ADMIN", "USER" })
    public void shouldGetAllMembersOfASingleDistributionGroup() {
        List<TblDistributionGroupMember> groupMembers = MockDataHelper.mockDistributionGroupMemberList();
        when(distributionGroupMemberRepository.findByTblDistributionGroupUuid(any(UUID.class))).thenReturn(groupMembers);
        List<DistributionGroupMemberDto> groupMemberDtoList = distributionGroupMemberService.getMembersByGroupId(groupMembers.get(1).getTblDistributionGroup().getUuid());

        assertEquals(groupMemberDtoList.size(), groupMembers.size());
        assertEquals(2, groupMemberDtoList.size());
        assertEquals(groupMemberDtoList.get(1).getUuid(), groupMembers.get(1).getUuid());
    }

    @Test
    @WithMockUser(username = "admin", authorities = { "ADMIN", "USER" })
    public void shouldFindASingleDistributionGroupMember() {
        TblDistributionGroupMember groupMember = MockDataHelper.mockTblDistributionGroupMember();
        when(distributionGroupMemberRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(groupMember));
        DistributionGroupMemberDto dto = distributionGroupMemberService.getMemberByUuid(groupMember.getTblDistributionGroup().getUuid(), UUID.randomUUID());

        assertEquals(dto.getUuid(), dto.getUuid());
        assertEquals("12345", dto.getPostcodeList().get(0));
        assertEquals("54321", dto.getPostcodeList().get(1));
    }

    @Test
    public void shouldThrowExceptionWhenFailureNotFound() {
        TblDistributionGroupMember groupMember = MockDataHelper.mockTblDistributionGroupMember();
        when(distributionGroupMemberRepository.findByUuid(any(UUID.class))).thenReturn(Optional.empty());
        assertThrows(NotFoundException.class,
                () -> distributionGroupMemberService.getMemberByUuid(groupMember.getTblDistributionGroup().getUuid(), UUID.randomUUID()));
    }

    @Test
    public void shouldInsertADistributionGroupMember() {
        DistributionGroupMemberDto memberDto = MockDataHelper.mockDistributionGroupMemberDto();
        TblDistributionGroupMember tblDistributionGroupMember = MockDataHelper.mockTblDistributionGroupMember();

        TblDistributionGroup tblDistributionGroup = MockDataHelper.mockTblDistributionGroup();

        when(distributionGroupMemberRepository.save(any(TblDistributionGroupMember.class))).thenReturn(tblDistributionGroupMember);
        when(distributionGroupRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(tblDistributionGroup));

        DistributionGroupMemberDto savedDto = distributionGroupMemberService.insertDistributionGroupMember(UUID.randomUUID(), memberDto);

        assertNotNull(savedDto.getUuid());
        assertEquals(savedDto.getUuid(), tblDistributionGroupMember.getUuid());
        assertEquals("12345,54321",
                tblDistributionGroupMember.getPostcodes());
    }

    @Test
    public void shouldNotInsertMember_Exception_Member_Exists() {
        DistributionGroupMemberDto memberDto = MockDataHelper.mockDistributionGroupMemberDto();
        TblDistributionGroupMember tblDistributionGroupMember = MockDataHelper.mockTblDistributionGroupMember();

        TblDistributionGroup tblDistributionGroup = MockDataHelper.mockTblDistributionGroup();

        when(distributionGroupRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(tblDistributionGroup));
        when(distributionGroupMemberRepository.countByDistributionGroupIdAndContactId(anyLong(),any(UUID.class))).thenReturn(4L);
        when(distributionGroupMemberRepository.save(any(TblDistributionGroupMember.class))).thenReturn(tblDistributionGroupMember);

        assertThrows(OperationDeniedException.class, () -> distributionGroupMemberService.insertDistributionGroupMember(UUID.randomUUID(), memberDto));
    }

    @Test
    public void shouldDeleteDistributionGroupMember() {
        TblDistributionGroupMember tblDistributionGroupMember = MockDataHelper.mockTblDistributionGroupMember();
        TblDistributionGroup tblDistributionGroup = MockDataHelper.mockTblDistributionGroup();

        when(distributionGroupMemberRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(tblDistributionGroupMember));
        when(distributionGroupRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(tblDistributionGroup));
        Mockito.doNothing().when(distributionGroupMemberRepository).delete( isA( TblDistributionGroupMember.class ));

        distributionGroupMemberService.deleteDistributionGroupMember(tblDistributionGroupMember.getTblDistributionGroup().getUuid(), tblDistributionGroupMember.getUuid());

        Mockito.verify(distributionGroupMemberRepository, times(1)).delete( tblDistributionGroupMember );
    }


    @Test
    public void shouldUpdateDistributionGroupMember() {
        DistributionGroupMemberDto memberDto = MockDataHelper.mockDistributionGroupMemberDto();
        TblDistributionGroupMember tblDistributionGroupMember = MockDataHelper.mockTblDistributionGroupMember();
        TblDistributionGroup tblDistributionGroup = MockDataHelper.mockTblDistributionGroup();

        when(distributionGroupMemberRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(tblDistributionGroupMember));
        when(distributionGroupRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(tblDistributionGroup));
        when(distributionGroupMemberRepository.save(any(TblDistributionGroupMember.class))).thenReturn(tblDistributionGroupMember);
        DistributionGroupMemberDto savedMemberDto = distributionGroupMemberService.updateGroupMember(UUID.randomUUID(), memberDto);

        assertEquals(tblDistributionGroupMember.getUuid(), savedMemberDto.getUuid());
    }

    @Test
    public void shouldNotUpdateMember_Exception_GroupNotFound() {
        DistributionGroupMemberDto memberDto = MockDataHelper.mockDistributionGroupMemberDto();
        TblDistributionGroupMember tblDistributionGroupMember = MockDataHelper.mockTblDistributionGroupMember();
        TblDistributionGroup tblDistributionGroup = MockDataHelper.mockTblDistributionGroup();

        when(distributionGroupMemberRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(tblDistributionGroupMember));
        when(distributionGroupRepository.findByUuid(any(UUID.class))).thenReturn(Optional.empty());
        when(distributionGroupMemberRepository.save(any(TblDistributionGroupMember.class))).thenReturn(tblDistributionGroupMember);

        when(distributionGroupMemberRepository.save(any(TblDistributionGroupMember.class)))
                .then((Answer<TblDistributionGroupMember>) invocation -> {
                    Object[] args = invocation.getArguments();
                    return (TblDistributionGroupMember) args[0];
                });
        assertThrows(NotFoundException.class, () -> distributionGroupMemberService.updateGroupMember(UUID.randomUUID(), memberDto));

    }

}